import * as http from "http";
import * as https from "https";
import * as fs from "fs";
import * as path from "path";
import * as zlib from "zlib";
import sqlite3 from "sqlite3";

// 配置文件路径
const CONFIG_FILE = path.join(__dirname, "config.json");
const API_LIST_FILE = path.join(__dirname, "mock", "api-list.json");
const MOCK_DIR = path.join(__dirname, "mock");
const DATA_DIR = path.join(__dirname, "data");
const DB_FILE = path.join(DATA_DIR, "mock-mappings.sqlite3");
const LEGACY_DB_FILE = path.join(MOCK_DIR, "mock-mappings.sqlite3");

// 定义类型
interface RouteConfig {
  [route: string]: string;
}

interface RouteStatusConfig {
  [route: string]: number;
}

interface AppConfig {
  /** 为 false 时所有请求走代理，不命中 mock 路由；缺省为 true */
  mockEnabled?: boolean;
  cacheConfig: boolean;
  reloadOnChange: boolean;
  defaultContentType: string;
  proxyPort: number;
  targetHost: string;
  /** 代理转发的目标端口；缺省 HTTPS 为 443，HTTP 为 80 */
  targetPort?: number;
  /** 为 false 时用 HTTP 连接上游；缺省 true（HTTPS） */
  targetHttps?: boolean;
}

interface ConfigFile {
  routes: RouteConfig;
  routeStatuses?: RouteStatusConfig;
  config: AppConfig;
}

interface ApiListItem {
  name: string;
  route: string;
}

interface MockFileItem {
  filePath: string;
  alias: string;
  content: string;
}

interface RouteRow {
  route_key: string;
  file_path: string;
  status_code: number;
}

interface MockFileRow {
  file_path: string;
  alias: string;
}

// 存储当前的路由配置
let MOCK_ROUTES: RouteConfig = {};
let RAW_ROUTES: RouteConfig = {};
let MOCK_ROUTE_STATUSES: RouteStatusConfig = {};
let RAW_ROUTE_STATUSES: RouteStatusConfig = {};
let CONFIG: AppConfig = {
  cacheConfig: true,
  reloadOnChange: true,
  defaultContentType: "application/json",
  proxyPort: 443,
  targetHost: "localhost",
  targetPort: 443,
};
let DB: sqlite3.Database;

// 过滤掉以 # 开头的路由（视为注释，不参与 mock）
function filterActiveRoutes(routes: RouteConfig): RouteConfig {
  const filtered: RouteConfig = {};
  for (const [route, filePath] of Object.entries(routes)) {
    if (route.startsWith("#")) continue;
    filtered[route] = filePath;
  }
  return filtered;
}

function filterActiveRouteStatuses(statuses: RouteStatusConfig): RouteStatusConfig {
  const filtered: RouteStatusConfig = {};
  for (const [route, statusCode] of Object.entries(statuses)) {
    if (route.startsWith("#")) continue;
    filtered[route] = statusCode;
  }
  return filtered;
}

function normalizeStatusCode(input: unknown, fallback = 200): number {
  const numeric =
    typeof input === "number" ? input : Number.parseInt(String(input ?? ""), 10);
  if (Number.isInteger(numeric) && numeric >= 100 && numeric <= 599) {
    return numeric;
  }
  return fallback;
}

function isTargetHttps(): boolean {
  return CONFIG.targetHttps !== false;
}

function getTargetPort(): number {
  if (CONFIG.targetPort != null) return CONFIG.targetPort;
  return isTargetHttps() ? 443 : 80;
}

function upstreamRequest(
  options: http.RequestOptions,
  callback: (proxyRes: http.IncomingMessage) => void,
): http.ClientRequest {
  return isTargetHttps()
    ? https.request(options, callback)
    : http.request(options, callback);
}

function dbRun(sql: string, params: unknown[] = []): Promise<void> {
  return new Promise((resolve, reject) => {
    DB.run(sql, params, (error) => {
      if (error) {
        reject(error);
        return;
      }
      resolve();
    });
  });
}

function dbAll<T = unknown>(sql: string, params: unknown[] = []): Promise<T[]> {
  return new Promise((resolve, reject) => {
    DB.all(sql, params, (error, rows) => {
      if (error) {
        reject(error);
        return;
      }
      resolve((rows as T[]) || []);
    });
  });
}

function openDatabase(): Promise<void> {
  return new Promise((resolve, reject) => {
    DB = new sqlite3.Database(DB_FILE, (error) => {
      if (error) {
        reject(error);
        return;
      }
      resolve();
    });
  });
}

