multi-platform-media-manage/client/electron/main.ts

// 使用 CommonJS 格式
const { app, BrowserWindow, ipcMain, shell, session, Menu, Tray, nativeImage, webContents } = require('electron');
const { join } = require('path');
const fs = require('fs');
const http = require('http');
const https = require('https');
const os = require('os');
import { startLocalServices, stopLocalServices, getServiceStatus, LOCAL_NODE_URL, LOCAL_PYTHON_URL, getLogPath } from './local-services';

let mainWindow: typeof BrowserWindow.prototype | null = null;

// ========== 内存监控 ==========
const MEMORY_THRESHOLD_MB = 512; // 超过 512MB 触发警告 / 清理
let lastMemoryReport = 0;

function getMemoryUsageMB(): number {
  const used = process.memoryUsage();
  return Math.round(used.heapUsed / 1024 / 1024);
}

function logMemory(prefix: string): void {
  const used = getMemoryUsageMB();
  const total = Math.round(os.totalmem() / 1024 / 1024);
  const free = Math.round(os.freemem() / 1024 / 1024);
  const usagePct = Math.round((used / total) * 100);
  console.log(`[MEM] ${prefix} heap=${used}MB total=${total}MB free=${free}MB usage=${usagePct}%`);
}

function monitorMemory(): void {
  const used = getMemoryUsageMB();
  const now = Date.now();
  // 每 60 秒报告一次
  if (now - lastMemoryReport > 60000) {
    logMemory('Electron');
    lastMemoryReport = now;
  }
  // 超过阈值，触发 GC 并报告
  if (used > MEMORY_THRESHOLD_MB) {
    console.warn(`[MEM] Memory high (${used}MB), triggering GC...`);
    if (global.gc) {
      global.gc();
    }
    // 关闭多余的 webContents
    if (mainWindow?.webContents) {
      const wc = mainWindow.webContents;
      // 尝试清理 devtools extension
      try {
        session.defaultSession?.webContents.forEach(w => {
          if (w !== wc && !w.isDestroyed()) {
            console.warn('[MEM] Closing idle webContents');
            w.close();
          }
        });
      } catch {}
    }
  }
}

// 启动内存监控
setInterval(monitorMemory, 30000);
let tray: typeof Tray.prototype | null = null;
let isQuitting = false;

const VITE_DEV_SERVER_URL = process.env.VITE_DEV_SERVER_URL;

function setupCertificateBypass() {
  app.on('certificate-error', (event: Event, _webContents: typeof webContents.prototype, _url: string, _error: string, _certificate: unknown, callback: (isTrusted: boolean) => void) => {
    event.preventDefault();
    callback(true);
  });
}

function setupCorsBypassForApiRequests() {
  const ses = session.defaultSession;
  if (!ses) return;

  ses.webRequest.onHeadersReceived((details: { url: string; responseHeaders?: Record<string, string[] | string> }, callback: (response: { responseHeaders: Record<string, string[] | string> }) => void) => {
    const url = String(details.url || '');
    const isHttp = url.startsWith('http://') || url.startsWith('https://');
    const isApiLike = url.includes('/api/') || url.includes('/uploads/');
    if (!isHttp || !isApiLike) {
      callback({ responseHeaders: details.responseHeaders || {} });
      return;
    }

    const responseHeaders = { ...(details.responseHeaders || {}) };
    // 移除服务端已有的 CORS 头，避免与下面设置的值合并成 "origin1, *" 导致违规
    const corsKeys = ['access-control-allow-origin', 'Access-Control-Allow-Origin'];
    corsKeys.forEach((k) => delete responseHeaders[k]);
    responseHeaders['access-control-allow-origin'] = ['*'];
    responseHeaders['access-control-allow-methods'] = ['GET,POST,PUT,PATCH,DELETE,OPTIONS'];
    responseHeaders['access-control-allow-headers'] = ['Authorization,Content-Type,X-Requested-With'];
    responseHeaders['access-control-expose-headers'] = ['Content-Disposition,Content-Type'];

    callback({ responseHeaders });
  });
}

function normalizeBaseUrl(url: string): string {
  const raw = String(url || '').trim();
  if (!raw) return '';
  try {
    const u = new URL(raw);
    return `${u.protocol}//${u.host}`.replace(/\/$/, '');
  } catch {
    return raw.replace(/\/$/, '');
  }
}

