#!/usr/bin/env node
const { execFileSync, spawn } = require('child_process');
const fs = require('fs');
const path = require('path');
const readline = require('readline');
const bcrypt = require('bcryptjs');
const http = require('http');
const Database = require('better-sqlite3');

const PROJECT_ROOT = __dirname;
const CONFIG_PATH = path.join(PROJECT_ROOT, '.env.json');
const DB_PATH = path.join(PROJECT_ROOT, 'data', 'rainweb.db');
const BACKUP_DIR = path.join(PROJECT_ROOT, 'backups');
const PID_PATH = path.join(PROJECT_ROOT, 'server.pid');
const SERVER_PATH = path.join(PROJECT_ROOT, 'server.js');
const PKG = require('./package.json');

// 只读命令不加载 db.js，避免检查状态时意外触发数据库迁移或写入。
let writableDb = null;
function getWritableDb() {
  if (!writableDb) writableDb = require('./db');
  return writableDb;
}

const HELP = `
RainWeb CLI v${PKG.version}
用法：node cli.js <命令> [参数] [选项]

命令：
  status                         查看版本、服务、数据库和备份状态
  health                         HTTP 健康检查和 SQLite 完整性检查
  db-check                       只读检查 SQLite 完整性和关键表
  start                          启动服务器（防重复启动）
  stop                           优雅停止本项目的 server.js
  restart                        停止后等待并启动服务器
  port [端口]                    查看或修改监听端口
  password                      交互式修改管理员密码
  captcha                       交互式配置验证码规则
  config                         查看配置（敏感值统一脱敏）
  backup                         创建数据库备份
  backup list                    列出并检查备份完整性
  backup prune --keep <数量>     预览清理旧备份；加 --yes 才会删除
  backup restore <文件> --yes    服务停止后恢复备份，显式确认才覆盖
  upgrade                        备份、检查工作区、快进升级、构建并验活
  help                           显示帮助

通用选项：
  --yes                          跳过需要确认的操作
  --json                         以 JSON 输出（status/health/config/backup list 等支持）
  --timeout <毫秒>               设置 HTTP 检查超时（100-60000）

说明：
  password 默认交互输入；为兼容旧脚本仍接受末尾明文参数，但不在帮助示例中推荐。
  upgrade 仅用于自托管机器上的本地操作，不会修改云端或远程服务。
`;

class CliError extends Error {
  constructor(message, code = 1) {
    super(message);
    this.name = 'CliError';
    this.exitCode = code;
  }
}

function parseArgs(argv) {
  const positionals = [];
  const options = { yes: false, json: false };
  const valueOptions = new Set(['keep', 'timeout', 'type', 'login', 'register', 'forum', 'failed', 'threshold']);
  const booleanOptions = new Set(['yes', 'json']);
  for (let i = 0; i < argv.length; i += 1) {
    const token = argv[i];
    if (token === '--') {
      positionals.push(...argv.slice(i + 1));
      break;
    }
    if (!token.startsWith('--')) {
      positionals.push(token);
      continue;
    }
    const match = token.match(/^--([^=]+)(?:=(.*))?$/);
    if (!match) throw new CliError(`无法解析选项：${token}`);
    const name = match[1];
    let value = match[2];
    if (booleanOptions.has(name)) {
      if (value !== undefined) throw new CliError(`选项 --${name} 不接受参数`);
      options[name] = true;
      continue;
    }
    if (!valueOptions.has(name)) throw new CliError(`未知选项：--${name}`);
    if (value === undefined) {
      value = argv[i + 1];
      if (!value || value.startsWith('--')) throw new CliError(`选项 --${name} 缺少参数`);
      i += 1;
    }
    options[name] = value;
  }
  return { positionals, ...options };
}

function readJson(file, fallback = {}) {
  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return fallback; }
}

function getConfigPort() {
  const config = readJson(CONFIG_PATH);
  const value = Number(process.env.PORT || config.port || 3001);
  return Number.isInteger(value) && value >= 1 && value <= 65535 ? value : 3001;
}

