import {
  app,
  BrowserWindow,
  dialog,
  ipcMain,
  Menu,
  nativeImage,
  shell,
  Tray,
  nativeTheme,
  session,
} from "electron";
import { fileURLToPath } from "node:url";
import path from "node:path";
import os from "node:os";
import fs from "node:fs";
import pino from "pino";
import https from "node:https";
import { handleCommandLine } from "./deeplink.js";
import { isLoaded } from "../global.js";
import { tasks } from "./backend/install-manager.js";
import { sendTelemetryOnce } from "./backend/telemetry.js";
import { initializeUpdateCenter } from "./backend/update-center/index.js";
import {
  getMainWindowCloseAction,
  type MainWindowCloseGuardState,
} from "./window-close-guard.js";

const __dirname = path.dirname(fileURLToPath(import.meta.url));
process.env.APP_ROOT = path.join(__dirname, "../..");

/** 与项目 package.json 一致的版本号：打包用 app.getVersion()，未打包时读 package.json */
function getAppVersion(): string {
  if (app.isPackaged) return app.getVersion();
  const pkgPath = path.join(process.env.APP_ROOT ?? __dirname, "package.json");
  try {
    const raw = fs.readFileSync(pkgPath, "utf8");
    const pkg = JSON.parse(raw) as { version?: string };
    return typeof pkg.version === "string" ? pkg.version : "dev";
  } catch {
    return "dev";
  }
}

function getSystemInfo(): { distro: string } {
  try {
    const raw = fs.readFileSync("/etc/os-release", "utf8");
    const fields = Object.fromEntries(
      raw
        .split("\n")
        .map((line) => line.match(/^([A-Z_]+)=(.*)$/))
        .filter((match): match is RegExpMatchArray => match !== null)
        .map((match) => [match[1], match[2].replace(/^"|"$/g, "")]),
    );
    const distro = fields.PRETTY_NAME || fields.NAME || "unknown";
    return { distro };
  } catch {
    return { distro: "unknown" };
  }
}

// 处理 --version 参数（在单实例检查之前）
if (process.argv.includes("--version") || process.argv.includes("-v")) {
  console.log(getAppVersion());
  process.exit(0);
}

// Assure single instance application
if (!app.requestSingleInstanceLock()) {
  app.exit(0);
}

import "./backend/install-manager.js";
import "./handle-url-scheme.js";

const logger = pino({ name: "index.ts" });
const FLARUM_TOKEN_URL = "https://bbs.spark-app.store/api/token";

// The built directory structure
//
// ├─┬ dist-electron
// │ ├─┬ main
// │ │ └── index.js    > Electron-Main
// │ └─┬ preload
// │   └── index.mjs   > Preload-Scripts
// ├─┬ dist
// │ └── index.html    > Electron-Renderer
//
export const MAIN_DIST = path.join(process.env.APP_ROOT, "dist-electron");
export const RENDERER_DIST = path.join(process.env.APP_ROOT, "dist");
export const VITE_DEV_SERVER_URL = process.env.VITE_DEV_SERVER_URL;

process.env.VITE_PUBLIC = VITE_DEV_SERVER_URL
  ? path.join(process.env.APP_ROOT, "public")
  : RENDERER_DIST;

// Disable GPU Acceleration for Windows 7
if (os.release().startsWith("6.1")) app.disableHardwareAcceleration();

// Set application name for Windows 10+ notifications
if (process.platform === "win32") app.setAppUserModelId(app.getName());

if (!app.requestSingleInstanceLock()) {
  app.quit();
  process.exit(0);
}

let win: BrowserWindow | null = null;
let submitterWin: BrowserWindow | null = null;
let allowAppExit = false;
const preload = path.join(__dirname, "../preload/index.mjs");
const indexHtml = path.join(RENDERER_DIST, "index.html");

const getUserAgent = (): string => {
  return `Spark-Store/${getAppVersion()}`;
};

logger.info("User Agent: " + getUserAgent());

/** 根据启动参数 --no-apm / --no-spark 决定只展示的来源 */
function getStoreFilterFromArgv(): "spark" | "apm" | "both" {
  if (process.arch === "loong64") {
    // Currently loong64 only have spark support
    return "spark";
  } else {
    const argv = process.argv;
    const noApm = argv.includes("--no-apm");
    const noSpark = argv.includes("--no-spark");
    if (noApm && noSpark) return "both";
    if (noApm) return "spark";
    if (noSpark) return "apm";
    return "both";
  }
}

ipcMain.handle("get-store-filter", (): "spark" | "apm" | "both" =>
  getStoreFilterFromArgv(),
);

ipcMain.handle("get-app-version", (): string => getAppVersion());
ipcMain.handle("get-system-info", (): { distro: string } => getSystemInfo());

ipcMain.handle("request-flarum-token", async (_event, payload: unknown) => {
  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
    throw new Error("登录信息格式不正确，请重新输入。");
  }

  const credentials = payload as Record<string, unknown>;
  if (
    typeof credentials.identification !== "string" ||
    typeof credentials.password !== "string"
  ) {
    throw new Error("登录信息格式不正确，请重新输入。");
  }

  logger.info({ endpoint: FLARUM_TOKEN_URL }, "Requesting Flarum login token");

  let response: Response;
  try {
    response = await fetch(FLARUM_TOKEN_URL, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Accept: "application/json",
        "User-Agent": getUserAgent(),
      },
      body: JSON.stringify({
        identification: credentials.identification,
        password: credentials.password,
      }),
    });
  } catch (err) {
    logger.error(
      { err, endpoint: FLARUM_TOKEN_URL },
      "Flarum token request failed before response",
    );
    throw new Error("无法连接星火论坛，请检查网络后重试。");
  }

  if (!response.ok) {
    logger.warn(
      { endpoint: FLARUM_TOKEN_URL, status: response.status },
      "Flarum rejected login token request",
    );
    throw new Error("论坛登录失败，请检查账号和密码。");
  }

  const data = (await response.json()) as Record<string, unknown>;
  const userId = data.userId ?? data.user_id;
  if (
    typeof data.token !== "string" ||
    userId === undefined ||
    userId === null
  ) {
    logger.warn(
      {
        endpoint: FLARUM_TOKEN_URL,
        hasToken: typeof data.token === "string" && data.token.length > 0,
        hasUserId: userId !== undefined && userId !== null,
      },
      "Flarum token response missing required fields",
    );
    throw new Error("论坛登录响应异常，请稍后重试。");
  }

  return {
    token: data.token,
    userId: String(userId),
  };
});

const getMainWindowCloseGuardState = (): MainWindowCloseGuardState => ({
  installTaskCount: tasks.size,
  hasRunningUpdateCenterTasks:
    initializeUpdateCenter().getState().hasRunningTasks,
});

const applyMainWindowCloseAction = (): void => {
  if (!win) {
    return;
  }

  const action = getMainWindowCloseAction(getMainWindowCloseGuardState());
  if (action === "hide") {
    win.hide();
    win.setSkipTaskbar(true);
    return;
  }

  win.destroy();
};

const requestApplicationExit = (): void => {
  if (!win) {
    allowAppExit = true;
    app.quit();
    return;
  }

  if (getMainWindowCloseAction(getMainWindowCloseGuardState()) === "hide") {
    win.hide();
    win.setSkipTaskbar(true);
    return;
  }

  allowAppExit = true;
  app.quit();
};

async function createWindow() {
  win = new BrowserWindow({
    title: "星火应用商店",
    width: 1366,
    height: 768,
    frame: false,
    autoHideMenuBar: true,
    icon: path.join(process.env.VITE_PUBLIC, "favicon.ico"),
    webPreferences: {
      preload,
      // Warning: Enable nodeIntegration and disable contextIsolation is not secure in production
      // nodeIntegration: true,

      // Consider using contextBridge.exposeInMainWorld
      // Read more on https://www.electronjs.org/docs/latest/tutorial/context-isolation
      // contextIsolation: false,
    },
  });

  if (VITE_DEV_SERVER_URL) {
    // #298
    win.loadURL(VITE_DEV_SERVER_URL);
    // Open devTool if the app is not packaged
    win.webContents.openDevTools({ mode: "detach" });
  } else {
    win.loadFile(indexHtml);
  }

  // Test actively push message to the Electron-Renderer
  win.webContents.on("did-finish-load", () => {
    win?.webContents.send("main-process-message", new Date().toLocaleString());
    logger.info("Renderer process is ready.");
  });

  // Make all links open with the browser, not with the application
  win.webContents.setWindowOpenHandler(({ url }) => {
    if (url.startsWith("https:")) shell.openExternal(url);
    return { action: "deny" };
  });
  // win.webContents.on('will-navigate', (event, url) => { }) #344

  win.on("close", (event) => {
    if (allowAppExit) {
      return;
    }

    // 截获 close 默认行为
    event.preventDefault();
    applyMainWindowCloseAction();
  });
}