function requestJson(url: string, timeoutMs: number): Promise<{ ok: boolean; status?: number; data?: any; error?: string }> {
  return new Promise((resolve) => {
    const u = new URL(url);
    const isHttps = u.protocol === 'https:';
    const lib = isHttps ? https : http;
    // Windows 上 localhost 常被解析为 ::1，而后端仅监听 127.0.0.1，导致 ECONNREFUSED
    const hostname = (u.hostname === 'localhost' || u.hostname === '::1') ? '127.0.0.1' : u.hostname;
    const req = lib.request({
      method: 'GET',
      protocol: u.protocol,
      hostname,
      port: u.port || (isHttps ? 443 : 80),
      path: `${u.pathname}${u.search}`,
      headers: {
        Accept: 'application/json',
      },
      timeout: timeoutMs,
      rejectUnauthorized: false,
    }, (res: any) => {
      const chunks: Buffer[] = [];
      res.on('data', (c: Buffer) => chunks.push(c));
      res.on('end', () => {
        const status = Number(res.statusCode || 0);
        const rawText = Buffer.concat(chunks).toString('utf-8');
        if (status < 200 || status >= 300) {
          resolve({ ok: false, status, error: `HTTP ${status}` });
          return;
        }
        try {
          const json = rawText ? JSON.parse(rawText) : null;
          resolve({ ok: true, status, data: json });
        } catch {
          resolve({ ok: false, status, error: '响应不是 JSON' });
        }
      });
    });

    req.on('timeout', () => {
      req.destroy(new Error('timeout'));
    });
    req.on('error', (err: any) => {
      resolve({ ok: false, error: err?.message || '网络错误' });
    });
    req.end();
  });
}

// 获取图标路径
function getIconPath() {
  return VITE_DEV_SERVER_URL
    ? join(__dirname, '../public/icons/icon-256.png')
    : join(__dirname, '../dist/icons/icon-256.png');
}

// 获取托盘图标路径
function getTrayIconPath() {
  return VITE_DEV_SERVER_URL
    ? join(__dirname, '../public/icons/tray-icon.png')
    : join(__dirname, '../dist/icons/tray-icon.png');
}

// 创建托盘图标
function createTrayIcon(): typeof nativeImage.prototype {
  const trayIconPath = getTrayIconPath();
  return nativeImage.createFromPath(trayIconPath);
}

// 创建系统托盘
function createTray() {
  const trayIcon = createTrayIcon();
  tray = new Tray(trayIcon);

  const contextMenu = Menu.buildFromTemplate([
    {
      label: '显示主窗口',
      click: () => {
        if (mainWindow) {
          mainWindow.show();
          mainWindow.focus();
        }
      }
    },
    {
      label: '最小化到托盘',
      click: () => {
        mainWindow?.hide();
      }
    },
    { type: 'separator' },
    {
      label: '退出',
      click: () => {
        isQuitting = true;
        app.quit();
      }
    }
  ]);

  tray.setToolTip('智媒通');
  tray.setContextMenu(contextMenu);

  // 点击托盘图标显示窗口
  tray.on('click', () => {
    if (mainWindow) {
      if (mainWindow.isVisible()) {
        mainWindow.focus();
      } else {
        mainWindow.show();
        mainWindow.focus();
      }
    }
  });

  // 双击托盘图标显示窗口
  tray.on('double-click', () => {
    if (mainWindow) {
      mainWindow.show();
      mainWindow.focus();
    }
  });
}

function createWindow() {
  // 隐藏默认菜单栏
  Menu.setApplicationMenu(null);

  const iconPath = getIconPath();

  mainWindow = new BrowserWindow({
    width: 1400,
    height: 900,
    minWidth: 1200,
    minHeight: 700,
    icon: iconPath,
    webPreferences: {
      preload: join(__dirname, 'preload.js'),
      nodeIntegration: false,
      contextIsolation: true,
      webviewTag: true, // 启用 webview 标签
    },
    frame: false, // 无边框窗口，自定义标题栏
    transparent: false,
    backgroundColor: '#f0f2f5',
    show: false,
  });

  // 窗口准备好后再显示，避免白屏
  mainWindow.once('ready-to-show', () => {
    mainWindow?.show();
    setupWindowEvents();
  });

  // 加载页面
  if (VITE_DEV_SERVER_URL) {
    mainWindow.loadURL(VITE_DEV_SERVER_URL);
    mainWindow.webContents.openDevTools();
  } else {
    mainWindow.loadFile(join(__dirname, '../dist/index.html'));
  }

  // 处理外部链接
  mainWindow.webContents.setWindowOpenHandler(({ url }: { url: string }) => {
    shell.openExternal(url);
    return { action: 'deny' };
  });

  // 关闭按钮默认最小化到托盘
  mainWindow.on('close', (event: Event) => {
    if (!isQuitting) {
      event.preventDefault();
      mainWindow?.hide();

      // 显示托盘通知（仅首次）
      if (tray && !app.isPackaged) {
        // 开发模式下可以显示通知
      }
    }
  });

  mainWindow.on('closed', () => {
    mainWindow = null;
  });
}

