/**
 * Sandbox Manager — 沙箱执行环境
 *
 * 四层纵深防御：进程隔离、路径白名单、网络策略、资源限制。
 *
 * @see docs/生产级通用 AI Agent 智能体桌面应用：完整设计与构建指南.html — 第五章
 */

import { resolve, sep } from 'path';
import { existsSync, realpathSync } from 'fs';

export interface SandboxConfig {
  allowedPaths?: string[];
  networkPolicy?: 'allowall' | 'deny-all' | 'allowlist';
  resourceLimits?: Partial<ResourceLimits>;
}

export interface ResourceLimits {
  maxMemoryMB: number;
  maxCpuSeconds: number;
  maxExecutionMs: number;
  maxOutputSizeKB: number;
}

export interface SandboxExecutionResult {
  success: boolean;
  output?: string;
  stderr?: string;
  exitCode?: number;
  error?: string;
  durationMs: number;
}

export class SandboxManager {
  private allowedPaths: Set<string> = new Set();
  private networkPolicy: 'allowall' | 'deny-all' | 'allowlist' = 'deny-all';
  private resourceLimits: ResourceLimits = {
    maxMemoryMB: 512,
    maxCpuSeconds: 30,
    maxExecutionMs: 60_000,
    maxOutputSizeKB: 1024,
  };

  constructor(private config: SandboxConfig) {
    this.allowedPaths = new Set(config.allowedPaths ?? []);
    this.networkPolicy = config.networkPolicy ?? 'allowlist';
  }

  /**
   * 校验文件路径是否在白名单内
   *
   * 安全策略：fail-closed — 如果未配置任何白名单路径，拒绝所有访问。
   * 同时解析符号链接，防止通过 symlink 逃逸白名单。
   */
  validatePath(requestedPath: string): { allowed: boolean; resolvedPath: string; reason?: string } {
    const resolved = resolve(requestedPath);

    if (this.allowedPaths.size === 0) {
      return { allowed: false, resolvedPath: resolved, reason: 'No allowed paths configured (fail-closed)' };
    }

    // 先做字符串级白名单校验
    const isAllowed = Array.from(this.allowedPaths).some(
      (allowed) => resolved === allowed || resolved.startsWith(allowed + sep),
    );
    if (!isAllowed) {
      return { allowed: false, resolvedPath: resolved, reason: 'Path not in allowed list' };
    }

    // 解析符号链接（如果路径存在）
    if (existsSync(resolved)) {
      try {
        const realPath = realpathSync(resolved);
        const realAllowed = Array.from(this.allowedPaths).some(
          (allowed) => realPath === allowed || realPath.startsWith(allowed + sep),
        );
        if (!realAllowed) {
          return { allowed: false, resolvedPath: realPath, reason: 'Symlink escape detected' };
        }
        return { allowed: true, resolvedPath: realPath };
      } catch {
        // realpath 解析失败（权限问题等），保守拒绝
        return { allowed: false, resolvedPath: resolved, reason: 'Path resolution failed' };
      }
    }

    return { allowed: true, resolvedPath: resolved };
  }

  /**
   * 静态代码安全扫描
   *
   * 检测危险模块导入、代码执行、路径遍历、危险命令、反向 shell、
   * fork bomb、PowerShell 编码执行、环境变量窃取、编码绕过等。
   */
  scanCode(code: string): { safe: boolean; reason?: string } {
    const dangerousPatterns = [
      // 危险模块导入
      /require\s*\(\s*['"]child_process['"]\s*\)/i,
      /import\s+.*from\s+['"]fs['"]/i,
      /import\s+.*from\s+['"]child_process['"]/i,
      // 代码执行
      /\beval\s*\(/i,
      /process\.exit/i,
      /Function\s*\(/i,
      // 路径遍历
      /\.\.\//i,
      /\\\.\.\\/i, // Windows ..\
      // 危险命令
      /\brm\s+-rf\b/i,
      /\bkillall\s+-9\b/i,
      /\bchown\s+-R\s+\//i,
      // 重定向到系统目录
      />\s*\/dev\/null/i,
      />\s*\/etc\//i,
      // 管道执行
      /\bcurl\b.*\|\s*(bash|sh|zsh)\b/i,
      /\bwget\b.*\|\s*(sh|bash|zsh)\b/i,
      // 反向 shell
      /\/bin\/(bash|sh)\s+-i/i,
      /\bnc\s+-e\b/i,
      /\bbash\s+-i\b/i,
      // Fork bomb
      /:\(\)\s*\{\s*:\|:\s*&\s*\};:/i,
      // PowerShell 编码执行
      /powershell.*-enc(odedCommand)?\s+/i,
      // 环境变量窃取
      /env\b.*\b(GITHUB_TOKEN|API_KEY|SECRET|PASSWORD)\b/i,
      // 编码绕过检测
      /\bbase64\b.*\|\s*(sh|bash|zsh)\b/i,
      /\batob\s*\(/i,
      /\bprintf\s+['"]\\x[0-9a-f]/i,
      // 命令替换
      /\$\([^)]*(rm|kill|del|format|mkfs)\b/i,
      // heredoc 执行
      /<<\s*(EOF|END)\s*[\s\S]*?\b(rm|kill|del|format|mkfs)\b/i,
    ];

    for (const pattern of dangerousPatterns) {
      if (pattern.test(code)) {
        // 不暴露 pattern.source，使用通用错误信息
        return { safe: false, reason: 'Command blocked by security policy' };
      }
    }

    return { safe: true };
  }
}