ipcMain.on("renderer-ready", (event, args) => {
  logger.info(
    "Received renderer-ready event with args: " + JSON.stringify(args),
  );
  isLoaded.value = args.status;
  logger.info(`isLoaded set to: ${isLoaded.value}`);
});

ipcMain.on("set-theme-source", (event, theme: "system" | "light" | "dark") => {
  nativeTheme.themeSource = theme;
});

ipcMain.on("window-control-minimize", () => {
  win?.minimize();
});

ipcMain.on("window-control-toggle-maximize", () => {
  if (!win) {
    return;
  }

  if (win.isMaximized()) {
    win.unmaximize();
    return;
  }

  win.maximize();
});

ipcMain.on("window-control-close", () => {
  win?.close();
});

// 配置文件路径
const SPARK_CONFIG_DIR = path.join(
  os.homedir(),
  ".config/spark-union/spark-store",
);
const UPDATE_CHECK_CONFIG = "ssshell-config-do-not-show-upgrade-notify";
const CREATE_DESKTOP_CONFIG = "ssshell-config-do-not-create-desktop";

// 获取安装设置
ipcMain.handle("get-install-settings", async () => {
  try {
    const result: Record<string, boolean> = {};

    // 检查更新检测配置
    result[UPDATE_CHECK_CONFIG] = fs.existsSync(
      path.join(SPARK_CONFIG_DIR, UPDATE_CHECK_CONFIG),
    );

    // 检查自动创建桌面启动器配置
    result[CREATE_DESKTOP_CONFIG] = fs.existsSync(
      path.join(SPARK_CONFIG_DIR, CREATE_DESKTOP_CONFIG),
    );

    return { success: true, data: result };
  } catch (err) {
    logger.error({ err }, "Failed to get install settings");
    return { success: false, message: (err as Error)?.message || String(err) };
  }
});

// 设置安装设置
ipcMain.handle(
  "set-install-settings",
  async (
    _event,
    settings: {
      [UPDATE_CHECK_CONFIG]?: boolean;
      [CREATE_DESKTOP_CONFIG]?: boolean;
    },
  ) => {
    try {
      // 确保配置目录存在
      if (!fs.existsSync(SPARK_CONFIG_DIR)) {
        fs.mkdirSync(SPARK_CONFIG_DIR, { recursive: true });
      }

      // 更新检测配置
      const updateCheckPath = path.join(SPARK_CONFIG_DIR, UPDATE_CHECK_CONFIG);
      if (settings[UPDATE_CHECK_CONFIG]) {
        fs.writeFileSync(updateCheckPath, "");
      } else {
        if (fs.existsSync(updateCheckPath)) {
          fs.unlinkSync(updateCheckPath);
        }
      }

      // 自动创建桌面启动器配置
      const createDesktopPath = path.join(
        SPARK_CONFIG_DIR,
        CREATE_DESKTOP_CONFIG,
      );
      if (settings[CREATE_DESKTOP_CONFIG]) {
        fs.writeFileSync(createDesktopPath, "");
      } else {
        if (fs.existsSync(createDesktopPath)) {
          fs.unlinkSync(createDesktopPath);
        }
      }

      return { success: true };
    } catch (err) {
      logger.error({ err }, "Failed to set install settings");
      return {
        success: false,
        message: (err as Error)?.message || String(err),
      };
    }
  },
);

// 检查更新
ipcMain.handle("check-for-updates", async () => {
  try {
    const { spawn } = await import("node:child_process");
    const scriptPath =
      "/opt/durapps/spark-store/bin/update-upgrade/ss-do-upgrade.sh";
    const child = spawn("systemd-run", ["--user", scriptPath], {
      detached: true,
      stdio: "ignore",
    });
    child.unref();
    logger.info(`Launched update check script: ${scriptPath}`);
    return { success: true };
  } catch (err) {
    logger.error({ err }, "Failed to launch update check script");
    return { success: false, message: (err as Error)?.message || String(err) };
  }
});

// 启动投稿器窗口
ipcMain.handle("launch-submitter", async () => {
  try {
    if (submitterWin && !submitterWin.isDestroyed()) {
      submitterWin.show();
      submitterWin.focus();
      return { success: true };
    }

    submitterWin = new BrowserWindow({
      title: "星火应用商店 - 投稿应用",
      width: 800,
      height: 900,
      frame: false,
      autoHideMenuBar: true,
      icon: path.join(process.env.VITE_PUBLIC, "favicon.ico"),
      webPreferences: {
        preload,
      },
    });

    if (VITE_DEV_SERVER_URL) {
      submitterWin.loadURL(`${VITE_DEV_SERVER_URL}#submitter`);
    } else {
      submitterWin.loadFile(indexHtml, { hash: "submitter" });
    }

    submitterWin.on("closed", () => {
      submitterWin = null;
    });

    submitterWin.webContents.setWindowOpenHandler(({ url }) => {
      if (url.startsWith("https:")) shell.openExternal(url);
      return { action: "deny" };
    });

    logger.info("Submitter window opened");
    return { success: true };
  } catch (err) {
    logger.error({ err }, "Failed to open submitter window");
    return { success: false, message: (err as Error)?.message || String(err) };
  }
});

ipcMain.on("close-submitter-window", () => {
  submitterWin?.close();
});

interface DebInfo {
  pkgname: string;
  version: string;
  author: string;
  maintainer: string;
  homepage: string;
  description: string;
  architecture: string;
}

interface HistoryAppInfo {
  id: number;
  name: string;
  pkgname: string;
  version: string;
  store: string;
  author: string;
  contributor: string;
  website: string;
  category: string;
  tags: string;
  more: string;
  icon: string;
  imgs: string[];
}

ipcMain.handle("select-deb-file", async (_event) => {
  try {
    const result = await dialog.showOpenDialog({
      title: "选择 deb 安装包",
      filters: [{ name: "Debian 包", extensions: ["deb"] }],
      properties: ["openFile"],
    });

    if (!result.canceled && result.filePaths.length > 0) {
      return { success: true, filePath: result.filePaths[0] };
    }

    return { success: false, message: "用户取消选择" };
  } catch (err) {
    logger.error({ err }, "Failed to select deb file");
    return {
      success: false,
      message: (err as Error)?.message || "选择文件失败",
    };
  }
});

