const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const os = require('os');
const { execSync } = require('child_process');

function getCurrentVersion() {
  const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
  return packageJson.version;
}

function getPackageSourceDir() {
  const sourceDirArg = process.argv
    .slice(2)
    .find((arg) => arg.startsWith('--source-dir='));
  const configuredSourceDir = sourceDirArg
    ? sourceDirArg.slice('--source-dir='.length)
    : process.env.DEPLOY_PACKAGE_SOURCE_DIR;

  if (!configuredSourceDir) {
    return path.join(__dirname, '../dist/apps/web');
  }

  return path.resolve(process.cwd(), configuredSourceDir);
}

function preparePackageRoot(sourceDir) {
  if (path.basename(sourceDir) === 'web') {
    return {
      rootDir: path.dirname(sourceDir),
      packageDirName: 'web',
      cleanup: () => {},
    };
  }

  const stagingRoot = fs.mkdtempSync(
    path.join(os.tmpdir(), 'opentu-deploy-package-')
  );
  const stagingWebDir = path.join(stagingRoot, 'web');
  fs.cpSync(sourceDir, stagingWebDir, {
    recursive: true,
    dereference: true,
  });

  return {
    rootDir: stagingRoot,
    packageDirName: 'web',
    cleanup: () => fs.rmSync(stagingRoot, { recursive: true, force: true }),
  };
}

function getTagAttribute(tag, attributeName) {
  const escapedName = attributeName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  const match = String(tag).match(
    new RegExp(`\\s${escapedName}\\s*=\\s*(['"])(.*?)\\1`, 'i')
  );
  return match ? match[2] : '';
}