function setConfigPort(port) {
  const config = readJson(CONFIG_PATH);
  config.port = port;
  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
}

function dbExists() { return fs.existsSync(DB_PATH); }

function openReadonlyDatabase(file = DB_PATH) {
  if (!fs.existsSync(file)) throw new CliError(`数据库不存在：${file}`);
  try { return new Database(file, { readonly: true, fileMustExist: true }); }
  catch (error) { throw new CliError(`无法打开数据库：${error.message}`); }
}

function inspectDatabase(file = DB_PATH) {
  const connection = openReadonlyDatabase(file);
  try {
    const quickCheck = connection.pragma('quick_check', { simple: true });
    const foreignKeyErrors = connection.prepare('PRAGMA foreign_key_check').all();
    const tables = connection.prepare("SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name").all().map((row) => row.name);
    const requiredTables = ['users', 'site_settings', 'tickets', 'ticket_messages', 'ticket_events'];
    const missingTables = requiredTables.filter((name) => !tables.includes(name));
    return {
      file,
      size: fs.statSync(file).size,
      userVersion: connection.pragma('user_version', { simple: true }),
      quickCheck,
      foreignKeyErrors,
      missingTables,
      valid: quickCheck === 'ok' && foreignKeyErrors.length === 0 && missingTables.length === 0,
    };
  } catch (error) {
    throw new CliError(`数据库完整性检查失败：${error.message}`);
  } finally { connection.close(); }
}

function formatBytes(bytes) {
  if (!Number.isFinite(bytes)) return '未知';
  if (bytes < 1024) return `${bytes} B`;
  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MiB`;
  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GiB`;
}

function formatMtime(date) {
  const pad = (value) => String(value).padStart(2, '0');
  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
}

function print(value, args) {
  if (args.json) console.log(JSON.stringify(value, null, 2));
  else console.log(value);
}

function maskValue(key, value) {
  if (value === undefined || value === null || value === '') return '(空)';
  const sensitive = /(pass(word)?|secret|token|private|jwt|credential|api[_-]?key|client[_-]?secret|pin[_-]?(hash|salt)|terminal_pin)/i.test(key);
  if (!sensitive) return String(value);
  const text = String(value);
  return text.length <= 4 ? '****' : `****${text.slice(-4)}`;
}

function getPidFromFile() {
  if (!fs.existsSync(PID_PATH)) return null;
  const raw = fs.readFileSync(PID_PATH, 'utf8').trim();
  if (!/^\d+$/.test(raw)) return { invalid: true, raw };
  return Number(raw);
}

function isRunning(pid) {
  if (!Number.isInteger(pid) || pid <= 0) return false;
  try { process.kill(pid, 0); return true; } catch { return false; }
}

function readProcessDetails(pid) {
  if (!isRunning(pid)) return null;
  let cwd = '';
  let command = '';
  if (process.platform === 'win32') {
    try {
      const script = "$p=Get-CimInstance Win32_Process -Filter 'ProcessId = ' + $args[0]; if ($p) { $p | Select-Object ProcessId,CommandLine | ConvertTo-Json -Compress }";
      const output = execFileSync('powershell.exe', ['-NoProfile', '-Command', script, String(pid)], { encoding: 'utf8' }).trim();
      const processInfo = output ? JSON.parse(output) : null;
      command = processInfo && processInfo.CommandLine ? processInfo.CommandLine : '';
    } catch {}
  }
  try {
    if (process.platform !== 'win32') {
      cwd = fs.realpathSync(`/proc/${pid}/cwd`);
      command = fs.readFileSync(`/proc/${pid}/cmdline`).toString().replace(/\0/g, ' ').trim();
    }
  } catch {}
  if (!command && process.platform !== 'win32') {
    try { command = execFileSync('ps', ['-p', String(pid), '-o', 'command='], { encoding: 'utf8' }).trim(); } catch {}
  }
  const normalizedCommand = command.replace(/\\/g, '/');
  const normalizedServer = SERVER_PATH.replace(/\\/g, '/');
  const hasServerScript = normalizedCommand.includes(normalizedServer)
    || (cwd === PROJECT_ROOT && /(?:^|\s)server\.js(?:\s|$)/.test(command));
  const owned = (process.platform === 'win32' ? hasServerScript : cwd === PROJECT_ROOT && hasServerScript)
    && !/cli\.js/.test(command);
  return { pid, cwd, command, owned };
}