ipcMain.handle("parse-deb-file", async (_event, debPath: string) => {
  try {
    logger.info({ debPath }, "[Submitter] Starting parse-deb-file handler");

    const { exec } = await import("node:child_process");
    const util = await import("util");
    const execAsync = util.promisify(exec);

    const absoluteDebPath = path.resolve(debPath);
    logger.info(
      { debPath, absoluteDebPath },
      "[Submitter] Resolved absolute deb path",
    );

    if (!fs.existsSync(absoluteDebPath)) {
      logger.error(
        { debPath, absoluteDebPath },
        "[Submitter] Deb file not found",
      );
      return { success: false, message: `文件不存在: ${absoluteDebPath}` };
    }

    logger.info(
      { absoluteDebPath },
      "[Submitter] Deb file exists, executing dpkg-deb command",
    );

    const { stdout, stderr } = await execAsync(
      `dpkg-deb -f "${absoluteDebPath}" Package Version Maintainer Homepage Description Architecture`,
    );

    logger.info({ stdout, stderr }, "[Submitter] dpkg-deb command executed");

    if (stderr) {
      logger.error({ stderr }, "[Submitter] dpkg-deb returned error");
      return { success: false, message: stderr };
    }

    const lines = stdout.trim().split("\n");
    logger.info(
      { lineCount: lines.length, rawOutput: stdout },
      "[Submitter] Parsing dpkg-deb output",
    );

    const debInfo: DebInfo = {
      pkgname: "",
      version: "",
      author: "",
      maintainer: "",
      homepage: "",
      description: "",
      architecture: "",
    };

    for (const line of lines) {
      const [key, ...valueParts] = line.split(":");
      const value = valueParts.join(":").trim();
      logger.debug(
        { line, key, value },
        "[Submitter] Processing dpkg-deb line",
      );

      switch (key.trim()) {
        case "Package":
          debInfo.pkgname = value.toLowerCase();
          logger.info(
            { pkgname: debInfo.pkgname },
            "[Submitter] Found Package name",
          );
          break;
        case "Version":
          debInfo.version = value;
          logger.info(
            { version: debInfo.version },
            "[Submitter] Found Version",
          );
          break;
        case "Maintainer":
          debInfo.maintainer = value;
          debInfo.author = value;
          logger.info(
            { maintainer: debInfo.maintainer },
            "[Submitter] Found Maintainer",
          );
          break;
        case "Homepage":
          debInfo.homepage = value;
          logger.info(
            { homepage: debInfo.homepage },
            "[Submitter] Found Homepage",
          );
          break;
        case "Description":
          debInfo.description = value;
          logger.info(
            { description: debInfo.description.substring(0, 100) + "..." },
            "[Submitter] Found Description",
          );
          break;
        case "Architecture":
          debInfo.architecture = value;
          logger.info(
            { architecture: debInfo.architecture },
            "[Submitter] Found Architecture",
          );
          break;
      }
    }

    logger.info(
      { debInfo },
      "[Submitter] Deb file parsing completed successfully",
    );

    return { success: true, data: debInfo };
  } catch (err) {
    logger.error(
      { err, debPath },
      "[Submitter] Failed to parse deb file with exception",
    );
    return {
      success: false,
      message: (err as Error)?.message || "解析deb文件失败",
    };
  }
});

ipcMain.handle(
  "search-history-app",
  async (_event, pkgname: string, useMirror = false) => {
    try {
      const baseUrl = useMirror
        ? "https://mirrors.sdu.edu.cn/spark-store"
        : "https://spk-json.spark-app.store";
      const storeArchs = ["store", "aarch64-store", "loong64-store"];
      const categories = [
        "chat",
        "development",
        "games",
        "image_graphics",
        "music",
        "network",
        "office",
        "others",
        "reading",
        "themes",
        "tools",
        "video",
      ];
      const results: HistoryAppInfo[] = [];

      logger.info(
        "[Submitter] ============== SEARCH HISTORY APP START ==============",
      );
      logger.info(
        { pkgname, useMirror, baseUrl, storeArchs, categories },
        "[Submitter] Search parameters",
      );

      const allPromises: Promise<void>[] = [];

      for (const arch of storeArchs) {
        for (const category of categories) {
          const url = `${baseUrl}/${arch}/${category}/${pkgname}/app.json`;
          logger.info(
            { arch, category, url },
            "[Submitter] Starting search request",
          );

          const promise = fetch(url, {
            headers: { "User-Agent": getUserAgent() },
          })
            .then(async (response) => {
              logger.info(
                { arch, category, status: response.status },
                "[Submitter] Fetch completed",
              );

              if (response.ok) {
                const json = await response.json();
                logger.info(
                  { arch, category, rawJson: JSON.stringify(json, null, 2) },
                  "[Submitter] Response parsed",
                );

                const appPkgname =
                  json?.pkgname || json?.Pkgname || json?.packageName || "";
                logger.info(
                  { arch, category, appPkgname, searchPkgname: pkgname },
                  "[Submitter] Comparing pkgname",
                );

                if (appPkgname.toLowerCase() === pkgname.toLowerCase()) {
                  logger.info(
                    { arch, category, item: json },
                    "[Submitter] Found matching item",
                  );

                  let iconUrl = json.icons || json.icon || "";
                  let imgs = json.imgUrls || json.imgs || json.img_urls || [];

                  if (typeof imgs === "string") {
                    try {
                      imgs = JSON.parse(imgs);
                      logger.info(
                        {
                          arch,
                          category,
                          parsedImgsCount: Array.isArray(imgs)
                            ? imgs.length
                            : 0,
                        },
                        "[Submitter] Parsed img_urls from string",
                      );
                    } catch {
                      imgs = [];
                      logger.warn(
                        { arch, category, imgsString: imgs },
                        "[Submitter] Failed to parse img_urls string",
                      );
                    }
                  }

                  if (iconUrl && typeof iconUrl === "string") {
                    if (useMirror) {
                      iconUrl = iconUrl.replace(
                        "spk-json.spark-app.store",
                        "mirrors.sdu.edu.cn/spark-store",
                      );
                    }
                  }

                  if (Array.isArray(imgs)) {
                    imgs = imgs.map((img: string) => {
                      if (useMirror && typeof img === "string") {
                        return img.replace(
                          "spk-json.spark-app.store",
                          "mirrors.sdu.edu.cn/spark-store",
                        );
                      }
                      return img;
                    });
                  }

                  results.push({
                    id: json.id || json.Id || 0,
                    name: json.name || json.Name || "",
                    pkgname: json.pkgname || json.Pkgname || "",
                    version: json.version || json.Version || "",
                    store: arch,
                    author: json.author || json.Author || "",
                    contributor: json.contributor || json.Contributor || "",
                    website: json.website || json.Website || "",
                    category: category,
                    tags: json.tags || json.Tags || "",
                    more: json.more || json.More || "",
                    icon: iconUrl,
                    imgs: imgs,
                  });

                  logger.info(
                    { arch, count: results.length },
                    "[Submitter] Added to results",
                  );
                }
              }
            })
            .catch((error) => {
              logger.warn(
                { arch, category, error },
                "[Submitter] Request failed or exception caught",
              );
            });

          allPromises.push(promise);
        }
      }

      await Promise.all(allPromises);

      logger.info("[Submitter] ============== SEARCH COMPLETED ==============");
      logger.info(
        { totalResults: results.length, results },
        "[Submitter] Search results",
      );

      return { success: true, data: results };
    } catch (err) {
      logger.error("[Submitter] ============== SEARCH FAILED ==============");
      logger.error(
        {
          errorType: (err as Error)?.name,
          errorMessage: (err as Error)?.message,
          errorStack: (err as Error)?.stack,
        },
        "[Submitter] Exception caught",
      );
      return {
        success: false,
        message: (err as Error)?.message || "搜索历史信息失败",
      };
    }
  },
);

ipcMain.handle("get-category-list", async () => {
  try {
    const apiUrl = "https://upload.deepinos.org.cn/api/index/getTypeList";
    logger.info(
      "[Submitter] ============== GET CATEGORY LIST START ==============",
    );
    logger.info(
      { apiUrl, userAgent: getUserAgent() },
      "[Submitter] Request parameters",
    );

    const startTime = Date.now();
    const response = await fetch(apiUrl, {
      headers: { "User-Agent": getUserAgent() },
    });
    const endTime = Date.now();

    logger.info(
      {
        status: response.status,
        statusText: response.statusText,
        duration: endTime - startTime,
      },
      "[Submitter] Fetch completed",
    );

    if (!response.ok) {
      const errorText = await response.text();
      logger.error(
        { status: response.status, errorBody: errorText },
        "[Submitter] Request failed",
      );
      return {
        success: false,
        message: `获取分类列表失败 (${response.status})`,
      };
    }

    const json = await response.json();
    logger.info(
      {
        code: json?.code,
        msg: json?.msg,
        dataType: typeof json?.data,
        dataLength: json?.data?.length || "N/A",
        response: json,
      },
      "[Submitter] Response parsed",
    );

    return { success: true, data: json };
  } catch (err) {
    logger.error(
      {
        errorType: (err as Error)?.name,
        errorMessage: (err as Error)?.message,
        errorStack: (err as Error)?.stack,
      },
      "[Submitter] Exception caught",
    );
    return {
      success: false,
      message: (err as Error)?.message || "获取分类列表失败",
    };
  }
});