// 单实例锁定
const gotTheLock = app.requestSingleInstanceLock();

if (!gotTheLock) {
  app.quit();
} else {
  app.on('second-instance', () => {
    if (mainWindow) {
      mainWindow.show();
      if (mainWindow.isMinimized()) mainWindow.restore();
      mainWindow.focus();
    }
  });

  // ========== 降低 Electron 内存占用（必须在 app.whenReady 之前） ==========
  app.commandLine.appendSwitch('js-flags', '--max-old-space-size=512');
  app.commandLine.appendSwitch('renderer-process-limit', '2');

  app.whenReady().then(async () => {
    logMemory('AppReady');
    // 先创建窗口显示 splash screen
    createWindow();
    createTray();

    // 后台启动本地 Node 和 Python 服务，不阻塞窗口显示
    console.log('[Main] 正在后台启动本地服务...');
    startLocalServices().then(({ nodeOk, pythonOk }) => {
      console.log(`[Main] 本地服务状态: Node=${nodeOk ? '就绪' : '未就绪'}, Python=${pythonOk ? '就绪' : '未就绪'}`);
      // 通知渲染进程服务状态变化
      mainWindow?.webContents.send('services-status-changed', { nodeOk, pythonOk });
    });

    // 配置 webview session，允许第三方 cookies 和跨域请求
    setupWebviewSessions();
    setupCertificateBypass();
    setupCorsBypassForApiRequests();

    app.on('activate', () => {
      if (BrowserWindow.getAllWindows().length === 0) {
        createWindow();
      } else if (mainWindow) {
        mainWindow.show();
      }
    });
  });
}

// 配置 webview sessions
function setupWebviewSessions() {
  // 监听新的 webContents 创建
  app.on('web-contents-created', (_event: unknown, contents: typeof webContents.prototype) => {
    // 为 webview 类型的 webContents 配置
    if (contents.getType() === 'webview') {
      // 设置 User-Agent（模拟 Chrome 浏览器）
      contents.setUserAgent(
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
      );

      // 拦截自定义协议链接（如 bitbrowser://）的导航
      contents.on('will-navigate', (event: Event, url: string) => {
        if (!isAllowedUrl(url)) {
          console.log('[WebView] 阻止导航到自定义协议:', url);
          event.preventDefault();
        }
      });

      // 拦截新窗口打开（包括自定义协议）
      contents.setWindowOpenHandler(({ url }: { url: string }) => {
        if (!isAllowedUrl(url)) {
          console.log('[WebView] 阻止打开自定义协议窗口:', url);
          return { action: 'deny' };
        }
        // 对于正常的 http/https 链接，在当前 webview 中打开
        console.log('[WebView] 拦截新窗口，在当前页面打开:', url);
        contents.loadURL(url);
        return { action: 'deny' };
      });

      // 允许所有的权限请求（如摄像头、地理位置等）
      contents.session.setPermissionRequestHandler((_webContents: unknown, permission: string, callback: (granted: boolean) => void) => {
        // 允许所有权限请求
        callback(true);
      });

      // 配置 webRequest 修改请求头，移除可能暴露 Electron 的特征
      contents.session.webRequest.onBeforeSendHeaders((details: { requestHeaders: Record<string, string> }, callback: (response: { requestHeaders: Record<string, string> }) => void) => {
        // 移除可能暴露 Electron 的请求头
        delete details.requestHeaders['X-DevTools-Emulate-Network-Conditions-Client-Id'];

        // 确保有正常的 Origin 和 Referer
        if (!details.requestHeaders['Origin'] && !details.requestHeaders['origin']) {
          // 不添加 Origin，让浏览器自动处理
        }

        callback({ requestHeaders: details.requestHeaders });
      });
    }
  });
}

