#!/usr/bin/env node

/**
 * 启动后台进程脚本
 *
 * 功能:
 * - 调用 process-manager.mjs 清理旧进程
 * - 构建项目(如果需要)
 * - 启动 Admin 服务(Admin 会自动启动 Bridge 子进程)
 */

import fs from 'node:fs';
import path from 'node:path';
import process from 'node:process';
import { spawn, spawnSync } from 'node:child_process';
import { fileURLToPath } from 'node:url';

const scriptFile = fileURLToPath(import.meta.url);
const scriptDir = path.dirname(scriptFile);
const rootDir = path.resolve(scriptDir, '..');
const logsDir = path.join(rootDir, 'logs');
const pidFile = path.join(logsDir, 'bridge.pid');
const outLog = path.join(logsDir, 'service.log');
const errLog = path.join(logsDir, 'service.err');
const adminEntryFile = path.join(rootDir, 'dist', 'admin', 'index.js');
const processManagerPath = path.join(rootDir, 'scripts', 'process-manager.mjs');

// 是否跳过 opencode serve 启动(用于已由外部管理 opencode 的场景)
const skipOpencodeStart = process.argv.includes('--no-opencode');

function isWindows() {
 return process.platform === 'win32';
}

function getNpmCommandVariants(args) {
 const variants = [];
 const npmExecPath = process.env.npm_execpath;

 if (npmExecPath) {
 variants.push({
 command: process.execPath,
 args: [npmExecPath, ...args],
 });
 }

 variants.push({ command: 'npm', args });

 if (isWindows()) {
 variants.push({ command: 'npm.cmd', args });
 variants.push({ command: 'npm.exe', args });
 }

 const seen = new Set();
 const uniqueVariants = [];

 for (const variant of variants) {
 const key = `${variant.command}::${variant.args.join('\u0000')}`;
 if (seen.has(key)) {
 continue;
 }
 seen.add(key);
 uniqueVariants.push(variant);
 }

 return uniqueVariants;
}

function runNpm(args) {
 const variants = getNpmCommandVariants(args);
 let lastResult = null;

 for (const variant of variants) {
 const result = spawnSync(variant.command, variant.args, {
 cwd: rootDir,
 stdio: 'inherit',
 windowsHide: isWindows(),
 });

 if (result.error) {
 lastResult = result;
 continue;
 }

 if (result.status === 0) {
 return result;
 }

 lastResult = result;
 }

 return lastResult;
}

function ensureLogDir() {
 fs.mkdirSync(logsDir, { recursive: true });
}

function ensureBuildIfMissing() {
 const webEntryFile = path.join(rootDir, 'dist', 'public', 'index.html');
 const backendMissing = !fs.existsSync(adminEntryFile);
 const frontendMissing = !fs.existsSync(webEntryFile);

 if (!backendMissing && !frontendMissing) {
 return;
 }

 if (backendMissing && frontendMissing) {
 console.log('[start] 未检测到构建产物,开始自动全量构建');
 } else if (backendMissing) {
 console.log('[start] 未检测到 dist/admin/index.js,开始自动构建');
 } else {
 console.log('[start] 未检测到 dist/public/index.html,开始自动构建前端控制台');
 }

 const result = runNpm(['run', 'build:all']);

 if (!result || result.error || result.status !== 0) {
 console.error('[start] 构建失败,启动中止');
 process.exit(result?.status ?? 1);
 }
}

function startAdmin() {
 const stdoutFd = fs.openSync(outLog, 'a');
 const stderrFd = fs.openSync(errLog, 'a');

 const child = spawn(process.execPath, [adminEntryFile], {
 cwd: rootDir,
 detached: true,
 stdio: ['ignore', stdoutFd, stderrFd],
 windowsHide: isWindows(),
 });

 child.unref();
 fs.closeSync(stdoutFd);
 fs.closeSync(stderrFd);

 fs.writeFileSync(pidFile, String(child.pid), 'utf-8');
 console.log(`[start] 启动成功,PID=${child.pid}`);
 console.log(`[start] 日志文件:${outLog}`);
}

function sleep(ms) {
 const end = Date.now() + ms;
 while (Date.now() < end) {
 // 忙等待
 }
}

function runProcessManager(args, options = {}) {
 const result = spawnSync(process.execPath, [processManagerPath, ...args], {
 stdio: 'pipe',
 encoding: 'utf-8',
 windowsHide: isWindows(),
 ...options,
 });
 if (result.stdout?.trim()) console.log(result.stdout.trim());
 if (result.stderr?.trim()) console.error(result.stderr.trim());
 return result;
}

function main() {
 ensureLogDir();

 // 0. 启动 opencode serve(幂等 - 如果已在运行则跳过)
 if (skipOpencodeStart) {
 console.log('[start] 跳过 opencode serve 启动(--no-opencode)');
 } else {
 console.log('[start] 启动 opencode serve...');
 const opencodeResult = runProcessManager(['start-opencode']);
 if (opencodeResult.status !== 0) {
 console.warn('[start] 警告:opencode serve 启动失败,继续启动 Bridge(可稍后手动启动 opencode)');
 }
 }

 // 1. 调用进程管理工具清理旧 Bridge 进程(不传递 --exclude-self,因为这是独立调用)
 console.log('[start] 清理旧 Bridge 进程...');
 runProcessManager(['kill-bridge']);

 // 2. 等待 3 秒,确保旧进程完全退出
 console.log('[start] 等待进程退出...');
 sleep(3000);

 ensureBuildIfMissing();

 // 3. 启动 Admin 服务(Admin 会自动启动 Bridge 子进程)
 startAdmin();
}

main();