ipcMain.handle("get-tags-list", async () => {
  try {
    const apiUrl = "https://upload.deepinos.org.cn/api/index/getTagsList";
    logger.info(
      "[Submitter] ============== GET TAGS LIST START ==============",
    );
    logger.info(
      { apiUrl, userAgent: getUserAgent() },
      "[Submitter] Request parameters",
    );

    const startTime = Date.now();
    const response = await fetch(apiUrl, {
      headers: { "User-Agent": getUserAgent() },
    });
    const endTime = Date.now();

    logger.info(
      {
        status: response.status,
        statusText: response.statusText,
        duration: endTime - startTime,
      },
      "[Submitter] Fetch completed",
    );

    if (!response.ok) {
      const errorText = await response.text();
      logger.error(
        { status: response.status, errorBody: errorText },
        "[Submitter] Request failed",
      );
      return {
        success: false,
        message: `获取标签列表失败 (${response.status})`,
      };
    }

    const json = await response.json();
    logger.info(
      {
        code: json?.code,
        msg: json?.msg,
        dataType: typeof json?.data,
        dataLength: json?.data?.length || "N/A",
        response: json,
      },
      "[Submitter] Response parsed",
    );

    return { success: true, data: json };
  } catch (err) {
    logger.error(
      {
        errorType: (err as Error)?.name,
        errorMessage: (err as Error)?.message,
        errorStack: (err as Error)?.stack,
      },
      "[Submitter] Exception caught",
    );
    return {
      success: false,
      message: (err as Error)?.message || "获取标签列表失败",
    };
  }
});

interface OssUploadMetadata {
  code: number;
  msg: string;
  data: {
    dir: string;
    host: string;
    ossAccessKeyId: string;
    policy: string;
    signature: string;
  };
}

const categoryNameToIdMap: Record<string, number> = {
  network: 3,
  chat: 9,
  music: 2,
  video: 12,
  image_graphics: 6,
  games: 1,
  office: 4,
  reading: 8,
  development: 7,
  tools: 11,
  themes: 10,
  others: 5,
};

function getCategoryIdByName(categoryName: string): number {
  return categoryNameToIdMap[categoryName];
}

function generateUUID(): string {
  const hexChars = "0123456789abcdef";
  let uuid = "";
  for (let i = 0; i < 32; i++) {
    uuid += hexChars[Math.floor(Math.random() * 16)];
  }
  return uuid;
}

function getUUIDFileNameSuggestIcoPic(filePath: string): string {
  const ext = path.extname(filePath).toLowerCase().replace(".", "");
  const uuid = generateUUID();
  return `${uuid}.${ext}`;
}

function getUUIDFileNameSuggestDeb(_filePath: string): string {
  const uuid = generateUUID();
  return `${uuid}.deb`;
}

async function getOssUploadMetadata(
  type: "icons" | "pic" | "deb",
): Promise<OssUploadMetadata> {
  const startTime = Date.now();
  const pathMap: Record<string, string> = {
    icons: "upload_icons",
    pic: "upload_pic",
    deb: "upload_deb",
  };
  const url = `https://upload.deepinos.org.cn/api/index/${pathMap[type]}`;
  logger.info(
    `[Submitter] ============== GET OSS METADATA START (${type}) ==============`,
  );
  logger.info(
    { url, timestamp: new Date().toISOString() },
    `[Submitter] Getting OSS metadata for ${type}`,
  );

  const response = await fetch(url, {
    method: "GET",
    headers: {
      "User-Agent": getUserAgent(),
    },
  });

  const duration = Date.now() - startTime;
  logger.info(
    { status: response.status, statusText: response.statusText, duration },
    `[Submitter] OSS metadata response for ${type}`,
  );

  if (!response.ok) {
    const errorText = await response.text();
    logger.error(
      { errorText },
      `[Submitter] Failed to get OSS metadata for ${type}`,
    );
    throw new Error(
      `获取 ${type} 上传签名失败: ${response.status} - ${errorText.substring(0, 200)}`,
    );
  }

  const responseText = await response.text();
  logger.info(
    {
      responseTextLength: responseText.length,
      responseText: responseText.substring(0, 1000),
    },
    `[Submitter] Raw OSS metadata response for ${type}`,
  );

  let result: unknown;
  try {
    result = JSON.parse(responseText);
    logger.info(
      {
        resultType: typeof result,
        resultKeys:
          typeof result === "object" && result !== null
            ? Object.keys(result as object)
            : [],
      },
      `[Submitter] Parsed OSS metadata result type for ${type}`,
    );
  } catch (parseError) {
    logger.error(
      { parseError: (parseError as Error)?.message },
      `[Submitter] Failed to parse OSS metadata response for ${type}`,
    );
    throw new Error(
      `解析 ${type} 上传签名响应失败: ${(parseError as Error)?.message}`,
    );
  }

  if (typeof result !== "object" || result === null) {
    logger.error(
      { result },
      `[Submitter] OSS metadata response is not an object for ${type}`,
    );
    throw new Error(`${type} 上传签名响应格式错误`);
  }

  const resultObj = result as Record<string, unknown>;
  if (resultObj.data === undefined || resultObj.data === null) {
    logger.error(
      { result },
      `[Submitter] OSS metadata response data field is undefined for ${type}`,
    );
    throw new Error(`${type} 上传签名响应缺少 data 字段`);
  }

  const dataObj = resultObj.data as Record<string, unknown>;
  if (!dataObj.host || !dataObj.dir) {
    logger.error(
      { data: resultObj.data },
      `[Submitter] OSS metadata response data missing host or dir for ${type}`,
    );
    throw new Error(`${type} 上传签名响应 data 字段缺少 host 或 dir`);
  }

  const ossMetadata: OssUploadMetadata = {
    code: Number(resultObj.code) || 0,
    msg: String(resultObj.msg || ""),
    data: {
      dir: String(dataObj.dir),
      host: String(dataObj.host),
      ossAccessKeyId: String(
        dataObj.OSSAccessKeyId ||
          dataObj.ossAccessKeyId ||
          dataObj.oss_access_key_id ||
          "",
      ),
      policy: String(dataObj.policy || ""),
      signature: String(dataObj.signature || ""),
    },
  };

  logger.info(
    `[Submitter] ============== OSS METADATA RECEIVED (${type}) ==============`,
  );
  logger.info(
    { code: ossMetadata.code, msg: ossMetadata.msg },
    `[Submitter] OSS metadata result for ${type}`,
  );
  logger.info(
    { host: ossMetadata.data.host, dir: ossMetadata.data.dir },
    `[Submitter] OSS upload host and dir for ${type}`,
  );
  logger.info(
    {
      ossAccessKeyIdLength: ossMetadata.data.ossAccessKeyId.length,
      policyLength: ossMetadata.data.policy.length,
      signatureLength: ossMetadata.data.signature.length,
    },
    `[Submitter] OSS credential lengths for ${type}`,
  );

  return ossMetadata;
}

type UploadProgressCallback = (progress: number, fileType: string) => void;