function listCandidatePids() {
  try { return fs.readdirSync('/proc').filter((entry) => /^\d+$/.test(entry)).map(Number); }
  catch {
    try { return execFileSync('ps', ['-A', '-o', 'pid='], { encoding: 'utf8' }).split(/\s+/).filter(Boolean).map(Number); }
    catch { return []; }
  }
}

function findOwnedServers() {
  return listCandidatePids().filter((pid) => pid !== process.pid).map(readProcessDetails).filter((details) => details && details.owned);
}

function getOwnedServer() {
  const pidInfo = getPidFromFile();
  if (pidInfo && pidInfo.invalid) throw new CliError(`PID 文件格式错误：${PID_PATH}`);
  if (Number.isInteger(pidInfo)) {
    if (!isRunning(pidInfo)) {
      try { fs.unlinkSync(PID_PATH); } catch {}
    } else {
      const details = readProcessDetails(pidInfo);
      if (!details || !details.owned) throw new CliError(`拒绝操作：${PID_PATH} 中的 PID ${pidInfo} 不属于本项目的 server.js`);
      return details;
    }
  }
  const servers = findOwnedServers();
  if (servers.length > 1) throw new CliError(`发现多个本项目 server.js 进程（${servers.map((item) => item.pid).join(', ')}），请先人工处理`);
  return servers[0] || null;
}

async function waitForExit(pid, timeoutMs = 10000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    if (!isRunning(pid)) return true;
    await new Promise((resolve) => setTimeout(resolve, 100));
  }
  return !isRunning(pid);
}

function probeHttp(port, timeoutMs = 3000) {
  return new Promise((resolve) => {
    const started = Date.now();
    const request = http.get({ hostname: '127.0.0.1', port, path: '/', timeout: timeoutMs }, (response) => {
      response.resume();
      response.on('end', () => resolve({ reachable: true, healthy: response.statusCode >= 200 && response.statusCode < 400, statusCode: response.statusCode, latencyMs: Date.now() - started }));
    });
    request.on('timeout', () => request.destroy(new Error('请求超时')));
    request.on('error', (error) => resolve({ reachable: false, healthy: false, error: error.message, latencyMs: Date.now() - started }));
  });
}

function getTimeout(args) {
  const value = args.timeout === undefined ? 3000 : Number(args.timeout);
  if (!Number.isInteger(value) || value < 100 || value > 60000) throw new CliError('--timeout 必须是 100-60000 的整数（毫秒）');
  return value;
}

async function waitForStartedServer(pid, port, timeoutMs = 12000) {
  const deadline = Date.now() + timeoutMs;
  let last = null;
  while (Date.now() < deadline) {
    const details = readProcessDetails(pid);
    if (!details || !details.owned) throw new CliError(`新启动的 PID ${pid} 未能确认属于本项目 server.js`);
    last = await probeHttp(port, 1000);
    if (last.healthy) return last;
    await new Promise((resolve) => setTimeout(resolve, 250));
  }
  throw new CliError(`服务器启动后健康检查失败：${last && last.error ? last.error : `HTTP ${last && last.statusCode ? last.statusCode : '无响应'}`}`);
}