async function initDatabase(): Promise<void> {
  fs.mkdirSync(MOCK_DIR, { recursive: true });
  fs.mkdirSync(DATA_DIR, { recursive: true });
  if (!fs.existsSync(DB_FILE) && fs.existsSync(LEGACY_DB_FILE)) {
    fs.copyFileSync(LEGACY_DB_FILE, DB_FILE);
  }
  await openDatabase();
  await dbRun(`
    CREATE TABLE IF NOT EXISTS route_mappings (
      route_key TEXT PRIMARY KEY,
      file_path TEXT NOT NULL,
      status_code INTEGER NOT NULL DEFAULT 200
    )
  `);
  await dbRun(
    "ALTER TABLE route_mappings ADD COLUMN status_code INTEGER NOT NULL DEFAULT 200",
  ).catch(() => {
    // ignore when column already exists
  });
  await dbRun(`
    CREATE TABLE IF NOT EXISTS api_list (
      route TEXT PRIMARY KEY,
      name TEXT NOT NULL
    )
  `);
  await dbRun(`
    CREATE TABLE IF NOT EXISTS mock_files (
      file_path TEXT PRIMARY KEY,
      alias TEXT NOT NULL DEFAULT ''
    )
  `);
  await dbRun("ALTER TABLE mock_files ADD COLUMN alias TEXT NOT NULL DEFAULT ''").catch(
    () => {
      // ignore when column already exists
    },
  );
  // 清理不该出现在 mock 列表中的系统文件
  await dbRun(
    "DELETE FROM mock_files WHERE file_path = ? OR file_path LIKE ?",
    ["mock/api-list.json", "%.sqlite3"],
  );
}

async function saveRoutesToDb(
  routes: RouteConfig,
  routeStatuses: RouteStatusConfig = {},
): Promise<void> {
  await dbRun("DELETE FROM route_mappings");
  for (const [routeKey, filePath] of Object.entries(routes)) {
    const statusCode = normalizeStatusCode(routeStatuses[routeKey], 200);
    await dbRun(
      "INSERT INTO route_mappings(route_key, file_path, status_code) VALUES(?, ?, ?)",
      [routeKey, filePath, statusCode],
    );
    await dbRun("INSERT OR IGNORE INTO mock_files(file_path) VALUES(?)", [
      filePath,
    ]);
  }
}

async function loadRoutesFromDb(): Promise<{
  routes: RouteConfig;
  routeStatuses: RouteStatusConfig;
}> {
  const rows = await dbAll<RouteRow>(
    "SELECT route_key, file_path, status_code FROM route_mappings ORDER BY route_key ASC",
  );
  const routes: RouteConfig = {};
  const routeStatuses: RouteStatusConfig = {};
  for (const row of rows) {
    routes[row.route_key] = row.file_path;
    routeStatuses[row.route_key] = normalizeStatusCode(row.status_code, 200);
  }
  return { routes, routeStatuses };
}

async function upsertApiListToDb(list: ApiListItem[]): Promise<void> {
  await dbRun("DELETE FROM api_list");
  for (const item of list) {
    await dbRun("INSERT INTO api_list(route, name) VALUES(?, ?)", [
      item.route,
      item.name,
    ]);
  }
}

async function loadApiListFromDb(): Promise<ApiListItem[]> {
  const rows = await dbAll<{ route: string; name: string }>(
    "SELECT route, name FROM api_list ORDER BY route ASC",
  );
  return rows.map((row) => ({ route: row.route, name: row.name }));
}

async function upsertMockFilePathToDb(filePath: string, alias?: string): Promise<void> {
  if (typeof alias === "string") {
    await dbRun(
      "INSERT INTO mock_files(file_path, alias) VALUES(?, ?) ON CONFLICT(file_path) DO UPDATE SET alias = excluded.alias",
      [filePath, alias],
    );
    return;
  }
  await dbRun("INSERT OR IGNORE INTO mock_files(file_path, alias) VALUES(?, '')", [
    filePath,
  ]);
}

async function removeMockFilePathFromDb(filePath: string): Promise<void> {
  await dbRun("DELETE FROM mock_files WHERE file_path = ?", [filePath]);
}

async function loadMockFilePathsFromDb(): Promise<MockFileRow[]> {
  const rows = await dbAll<MockFileRow>(
    "SELECT file_path, alias FROM mock_files ORDER BY file_path ASC",
  );
  return rows.map((row) => ({
    file_path: row.file_path,
    alias: String(row.alias || ""),
  }));
}