// 检查 URL 是否是允许的协议
function isAllowedUrl(url: string): boolean {
  if (!url) return false;
  const lowerUrl = url.toLowerCase();
  return lowerUrl.startsWith('http://') ||
    lowerUrl.startsWith('https://') ||
    lowerUrl.startsWith('about:') ||
    lowerUrl.startsWith('data:');
}

// 阻止默认的 window-all-closed 行为，保持托盘运行
app.on('window-all-closed', () => {
  // 不退出应用，保持托盘运行
  // 只有在 isQuitting 为 true 时才真正退出
});

// 应用退出前清理托盘
app.on('before-quit', () => {
  isQuitting = true;
});

app.on('quit', () => {
  stopLocalServices();
  if (tray) {
    tray.destroy();
    tray = null;
  }
});

ipcMain.handle('test-server-connection', async (_event: unknown, args: { url: string }) => {
  try {
    const baseUrl = normalizeBaseUrl(args?.url);
    if (!baseUrl) return { ok: false, error: '未填写服务器地址' };
    const result = await requestJson(`${baseUrl}/api/health`, 5000);
    if (!result.ok) return { ok: false, error: result.error || '连接失败' };
    if (result.data?.status === 'ok') return { ok: true };
    return { ok: false, error: '服务器响应异常' };
  } catch (e: any) {
    return { ok: false, error: e?.message || '连接失败' };
  }
});

// Python 服务测试连接（主进程发起，支持 HTTP/HTTPS，无跨域限制）
ipcMain.handle('test-python-service-connection', async (_event: unknown, args: { url: string }) => {
  try {
    const baseUrl = normalizeBaseUrl(args?.url);
    if (!baseUrl) return { ok: false, error: '未填写 Python 服务地址' };
    const result = await requestJson(`${baseUrl}/health`, 5000);
    if (!result.ok) return { ok: false, error: result.error || '连接失败' };
    return { ok: true };
  } catch (e: any) {
    return { ok: false, error: e?.message || '连接失败' };
  }
});

// 本地服务状态查询
ipcMain.handle('get-local-services-status', () => {
  return getServiceStatus();
});

ipcMain.handle('get-local-urls', () => {
  return { nodeUrl: LOCAL_NODE_URL, pythonUrl: LOCAL_PYTHON_URL };
});

ipcMain.handle('get-service-log', () => {
  try {
    const logPath = getLogPath();
    if (fs.existsSync(logPath)) {
      return { path: logPath, content: fs.readFileSync(logPath, 'utf-8') };
    }
    return { path: logPath, content: '(日志文件不存在)' };
  } catch (e: any) {
    return { path: '', content: `读取失败: ${e.message}` };
  }
});

ipcMain.handle('open-log-file', () => {
  try {
    const logPath = getLogPath();
    if (fs.existsSync(logPath)) {
      shell.showItemInFolder(logPath);
    }
  } catch { /* ignore */ }
});

// IPC 处理
ipcMain.handle('get-app-version', () => {
  return app.getVersion();
});

ipcMain.handle('get-platform', () => {
  return process.platform;
});

// 窗口控制
ipcMain.on('window-minimize', () => {
  mainWindow?.minimize();
});

ipcMain.on('window-maximize', () => {
  if (mainWindow?.isMaximized()) {
    mainWindow.unmaximize();
  } else {
    mainWindow?.maximize();
  }
});

// 关闭窗口（最小化到托盘）
ipcMain.on('window-close', () => {
  mainWindow?.hide();
});

// 真正退出应用
ipcMain.on('app-quit', () => {
  isQuitting = true;
  app.quit();
});

// 获取窗口最大化状态
ipcMain.handle('window-is-maximized', () => {
  return mainWindow?.isMaximized() || false;
});

// 监听窗口最大化/还原事件，通知渲染进程
function setupWindowEvents() {
  mainWindow?.on('maximize', () => {
    mainWindow?.webContents.send('window-maximized', true);
  });
  mainWindow?.on('unmaximize', () => {
    mainWindow?.webContents.send('window-maximized', false);
  });
}