async function uploadFileToOss(
  metadata: OssUploadMetadata,
  filePath: string,
  fileName: string,
  mimeType: string,
  fileType: string,
  progressCallback?: UploadProgressCallback,
): Promise<string> {
  const startTime = Date.now();
  const { host, dir, ossAccessKeyId, policy, signature } = metadata.data;
  const uploadUrl = host;
  const objectKey = `${dir}${fileName}`;

  logger.info(
    `[Submitter] ============== UPLOAD FILE START (${fileType}) ==============`,
  );
  logger.info(
    {
      uploadUrl,
      objectKey,
      filePath,
      fileName,
      mimeType,
      timestamp: new Date().toISOString(),
    },
    `[Submitter] Starting upload for ${fileType}`,
  );

  const fileStat = fs.statSync(filePath);
  const fileSize = fileStat.size;
  logger.info(
    { fileSize, fileSizeHuman: `${(fileSize / 1024 / 1024).toFixed(2)} MB` },
    `[Submitter] File size for ${fileType}`,
  );

  const fileBuffer = fs.readFileSync(filePath);
  logger.info(
    { bufferSize: fileBuffer.length },
    `[Submitter] File buffer ready for ${fileType}`,
  );

  const boundary = `----SparkStoreUploadBoundary${Date.now().toString(36)}`;
  const CRLF = Buffer.from("\r\n", "ascii");

  const encodeField = (str: string) => Buffer.from(str, "utf8");

  const headerBuffers: Buffer[] = [];
  headerBuffers.push(encodeField(`--${boundary}\r\n`));
  headerBuffers.push(
    encodeField(`Content-Disposition: form-data; name="key"\r\n\r\n`),
  );
  headerBuffers.push(encodeField(objectKey));
  headerBuffers.push(CRLF);

  headerBuffers.push(encodeField(`--${boundary}\r\n`));
  headerBuffers.push(
    encodeField(
      `Content-Disposition: form-data; name="ossAccessKeyId"\r\n\r\n`,
    ),
  );
  headerBuffers.push(encodeField(ossAccessKeyId));
  headerBuffers.push(CRLF);

  headerBuffers.push(encodeField(`--${boundary}\r\n`));
  headerBuffers.push(
    encodeField(`Content-Disposition: form-data; name="policy"\r\n\r\n`),
  );
  headerBuffers.push(encodeField(policy));
  headerBuffers.push(CRLF);

  headerBuffers.push(encodeField(`--${boundary}\r\n`));
  headerBuffers.push(
    encodeField(`Content-Disposition: form-data; name="signature"\r\n\r\n`),
  );
  headerBuffers.push(encodeField(signature));
  headerBuffers.push(CRLF);

  headerBuffers.push(encodeField(`--${boundary}\r\n`));
  headerBuffers.push(
    encodeField(
      `Content-Disposition: form-data; name="success_action_status"\r\n\r\n`,
    ),
  );
  headerBuffers.push(encodeField("200"));
  headerBuffers.push(CRLF);

  headerBuffers.push(encodeField(`--${boundary}\r\n`));
  headerBuffers.push(
    encodeField(
      `Content-Disposition: form-data; name="file"; filename="${fileName}"\r\n`,
    ),
  );
  headerBuffers.push(encodeField(`Content-Type: ${mimeType}\r\n\r\n`));

  const formHeaderBuffer = Buffer.concat(headerBuffers);
  const formFooterBuffer = Buffer.concat([
    CRLF,
    encodeField(`--${boundary}--\r\n`),
  ]);
  const totalLength =
    formHeaderBuffer.length + fileBuffer.length + formFooterBuffer.length;

  logger.info(
    {
      formHeaderLength: formHeaderBuffer.length,
      formFooterLength: formFooterBuffer.length,
      totalLength,
      fileSize,
    },
    `[Submitter] Form lengths for ${fileType}`,
  );

  return new Promise((resolve, reject) => {
    const url = new URL(uploadUrl);
    const options: https.RequestOptions = {
      hostname: url.hostname,
      port: url.port ? parseInt(url.port) : 443,
      path: url.pathname + url.search,
      method: "POST",
      headers: {
        "User-Agent": getUserAgent(),
        "Content-Type": `multipart/form-data; boundary=${boundary}`,
        "Content-Length": totalLength,
      },
    };

    logger.info(
      `[Submitter] ============== SENDING UPLOAD REQUEST (${fileType}) ==============`,
    );

    const req = https.request(options, (res) => {
      let responseData = "";
      res.on("data", (chunk) => {
        responseData += chunk;
      });
      res.on("end", () => {
        const duration = Date.now() - startTime;
        logger.info(
          `[Submitter] ============== UPLOAD RESPONSE RECEIVED (${fileType}) ==============`,
        );
        logger.info(
          { status: res.statusCode, duration },
          `[Submitter] Upload response for ${fileType}`,
        );
        logger.info(
          { responseHeaders: res.headers },
          `[Submitter] Response headers for ${fileType}`,
        );
        logger.info(
          { responseBody: responseData.substring(0, 1000) },
          `[Submitter] Response body for ${fileType}`,
        );

        if (res.statusCode !== 200) {
          logger.error(
            { errorText: responseData.substring(0, 500) },
            `[Submitter] Upload failed for ${fileType}`,
          );
          reject(
            new Error(
              `${fileType} 上传失败: ${res.statusCode} - ${responseData.substring(0, 500)}`,
            ),
          );
          return;
        }

        const finalUrl = `${host}${objectKey}`;
        logger.info(
          { finalUrl },
          `[Submitter] ${fileType} upload successful, URL: ${finalUrl}`,
        );
        resolve(finalUrl);
      });
    });

    req.on("error", (err) => {
      logger.error({ err }, `[Submitter] Upload request error for ${fileType}`);
      reject(new Error(`${fileType} 上传失败: ${err.message}`));
    });

    req.write(formHeaderBuffer);

    let uploadedBytes = formHeaderBuffer.length;

    const chunkSize = 1024 * 1024;
    for (let offset = 0; offset < fileBuffer.length; offset += chunkSize) {
      const chunk = fileBuffer.slice(
        offset,
        Math.min(offset + chunkSize, fileBuffer.length),
      );
      req.write(chunk);
      uploadedBytes += chunk.length;

      if (progressCallback) {
        const progress = Math.min((uploadedBytes / totalLength) * 100, 100);
        progressCallback(progress, fileType);
      }
    }

    req.write(formFooterBuffer);
    req.end();
  });
}