// 加载配置文件
async function loadConfig() {
  try {
    if (!fs.existsSync(CONFIG_FILE)) {
      console.warn(`[CONFIG] 配置文件不存在: ${CONFIG_FILE}`);
      console.warn(`[CONFIG] 正在创建默认配置文件...`);

      // 创建默认配置
      const defaultConfig: ConfigFile = {
        routes: {
          "/api2/test": "mock/test.txt",
        },
        config: {
          cacheConfig: true,
          reloadOnChange: true,
          defaultContentType: "application/json",
          proxyPort: 443,
          targetHost: "localhost",
          targetPort: 443,
        },
      };

      // 确保mock目录存在
      const mockDir = path.join(__dirname, "mock");
      if (!fs.existsSync(mockDir)) {
        fs.mkdirSync(mockDir, { recursive: true });
      }

      // 保存配置文件
      fs.writeFileSync(
        CONFIG_FILE,
        JSON.stringify(defaultConfig, null, 2),
        "utf-8",
      );
      console.log(`[CONFIG] 已创建默认配置文件: ${CONFIG_FILE}`);

      // 加载配置，路由最终以 sqlite 为准
      const configData: ConfigFile = JSON.parse(
        fs.readFileSync(CONFIG_FILE, "utf-8"),
      );
      CONFIG = configData.config || CONFIG;
      await saveRoutesToDb(configData.routes || {}, configData.routeStatuses || {});
    } else {
      const configData: ConfigFile = JSON.parse(
        fs.readFileSync(CONFIG_FILE, "utf-8"),
      );
      CONFIG = configData.config || CONFIG;
      const dbMappings = await loadRoutesFromDb();
      if (Object.keys(dbMappings.routes).length === 0 && configData.routes) {
        await saveRoutesToDb(configData.routes, configData.routeStatuses || {});
      }
    }

    const dbMappings = await loadRoutesFromDb();
    RAW_ROUTES = dbMappings.routes;
    RAW_ROUTE_STATUSES = dbMappings.routeStatuses;
    MOCK_ROUTES = filterActiveRoutes(RAW_ROUTES);
    MOCK_ROUTE_STATUSES = filterActiveRouteStatuses(RAW_ROUTE_STATUSES);
    console.log(
      `[CONFIG] 配置已加载（sqlite 路由 ${Object.keys(MOCK_ROUTES).length} 条）${CONFIG.mockEnabled !== false ? "" : "（mock 已关闭，全部走代理）"}`,
    );

    // 验证mock文件是否存在
    validateMockFiles();
  } catch (error) {
    console.error(`[CONFIG] 加载配置文件失败:`, error);
    // 使用默认配置
    MOCK_ROUTES = {
      "/api2/user/list": "mock/user_list.txt",
    };
    RAW_ROUTES = { ...MOCK_ROUTES };
    RAW_ROUTE_STATUSES = {};
    MOCK_ROUTE_STATUSES = {};
    CONFIG = {
      cacheConfig: true,
      reloadOnChange: true,
      defaultContentType: "application/json",
      proxyPort: 9443,
      targetHost: "devrmtapp.resmart.cn",
      targetPort: 443,
    };
  }
}

function buildCurrentConfigFile(): ConfigFile {
  return {
    routes: { ...RAW_ROUTES },
    routeStatuses: { ...RAW_ROUTE_STATUSES },
    config: { ...CONFIG },
  };
}

async function saveConfigFile(nextConfig: ConfigFile): Promise<void> {
  // routes 持久化到 sqlite，config 仍使用 config.json
  await saveRoutesToDb(nextConfig.routes || {}, nextConfig.routeStatuses || {});
  fs.writeFileSync(CONFIG_FILE, JSON.stringify(nextConfig, null, 2), "utf-8");
  const dbMappings = await loadRoutesFromDb();
  RAW_ROUTES = dbMappings.routes;
  RAW_ROUTE_STATUSES = dbMappings.routeStatuses;
  MOCK_ROUTES = filterActiveRoutes(RAW_ROUTES);
  MOCK_ROUTE_STATUSES = filterActiveRouteStatuses(RAW_ROUTE_STATUSES);
  CONFIG = nextConfig.config || CONFIG;
}

function loadApiListFromJson(): ApiListItem[] {
  if (!fs.existsSync(API_LIST_FILE)) {
    return [];
  }
  try {
    const text = fs.readFileSync(API_LIST_FILE, "utf-8").trim();
    if (!text) {
      return [];
    }
    const parsed = JSON.parse(text);
    if (!Array.isArray(parsed)) {
      return [];
    }
    const seenRoutes = new Set<string>();
    const list: ApiListItem[] = [];
    for (const item of parsed) {
      const route = String(item?.route || "").trim();
      const name = String(item?.name || "").trim();
      if (!route || !route.startsWith("/") || !name || seenRoutes.has(route)) {
        continue;
      }
      seenRoutes.add(route);
      list.push({ name, route });
    }
    return list;
  } catch (error) {
    console.warn("[ADMIN] 读取 api-list.json 失败:", error);
    return [];
  }
}

async function loadApiList(): Promise<ApiListItem[]> {
  const dbList = await loadApiListFromDb();
  if (dbList.length > 0) {
    return dbList;
  }
  const jsonList = loadApiListFromJson();
  if (jsonList.length > 0) {
    await upsertApiListToDb(jsonList);
  }
  return jsonList;
}