async function stopServer({ quiet = false } = {}) {
  const server = getOwnedServer();
  if (!server) {
    if (!quiet) console.log('服务器当前未运行。');
    return { stopped: false, pid: null };
  }
  process.kill(server.pid, 'SIGTERM');
  let exited = await waitForExit(server.pid, 10000);
  if (!exited) {
    const stillOwned = readProcessDetails(server.pid);
    if (!stillOwned || !stillOwned.owned) throw new CliError(`PID ${server.pid} 在等待期间不再确认属于本项目，未强制结束`);
    process.kill(server.pid, 'SIGKILL');
    exited = await waitForExit(server.pid, 3000);
  }
  if (!exited) throw new CliError(`服务器未能退出（PID: ${server.pid}）`);
  if (fs.existsSync(PID_PATH) && getPidFromFile() === server.pid) fs.unlinkSync(PID_PATH);
  if (!quiet) console.log(`服务器已停止（PID: ${server.pid}）。`);
  return { stopped: true, pid: server.pid };
}

async function startServer({ quiet = false } = {}) {
  const existing = getOwnedServer();
  if (existing) {
    if (!quiet) console.log(`服务器已经运行（PID: ${existing.pid}）。`);
    return { started: false, alreadyRunning: true, pid: existing.pid, port: getConfigPort() };
  }
  const port = getConfigPort();
  const child = spawn(process.execPath, [SERVER_PATH], { cwd: PROJECT_ROOT, stdio: 'ignore', detached: true, env: { ...process.env, PORT: String(port) } });
  if (!child.pid) throw new CliError('无法启动服务器进程');
  fs.writeFileSync(PID_PATH, `${child.pid}\n`, { mode: 0o644 });
  try { await waitForStartedServer(child.pid, port); }
  catch (error) {
    if (isRunning(child.pid)) {
      const details = readProcessDetails(child.pid);
      if (details && details.owned) { process.kill(child.pid, 'SIGTERM'); await waitForExit(child.pid, 3000); }
    }
    if (fs.existsSync(PID_PATH) && getPidFromFile() === child.pid) fs.unlinkSync(PID_PATH);
    throw error;
  }
  child.unref();
  if (!quiet) console.log(`服务器已启动（端口: ${port}，PID: ${child.pid}）。`);
  return { started: true, alreadyRunning: false, pid: child.pid, port };
}

function listBackupFiles() {
  if (!fs.existsSync(BACKUP_DIR)) return [];
  return fs.readdirSync(BACKUP_DIR).filter((file) => /^rainweb-.+\.db$/.test(file)).map((file) => path.join(BACKUP_DIR, file)).filter((file) => fs.statSync(file).isFile()).sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
}

function inspectBackup(file) {
  try {
    const result = inspectDatabase(file);
    const integrityValid = result.quickCheck === 'ok' && result.foreignKeyErrors.length === 0;
    return { file: path.basename(file), size: result.size, modifiedAt: formatMtime(fs.statSync(file).mtime), valid: integrityValid, schemaReady: result.missingTables.length === 0, quickCheck: result.quickCheck, foreignKeyErrors: result.foreignKeyErrors.length, missingTables: result.missingTables, userVersion: result.userVersion };
  } catch (error) {
    return { file: path.basename(file), size: fs.existsSync(file) ? fs.statSync(file).size : 0, modifiedAt: fs.existsSync(file) ? formatMtime(fs.statSync(file).mtime) : '', valid: false, schemaReady: false, error: error.message };
  }
}