ipcMain.handle("submit-app", async (event, formData: unknown) => {
  try {
    const startTime = Date.now();
    logger.info("[Submitter] ============== SUBMIT APP START ==============");
    logger.info(
      { timestamp: new Date().toISOString() },
      "[Submitter] Submission started at",
    );

    if (typeof formData !== "object" || formData === null) {
      logger.error("[Submitter] Form data is not an object");
      return { success: false, message: "表单数据格式错误" };
    }

    const dataObj = formData as Record<string, unknown>;
    logger.info("[Submitter] ============== FORM DATA RECEIVED ==============");
    logger.info({ name: dataObj.name }, "[Submitter] App name");
    logger.info({ pkgname: dataObj.pkgname }, "[Submitter] Package name");
    logger.info({ version: dataObj.version }, "[Submitter] Version");
    logger.info({ author: dataObj.author }, "[Submitter] Author");
    logger.info(
      { contributor: dataObj.contributor },
      "[Submitter] Contributor",
    );
    logger.info({ website: dataObj.website }, "[Submitter] Website");
    logger.info(
      { debFilePath: dataObj.debFilePath },
      "[Submitter] Deb file path",
    );
    logger.info({ iconPath: dataObj.iconPath }, "[Submitter] Icon path");
    logger.info({ category: dataObj.category }, "[Submitter] Category");
    logger.info({ tags: dataObj.tags }, "[Submitter] Tags");
    logger.info(
      {
        descriptionLength:
          typeof dataObj.description === "string"
            ? dataObj.description.length
            : 0,
      },
      "[Submitter] Description length",
    );
    logger.info(
      {
        screenshotsCount: Array.isArray(dataObj.screenshots)
          ? dataObj.screenshots.length
          : 0,
      },
      "[Submitter] Screenshots count",
    );

    const debFilePath = String(dataObj.debFilePath || "");
    const iconPath = String(dataObj.iconPath || "");
    const screenshots = Array.isArray(dataObj.screenshots)
      ? dataObj.screenshots
      : [];

    if (!debFilePath) {
      logger.error("[Submitter] Deb file path is empty");
      return { success: false, message: "请选择 deb 文件" };
    }

    if (!fs.existsSync(debFilePath)) {
      logger.error({ debFilePath }, "[Submitter] Deb file does not exist");
      return { success: false, message: `deb 文件不存在: ${debFilePath}` };
    }

    const sendUploadProgress = (
      step: string,
      progress: number,
      message: string,
    ) => {
      event.sender.send("submit-upload-progress", { step, progress, message });
    };

    let iconUrl = "";
    if (iconPath) {
      logger.info(
        "[Submitter] ============== STEP 1: UPLOAD ICON ==============",
      );
      let iconFilePath = iconPath;

      if (iconPath.startsWith("http://") || iconPath.startsWith("https://")) {
        logger.info(
          { iconPath },
          "[Submitter] Icon is a remote URL, downloading first",
        );
        const tempDir = fs.mkdtempSync(
          path.join(os.tmpdir(), "spark-store-submitter-"),
        );
        iconFilePath = path.join(tempDir, "icon.png");

        try {
          const response = await fetch(iconPath);
          if (!response.ok) {
            throw new Error(`下载图标失败: ${response.status}`);
          }
          const blob = await response.blob();
          const buffer = Buffer.from(await blob.arrayBuffer());
          fs.writeFileSync(iconFilePath, buffer);
          logger.info(
            { iconFilePath, size: buffer.length },
            "[Submitter] Icon downloaded successfully",
          );
        } catch (err) {
          logger.error(
            { err, iconPath },
            "[Submitter] Failed to download icon from URL",
          );
          return {
            success: false,
            message: `下载图标失败: ${(err as Error).message}`,
          };
        }
      }

      if (fs.existsSync(iconFilePath)) {
        const iconMetadata = await getOssUploadMetadata("icons");
        const iconFileName = getUUIDFileNameSuggestIcoPic(iconFilePath);
        sendUploadProgress("icon", 0, "正在上传图标...");
        iconUrl = await uploadFileToOss(
          iconMetadata,
          iconFilePath,
          iconFileName,
          "image/png",
          "icon",
          (progress) => {
            sendUploadProgress(
              "icon",
              progress,
              `正在上传图标... ${Math.floor(progress)}%`,
            );
          },
        );
        sendUploadProgress("icon", 100, "图标上传完成");
        logger.info({ iconUrl }, "[Submitter] Icon upload completed");

        if (iconPath.startsWith("http://") || iconPath.startsWith("https://")) {
          fs.unlinkSync(iconFilePath);
          fs.rmdirSync(path.dirname(iconFilePath));
        }
      } else {
        logger.error({ iconFilePath }, "[Submitter] Icon file does not exist");
        return { success: false, message: `图标文件不存在: ${iconFilePath}` };
      }
    }

    const screenshotUrls: string[] = [];
    for (let i = 0; i < screenshots.length; i++) {
      const screenshot = screenshots[i];
      logger.info(
        { index: i, screenshot },
        "[Submitter] Processing screenshot",
      );

      if (typeof screenshot === "string") {
        logger.info(
          `[Submitter] ============== STEP 2: UPLOAD SCREENSHOT ${i + 1} ==============`,
        );
        let screenshotFilePath = screenshot;

        if (
          screenshot.startsWith("http://") ||
          screenshot.startsWith("https://")
        ) {
          logger.info(
            { screenshot },
            "[Submitter] Screenshot is a remote URL, downloading first",
          );
          const tempDir = fs.mkdtempSync(
            path.join(os.tmpdir(), "spark-store-submitter-"),
          );
          screenshotFilePath = path.join(tempDir, `screen_${i + 1}.png`);

          try {
            const response = await fetch(screenshot);
            if (!response.ok) {
              throw new Error(`下载截图失败: ${response.status}`);
            }
            const blob = await response.blob();
            const buffer = Buffer.from(await blob.arrayBuffer());
            fs.writeFileSync(screenshotFilePath, buffer);
            logger.info(
              { screenshotFilePath, size: buffer.length },
              "[Submitter] Screenshot downloaded successfully",
            );
          } catch (err) {
            logger.error(
              { err, screenshot },
              "[Submitter] Failed to download screenshot from URL",
            );
            continue;
          }
        }

        if (fs.existsSync(screenshotFilePath)) {
          const picMetadata = await getOssUploadMetadata("pic");
          const picFileName = getUUIDFileNameSuggestIcoPic(screenshotFilePath);
          sendUploadProgress(`screenshot-${i}`, 0, `正在上传截图 ${i + 1}...`);
          const picUrl = await uploadFileToOss(
            picMetadata,
            screenshotFilePath,
            picFileName,
            "image/png",
            `screenshot ${i + 1}`,
            (progress) => {
              sendUploadProgress(
                `screenshot-${i}`,
                progress,
                `正在上传截图 ${i + 1}... ${Math.floor(progress)}%`,
              );
            },
          );
          sendUploadProgress(`screenshot-${i}`, 100, `截图 ${i + 1} 上传完成`);
          screenshotUrls.push(picUrl);
          logger.info(
            { picUrl },
            `[Submitter] Screenshot ${i + 1} upload completed`,
          );

          if (
            screenshot.startsWith("http://") ||
            screenshot.startsWith("https://")
          ) {
            fs.unlinkSync(screenshotFilePath);
            fs.rmdirSync(path.dirname(screenshotFilePath));
          }
        } else {
          logger.warn(
            { screenshotFilePath },
            "[Submitter] Screenshot file does not exist, skipping",
          );
        }
      }
    }

    logger.info("[Submitter] ============== STEP 3: UPLOAD DEB ==============");
    logger.info(
      { debFilePath, debFileName: getUUIDFileNameSuggestDeb(debFilePath) },
      "[Submitter] Starting deb upload",
    );
    const debMetadata = await getOssUploadMetadata("deb");
    const debFileName = getUUIDFileNameSuggestDeb(debFilePath);
    sendUploadProgress("deb", 0, "正在上传安装包...");
    const debUrl = await uploadFileToOss(
      debMetadata,
      debFilePath,
      debFileName,
      "application/vnd.debian.binary-package",
      "deb",
      (progress) => {
        sendUploadProgress(
          "deb",
          progress,
          `正在上传安装包... ${Math.floor(progress)}%`,
        );
      },
    );
    sendUploadProgress("deb", 100, "安装包上传完成");
    logger.info(
      "[Submitter] ============== DEB UPLOAD SUCCESSFUL ==============",
    );
    logger.info(
      { debUrl, debFileName },
      "[Submitter] Deb upload completed successfully",
    );

    logger.info(
      "[Submitter] ============== STEP 4: SUBMIT APPLICATION ==============",
    );

    const debFileStat = fs.statSync(debFilePath);

    const categoryName = String(dataObj.category || "");
    const categoryId = getCategoryIdByName(categoryName);
    logger.info(
      { categoryName, categoryId },
      "[Submitter] Category name and ID",
    );

    const tagsString = String(dataObj.tags || "");
    const tagsArray = tagsString
      ? tagsString
          .split(";")
          .map((t: string) => t.trim())
          .filter((t: string) => t)
      : [];
    logger.info({ tagsString, tagsArray }, "[Submitter] Tags conversion");

    const submitData = {
      application_name: String(dataObj.pkgname || ""),
      application_name_zh: String(dataObj.name || ""),
      contributor: String(dataObj.contributor || ""),
      icons: iconUrl,
      size: debFileStat.size,
      file_name: path.basename(debFilePath).replace(/\s+/g, "_plus_"),
      website: String(dataObj.website || ""),
      version: String(dataObj.version || ""),
      more: String(dataObj.description || ""),
      type_id: categoryId,
      author: String(dataObj.author || ""),
      remark:
        ((dataObj.remark as string) || "") +
        " - (来自于投稿器_v" +
        getAppVersion() +
        ")",
      img_urls: screenshotUrls,
      deb_url: debUrl,
      mail: String(dataObj.mail || dataObj.contributor || ""),
      tags: tagsArray,
    };

    logger.info(
      "[Submitter] ============== VALIDATING SUBMISSION DATA ==============",
    );
    const requiredFields = [
      "application_name",
      "application_name_zh",
      "contributor",
      "icons",
      "size",
      "file_name",
      "version",
      "type_id",
      "author",
      "deb_url",
    ];
    const missingFields = requiredFields.filter(
      (field) => !submitData[field as keyof typeof submitData],
    );
    if (missingFields.length > 0) {
      logger.error({ missingFields }, "[Submitter] Missing required fields");
    }

    logger.info(
      "[Submitter] ============== PREPARING SUBMISSION REQUEST ==============",
    );
    logger.info({ submitData }, "[Submitter] Final submission data");

    const submitterApiUrl =
      "https://upload.deepinos.org.cn/api/index/upload_application";
    logger.info({ submitterApiUrl }, "[Submitter] Submission API URL");

    logger.info(
      "[Submitter] ============== SENDING SUBMISSION REQUEST ==============",
    );
    logger.info(
      { submitterApiUrl, timestamp: new Date().toISOString() },
      "[Submitter] Submission request sent to API",
    );

    const response = await fetch(submitterApiUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "User-Agent": getUserAgent(),
      },
      body: JSON.stringify(submitData),
    });

    const requestDuration = Date.now() - startTime;
    logger.info(
      "[Submitter] ============== SUBMISSION RESPONSE RECEIVED ==============",
    );
    logger.info(
      { status: response.status, statusText: response.statusText },
      "[Submitter] Submission response status",
    );
    logger.info(
      { duration: requestDuration },
      "[Submitter] Total submission duration (ms)",
    );

    const responseText = await response.text();
    logger.info(
      { responseTextLength: responseText.length },
      "[Submitter] Submission response text length",
    );

    if (!response.ok) {
      logger.error(
        "[Submitter] ============== SUBMISSION FAILED ==============",
      );
      logger.error(
        { status: response.status, statusText: response.statusText },
        "[Submitter] Submission failed with status",
      );
      logger.error(
        { responseText: responseText.substring(0, 2000) },
        "[Submitter] Submission API error response (full)",
      );

      let message = "提交失败";
      let apiResponse: unknown = null;

      try {
        apiResponse = JSON.parse(responseText);
        logger.error({ apiResponse }, "[Submitter] Parsed API error response");
      } catch (parseError) {
        logger.warn(
          { parseError: (parseError as Error)?.message },
          "[Submitter] Failed to parse error response as JSON",
        );
      }

      if (response.status === 521) {
        message = "服务器暂时不可用，请稍后重试";
      } else if (response.status === 400) {
        if (typeof apiResponse === "object" && apiResponse !== null) {
          const errorObj = apiResponse as Record<string, unknown>;
          message = String(errorObj.msg || errorObj.message || "请求参数错误");
        } else {
          message = responseText.substring(0, 200) || "请求参数错误";
        }
      } else if (response.status === 401) {
        message = "未授权，请登录后再试";
      } else if (response.status === 403) {
        message = "权限不足";
      } else if (response.status === 429) {
        message = "请求过于频繁，请稍后重试";
      } else {
        message = `提交失败 [${response.status}]: ${responseText.substring(0, 200)}`;
      }

      logger.error(
        { finalMessage: message },
        "[Submitter] Final error message to user",
      );
      return { success: false, message, apiResponse };
    }

    let result: unknown;
    try {
      result = JSON.parse(responseText);
    } catch (parseError) {
      logger.warn(
        { parseError: (parseError as Error)?.message },
        "[Submitter] Failed to parse success response as JSON",
      );
      result = responseText;
    }

    logger.info(
      "[Submitter] ============== SUBMISSION SUCCESSFUL ==============",
    );
    logger.info({ result }, "[Submitter] Submission API response content");
    logger.info(
      { duration: requestDuration },
      "[Submitter] Total duration (ms)",
    );

    return { success: true, data: result };
  } catch (err) {
    logger.error("[Submitter] ============== EXCEPTION CAUGHT ==============");
    logger.error({ errorType: (err as Error)?.name }, "[Submitter] Error type");
    logger.error(
      { errorMessage: (err as Error)?.message },
      "[Submitter] Error message",
    );
    logger.error(
      { errorStack: (err as Error)?.stack },
      "[Submitter] Error stack",
    );

    return { success: false, message: (err as Error)?.message || "提交失败" };
  }
});