// 弹窗打开平台后台（独立窗口，不嵌入；用于实验，可回归为嵌入）
ipcMain.handle('open-backend-external', async (_event: unknown, payload: { url: string; cookieData?: string; title?: string }) => {
  const { url, cookieData, title } = payload || {};
  if (!url || typeof url !== 'string') return;

  const partition = 'persist:backend-popup-' + Date.now();
  const ses = session.fromPartition(partition);

  if (cookieData && typeof cookieData === 'string' && cookieData.trim()) {
    const raw = cookieData.trim();
    let cookiesToSet: Array<{ name: string; value: string; domain?: string; path?: string }> = [];
    try {
      if (raw.startsWith('[') || raw.startsWith('{')) {
        const parsed = JSON.parse(raw);
        const arr = Array.isArray(parsed) ? parsed : (parsed?.cookies || []);
        cookiesToSet = arr.map((c: { name?: string; value?: string; domain?: string; path?: string }) => ({
          name: String(c?.name ?? '').trim(),
          value: String(c?.value ?? '').trim(),
          domain: c?.domain ? String(c.domain) : undefined,
          path: c?.path ? String(c.path) : '/',
        })).filter((c: { name: string }) => c.name);
      } else {
        raw.split(';').forEach((p: string) => {
          const idx = p.indexOf('=');
          if (idx > 0) {
            const name = p.slice(0, idx).trim();
            const value = p.slice(idx + 1).trim();
            if (name) cookiesToSet.push({ name, value, path: '/' });
          }
        });
      }
    } catch (e) {
      console.warn('[open-backend-external] 解析 cookie 失败', e);
    }

    const origin = new URL(url).origin;
    const hostname = new URL(url).hostname;
    const defaultDomain = hostname.startsWith('www.') ? hostname.slice(4) : hostname;
    const domainWithDot = defaultDomain.includes('.') ? '.' + defaultDomain.split('.').slice(-2).join('.') : undefined;

    for (const c of cookiesToSet) {
      try {
        await ses.cookies.set({
          url: origin + '/',
          name: c.name,
          value: c.value,
          domain: c.domain || domainWithDot || hostname,
          path: c.path || '/',
        });
      } catch (err) {
        console.warn('[open-backend-external] 设置 cookie 失败', c.name, err);
      }
    }
  }

  const win = new BrowserWindow({
    width: 1280,
    height: 800,
    title: title || '平台后台',
    icon: getIconPath(),
    webPreferences: {
      session: ses,
      nodeIntegration: false,
      contextIsolation: true,
    },
    show: false,
  });

  win.once('ready-to-show', () => {
    win.show();
  });

  await win.loadURL(url);
  return { ok: true };
});

// 获取 webview 的 cookies
ipcMain.handle('get-webview-cookies', async (_event: unknown, partition: string, url: string) => {
  try {
    const ses = session.fromPartition(partition);
    const cookies = await ses.cookies.get({ url });
    return cookies;
  } catch (error) {
    console.error('获取 cookies 失败:', error);
    return [];
  }
});

// 获取 webview 的全部 cookies（按 partition）
ipcMain.handle('get-webview-all-cookies', async (_event: unknown, partition: string) => {
  try {
    const ses = session.fromPartition(partition);
    return await ses.cookies.get({});
  } catch (error) {
    console.error('获取全部 cookies 失败:', error);
    return [];
  }
});

// 清除 webview 的 cookies
ipcMain.handle('clear-webview-cookies', async (_event: unknown, partition: string) => {
  try {
    const ses = session.fromPartition(partition);
    await ses.clearStorageData({ storages: ['cookies'] });
    return true;
  } catch (error) {
    console.error('清除 cookies 失败:', error);
    return false;
  }
});