async function createBackup() {
  if (!dbExists()) throw new CliError(`数据库不存在：${DB_PATH}`);
  fs.mkdirSync(BACKUP_DIR, { recursive: true });
  const now = new Date();
  const stamp = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}-${String(now.getHours()).padStart(2, '0')}${String(now.getMinutes()).padStart(2, '0')}${String(now.getSeconds()).padStart(2, '0')}${String(now.getMilliseconds()).padStart(3, '0')}`;
  const destination = path.join(BACKUP_DIR, `rainweb-${stamp}.db`);
  const source = new Database(DB_PATH, { readonly: true, fileMustExist: true });
  try { await source.backup(destination); } finally { source.close(); }
  const check = inspectBackup(destination);
  if (!check.valid) { try { fs.unlinkSync(destination); } catch {} throw new CliError(`备份已生成但完整性检查失败：${check.error || check.quickCheck}`); }
  return { path: destination, ...check };
}

function resolveBackupFile(input) {
  if (!input) throw new CliError('请指定备份文件名，例如 backup restore rainweb-YYYYMMDD-HHmmss.db');
  const candidate = path.resolve(BACKUP_DIR, input);
  if (path.dirname(candidate) !== path.resolve(BACKUP_DIR)) throw new CliError('备份文件必须位于 backups/ 目录内');
  if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile()) throw new CliError(`备份文件不存在：${candidate}`);
  return candidate;
}

function readSettingRows() {
  if (!dbExists()) return [];
  const connection = openReadonlyDatabase();
  try { return connection.prepare('SELECT key, value FROM site_settings ORDER BY key').all(); } finally { connection.close(); }
}

function normalizeSwitch(value, label) {
  const normalized = String(value || '').toLowerCase();
  if (['1', 'on', 'yes', 'y', 'true'].includes(normalized)) return '1';
  if (['0', 'off', 'no', 'n', 'false'].includes(normalized)) return '0';
  throw new CliError(`${label} 必须是 on/off、yes/no 或 1/0`);
}

function ask(rl, question) { return new Promise((resolve) => rl.question(question, resolve)); }

async function cmdStatus(args) {
  const port = getConfigPort();
  const httpState = await probeHttp(port, getTimeout(args));
  let server = null;
  let serverError = null;
  try { server = getOwnedServer(); } catch (error) { serverError = error.message; }
  let database = null;
  if (dbExists()) { try { database = inspectDatabase(); } catch (error) { database = { valid: false, error: error.message }; } }
  const latest = listBackupFiles()[0];
  const result = { version: PKG.version, node: process.version, platform: process.platform, port, server: { running: !!server, pid: server ? server.pid : null, error: serverError, http: httpState }, database: database || { valid: false, error: '数据库不存在' }, latestBackup: latest ? inspectBackup(latest) : null };
  if (args.json) return print(result, args);
  console.log(`RainWeb v${result.version}`);
  console.log(`Node.js：${result.node}`);
  console.log(`平台：${result.platform}`);
  console.log(`端口：${result.port}`);
  console.log(`服务：${result.server.running ? `运行中（PID: ${result.server.pid}）` : result.server.error || '未运行'}`);
  console.log(`HTTP：${httpState.healthy ? `正常（${httpState.statusCode}，${httpState.latencyMs} ms）` : '不可用'}`);
  console.log(`数据库：${result.database.valid ? '完整性正常' : result.database.error || '检查失败'}`);
  console.log(`最近备份：${result.latestBackup ? `${result.latestBackup.file}（${formatBytes(result.latestBackup.size)}）` : '无'}`);
}

async function cmdHealth(args) {
  const port = getConfigPort();
  const [httpState, database] = await Promise.all([probeHttp(port, getTimeout(args)), Promise.resolve().then(() => (dbExists() ? inspectDatabase() : { valid: false, error: '数据库不存在' }))]);
  const result = { healthy: httpState.healthy && database.valid, port, http: httpState, database };
  print(args.json ? result : `HTTP：${httpState.healthy ? '正常' : `失败（${httpState.error || httpState.statusCode || '无响应'}）`}\n数据库：${database.valid ? '完整性正常' : database.error || '检查失败'}\n总体：${result.healthy ? '健康' : '不健康'}`, args);
  return result.healthy ? 0 : 2;
}

async function cmdDbCheck(args) {
  const result = dbExists() ? inspectDatabase() : { valid: false, error: '数据库不存在', file: DB_PATH };
  const foreignKeyCount = Array.isArray(result.foreignKeyErrors) ? result.foreignKeyErrors.length : result.foreignKeyErrors;
  print(args.json ? result : `数据库：${result.file}\n版本：${result.userVersion ?? '未知'}\nquick_check：${result.quickCheck || '未执行'}\n外键错误：${foreignKeyCount ?? '未知'}\n关键表缺失：${result.missingTables ? result.missingTables.join(', ') || '无' : '未知'}\n结果：${result.valid ? '通过' : result.error || '失败'}`, args);
  return result.valid ? 0 : 2;
}

async function cmdPort(args) {
  const value = args.positionals[1];
  if (value === undefined) return print(args.json ? { port: getConfigPort() } : `当前端口：${getConfigPort()}`, args);
  if (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > 65535) throw new CliError('端口必须是 1-65535 的整数');
  setConfigPort(Number(value));
  print(args.json ? { port: Number(value), message: '端口已保存，重启后生效' } : `端口已设置为 ${value}，重启后生效。`, args);
}

async function cmdPassword(args) {
  await warnIfServerRunning();
  let newPass = args.positionals[1];
  if (!newPass) {
    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
    newPass = await ask(rl, '请输入新的管理员密码（至少 6 位）：');
    const confirm = await ask(rl, '请再次输入密码：');
    rl.close();
    if (newPass !== confirm) throw new CliError('两次输入的密码不一致');
  }
  if (!newPass || newPass.length < 6) throw new CliError('密码至少需要 6 位');
  const db = getWritableDb();
  db.getDb();
  const admin = db.get("SELECT id FROM users WHERE role = 'admin'");
  if (!admin) throw new CliError('未找到管理员账号');
  db.run('UPDATE users SET password = ? WHERE id = ?', [bcrypt.hashSync(newPass, 10), admin.id]);
  print(args.json ? { message: '管理员密码已更新' } : '管理员密码已更新。', args);
}

async function cmdCaptcha(args) {
  await warnIfServerRunning();
  const db = getWritableDb();
  db.getDb();
  const scopes = ['login', 'register', 'forum'];
  const currentType = db.getSetting('captcha_type') || 'builtin';
  const allowedTypes = new Set(['none', 'builtin', 'recaptcha', 'turnstile', 'both']);
  const typeArg = args.type;
  if (typeArg && !allowedTypes.has(typeArg)) throw new CliError('--type 必须是 none、builtin、recaptcha、turnstile 或 both');
  const hasOptions = typeArg || scopes.some((scope) => args[scope] !== undefined) || args.failed !== undefined || args.threshold !== undefined;
  const updates = {};
  if (hasOptions) {
    updates.captcha_type = typeArg || currentType;
    for (const scope of scopes) if (args[scope] !== undefined) updates[`captcha_${scope}`] = normalizeSwitch(args[scope], `--${scope}`);
    if (args.failed !== undefined) updates.captcha_failed = normalizeSwitch(args.failed, '--failed');
    if (args.threshold !== undefined) {
      if (!/^\d+$/.test(String(args.threshold)) || Number(args.threshold) < 1) throw new CliError('--threshold 必须是正整数');
      updates.captcha_failed_threshold = String(Number(args.threshold));
    }
  } else {
    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
    console.log('验证码配置（直接回车保留当前值）');
    const type = await ask(rl, `类型 none/builtin/recaptcha/turnstile/both [${currentType}]：`);
    const selectedType = type || currentType;
    if (!allowedTypes.has(selectedType)) { rl.close(); throw new CliError('验证码类型不合法'); }
    updates.captcha_type = selectedType;
    for (const scope of scopes) {
      const current = db.getSetting(`captcha_${scope}`) || '0';
      const answer = await ask(rl, `启用 ${scope} 验证码？(y/n) [${current === '1' ? 'y' : 'n'}]：`);
      updates[`captcha_${scope}`] = answer ? normalizeSwitch(answer, scope) : current;
    }
    const failed = await ask(rl, `失败尝试后启用验证码？(y/n) [${db.getSetting('captcha_failed') === '1' ? 'y' : 'n'}]：`);
    updates.captcha_failed = failed ? normalizeSwitch(failed, 'failed') : (db.getSetting('captcha_failed') || '0');
    if (updates.captcha_failed === '1') {
      const threshold = await ask(rl, `失败次数阈值 [${db.getSetting('captcha_failed_threshold') || '5'}]：`);
      if (threshold) {
        if (!/^\d+$/.test(threshold) || Number(threshold) < 1) { rl.close(); throw new CliError('失败次数阈值必须是正整数'); }
        updates.captcha_failed_threshold = threshold;
      }
    }
    rl.close();
  }
  for (const [key, value] of Object.entries(updates)) db.setSetting(key, value);
  print(args.json ? { message: '验证码规则已更新', settings: updates } : '验证码规则已更新。', args);
}

async function cmdConfig(args) {
  const settings = Object.fromEntries(readSettingRows().map((row) => [row.key, maskValue(row.key, row.value)]));
  const envConfig = readJson(CONFIG_PATH);
  const safeEnv = Object.fromEntries(Object.entries(envConfig).map(([key, value]) => [key, maskValue(key, value)]));
  const result = { settings, env: safeEnv, listen_port: getConfigPort() };
  if (args.json) return print(result, args);
  console.log('=== RainWeb 配置 ===');
  for (const [key, value] of Object.entries(settings)) console.log(`  ${key}：${value}`);
  for (const [key, value] of Object.entries(safeEnv)) console.log(`  env.${key}：${value}`);
  console.log(`  listen_port：${result.listen_port}`);
}

async function cmdBackup(args) {
  const action = args.positionals[1] || 'create';
  if (action === 'create') {
    const result = await createBackup();
    print(args.json ? result : `备份成功：${result.path}\n完整性：通过（${formatBytes(result.size)}）`, args);
    return;
  }
  if (action === 'list') {
    const result = listBackupFiles().map(inspectBackup);
    print(args.json ? result : (result.length ? result.map((item) => `${item.valid ? '正常' : '损坏'}${item.valid && !item.schemaReady ? '（待迁移）' : ''}  ${item.file}  ${formatBytes(item.size)}  ${item.modifiedAt}`).join('\n') : '暂无备份。'), args);
    return;
  }
  if (action === 'prune') {
    if (args.keep === undefined) throw new CliError('prune 必须明确指定 --keep <数量>；未指定时不会删除任何文件');
    if (!/^\d+$/.test(String(args.keep)) || Number(args.keep) < 1) throw new CliError('--keep 必须是正整数');
    const keep = Number(args.keep);
    const remove = listBackupFiles().slice(keep);
    const result = { keep, candidates: remove.map((file) => path.basename(file)), deleted: [] };
    if (args.yes) for (const file of remove) { fs.unlinkSync(file); result.deleted.push(path.basename(file)); }
    print(args.json ? result : (args.yes ? `已删除 ${result.deleted.length} 个旧备份，保留最新 ${keep} 个。` : `预览：将删除 ${remove.length} 个旧备份；加 --yes 才会执行。\n${result.candidates.join('\n')}`), args);
    return;
  }
  if (action === 'restore') {
    if (!args.yes) throw new CliError('restore 会覆盖当前数据库，必须显式使用 --yes；且服务必须已停止');
    if (getOwnedServer()) throw new CliError('restore 必须先停止 RainWeb 服务');
    const httpState = await probeHttp(getConfigPort(), getTimeout(args));
    if (httpState.reachable) throw new CliError('检测到 HTTP 服务仍在运行，拒绝 restore');
    const sourcePath = resolveBackupFile(args.positionals[2]);
    const check = inspectBackup(sourcePath);
    if (!check.valid) throw new CliError(`备份完整性检查失败，拒绝恢复：${check.error || check.quickCheck}`);
    if (!dbExists()) fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
    const tempPath = `${DB_PATH}.restore-${process.pid}-${Date.now()}`;
    const source = new Database(sourcePath, { readonly: true, fileMustExist: true });
    try { await source.backup(tempPath); } finally { source.close(); }
    let oldPath = null;
    try {
      if (fs.existsSync(DB_PATH)) { oldPath = `${DB_PATH}.before-restore-${Date.now()}`; fs.renameSync(DB_PATH, oldPath); }
      fs.renameSync(tempPath, DB_PATH);
    } catch (error) {
      try { if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath); } catch {}
      try { if (oldPath && fs.existsSync(oldPath) && !fs.existsSync(DB_PATH)) fs.renameSync(oldPath, DB_PATH); } catch {}
      throw new CliError(`恢复失败，已尝试保留原数据库：${error.message}`);
    }
    print(args.json ? { message: '数据库已恢复', source: sourcePath, previousDatabase: oldPath } : `数据库已恢复：${sourcePath}\n原数据库保留为：${oldPath || '无'}。`, args);
    return;
  }
  throw new CliError(`未知 backup 子命令：${action}`);
}

function runCommand(command, commandArgs, label) {
  console.log(`${label}：${command} ${commandArgs.join(' ')}`);
  try { execFileSync(command, commandArgs, { cwd: PROJECT_ROOT, stdio: 'inherit' }); }
  catch (error) { throw new CliError(`${label}失败（退出码 ${error.status ?? '未知'}）`); }
}

function getNpmCommand() {
  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
}

async function cmdUpgrade(args) {
  if (args.json) throw new CliError('upgrade 不支持 --json，请使用普通输出查看升级过程');
  if (!fs.existsSync(path.join(PROJECT_ROOT, '.git'))) throw new CliError('当前目录不是 git 仓库，无法升级');
  let status;
  try { status = execFileSync('git', ['status', '--porcelain'], { cwd: PROJECT_ROOT, encoding: 'utf8' }); }
  catch (error) { throw new CliError(`无法读取 git 工作区：${error.message}`); }
  if (status.trim()) throw new CliError('git 工作区不干净，已停止升级；请先处理本地修改或未跟踪文件');
  const backup = await createBackup();
  console.log(`升级前备份完成：${backup.file}`);
  const wasRunning = !!getOwnedServer();
  if (wasRunning) await stopServer();
  try {
    runCommand('git', ['pull', '--ff-only'], 'git 快进更新');
    runCommand(getNpmCommand(), ['install'], '依赖安装');
    runCommand(getNpmCommand(), ['run', 'build'], '前端构建');
    if (wasRunning) {
      await startServer();
      const health = await cmdHealth({ json: false });
      if (health !== 0) throw new CliError('升级后健康检查未通过');
    }
  } catch (error) {
    if (wasRunning) {
      let running = false;
      try { running = !!getOwnedServer(); } catch {}
      if (!running) {
        try { await startServer(); } catch (restartError) { console.error(`升级失败后恢复启动也失败：${restartError.message}`); }
      }
    }
    throw error instanceof CliError ? error : new CliError(error.message);
  }
  console.log('升级完成。');
}

async function cmdPortlessStart() { await startServer(); }
async function cmdPortlessStop() { await stopServer(); }
async function cmdPortlessRestart() { await stopServer(); await startServer(); }

async function warnIfServerRunning() {
  let owned = null;
  try { owned = getOwnedServer(); } catch {}
  if (owned) console.log('警告：server 正在运行，并发写库可能等待；建议先停止服务。');
}

async function dispatch(args) {
  const command = args.positionals[0] || 'help';
  switch (command) {
    case 'status': return cmdStatus(args);
    case 'health': return cmdHealth(args);
    case 'db-check': return cmdDbCheck(args);
    case 'start': return cmdPortlessStart(args);
    case 'stop': return cmdPortlessStop(args);
    case 'restart': return cmdPortlessRestart(args);
    case 'port': return cmdPort(args);
    case 'password': return cmdPassword(args);
    case 'captcha': return cmdCaptcha(args);
    case 'config': return cmdConfig(args);
    case 'backup': return cmdBackup(args);
    case 'upgrade': return cmdUpgrade(args);
    case 'help': return console.log(HELP);
    default: throw new CliError(`未知命令：${command}\n\n${HELP}`);
  }
}

async function main() {
  const args = parseArgs(process.argv.slice(2));
  const result = await dispatch(args);
  if (Number.isInteger(result)) process.exitCode = result;
}

main().catch((error) => {
  const exitCode = error.exitCode || 1;
  if (process.argv.includes('--json')) console.error(JSON.stringify({ error: error.message, exitCode }));
  else console.error(`错误：${error.message}`);
  process.exitCode = exitCode;
});