ipcMain.handle("package-app", async (event, formData: unknown) => {
  try {
    const startTime = Date.now();
    logger.info("[Submitter] ============== PACKAGE APP START ==============");

    if (typeof formData !== "object" || formData === null) {
      return { success: false, message: "表单数据格式错误" };
    }

    const dataObj = formData as Record<string, unknown>;
    const pkgname = String(dataObj.pkgname || "");
    const packageName = String(dataObj.name || "");
    const packageVersion = String(dataObj.version || "");
    const packageCategory = String(dataObj.category || "");
    const packageAuthor = String(dataObj.author || "");
    const packageContributor = String(dataObj.contributor || "");
    const packageWebsite = String(dataObj.website || "");
    const packageDescription = String(dataObj.description || "");
    const packageTags = String(dataObj.tags || "");
    const debFilePath = String(dataObj.debFilePath || "");
    const iconPath = String(dataObj.iconPath || "");
    const screenshots = Array.isArray(dataObj.screenshots)
      ? dataObj.screenshots
      : [];
    const storeArch = String(dataObj.storeArch || "store");

    if (!debFilePath) return { success: false, message: "请选择 deb 文件" };
    if (!fs.existsSync(debFilePath))
      return { success: false, message: `deb 文件不存在: ${debFilePath}` };
    if (!pkgname) return { success: false, message: "包名不能为空" };
    if (!packageCategory) return { success: false, message: "分类不能为空" };

    const sendPackageProgress = (
      step: string,
      progress: number,
      message: string,
    ) => {
      try {
        event.sender.send("package-progress", { step, progress, message });
      } catch (e) {
        logger.warn({ e }, "[Submitter] Failed to send progress event");
      }
    };

    const { exec } = await import("node:child_process");
    const util = await import("util");
    const execAsync = util.promisify(exec);

    sendPackageProgress("init", 0, "正在创建临时目录...");

    const { stdout: tempDir } = await execAsync("mktemp -d");
    const baseTempDir = tempDir.trim();
    logger.info({ baseTempDir }, "[Submitter] Temp directory created");

    const packDir = path.join(baseTempDir, packageCategory, pkgname);
    fs.mkdirSync(packDir, { recursive: true });
    logger.info({ packDir }, "[Submitter] Package directory created");

    sendPackageProgress("icon", 10, "正在处理图标...");
    logger.info({ iconPath }, "[Submitter] Processing icon...");
    if (iconPath) {
      const iconDest = path.join(packDir, "icon.png");
      if (iconPath.startsWith("http://") || iconPath.startsWith("https://")) {
        const controller = new AbortController();
        const timeout = setTimeout(() => controller.abort(), 10000);
        try {
          const response = await fetch(iconPath, { signal: controller.signal });
          clearTimeout(timeout);
          if (response.ok) {
            const buffer = Buffer.from(await response.arrayBuffer());
            fs.writeFileSync(iconDest, buffer);
          } else {
            return {
              success: false,
              message: `下载图标失败: ${response.status}`,
            };
          }
        } catch (e) {
          clearTimeout(timeout);
          return {
            success: false,
            message: `下载图标失败: ${(e as Error).message}`,
          };
        }
      } else if (iconPath.startsWith("data:")) {
        const base64Data = iconPath.split(",")[1];
        if (base64Data) {
          fs.writeFileSync(iconDest, Buffer.from(base64Data, "base64"));
        } else {
          return { success: false, message: "图标数据格式错误" };
        }
      } else if (fs.existsSync(iconPath)) {
        fs.copyFileSync(iconPath, iconDest);
      } else {
        return { success: false, message: `图标文件不存在: ${iconPath}` };
      }
    } else {
      return { success: false, message: "请选择应用图标" };
    }
    logger.info("[Submitter] Icon processed");

    sendPackageProgress("screenshots", 30, "正在处理截图...");
    logger.info({ count: screenshots.length }, "[Submitter] Processing screenshots...");
    const imgUrls: string[] = [];
    const originUrl = `https://spk-json.spark-app.store/${storeArch}/${packageCategory}/${pkgname}`;

    for (let i = 0; i < screenshots.length && i < 5; i++) {
      const screenshot = screenshots[i];
      const screenFileName = `screen_${i + 1}.png`;
      const screenFilePath = path.join(packDir, screenFileName);

      if (typeof screenshot === "string") {
        if (
          screenshot.startsWith("http://") ||
          screenshot.startsWith("https://")
        ) {
          const controller = new AbortController();
          const timeout = setTimeout(() => controller.abort(), 10000);
          try {
            const response = await fetch(screenshot, { signal: controller.signal });
            clearTimeout(timeout);
            if (response.ok) {
              const buffer = Buffer.from(await response.arrayBuffer());
              fs.writeFileSync(screenFilePath, buffer);
            }
          } catch {
            clearTimeout(timeout);
            logger.warn(
              { screenshot },
              "[Submitter] Failed to download screenshot, skipping",
            );
          }
        } else if (screenshot.startsWith("data:")) {
          const base64Data = screenshot.split(",")[1];
          if (base64Data) {
            fs.writeFileSync(screenFilePath, Buffer.from(base64Data, "base64"));
          }
        } else if (fs.existsSync(screenshot)) {
          fs.copyFileSync(screenshot, screenFilePath);
        }
        imgUrls.push(`${originUrl}/${screenFileName}`);
      }
    }
    logger.info("[Submitter] Screenshots processed");

    sendPackageProgress("deb", 50, "正在复制安装包...");
    logger.info({ debFilePath }, "[Submitter] Processing deb package...");
    let debInfoRaw: string;
    try {
      const result = await execAsync(
        `dpkg-deb -f "${debFilePath}" Package Version Architecture`,
      );
      debInfoRaw = result.stdout;
    } catch (debErr) {
      logger.error({ debErr }, "[Submitter] dpkg-deb failed");
      return { success: false, message: `读取 deb 信息失败: ${(debErr as Error).message}` };
    }
    logger.info({ debInfoRaw }, "[Submitter] dpkg-deb output");
    let debPkgName = pkgname;
    let debVersion = packageVersion;
    let debArch = "amd64";

    for (const line of debInfoRaw.trim().split("\n")) {
      const [key, ...valueParts] = line.split(":");
      const value = valueParts.join(":").trim();
      switch (key.trim()) {
        case "Package":
          debPkgName = value.toLowerCase();
          break;
        case "Version":
          debVersion = value;
          break;
        case "Architecture":
          debArch = value;
          break;
      }
    }
    logger.info({ debPkgName, debVersion, debArch }, "[Submitter] Deb metadata parsed");

    const packDebFileName = `${debPkgName}_${debVersion}_${debArch}.deb`;
    logger.info({ from: debFilePath, to: path.join(packDir, packDebFileName) }, "[Submitter] Copying deb file...");
    fs.copyFileSync(debFilePath, path.join(packDir, packDebFileName));
    logger.info({ packDebFileName }, "[Submitter] Deb copied");

    const debFileStat = fs.statSync(debFilePath);
    const sizeInMb = debFileStat.size / 1000 / 1000;
    const sizeStr =
      sizeInMb < 10
        ? `${Math.round(debFileStat.size / 1000)} Kb`
        : `${Math.round(sizeInMb)} Mb`;
    logger.info({ sizeStr }, "[Submitter] Deb size calculated");

    sendPackageProgress("json", 70, "正在生成 app.json...");
    logger.info("[Submitter] Generating app.json...");

    const now = new Date();
    const updateStr = `${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")}`;

    const appJson = {
      Name: packageName,
      Version: packageVersion,
      Filename: packDebFileName,
      Torrent_address: `${packDebFileName}.torrent`,
      Pkgname: pkgname,
      Author: packageAuthor,
      Contributor: packageContributor,
      Website: packageWebsite,
      Update: updateStr,
      Size: sizeStr,
      More: packageDescription,
      Tags: packageTags,
      img_urls: imgUrls,
      icons: `${originUrl}/icon.png`,
    };

    fs.writeFileSync(
      path.join(packDir, "app.json"),
      JSON.stringify(appJson, null, 2),
    );
    logger.info("[Submitter] app.json written");

    sendPackageProgress("tar", 85, "正在打包 tar.gz...");
    logger.info("[Submitter] Starting tar...");

    const tarFileName = `${pkgname}-${storeArch}.tar.gz`;
    const tarOutputPath = path.join(baseTempDir, tarFileName);
    try {
      await execAsync(
        `tar czf "${tarOutputPath}" -C "${baseTempDir}" "${packageCategory}"`,
      );
      logger.info({ tarOutputPath }, "[Submitter] tar command succeeded");
    } catch (tarErr) {
      logger.error({ tarErr }, "[Submitter] tar command failed");
      return {
        success: false,
        message: `打包失败: ${(tarErr as Error).message}`,
      };
    }

    if (!fs.existsSync(tarOutputPath)) {
      return { success: false, message: "打包后的 tar.gz 文件未找到" };
    }

    sendPackageProgress("done", 100, "打包完成！");

    logger.info({ baseTempDir }, "[Submitter] Opening folder");
    await shell.openPath(baseTempDir);

    const duration = Date.now() - startTime;
    logger.info(
      { tarOutputPath: tarOutputPath, duration, tempDir: baseTempDir },
      "[Submitter] Package completed successfully",
    );

    return {
      success: true,
      data: {
        tarPath: tarOutputPath,
        tempDir: baseTempDir,
        tarFileName,
      },
    };
  } catch (err) {
    logger.error("[Submitter] ============== PACKAGE EXCEPTION ==============");
    logger.error(
      {
        errorMessage: (err as Error)?.message,
        errorStack: (err as Error)?.stack,
      },
      "[Submitter] Exception caught",
    );
    return { success: false, message: (err as Error)?.message || "打包失败" };
  }
});