// 设置 webview 的 cookies
ipcMain.handle('set-webview-cookies', async (_event: unknown, partition: string, cookies: Electron.CookiesSetDetails[]) => {
  try {
    if (!Array.isArray(cookies) || cookies.length === 0) {
      console.warn(`[Main] set-webview-cookies: cookies 为空, partition=${partition}`);
      return false;
    }

    console.log(`[Main] 设置 webview cookies, partition=${partition}, count=${cookies.length}`);
    const ses = session.fromPartition(partition);

    // 逐个设置 cookie
    let successCount = 0;
    for (const cookie of cookies) {
      try {
        // 确保 Cookie 格式正确
        const cookieToSet: Electron.CookiesSetDetails = {
          url: cookie.url,
          name: cookie.name,
          value: cookie.value,
          domain: cookie.domain,
          path: cookie.path || '/',
        };

        // 可选字段
        if (typeof cookie.expirationDate === 'number' && Number.isFinite(cookie.expirationDate) && cookie.expirationDate > 0) {
          cookieToSet.expirationDate = cookie.expirationDate;
        }
        if (cookie.httpOnly !== undefined) {
          cookieToSet.httpOnly = cookie.httpOnly;
        }
        if (cookie.secure !== undefined) {
          cookieToSet.secure = cookie.secure;
        }
        if (cookie.sameSite) {
          cookieToSet.sameSite = cookie.sameSite as 'no_restriction' | 'lax' | 'strict';
        }

        await ses.cookies.set(cookieToSet);
        successCount++;

        // 记录关键 Cookie
        if (cookie.name === 'BDUSS' || cookie.name === 'STOKEN' || cookie.name === 'sessionid') {
          console.log(`[Main] 成功设置关键 Cookie: ${cookie.name}, domain: ${cookie.domain}`);
        }
      } catch (error) {
        console.error(`[Main] 设置 cookie 失败 (${cookie.name}):`, error);
      }
    }

    console.log(`[Main] 成功设置 ${successCount}/${cookies.length} 个 cookies`);

    // 验证 Cookie 是否真的设置成功
    try {
      const setCookies = await ses.cookies.get({ domain: '.baidu.com' });
      console.log(`[Main] 验证：当前 session 中有 ${setCookies.length} 个百度 Cookie`);
      const keyNames = setCookies.slice(0, 5).map(c => c.name).join(', ');
      console.log(`[Main] 关键 Cookie 名称: ${keyNames}`);
    } catch (verifyError) {
      console.error('[Main] 验证 Cookie 失败:', verifyError);
    }

    return successCount > 0;
  } catch (error) {
    console.error('[Main] 设置 cookies 失败:', error);
    return false;
  }
});

// 截取 webview 页面截图（用于 AI 分析）
ipcMain.handle('capture-webview-page', async (_event: unknown, webContentsId: number) => {
  try {
    const wc = webContents.fromId(webContentsId);
    if (!wc) {
      console.error('找不到 webContents:', webContentsId);
      return null;
    }

    const image = await wc.capturePage();
    if (!image || image.isEmpty()) {
      console.warn('截图为空');
      return null;
    }

    // 转换为 JPEG 格式的 Base64
    const buffer = image.toJPEG(80);
    return buffer.toString('base64');
  } catch (error) {
    console.error('截图失败:', error);
    return null;
  }
});

// 向 webview 发送鼠标点击事件
ipcMain.handle('webview-send-mouse-click', async (_event: unknown, webContentsId: number, x: number, y: number) => {
  try {
    const wc = webContents.fromId(webContentsId);
    if (!wc) {
      console.error('找不到 webContents:', webContentsId);
      return false;
    }

    // 发送鼠标移动事件
    wc.sendInputEvent({
      type: 'mouseMove',
      x: Math.round(x),
      y: Math.round(y),
    });

    // 短暂延迟后发送点击事件
    await new Promise(resolve => setTimeout(resolve, 50));

    // 发送鼠标按下事件
    wc.sendInputEvent({
      type: 'mouseDown',
      x: Math.round(x),
      y: Math.round(y),
      button: 'left',
      clickCount: 1,
    });

    // 短暂延迟后发送鼠标抬起事件
    await new Promise(resolve => setTimeout(resolve, 50));

    wc.sendInputEvent({
      type: 'mouseUp',
      x: Math.round(x),
      y: Math.round(y),
      button: 'left',
      clickCount: 1,
    });

    console.log(`[webview-send-mouse-click] Clicked at (${x}, ${y})`);
    return true;
  } catch (error) {
    console.error('发送点击事件失败:', error);
    return false;
  }
});

// 向 webview 发送键盘输入事件
ipcMain.handle('webview-send-text-input', async (_event: unknown, webContentsId: number, text: string) => {
  try {
    const wc = webContents.fromId(webContentsId);
    if (!wc) {
      console.error('找不到 webContents:', webContentsId);
      return false;
    }

    // 逐字符输入
    for (const char of text) {
      wc.sendInputEvent({
        type: 'char',
        keyCode: char,
      });
      await new Promise(resolve => setTimeout(resolve, 30));
    }

    console.log(`[webview-send-text-input] Typed: ${text}`);
    return true;
  } catch (error) {
    console.error('发送输入事件失败:', error);
    return false;
  }
});