function normalizeEntryAssetPath(value) {
  let normalized = String(value || '')
    .split(/[?#]/, 1)[0]
    .trim();
  if (!normalized) {
    return '';
  }

  if (/^https?:\/\//i.test(normalized)) {
    try {
      normalized = new URL(normalized).pathname;
    } catch (_error) {
      return '';
    }
  }

  normalized = normalized
    .replace(/^\//, '')
    .replace(/^\.\//, '')
    .replace(/^npm\/aitu-app@[^/]+\//, '')
    .replace(/^aitu-app@[^/]+\//, '');

  return normalized;
}

function collectEntryAssetsFromHtml(html) {
  const assets = new Set();

  const scriptTags =
    String(html).match(
      /<script\b[^>]*\bsrc\s*=\s*(['"]).*?\1[^>]*><\/script>/gi
    ) || [];
  for (const tag of scriptTags) {
    const asset = normalizeEntryAssetPath(
      getTagAttribute(tag, 'data-local-src') || getTagAttribute(tag, 'src')
    );
    if (asset.startsWith('assets/') && asset.endsWith('.js')) {
      assets.add(asset);
    }
  }

  const linkTags = String(html).match(/<link\b[^>]*>/gi) || [];
  for (const tag of linkTags) {
    const rel = getTagAttribute(tag, 'rel').toLowerCase();
    if (!rel.split(/\s+/).includes('stylesheet')) {
      continue;
    }

    const asset = normalizeEntryAssetPath(
      getTagAttribute(tag, 'data-local-href') || getTagAttribute(tag, 'href')
    );
    if (asset.startsWith('assets/') && asset.endsWith('.css')) {
      assets.add(asset);
    }
  }

  return Array.from(assets);
}

// 加载 .env 配置文件
function loadEnvConfig() {
  const envPath = path.join(__dirname, '../.env');
  const config = {
    DEPLOY_HOST: '',
    DEPLOY_USER: '',
    DEPLOY_PORT: '22',
    DEPLOY_SSH_KEY: '',
    DEPLOY_SSH_PASSWORD: '',
    DEPLOY_UPLOAD_DIR: '',
    DEPLOY_SCRIPT_PATH: '',
    DEPLOY_AUTO_UPLOAD: 'false',
    DEPLOY_AUTO_DEPLOY: 'false', // 'false', 'true' (prod), 'test'
  };

  if (fs.existsSync(envPath)) {
    const envContent = fs.readFileSync(envPath, 'utf8');
    envContent.split('\n').forEach((line) => {
      line = line.trim();
      // 跳过注释和空行
      if (line && !line.startsWith('#')) {
        const match = line.match(/^([^=]+)=(.*)$/);
        if (match) {
          const key = match[1].trim();
          let value = match[2].trim();
          // 移除引号
          if (
            (value.startsWith('"') && value.endsWith('"')) ||
            (value.startsWith("'") && value.endsWith("'"))
          ) {
            value = value.slice(1, -1);
          }
          if (config.hasOwnProperty(key)) {
            config[key] = value;
          }
        }
      }
    });
  }

  return config;
}

// 检查 sshpass 是否安装
function checkSshpassInstalled() {
  try {
    execSync('which sshpass', { stdio: 'ignore' });
    return true;
  } catch (e) {
    return false;
  }
}

// 执行远程部署脚本
function executeRemoteDeploy(
  config,
  tarName,
  env = 'test',
  usePassword = false
) {
  if (!config.DEPLOY_SCRIPT_PATH) {
    console.error(`\n❌ 未配置部署脚本路径`);
    console.error(`   请在 .env 文件中配置 DEPLOY_SCRIPT_PATH`);
    return false;
  }

  const deployScriptPath = config.DEPLOY_SCRIPT_PATH;

  console.log(`\n🚀 开始自动部署到${env === 'test' ? '测试' : '生产'}环境...`);
  console.log(`   部署脚本: ${deployScriptPath}`);
  console.log(`   包文件: ${tarName}`);

  try {
    // 构建 SSH 命令
    let sshCommand = '';
    let usePassword = false;

    // 如果配置了密码，使用 sshpass
    if (config.DEPLOY_SSH_PASSWORD && !config.DEPLOY_SSH_KEY) {
      if (!checkSshpassInstalled()) {
        console.error(`\n❌ 未安装 sshpass，无法执行远程部署`);
        console.error(`   请安装: brew install hudochenkov/sshpass/sshpass`);
        return false;
      }
      usePassword = true;
      sshCommand = `sshpass -p "${config.DEPLOY_SSH_PASSWORD}" `;
    }

    sshCommand += 'ssh';

    // 添加端口
    if (config.DEPLOY_PORT && config.DEPLOY_PORT !== '22') {
      sshCommand += ` -p ${config.DEPLOY_PORT}`;
    }

    // 添加 SSH 密钥
    if (config.DEPLOY_SSH_KEY) {
      const sshKeyPath = config.DEPLOY_SSH_KEY.startsWith('/')
        ? config.DEPLOY_SSH_KEY
        : path.join(
            process.env.HOME || '',
            config.DEPLOY_SSH_KEY.replace(/^~/, '')
          );

      if (fs.existsSync(sshKeyPath)) {
        sshCommand += ` -i "${sshKeyPath}"`;
      }
    }

    // 禁用严格主机密钥检查
    sshCommand += ` -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null`;

    // 构建远程命令
    const remoteCommand = `bash ${deployScriptPath} --${env} ${tarName}`;
    sshCommand += ` ${config.DEPLOY_USER}@${config.DEPLOY_HOST} "${remoteCommand}"`;

    console.log(`🔄 执行远程部署命令...`);
    execSync(sshCommand, { stdio: 'inherit' });

    console.log(`✅ 部署成功!`);
    return true;
  } catch (error) {
    console.error(`❌ 部署失败:`, error.message);
    console.error(`\n💡 请检查:`);
    console.error(`   1. 部署脚本路径是否正确: ${deployScriptPath}`);
    console.error(`   2. 脚本是否有执行权限`);
    console.error(`   3. 服务器目录权限是否正确`);
    return false;
  }
}

// 上传文件到远程服务器
function uploadToServer(tarPath, tarName, config) {
  if (!config.DEPLOY_HOST || !config.DEPLOY_USER) {
    console.log(`\n⚠️  未配置远程服务器信息，跳过上传`);
    console.log(`   请在 .env 文件中配置 DEPLOY_HOST 和 DEPLOY_USER`);
    return false;
  }

  if (!config.DEPLOY_UPLOAD_DIR) {
    console.error(`\n❌ 未配置上传目录`);
    console.error(`   请在 .env 文件中配置 DEPLOY_UPLOAD_DIR`);
    return false;
  }

  console.log(`\n🚀 开始上传到远程服务器...`);
  console.log(
    `   服务器: ${config.DEPLOY_USER}@${config.DEPLOY_HOST}:${config.DEPLOY_PORT}`
  );
  console.log(`   目标目录: ${config.DEPLOY_UPLOAD_DIR}`);
  console.log(`   文件: ${tarName}`);

  try {
    // 构建 scp 命令
    let scpCommand = '';
    let usePassword = false;

    // 如果配置了密码，使用 sshpass
    if (config.DEPLOY_SSH_PASSWORD && !config.DEPLOY_SSH_KEY) {
      if (!checkSshpassInstalled()) {
        console.error(`\n❌ 未安装 sshpass，无法使用密码认证`);
        console.error(`\n💡 安装方法:`);
        console.error(`   macOS: brew install hudochenkov/sshpass/sshpass`);
        console.error(
          `   Linux: apt-get install sshpass 或 yum install sshpass`
        );
        console.error(`\n   或者配置 SSH 密钥认证（更安全）`);
        return false;
      }
      usePassword = true;
      scpCommand = `sshpass -p "${config.DEPLOY_SSH_PASSWORD}" `;
    }

    scpCommand += 'scp';

    // 添加端口
    if (config.DEPLOY_PORT && config.DEPLOY_PORT !== '22') {
      scpCommand += ` -P ${config.DEPLOY_PORT}`;
    }

    // 添加 SSH 密钥（如果配置了密钥，优先使用密钥）
    if (config.DEPLOY_SSH_KEY) {
      const sshKeyPath = config.DEPLOY_SSH_KEY.startsWith('/')
        ? config.DEPLOY_SSH_KEY
        : path.join(process.env.HOME || '', config.DEPLOY_SSH_KEY);

      if (fs.existsSync(sshKeyPath)) {
        scpCommand += ` -i "${sshKeyPath}"`;
      } else {
        console.warn(`⚠️  SSH 密钥文件不存在: ${sshKeyPath}`);
      }
    }

    // 禁用严格主机密钥检查（可选，用于自动化场景）
    scpCommand += ` -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null`;

    // 添加源文件和目标
    const remotePath = `${config.DEPLOY_USER}@${config.DEPLOY_HOST}:${config.DEPLOY_UPLOAD_DIR}`;
    scpCommand += ` "${tarPath}" "${remotePath}/"`;

    console.log(`🔄 执行上传命令...`);
    if (usePassword) {
      console.log(`   使用密码认证`);
    } else if (config.DEPLOY_SSH_KEY) {
      console.log(`   使用 SSH 密钥认证`);
    } else {
      console.log(`   使用默认 SSH 认证`);
    }

    execSync(scpCommand, { stdio: 'inherit' });

    console.log(`✅ 上传成功!`);
    console.log(`📦 远程路径: ${config.DEPLOY_UPLOAD_DIR}/${tarName}`);

    return { success: true, tarName };
  } catch (error) {
    console.error(`❌ 上传失败:`, error.message);
    console.error(`\n💡 请检查:`);
    console.error(`   1. 服务器地址和端口是否正确`);
    if (config.DEPLOY_SSH_PASSWORD) {
      console.error(`   2. 密码是否正确`);
      console.error(
        `   3. 是否已安装 sshpass (brew install hudochenkov/sshpass/sshpass)`
      );
    } else {
      console.error(`   2. SSH 密钥是否正确配置`);
    }
    console.error(`   4. 服务器目录权限是否正确`);
    console.error(`   5. 网络连接是否正常`);
    return false;
  }

  return false;
}

function createDeployPackage() {
  const version = getCurrentVersion();
  const distPath = getPackageSourceDir();
  const tarName = `web-${version}.tar.gz`;
  const tarPath = path.join(__dirname, '../dist/apps', tarName);

  console.log(`📦 开始创建部署包...`);
  console.log(`📂 源目录: ${distPath}`);
  console.log(`📁 目标文件: ${tarPath}`);

  // 检查源目录是否存在
  if (!fs.existsSync(distPath)) {
    console.error(`❌ 构建目录不存在: ${distPath}`);
    console.error(`请先运行 npm run build 命令`);
    process.exit(1);
  }

  // 检查目录是否为空
  const files = fs.readdirSync(distPath);
  if (files.length === 0) {
    console.error(`❌ 构建目录为空: ${distPath}`);
    process.exit(1);
  }

  // 检查 version.json 是否存在
  const versionJsonPath = path.join(distPath, 'version.json');
  if (!fs.existsSync(versionJsonPath)) {
    console.error(`❌ version.json 不存在: ${versionJsonPath}`);
    console.error(`请确保构建过程已正确复制 version.json`);
    process.exit(1);
  }

  console.log(`📝 目录内容 (${files.length} 个文件/目录):`);
  files.forEach((file) => {
    const filePath = path.join(distPath, file);
    const stats = fs.statSync(filePath);
    const type = stats.isDirectory() ? '📁' : '📄';
    const size = stats.isDirectory()
      ? ''
      : ` (${(stats.size / 1024).toFixed(1)} KB)`;
    console.log(`   ${type} ${file}${size}`);
  });

  try {
    fs.mkdirSync(path.dirname(tarPath), { recursive: true });

    // 删除可能存在的旧版本 tar.gz 文件
    if (fs.existsSync(tarPath)) {
      fs.unlinkSync(tarPath);
      console.log(`🗑️  删除旧版本: ${tarName}`);
    }

    // 创建 tar.gz 包
    // 包内结构应该是 web/ 目录，这样 deploy.sh 可以从 web/version.json 读取版本
    // 进入 dist/apps 目录，打包 web 目录，这样包内路径就是 web/
    // 使用 COPYFILE_DISABLE=1 禁用 macOS 扩展属性，确保跨平台兼容性
    const packageRoot = preparePackageRoot(distPath);

    // 切换到 apps 目录，使用相对路径避免路径问题
    // 排除 macOS 特定文件，使用 --exclude 选项
    console.log(`🔄 执行压缩命令...`);
    console.log(`   工作目录: ${packageRoot.rootDir}`);
    console.log(`   打包目录: ${packageRoot.packageDirName}`);
    console.log(`   输出文件: ${tarPath}`);

    const env = { ...process.env, COPYFILE_DISABLE: '1' };
    // 使用 tar 打包，确保包含所有文件
    // COPYFILE_DISABLE=1 环境变量会禁用 macOS 扩展属性
    // 只排除系统文件，不排除任何业务文件
    try {
      execSync(
        `tar -czf "${tarPath}" --exclude='.DS_Store' --exclude='._*' --exclude='.git*' ${packageRoot.packageDirName}`,
        {
          cwd: packageRoot.rootDir,
          stdio: 'inherit',
          env: env,
        }
      );
    } finally {
      packageRoot.cleanup();
    }

    // 验证 tar.gz 文件是否创建成功
    if (fs.existsSync(tarPath)) {
      const tarStats = fs.statSync(tarPath);
      const tarSizeMB = (tarStats.size / 1024 / 1024).toFixed(2);

      // 验证包内结构（检查是否能从 web/version.json 读取）
      try {
        // 使用 2>/dev/null 忽略扩展属性警告，这些警告不影响功能
        const versionCheck = execSync(
          `tar -xzf "${tarPath}" -O web/version.json 2>/dev/null`,
          { encoding: 'utf8' }
        );
        const versionInfo = JSON.parse(versionCheck.trim());
        if (versionInfo.version === version) {
          console.log(`✅ 版本验证通过: ${version}`);
        } else {
          console.warn(
            `⚠️  版本不匹配: 期望 ${version}, 实际 ${versionInfo.version}`
          );
        }
      } catch (e) {
        console.warn(`⚠️  无法验证包内版本信息: ${e.message}`);
        console.warn(
          `   这可能是由于 macOS 扩展属性警告导致的，但不影响包的功能`
        );
      }

      // 验证关键文件是否存在
      try {
        const fileList = execSync(`tar -tzf "${tarPath}" 2>/dev/null`, {
          encoding: 'utf8',
        });
        const files = fileList.split('\n').filter((f) => f.trim());
        const fileSet = new Set(files);
        const rootIndexEntry =
          files.find((f) => f === 'web/index.html') ||
          files.find((f) => /(^|\/)index\.html$/.test(f));
        const hasAssets = files.some((f) => f.includes('assets/'));
        const hasIndex = Boolean(rootIndexEntry);
        const assetCount = files.filter(
          (f) =>
            f.includes('assets/') && (f.endsWith('.js') || f.endsWith('.css'))
        ).length;
        let entryAssets = [];
        let missingEntryAssets = [];

        if (rootIndexEntry) {
          const indexHtml = execSync(
            `tar -xOzf "${tarPath}" "${rootIndexEntry}" 2>/dev/null`,
            { encoding: 'utf8' }
          );
          const rootDir = path.posix.dirname(rootIndexEntry);
          entryAssets = collectEntryAssetsFromHtml(indexHtml);
          missingEntryAssets = entryAssets.filter(
            (asset) => !fileSet.has(path.posix.join(rootDir, asset))
          );
        }
        const hasEntryJs = entryAssets.some((asset) => asset.endsWith('.js'));
        const hasEntryCss = entryAssets.some((asset) => asset.endsWith('.css'));

        // 检查当前构建产物的关键资源组（文件名哈希是动态的，只检查 chunk 前缀 / manifest 语义）
        const hasAssetChunk = (pattern) =>
          files.some((f) => f.includes('assets/') && pattern.test(f));
        const hasToolWindowsJs = hasAssetChunk(
          /\/?assets\/tool-windows-[^/]+\.js$/
        );
        const hasToolWindowsCss = hasAssetChunk(
          /\/?assets\/tool-windows-[^/]+\.css$/
        );
        const hasToolRuntimeJs = hasAssetChunk(
          /\/?assets\/tool-runtime-[^/]+\.js$/
        );
        const hasToolDrawersJs = hasAssetChunk(
          /\/?assets\/tool-drawers-[^/]+\.js$/
        );
        const hasToolDialogsJs = hasAssetChunk(
          /\/?assets\/tool-dialogs-[^/]+\.js$/
        );
        const hasExternalSkillsJs = hasAssetChunk(
          /\/?assets\/external-skills-[^/]+\.js$/
        );
        const hasAnyAssetJs = files.some(
          (f) => f.includes('assets/') && f.endsWith('.js')
        );
        const idlePrefetchManifestEntry = files.find((f) =>
          /(^|\/)idle-prefetch-manifest\.json$/.test(f)
        );
        let idlePrefetchManifest = null;
        let idlePrefetchGroupCounts = {};
        let idlePrefetchDefaults = [];

        if (idlePrefetchManifestEntry) {
          try {
            const manifestContent = execSync(
              `tar -xOzf "${tarPath}" "${idlePrefetchManifestEntry}" 2>/dev/null`,
              { encoding: 'utf8' }
            );
            idlePrefetchManifest = JSON.parse(manifestContent);
            idlePrefetchGroupCounts = Object.fromEntries(
              Object.entries(idlePrefetchManifest.groups || {}).map(
                ([group, entries]) => [
                  group,
                  Array.isArray(entries) ? entries.length : 0,
                ]
              )
            );
            idlePrefetchDefaults = Array.isArray(idlePrefetchManifest.defaults)
              ? idlePrefetchManifest.defaults
              : [];
          } catch (e) {
            console.warn(
              `⚠️  无法读取 idle-prefetch-manifest.json: ${e.message}`
            );
          }
        }

        const hasRuntimeStaticAssetsGroup =
          Object.prototype.hasOwnProperty.call(
            idlePrefetchGroupCounts,
            'runtime-static-assets'
          );
        const runtimeStaticAssetsCount =
          idlePrefetchGroupCounts['runtime-static-assets'] || 0;
        const hasOfflineStaticAssetsGroup =
          Object.prototype.hasOwnProperty.call(
            idlePrefetchGroupCounts,
            'offline-static-assets'
          );
        const offlineStaticAssetsCount =
          idlePrefetchGroupCounts['offline-static-assets'] || 0;
        const usesCurrentToolChunkLayout =
          hasToolWindowsJs ||
          hasRuntimeStaticAssetsGroup ||
          idlePrefetchDefaults.includes('tool-windows');
        const usesLegacyToolChunkLayout =
          hasToolRuntimeJs || hasToolDrawersJs || hasToolDialogsJs;
        const missingCriticalGroups = [];

        if (!hasEntryJs) missingCriticalGroups.push('entry script');
        if (!hasEntryCss) missingCriticalGroups.push('entry stylesheet');
        missingCriticalGroups.push(...missingEntryAssets);
        if (usesCurrentToolChunkLayout) {
          if (!hasToolWindowsJs)
            missingCriticalGroups.push('tool-windows-*.js');
          if (!hasRuntimeStaticAssetsGroup) {
            missingCriticalGroups.push('runtime-static-assets(group)');
          }
        } else {
          if (!hasToolRuntimeJs)
            missingCriticalGroups.push('tool-runtime-*.js');
          if (!hasToolDrawersJs)
            missingCriticalGroups.push('tool-drawers-*.js');
          if (!hasToolDialogsJs)
            missingCriticalGroups.push('tool-dialogs-*.js');
        }

        console.log(`📊 打包统计:`);
        console.log(`   总文件数: ${files.length}`);
        console.log(`   Assets 文件数: ${assetCount}`);
        console.log(`   关键资源组检查:`);
        console.log(
          `     - entry script: ${
            hasEntryJs
              ? `✅ (${entryAssets
                  .filter((asset) => asset.endsWith('.js'))
                  .join(', ')})`
              : '❌'
          }`
        );
        console.log(
          `     - entry stylesheet: ${
            hasEntryCss
              ? `✅ (${entryAssets
                  .filter((asset) => asset.endsWith('.css'))
                  .join(', ')})`
              : '❌'
          }`
        );
        if (usesCurrentToolChunkLayout) {
          console.log(
            `     - tool-windows-*.js: ${hasToolWindowsJs ? '✅' : '❌'}`
          );
          console.log(
            `     - tool-windows-*.css: ${
              hasToolWindowsCss ? '✅' : 'ℹ️  未生成'
            }`
          );
          console.log(
            `     - runtime-static-assets(group): ${
              hasRuntimeStaticAssetsGroup
                ? `✅ (${runtimeStaticAssetsCount} entries)`
                : '❌'
            }`
          );
          console.log(
            `     - offline-static-assets(group): ${
              hasOfflineStaticAssetsGroup
                ? `✅ (${offlineStaticAssetsCount} entries)`
                : 'ℹ️  未生成'
            }`
          );
          if (usesLegacyToolChunkLayout) {
            console.log(
              `     - legacy tool-runtime/tool-drawers/tool-dialogs: ℹ️  兼容存在，不再作为当前布局必需项`
            );
          }
        } else {
          console.log(
            `     - tool-runtime-*.js: ${hasToolRuntimeJs ? '✅' : '❌'}`
          );
          console.log(
            `     - tool-drawers-*.js: ${hasToolDrawersJs ? '✅' : '❌'}`
          );
          console.log(
            `     - tool-dialogs-*.js: ${hasToolDialogsJs ? '✅' : '❌'}`
          );
        }
        console.log(
          `     - external-skills-*.js: ${
            hasExternalSkillsJs ? '✅' : 'ℹ️  未生成'
          }`
        );
        if (idlePrefetchManifest) {
          console.log(
            `     - idle-prefetch defaults: ${
              idlePrefetchDefaults.length > 0
                ? idlePrefetchDefaults.join(', ')
                : 'ℹ️  空'
            }`
          );
        } else {
          console.log(`     - idle-prefetch-manifest.json: ℹ️  未找到`);
        }

        if (!hasAssets) {
          console.warn(`⚠️  警告: 未找到 assets 目录`);
        }
        if (!hasIndex) {
          console.warn(`⚠️  警告: 未找到 index.html`);
        }
        if (assetCount < 50) {
          console.warn(
            `⚠️  警告: Assets 文件数量较少 (${assetCount})，可能不完整`
          );
        }
        if (!hasAnyAssetJs) {
          console.warn(
            `⚠️  警告: assets 目录下未找到任何 JS 文件，产物可能不完整`
          );
        }
        if (missingCriticalGroups.length > 0) {
          throw new Error(`关键资源缺失: ${missingCriticalGroups.join(', ')}`);
        }
      } catch (e) {
        if (
          e.message === '关键文件缺失' ||
          e.message.startsWith('关键资源缺失:')
        ) {
          throw e;
        }
        console.warn(`⚠️  无法验证包内文件列表: ${e.message}`);
      }

      // 测试解压（在临时目录）
      console.log(`🧪 测试解压...`);
      const testDir = fs.mkdtempSync(
        path.join(os.tmpdir(), 'opentu-test-extract-')
      );
      try {
        execSync(
          `tar -xzf "${tarPath}" -C "${testDir}" --strip-components=1 2>/dev/null`,
          { stdio: 'ignore' }
        );

        // 验证解压后的关键文件（只检查必须存在的文件）
        const requiredFiles = ['version.json', 'index.html', 'assets'];

        let allFilesExist = true;
        for (const testFile of requiredFiles) {
          const testPath = path.join(testDir, testFile);
          if (!fs.existsSync(testPath)) {
            console.error(`❌ 测试解压失败: 未找到 ${testFile}`);
            allFilesExist = false;
          }
        }

        // 检查 assets 目录中是否有 JS 文件
        const assetsDir = path.join(testDir, 'assets');
        if (fs.existsSync(assetsDir)) {
          const assetFiles = fs
            .readdirSync(assetsDir)
            .filter((f) => f.endsWith('.js'));
          if (assetFiles.length === 0) {
            console.error(`❌ 测试解压失败: assets 目录为空`);
            allFilesExist = false;
          } else {
            console.log(`✅ assets 目录包含 ${assetFiles.length} 个 JS 文件`);
          }
        }

        if (allFilesExist) {
          console.log(`✅ 解压测试通过: 所有关键文件都能正确解压`);
        } else {
          throw new Error('解压测试失败');
        }
      } catch (e) {
        if (e.message === '解压测试失败') {
          throw e;
        }
        console.warn(`⚠️  解压测试跳过: ${e.message}`);
      } finally {
        fs.rmSync(testDir, { recursive: true, force: true });
      }

      // 计算文件哈希
      console.log(`🔐 计算文件哈希...`);
      const fileBuffer = fs.readFileSync(tarPath);
      const hash = crypto.createHash('sha256').update(fileBuffer).digest('hex');
      console.log(`✅ 文件哈希: ${hash.substring(0, 16)}...`);

      console.log(`✅ 部署包创建成功!`);
      console.log(`📦 文件: ${tarName}`);
      console.log(`📏 大小: ${tarSizeMB} MB`);
      console.log(`📍 路径: ${tarPath}`);
      console.log(`🔐 SHA256: ${hash}`);

      // 显示相对路径，更友好
      const relativePath = path.relative(process.cwd(), tarPath);
      console.log(`🎉 相对路径: ${relativePath}`);

      // 返回 tar 文件路径和名称，供上传使用
      return { tarPath, tarName, hash };
    } else {
      throw new Error('TAR.GZ 文件创建失败');
    }
  } catch (error) {
    console.error(`❌ 创建部署包失败:`, error.message);

    // 提供备用方案
    console.log(`\n💡 手动创建方案:`);
    console.log(`   cd ${path.dirname(distPath)}`);
    console.log(`   tar -czf ${tarName} -C web .`);

    process.exit(1);
  }
}

// 主函数
function main() {
  // 解析命令行参数
  const args = process.argv.slice(2);

  console.log(`🚀 Opentu 部署包创建工具`);
  console.log(`⏰ 时间: ${new Date().toLocaleString()}`);
  console.log(`───────────────────────────────────`);

  // 加载环境配置
  const config = loadEnvConfig();

  // 创建部署包
  const result = createDeployPackage();

  console.log(`───────────────────────────────────`);
  console.log(`🎊 部署包创建完成!`);

  // 自动上传（如果配置了服务器信息）
  let uploadSuccess = false;
  let deploySuccess = false;

  // 兼容 DEPLOY_AUTO_UPLOAD 配置（如果设置了，也设置 DEPLOY_AUTO_DEPLOY）
  // 如果 DEPLOY_AUTO_UPLOAD 设置了且不为 'false'，且 DEPLOY_AUTO_DEPLOY 未设置或为 'false'，则使用 DEPLOY_AUTO_UPLOAD 的值
  if (config.DEPLOY_AUTO_UPLOAD && config.DEPLOY_AUTO_UPLOAD !== 'false') {
    if (!config.DEPLOY_AUTO_DEPLOY || config.DEPLOY_AUTO_DEPLOY === 'false') {
      config.DEPLOY_AUTO_DEPLOY = config.DEPLOY_AUTO_UPLOAD;
      console.log(
        `ℹ️  检测到 DEPLOY_AUTO_UPLOAD=${
          config.DEPLOY_AUTO_UPLOAD
        }，将自动部署到${
          config.DEPLOY_AUTO_UPLOAD === 'test' ? '测试' : '生产'
        }环境`
      );
    }
  }

  if (config.DEPLOY_HOST && config.DEPLOY_USER) {
    // 默认自动上传，除非明确禁用
    const shouldSkipUpload = args.includes('--no-upload');
    if (!shouldSkipUpload) {
      // 使用打包时计算的哈希
      const uploadResult = uploadToServer(
        result.tarPath,
        result.tarName,
        config,
        result.hash
      );
      uploadSuccess = uploadResult && uploadResult.success;

      // 如果上传成功且配置了自动部署，执行远程部署脚本
      if (
        uploadSuccess &&
        (config.DEPLOY_AUTO_DEPLOY === 'true' ||
          config.DEPLOY_AUTO_DEPLOY === 'test')
      ) {
        const deployEnv =
          config.DEPLOY_AUTO_DEPLOY === 'test' ? 'test' : 'prod';
        deploySuccess = executeRemoteDeploy(
          config,
          result.tarName,
          deployEnv,
          uploadResult.usePassword
        );
      } else if (uploadSuccess) {
        console.log(`\n💡 上传成功，但未配置自动部署`);
        console.log(
          `   如需自动部署，请在 .env 中设置 DEPLOY_AUTO_DEPLOY=test 或 DEPLOY_AUTO_DEPLOY=true`
        );
      }
    } else {
      console.log(`\n💡 已跳过上传（使用 --no-upload 参数）`);
      console.log(
        `   手动上传: scp ${result.tarPath} ${config.DEPLOY_USER}@${config.DEPLOY_HOST}:${config.DEPLOY_UPLOAD_DIR}/`
      );
    }
  } else {
    console.log(`\n💡 未配置远程服务器信息，跳过上传`);
    console.log(`   请在 .env 文件中配置 DEPLOY_HOST 和 DEPLOY_USER`);
  }

  const version = getCurrentVersion();
  const tarName = `web-${version}.tar.gz`;
  console.log(`\n💡 使用方法:`);
  if (uploadSuccess) {
    console.log(`   ✅ 文件已上传到 ${config.DEPLOY_UPLOAD_DIR}/${tarName}`);
    if (deploySuccess) {
      console.log(
        `   ✅ 已自动部署到${
          config.DEPLOY_AUTO_DEPLOY === 'test' ? '测试' : '生产'
        }环境`
      );
    } else {
      if (config.DEPLOY_SCRIPT_PATH) {
        console.log(
          `   在服务器上运行: ${config.DEPLOY_SCRIPT_PATH} --test ${tarName}`
        );
      } else {
        console.log(`   在服务器上运行部署脚本 --test ${tarName}`);
      }
    }
  } else {
    console.log(`   本地部署: ./deploy.sh --test ${tarName}`);
    if (config.DEPLOY_HOST && config.DEPLOY_USER) {
      console.log(
        `   手动上传: scp ${result.tarPath} ${config.DEPLOY_USER}@${config.DEPLOY_HOST}:${config.DEPLOY_UPLOAD_DIR}/`
      );
    }
  }
}

main();