function normalizeMockFilePath(filePath: string): string {
  const trimmed = filePath.trim().replace(/\\/g, "/");
  if (!trimmed) {
    throw new Error("filePath is required");
  }
  const relative = trimmed.startsWith("mock/") ? trimmed : `mock/${trimmed}`;
  if (path.isAbsolute(relative)) {
    throw new Error("filePath must be a relative path");
  }
  return relative;
}

function resolveMockFullPath(relativePath: string): string {
  const normalized = normalizeMockFilePath(relativePath);
  const fullPath = path.resolve(__dirname, normalized);
  const mockRoot = path.resolve(MOCK_DIR);
  if (!fullPath.startsWith(mockRoot)) {
    throw new Error("filePath is invalid");
  }
  if (path.basename(fullPath) === "api-list.json") {
    throw new Error("api-list.json is read-only in this panel");
  }
  return fullPath;
}

function walkMockFiles(dir: string, baseDir: string, result: string[]): void {
  const entries = fs.readdirSync(dir, { withFileTypes: true });
  for (const entry of entries) {
    const fullPath = path.join(dir, entry.name);
    if (entry.isDirectory()) {
      walkMockFiles(fullPath, baseDir, result);
      continue;
    }
    if (!entry.isFile()) continue;
    if (entry.name === "api-list.json") continue;
    if (entry.name.endsWith(".sqlite3")) continue;
    const relative = path.relative(baseDir, fullPath).replace(/\\/g, "/");
    result.push(`mock/${relative}`);
  }
}

async function loadMockFiles(): Promise<MockFileItem[]> {
  let files = await loadMockFilePathsFromDb();
  files = files.filter(
    (item) =>
      item.file_path !== "mock/api-list.json" &&
      !item.file_path.endsWith(".sqlite3"),
  );
  if (files.length === 0 && fs.existsSync(MOCK_DIR)) {
    const fsFiles: string[] = [];
    walkMockFiles(MOCK_DIR, MOCK_DIR, fsFiles);
    fsFiles.sort((a, b) => a.localeCompare(b));
    for (const filePath of fsFiles) {
      await upsertMockFilePathToDb(filePath);
    }
    files = fsFiles.map((filePath) => ({ file_path: filePath, alias: "" }));
  }

  const result: MockFileItem[] = [];
  for (const item of files) {
    const filePath = item.file_path;
    const fullPath = path.join(__dirname, filePath);
    if (!fs.existsSync(fullPath)) continue;
    result.push({
      filePath,
      alias: String(item.alias || ""),
      content: fs.readFileSync(fullPath, "utf-8"),
    });
  }
  return result;
}

async function initMockFilesFromFsIfNeeded(): Promise<void> {
  const filesInDb = await loadMockFilePathsFromDb();
  if (filesInDb.length > 0 || !fs.existsSync(MOCK_DIR)) return;
  if (!fs.existsSync(MOCK_DIR)) {
    return;
  }
  const files: string[] = [];
  walkMockFiles(MOCK_DIR, MOCK_DIR, files);
  files.sort((a, b) => a.localeCompare(b));
  for (const filePath of files) {
    await upsertMockFilePathToDb(filePath);
  }
}

function readBody(req: http.IncomingMessage): Promise<string> {
  return new Promise((resolve, reject) => {
    const chunks: Buffer[] = [];
    req.on("data", (chunk: Buffer) => {
      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
    });
    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
    req.on("error", reject);
  });
}

// 验证mock文件是否存在
function validateMockFiles() {
  console.log(`[CONFIG] 验证mock文件...`);
  let missingFiles: Array<{
    route: string;
    filePath: string;
    fullPath: string;
  }> = [];

  for (const [route, filePath] of Object.entries(MOCK_ROUTES)) {
    const fullPath = path.join(__dirname, filePath);
    if (!fs.existsSync(fullPath)) {
      missingFiles.push({ route, filePath, fullPath });
      console.warn(
        `[CONFIG]  警告: mock文件不存在 - ${filePath} (用于路由: ${route})`,
      );
    }
  }

  if (missingFiles.length > 0) {
    console.log(
      `[CONFIG] 缺少 ${missingFiles.length} 个mock文件，请创建这些文件`,
    );
  } else {
    console.log(`[CONFIG] 所有mock文件验证通过`);
  }
}

// 检查是否为mock路由的函数
function isMockRoute(requestPath: string): boolean {
  if (CONFIG.mockEnabled === false) return false;
  return MOCK_ROUTES.hasOwnProperty(requestPath);
}

// 获取mock文件路径
function getMockFilePath(requestPath: string): string {
  return MOCK_ROUTES[requestPath];
}

function getMockStatusCode(requestPath: string): number {
  return normalizeStatusCode(MOCK_ROUTE_STATUSES[requestPath], 200);
}