// Register custom protocol handlers
if (process.defaultApp) {
  if (process.argv.length >= 2) {
    app.setAsDefaultProtocolClient("spk", process.execPath, [
      path.resolve(process.argv[1]),
    ]);
    app.setAsDefaultProtocolClient("apt", process.execPath, [
      path.resolve(process.argv[1]),
    ]);
  }
} else {
  app.setAsDefaultProtocolClient("spk");
  app.setAsDefaultProtocolClient("apt");
}

app.whenReady().then(() => {
  // Set User-Agent for client
  session.defaultSession.webRequest.onBeforeSendHeaders((details, callback) => {
    details.requestHeaders["User-Agent"] = getUserAgent();
    callback({ cancel: false, requestHeaders: details.requestHeaders });
  });
  createWindow();
  handleCommandLine(process.argv);
  initializeUpdateCenter();
  // 启动后执行一次遥测（仅 Linux，不阻塞）
  sendTelemetryOnce(getAppVersion());
});

app.on("window-all-closed", () => {
  win = null;
  allowAppExit = false;
  if (process.platform !== "darwin") app.quit();
});

app.on("second-instance", () => {
  if (win) {
    // Focus on the main window if the user tried to open another
    if (win.isMinimized()) win.restore();
    win.focus();
  }
});

app.on("activate", () => {
  const allWindows = BrowserWindow.getAllWindows();
  if (allWindows.length) {
    allWindows[0].focus();
  } else {
    createWindow();
  }
});

app.on("will-quit", () => {
  // Clean up temp dir
  logger.info("Cleaning up temp dir");
  fs.rmSync("/tmp/spark-store/", { recursive: true, force: true });
  logger.info("Done, exiting");
});

// 设置托盘：系统中应用名称为 spark-store，图标优先 spark-store，其次 spark-store.svg，再次替代图标
const ICONS_DIR = app.isPackaged
  ? path.join(process.resourcesPath, "icons")
  : path.join(__dirname, "../..", "icons");

function resolveIconPath(filename: string): string {
  return path.join(ICONS_DIR, filename);
}

/** 按优先级返回托盘图标路径：spark-store(.png|.ico) → amber-pm-logo.png。托盘不支持 SVG，故不尝试 spark-store.svg */
function getTrayIconPath(): string | null {
  const ext = process.platform === "win32" ? ".ico" : ".png";
  const candidates = [`spark-store${ext}`];
  for (const name of candidates) {
    const iconPath = resolveIconPath(name);
    if (fs.existsSync(iconPath)) {
      logger.info("托盘图标使用: " + iconPath);
      return iconPath;
    }
  }
  logger.warn("未找到托盘图标，将使用替代图标。查找目录: " + ICONS_DIR);
  return null;
}

/** 16x16 透明 PNG，用作托盘无图标时的替代 */
const FALLBACK_TRAY_PNG =
  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAHklEQVQ4T2NkYGD4z0ABYBwNwMAwGoChNQAAAABJRU5ErkJggg==";

function getTrayImage():
  | string
  | ReturnType<typeof nativeImage.createFromDataURL> {
  const iconPath = getTrayIconPath();
  if (iconPath) return iconPath;
  return nativeImage.createFromDataURL(FALLBACK_TRAY_PNG);
}

let tray: Tray | null = null;
app.whenReady().then(() => {
  tray = new Tray(getTrayImage());
  const contextMenu = Menu.buildFromTemplate([
    {
      label: "显示主界面",
      click: () => {
        win.show();
      },
    },
    {
      label: "退出程序",
      click: () => {
        requestApplicationExit();
      },
    },
  ]);
  tray.setToolTip("星火应用商店");
  tray.setContextMenu(contextMenu);
  // 双击触发
  tray.on("click", () => {
    // 双击通知区图标实现应用的显示或隐藏
    if (win.isVisible()) {
      win.hide();
      win.setSkipTaskbar(true);
    } else {
      win.show();
      win.setSkipTaskbar(false);
    }
  });
});

// New window example arg: new windows url
// ipcMain.handle('open-win', (_, arg) => {
//   const childWindow = new BrowserWindow({
//     webPreferences: {
//       preload,
//       nodeIntegration: true,
//       contextIsolation: false,
//     },
//   })

//   if (VITE_DEV_SERVER_URL) {
//     childWindow.loadURL(`${VITE_DEV_SERVER_URL}#${arg}`)
//   } else {
//     childWindow.loadFile(indexHtml, { hash: arg })
//   }
// })