// 获取 webview 页面元素位置
ipcMain.handle('webview-get-element-position', async (_event: unknown, webContentsId: number, selector: string) => {
  try {
    const wc = webContents.fromId(webContentsId);
    if (!wc) {
      console.error('找不到 webContents:', webContentsId);
      return null;
    }

    const result = await wc.executeJavaScript(`
      (function() {
        const el = document.querySelector('${selector.replace(/'/g, "\\'")}');
        if (!el) return null;
        const rect = el.getBoundingClientRect();
        return {
          x: rect.left + rect.width / 2,
          y: rect.top + rect.height / 2,
          width: rect.width,
          height: rect.height
        };
      })()
    `);

    return result;
  } catch (error) {
    console.error('获取元素位置失败:', error);
    return null;
  }
});

// 通过文本内容查找并点击元素
ipcMain.handle('webview-click-by-text', async (_event: unknown, webContentsId: number, text: string) => {
  try {
    const wc = webContents.fromId(webContentsId);
    if (!wc) {
      console.error('找不到 webContents:', webContentsId);
      return false;
    }

    // 查找包含指定文本的可点击元素的位置
    const position = await wc.executeJavaScript(`
      (function() {
        const searchText = '${text.replace(/'/g, "\\'")}';
        
        // 查找可点击元素
        const clickables = document.querySelectorAll('a, button, [role="button"], [onclick], input[type="submit"], input[type="button"]');
        for (const el of clickables) {
          if (el.textContent?.includes(searchText) || el.getAttribute('aria-label')?.includes(searchText) || el.getAttribute('title')?.includes(searchText)) {
            const rect = el.getBoundingClientRect();
            if (rect.width > 0 && rect.height > 0) {
              return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
            }
          }
        }
        
        // 查找所有包含文本的元素
        const allElements = document.querySelectorAll('*');
        for (const el of allElements) {
          const text = el.innerText?.trim();
          if (text && text.length < 100 && text.includes(searchText)) {
            const rect = el.getBoundingClientRect();
            if (rect.width > 0 && rect.height > 0 && rect.width < 500) {
              return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
            }
          }
        }
        
        return null;
      })()
    `);

    if (!position) {
      console.warn(`[webview-click-by-text] 未找到包含 "${text}" 的元素`);
      return false;
    }

    // 发送点击事件
    wc.sendInputEvent({ type: 'mouseMove', x: Math.round(position.x), y: Math.round(position.y) });
    await new Promise(resolve => setTimeout(resolve, 50));
    wc.sendInputEvent({ type: 'mouseDown', x: Math.round(position.x), y: Math.round(position.y), button: 'left', clickCount: 1 });
    await new Promise(resolve => setTimeout(resolve, 50));
    wc.sendInputEvent({ type: 'mouseUp', x: Math.round(position.x), y: Math.round(position.y), button: 'left', clickCount: 1 });

    console.log(`[webview-click-by-text] Clicked "${text}" at (${position.x}, ${position.y})`);
    return true;
  } catch (error) {
    console.error('通过文本点击失败:', error);
    return false;
  }
});

// ========== CDP 网络拦截功能 ==========
// 存储每个 webContents 的网络拦截配置
const networkInterceptors: Map<number, {
  patterns: Array<{ match: string, key: string }>;
  pendingRequests: Map<string, { url: string, timestamp: number }>;
}> = new Map();

// 清理已销毁的 webContents
app.on('web-contents-destroyed', (_event: unknown, contents: typeof webContents.prototype) => {
  const webContentsId = contents.id;
  if (networkInterceptors.has(webContentsId)) {
    // 清理网络拦截器
    try {
      contents.debugger.detach();
    } catch (e) {
      // 忽略错误
    }
    networkInterceptors.delete(webContentsId);
    console.log(`[CDP] 已清理已销毁的 webContents 拦截器: ${webContentsId}`);
  }
});