function decodeBodyByEncoding(
  bodyBuffer: Buffer,
  contentEncoding?: string,
): Buffer {
  const encoding = (contentEncoding || "").toLowerCase().trim();
  try {
    if (encoding.includes("gzip")) {
      return zlib.gunzipSync(bodyBuffer);
    }
    if (encoding.includes("br")) {
      return zlib.brotliDecompressSync(bodyBuffer);
    }
    if (encoding.includes("deflate")) {
      return zlib.inflateSync(bodyBuffer);
    }
  } catch (error) {
    console.warn("[MOCK] 解压上游响应失败，按原始内容写入文件", error);
  }
  return bodyBuffer;
}

// 代理服务器
const proxyServer = http.createServer(async (clientReq, clientRes) => {
  // 解析客户端请求的 URL
  const parsedUrl = new URL(`http://localhost${clientReq.url!}`);
  const requestPath = parsedUrl.pathname;

  // 管理接口：保留路径，不参与代理转发
  if (requestPath === "/__reload-config") {
    if (clientReq.method !== "POST") {
      clientRes.writeHead(405, {
        "Content-Type": "application/json",
        Allow: "POST",
      });
      clientRes.end(
        JSON.stringify({
          success: false,
          error: "Method Not Allowed",
          allow: ["POST"],
        }),
      );
      return;
    }

    try {
      const oldCount = Object.keys(MOCK_ROUTES).length;
      await loadConfig();
      const newCount = Object.keys(MOCK_ROUTES).length;

      clientRes.writeHead(200, { "Content-Type": "application/json" });
      clientRes.end(
        JSON.stringify({
          success: true,
          message: "Configuration reloaded successfully",
          routesCount: newCount,
          routesChanged: newCount - oldCount,
        }),
      );
      console.log(
        `[ADMIN] 通过API重新加载配置 (路由数: ${oldCount} -> ${newCount})`,
      );
    } catch (error) {
      clientRes.writeHead(500, { "Content-Type": "application/json" });
      clientRes.end(
        JSON.stringify({
          success: false,
          error: (error as Error).message,
        }),
      );
    }
    return;
  }

  if (requestPath === "/__config") {
    if (clientReq.method !== "GET" && clientReq.method !== "POST") {
      clientRes.writeHead(405, {
        "Content-Type": "application/json",
        Allow: "GET, POST",
      });
      clientRes.end(
        JSON.stringify({
          success: false,
          error: "Method Not Allowed",
          allow: ["GET", "POST"],
        }),
      );
      return;
    }

    if (clientReq.method === "POST") {
      readBody(clientReq)
        .then(async (bodyText) => {
          const body = bodyText ? JSON.parse(bodyText) : {};
          const nextConfig: ConfigFile = {
            routes: body.routes ?? RAW_ROUTES,
            routeStatuses: body.routeStatuses ?? RAW_ROUTE_STATUSES,
            config: body.config || CONFIG,
          };
          await saveConfigFile(nextConfig);
          validateMockFiles();
          clientRes.writeHead(200, { "Content-Type": "application/json" });
          clientRes.end(
            JSON.stringify({
              success: true,
              message: "Configuration saved successfully",
              totalRoutes: Object.keys(MOCK_ROUTES).length,
            }),
          );
        })
        .catch((error) => {
          clientRes.writeHead(400, { "Content-Type": "application/json" });
          clientRes.end(
            JSON.stringify({
              success: false,
              error: (error as Error).message,
            }),
          );
        });
      return;
    }

    try {
      clientRes.writeHead(200, { "Content-Type": "application/json" });
      clientRes.end(
        JSON.stringify(
          {
            routes: RAW_ROUTES,
            routeStatuses: RAW_ROUTE_STATUSES,
            config: CONFIG,
            timestamp: new Date().toISOString(),
            totalRoutes: Object.keys(MOCK_ROUTES).length,
          },
          null,
          2,
        ),
      );
    } catch (error) {
      clientRes.writeHead(500, { "Content-Type": "application/json" });
      clientRes.end(
        JSON.stringify({
          success: false,
          error: (error as Error).message,
        }),
      );
    }
    return;
  }

  if (requestPath === "/__routes") {
    if (clientReq.method !== "POST") {
      clientRes.writeHead(405, {
        "Content-Type": "application/json",
        Allow: "POST",
      });
      clientRes.end(
        JSON.stringify({
          success: false,
          error: "Method Not Allowed",
          allow: ["POST"],
        }),
      );
      return;
    }

    readBody(clientReq)
      .then(async (bodyText) => {
        const body = bodyText ? JSON.parse(bodyText) : {};
        let route = String(body.route || "").trim();
        const filePath = String(body.filePath || "").trim();
        const fileContent = String(body.fileContent || "");
        const overwrite = body.overwrite === true;
        const template = String(body.template || "").trim();
        const apiName = String(body.apiName || "").trim();
        const selectedApiRoute = String(body.selectedApiRoute || "").trim();
        const originalRoute = String(body.originalRoute || "").trim();
        const originalRawRoute = String(body.originalRawRoute || "").trim();
        const statusCode = normalizeStatusCode(body.statusCode, 200);
        const enabled = body.enabled !== false;
        const useExistingFile =
          body.useExistingFile === true || template === "basicError";
        const apiList = await loadApiList();
        const selectedApi = selectedApiRoute
          ? apiList.find((item) => item.route === selectedApiRoute)
          : undefined;
        const originalApi = originalRoute
          ? apiList.find((item) => item.route === originalRoute)
          : undefined;

        // 来自 api-list 的接口路由不可在新增/修改时变更
        if (selectedApi) {
          if (route && route !== selectedApi.route) {
            throw new Error("api-list route cannot be changed");
          }
          if (apiName && apiName !== selectedApi.name) {
            throw new Error("api-list name cannot be changed");
          }
          route = selectedApi.route;
        }
        if (originalApi && route !== originalApi.route) {
          throw new Error("api-list route cannot be changed");
        }
        if (originalApi && apiName && apiName !== originalApi.name) {
          throw new Error("api-list name cannot be changed");
        }

        if (!route.startsWith("/")) {
          throw new Error("route must start with '/'");
        }
        const normalizedFilePath = normalizeMockFilePath(filePath);
        const fullPath = resolveMockFullPath(normalizedFilePath);
        if (useExistingFile) {
          if (!fs.existsSync(fullPath)) {
            throw new Error("mock file does not exist");
          }
        } else {
          if (!overwrite && fs.existsSync(fullPath)) {
            throw new Error(
              "mock file already exists, set overwrite=true to replace",
            );
          }
          fs.mkdirSync(path.dirname(fullPath), { recursive: true });
          fs.writeFileSync(fullPath, fileContent, "utf-8");
        }

        const nextConfig = buildCurrentConfigFile();
        const nextRouteKey = enabled ? route : `#${route}`;
        const oldRouteCandidates = new Set<string>();
        if (originalRawRoute) {
          oldRouteCandidates.add(originalRawRoute);
        }
        if (originalRoute) {
          oldRouteCandidates.add(originalRoute);
          oldRouteCandidates.add(`#${originalRoute}`);
        }
        oldRouteCandidates.forEach((key) => {
          if (key && key !== nextRouteKey) {
            delete nextConfig.routes[key];
            delete nextConfig.routeStatuses?.[key];
          }
        });
        nextConfig.routes[nextRouteKey] = normalizedFilePath;
        if (!nextConfig.routeStatuses) {
          nextConfig.routeStatuses = {};
        }
        nextConfig.routeStatuses[nextRouteKey] = statusCode;
        await saveConfigFile(nextConfig);
        await upsertMockFilePathToDb(normalizedFilePath);

        clientRes.writeHead(200, { "Content-Type": "application/json" });
        clientRes.end(
          JSON.stringify({
            success: true,
            message: "Route and mock file created successfully",
            route,
            routeKey: nextRouteKey,
            filePath: normalizedFilePath,
            statusCode,
            enabled,
          }),
        );
      })
      .catch((error) => {
        clientRes.writeHead(400, { "Content-Type": "application/json" });
        clientRes.end(
          JSON.stringify({
            success: false,
            error: (error as Error).message,
          }),
        );
      });
    return;
  }

  if (requestPath === "/__api-list") {
    if (clientReq.method !== "GET") {
      clientRes.writeHead(405, {
        "Content-Type": "application/json",
        Allow: "GET",
      });
      clientRes.end(
        JSON.stringify({
          success: false,
          error: "Method Not Allowed",
          allow: ["GET"],
        }),
      );
      return;
    }
    clientRes.writeHead(200, { "Content-Type": "application/json" });
    clientRes.end(
      JSON.stringify({
        success: true,
        list: await loadApiList(),
      }),
    );
    return;
  }

  if (requestPath === "/__mock-files") {
    if (
      clientReq.method !== "GET" &&
      clientReq.method !== "POST" &&
      clientReq.method !== "DELETE"
    ) {
      clientRes.writeHead(405, {
        "Content-Type": "application/json",
        Allow: "GET, POST, DELETE",
      });
      clientRes.end(
        JSON.stringify({
          success: false,
          error: "Method Not Allowed",
          allow: ["GET", "POST", "DELETE"],
        }),
      );
      return;
    }

    if (clientReq.method === "GET") {
      clientRes.writeHead(200, { "Content-Type": "application/json" });
      clientRes.end(
        JSON.stringify({
          success: true,
          list: await loadMockFiles(),
        }),
      );
      return;
    }

    readBody(clientReq)
      .then(async (bodyText) => {
        const body = bodyText ? JSON.parse(bodyText) : {};
        const filePath = String(body.filePath || "").trim();
        const alias = String(body.alias || "");
        const fullPath = resolveMockFullPath(filePath);
        const normalizedPath = normalizeMockFilePath(filePath);

        if (clientReq.method === "POST") {
          const content = String(body.content || "");
          fs.mkdirSync(path.dirname(fullPath), { recursive: true });
          fs.writeFileSync(fullPath, content, "utf-8");
          await upsertMockFilePathToDb(normalizedPath, alias);
          clientRes.writeHead(200, { "Content-Type": "application/json" });
          clientRes.end(
            JSON.stringify({
              success: true,
              filePath: normalizedPath,
              alias,
            }),
          );
          return;
        }

        // DELETE
        if (!fs.existsSync(fullPath)) {
          throw new Error("mock file does not exist");
        }
        fs.unlinkSync(fullPath);
        await removeMockFilePathFromDb(normalizedPath);
        clientRes.writeHead(200, { "Content-Type": "application/json" });
        clientRes.end(
          JSON.stringify({
            success: true,
            filePath: normalizedPath,
          }),
        );
      })
      .catch((error) => {
        clientRes.writeHead(400, { "Content-Type": "application/json" });
        clientRes.end(
          JSON.stringify({
            success: false,
            error: (error as Error).message,
          }),
        );
      });
    return;
  }

  if (requestPath === "/__admin") {
    if (clientReq.method !== "GET") {
      clientRes.writeHead(405, { "Content-Type": "text/plain; charset=utf-8" });
      clientRes.end("Method Not Allowed");
      return;
    }
    const adminHtmlPath = path.join(__dirname, "admin.html");
    if (!fs.existsSync(adminHtmlPath)) {
      clientRes.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
      clientRes.end("admin.html not found");
      return;
    }
    const html = fs.readFileSync(adminHtmlPath, "utf-8");
    clientRes.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
    clientRes.end(html);
    return;
  }

  // 检查是否为需要mock的路由
  if (isMockRoute(requestPath)) {
    const mockFile = getMockFilePath(requestPath);
    const mockStatusCode = getMockStatusCode(requestPath);
    console.log(`[MOCK] 拦截路由: ${requestPath} -> 使用文件: ${mockFile}`);

    try {
      // 构建完整的文件路径
      const mockFilePath = path.join(__dirname, mockFile);

      // 检查文件是否存在
      if (!fs.existsSync(mockFilePath)) {
        console.warn(`[MOCK] Mock文件不存在，回源并自动生成: ${mockFilePath}`);

        const targetPort = getTargetPort();
        const options: http.RequestOptions = {
          hostname: CONFIG.targetHost,
          port: targetPort,
          method: clientReq.method,
          path: parsedUrl.pathname + parsedUrl.search,
          headers: {
            ...clientReq.headers,
            host: CONFIG.targetHost,
          },
        };

        const proxyReq = upstreamRequest(options, (proxyRes) => {
          const chunks: Buffer[] = [];
          proxyRes.on("data", (chunk: Buffer) => {
            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
          });

          proxyRes.on("end", () => {
            const bodyBuffer = Buffer.concat(chunks);

            try {
              const decodedBuffer = decodeBodyByEncoding(
                bodyBuffer,
                Array.isArray(proxyRes.headers["content-encoding"])
                  ? proxyRes.headers["content-encoding"][0]
                  : proxyRes.headers["content-encoding"],
              );
              const contentType = String(proxyRes.headers["content-type"] || "");
              const toWrite =
                contentType.includes("application/json") ||
                contentType.includes("text/") ||
                contentType.includes("application/xml") ||
                contentType.includes("application/javascript")
                  ? decodedBuffer.toString("utf-8")
                  : decodedBuffer;
              fs.mkdirSync(path.dirname(mockFilePath), { recursive: true });
              fs.writeFileSync(mockFilePath, toWrite);
              console.log(`[MOCK] 已自动写入mock文件: ${mockFilePath}`);
            } catch (writeErr) {
              console.error(`[MOCK] 自动写入mock文件失败: ${mockFilePath}`, writeErr);
            }

            clientRes.writeHead(mockStatusCode, {
              ...proxyRes.headers,
              "X-Mock-Autogenerated": "true",
              "X-Mock-Source": mockFile,
              "X-Mock-Status-Code": String(mockStatusCode),
            });
            clientRes.end(bodyBuffer);
          });
        });

        proxyReq.on("error", (err) => {
          console.error("Proxy request error:", err);
          clientRes.writeHead(500, { "Content-Type": "application/json" });
          clientRes.end(
            JSON.stringify({
              error: "Proxy error",
              route: requestPath,
              file: mockFile,
              message: err.message,
              timestamp: new Date().toISOString(),
            }),
          );
        });

        clientReq.pipe(proxyReq);
        return;
      }

      // 读取本地mock文件
      const mockData = fs.readFileSync(mockFilePath, "utf-8");

      // 设置响应头
      const contentType = CONFIG.defaultContentType || "application/json";
      clientRes.writeHead(mockStatusCode, {
        "Content-Type": contentType,
        "Access-Control-Allow-Origin": "*",
        "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
        "Access-Control-Allow-Headers": "Content-Type",
        "X-Mock-Source": mockFile,
        "X-Mock-Status-Code": String(mockStatusCode),
        "X-Mock-Timestamp": new Date().toISOString(),
      });

      // 返回mock数据
      clientRes.end(mockData);
      console.log(`[MOCK] 成功返回mock数据: ${mockFile}`);
    } catch (error) {
      console.error(`[MOCK] 读取mock文件失败: ${mockFile}`, error);
      clientRes.writeHead(500, { "Content-Type": "application/json" });
      clientRes.end(
        JSON.stringify({
          error: "Failed to read mock data",
          route: requestPath,
          file: mockFile,
          message: (error as Error).message,
          timestamp: new Date().toISOString(),
        }),
      );
    }
    return; // 直接返回，不转发到目标服务器
  }

  // 如果不是mock路由，正常代理转发
  console.log(`[PROXY] 转发请求: ${requestPath}`);

  const targetPort = getTargetPort();

  // 目标服务器的选项
  const options: http.RequestOptions = {
    hostname: CONFIG.targetHost,
    port: targetPort,
    method: clientReq.method,
    path: parsedUrl.pathname + parsedUrl.search,
    headers: {
      ...clientReq.headers,
      host: CONFIG.targetHost,
    },
  };

  const proxyReq = upstreamRequest(options, (proxyRes) => {
    // 将目标服务器的响应头复制到客户端响应
    clientRes.writeHead(proxyRes.statusCode!, proxyRes.headers);
    // 将目标服务器的响应数据管道传输到客户端
    proxyRes.pipe(clientRes);
  });

  // 错误处理
  proxyReq.on("error", (err) => {
    console.error("Proxy request error:", err);
    clientRes.writeHead(500, { "Content-Type": "application/json" });
    clientRes.end(
      JSON.stringify({
        error: "Proxy error",
        message: err.message,
        timestamp: new Date().toISOString(),
      }),
    );
  });

  // 将客户端请求体管道传输到代理请求
  clientReq.pipe(proxyReq);
});