// 启用 CDP 网络拦截
ipcMain.handle('enable-network-intercept', async (_event: unknown, webContentsId: number, patterns: Array<{ match: string, key: string }>) => {
  try {
    const wc = webContents.fromId(webContentsId);
    if (!wc) {
      console.error('[CDP] 找不到 webContents:', webContentsId);
      return false;
    }

    // 如果已经有拦截器，先清理
    if (networkInterceptors.has(webContentsId)) {
      try {
        wc.debugger.detach();
      } catch (e) {
        // 忽略
      }
    }

    // 存储配置
    networkInterceptors.set(webContentsId, {
      patterns,
      pendingRequests: new Map()
    });

    // 附加调试器
    try {
      wc.debugger.attach('1.3');
    } catch (err: unknown) {
      const error = err as Error;
      if (!error.message?.includes('Already attached')) {
        throw err;
      }
    }

    // 启用网络监听
    await wc.debugger.sendCommand('Network.enable');

    // 监听网络响应
    wc.debugger.on('message', async (_e: unknown, method: string, params: {
      requestId?: string;
      response?: { url?: string; status?: number; mimeType?: string };
      encodedDataLength?: number;
    }) => {
      const config = networkInterceptors.get(webContentsId);
      if (!config) return;

      if (method === 'Network.responseReceived') {
        const { requestId, response } = params;
        if (!requestId || !response?.url) return;

        // 调试：打印百家号相关的所有 API 请求
        if (response.url.includes('baijiahao.baidu.com')) {
          if (response.url.includes('/pcui/') || response.url.includes('/article')) {
            console.log(`[CDP DEBUG] 百家号 API: ${response.url}`);
          }
        }

        // 检查是否匹配我们关注的 API
        for (const pattern of config.patterns) {
          if (response.url.includes(pattern.match)) {
            // 记录请求，等待响应完成
            config.pendingRequests.set(requestId, {
              url: response.url,
              timestamp: Date.now()
            });
            console.log(`[CDP] 匹配到 API: ${pattern.key} - ${response.url}`);
            break;
          }
        }
      }

      if (method === 'Network.loadingFinished') {
        const { requestId } = params;
        if (!requestId) return;

        const pending = config.pendingRequests.get(requestId);
        if (!pending) return;

        config.pendingRequests.delete(requestId);

        try {
          // 获取响应体
          const result = await wc.debugger.sendCommand('Network.getResponseBody', { requestId }) as { body: string; base64Encoded: boolean };
          let body = result.body;

          // 如果是 base64 编码，解码
          if (result.base64Encoded) {
            body = Buffer.from(body, 'base64').toString('utf8');
          }

          // 解析 JSON
          const data = JSON.parse(body);

          // 找到匹配的 key
          let matchedKey = '';
          for (const pattern of config.patterns) {
            if (pending.url.includes(pattern.match)) {
              matchedKey = pattern.key;
              break;
            }
          }

          if (matchedKey) {
            console.log(`[CDP] 获取到响应: ${matchedKey}`, JSON.stringify(data).substring(0, 200));
            // 发送到渲染进程
            mainWindow?.webContents.send('network-intercept-data', {
              webContentsId,
              key: matchedKey,
              url: pending.url,
              data
            });
          }
        } catch (err) {
          console.warn(`[CDP] 获取响应体失败:`, err);
        }
      }
    });

    console.log(`[CDP] 已启用网络拦截，webContentsId: ${webContentsId}, patterns:`, patterns.map(p => p.key));
    return true;
  } catch (error) {
    console.error('[CDP] 启用网络拦截失败:', error);
    return false;
  }
});

// 禁用 CDP 网络拦截
ipcMain.handle('disable-network-intercept', async (_event: unknown, webContentsId: number) => {
  try {
    const wc = webContents.fromId(webContentsId);
    if (wc) {
      try {
        wc.debugger.detach();
      } catch (e) {
        // 忽略
      }
    }
    const config = networkInterceptors.get(webContentsId);
    if (config) {
      // 清理待处理请求的 Map
      config.pendingRequests.clear();
    }
    networkInterceptors.delete(webContentsId);
    console.log(`[CDP] 已禁用网络拦截，webContentsId: ${webContentsId}`);
    return true;
  } catch (error) {
    console.error('[CDP] 禁用网络拦截失败:', error);
    return false;
  }
});

// 更新网络拦截的 patterns
ipcMain.handle('update-network-patterns', async (_event: unknown, webContentsId: number, patterns: Array<{ match: string, key: string }>) => {
  const config = networkInterceptors.get(webContentsId);
  if (config) {
    config.patterns = patterns;
    console.log(`[CDP] 已更新 patterns，webContentsId: ${webContentsId}`);
    return true;
  }
  return false;
});