function setupConfigWatcher(): void {
  if (!CONFIG.reloadOnChange) return;
  fs.watchFile(CONFIG_FILE, async () => {
    console.log(`[CONFIG] 配置文件已修改，重新加载...`);
    try {
      const oldRoutesCount = Object.keys(MOCK_ROUTES).length;
      await loadConfig();
      const newRoutesCount = Object.keys(MOCK_ROUTES).length;
      console.log(
        `[CONFIG] 配置重载完成 (路由数: ${oldRoutesCount} -> ${newRoutesCount})`,
      );
    } catch (error) {
      console.error(`[CONFIG] 重新加载配置文件失败:`, error);
    }
  });
  console.log(`[CONFIG] 已启用配置文件监视: ${CONFIG_FILE}`);
}

function startServer(): void {
  proxyServer.listen(CONFIG.proxyPort, "0.0.0.0", () => {
  const targetPort = getTargetPort();
  const proto = isTargetHttps() ? "https" : "http";
  const defaultPort = isTargetHttps() ? 443 : 80;
  console.log(`========================================`);
  console.log(`代理服务器运行在: http://localhost:${CONFIG.proxyPort}`);
  console.log(
    `目标服务器: ${proto}://${CONFIG.targetHost}${targetPort !== defaultPort ? `:${targetPort}` : ""}`,
  );
  console.log(`配置文件: ${CONFIG_FILE}`);
  console.log(
    `已配置Mock路由: ${Object.keys(MOCK_ROUTES).length} 个${CONFIG.mockEnabled !== false ? "" : "（当前 mockEnabled=false，未生效）"}`,
  );
  console.log(`========================================`);
  console.log(`管理接口:`);
  console.log(
    `  GET http://localhost:${CONFIG.proxyPort}/__config    查看当前配置`,
  );
  console.log(
    `  POST http://localhost:${CONFIG.proxyPort}/__reload-config 重新加载配置`,
  );
  console.log(`========================================`);
  console.log(`Mock路由列表:`);

  for (const [route, file] of Object.entries(MOCK_ROUTES)) {
    const filePath = path.join(__dirname, file);
    const exists = fs.existsSync(filePath) ? "✓" : "✗";
    console.log(`  ${exists} ${route} -> ${file}`);
  }
  console.log(`========================================`);
  });
}

async function bootstrap(): Promise<void> {
  await initDatabase();
  await initMockFilesFromFsIfNeeded();
  await loadConfig();
  const apiListFromDb = await loadApiListFromDb();
  if (apiListFromDb.length === 0) {
    await upsertApiListToDb(loadApiListFromJson());
  }
  setupConfigWatcher();
  startServer();
}

bootstrap().catch((error) => {
  console.error("[BOOTSTRAP] 启动失败:", error);
  process.exit(1);
});