const { app, BrowserWindow, dialog, ipcMain, safeStorage, session } = require("electron");
const crypto = require("node:crypto");
const fs = require("node:fs");
const path = require("node:path");
const tls = require("node:tls");
const { HardwareAgentClient } = require("./hardware-agent-client.cjs");

app.commandLine.appendSwitch("autoplay-policy", "no-user-gesture-required");
const automatedUI = process.env.SIMULATOR_AUTO_TEST === "1" || process.env.SIMULATOR_REAL_E2E === "1";
if (automatedUI) {
  app.commandLine.appendSwitch("use-fake-device-for-media-stream");
  app.commandLine.appendSwitch("use-fake-ui-for-media-stream");
}
app.disableHardwareAcceleration();

let deviceConfig = null;
let desiredConfigRevision = 1;
let mainWindow = null;
let hardwareConfig = null;
let hardwareClient = null;
let activeHardwarePlatformSession = null;

function createWindow() {
  const window = new BrowserWindow({
    width: 1220,
    height: 820,
    minWidth: 980,
    minHeight: 700,
    backgroundColor: "#eef3f0",
    autoHideMenuBar: true,
    title: "语音终端模拟器",
    webPreferences: {
      preload: path.join(__dirname, "preload.cjs"),
      contextIsolation: true,
      nodeIntegration: false,
      sandbox: true,
    },
  });
  mainWindow = window;
  window.once("closed", () => {
    if (mainWindow === window) mainWindow = null;
  });

  const devArgument = process.argv.find((argument) => argument.startsWith("--dev-server-url="));
  const devServerURL = devArgument ? devArgument.slice("--dev-server-url=".length) : "";
  window.webContents.on("did-fail-load", (_event, errorCode, errorDescription, validatedURL) => {
    console.error("renderer load failed", { errorCode, errorDescription, validatedURL });
  });
  window.webContents.on("render-process-gone", (_event, details) => {
    console.error("renderer process exited", details);
  });
  window.webContents.on("console-message", (_event, ...args) => {
    const details = args[0];
    const message = typeof details === "object" && details ? details.message : String(args[1] ?? details ?? "");
    console.log(`[renderer] ${message}`);
  });
  window.webContents.once("did-finish-load", async () => {
    try {
      const diagnostics = await window.webContents.executeJavaScript(`JSON.stringify({readyState: document.readyState, bodyLength: document.body.innerText.length, appChildren: document.querySelector('#app')?.childElementCount || 0})`);
      console.log(`[renderer-ready] ${diagnostics}`);
    } catch (error) {
      console.error("renderer diagnostics failed", error);
    }
    if (automatedUI) {
      void runAutomatedSmoke(window);
    }
  });

  if (devServerURL) {
    window.loadURL(devServerURL);
  } else {
    window.loadFile(path.join(__dirname, "..", "dist", "index.html"));
  }

  const screenshotPath = process.env.SIMULATOR_SCREENSHOT_PATH;
  if (screenshotPath) {
    window.webContents.once("did-finish-load", () => {
      setTimeout(async () => {
        try {
          const image = await window.webContents.capturePage();
          fs.writeFileSync(screenshotPath, image.toPNG());
        } catch (error) {
          console.error("simulator screenshot failed", error);
          process.exitCode = 1;
        } finally {
          app.quit();
        }
      }, 1200);
    });
  }
}

async function runAutomatedSmoke(window) {
  const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
  await delay(800);
  await window.webContents.executeJavaScript(`document.querySelector('#checkButton')?.click()`);
  for (let attempt = 0; attempt < 30; attempt += 1) {
    await delay(500);
    const state = await window.webContents.executeJavaScript(`JSON.stringify({phase: document.querySelector('#phaseBadge')?.textContent, canStart: !document.querySelector('#startButton')?.disabled, detail: document.querySelector('#apiDetail')?.textContent})`);
    console.log(`[auto-test] ${state}`);
    const parsed = JSON.parse(state);
    if (parsed.canStart) {
      await window.webContents.executeJavaScript(`document.querySelector('#startButton')?.click()`);
      console.log("[auto-test] start requested");
      await collectAutomatedConversationResult(window);
      return;
    }
    if (parsed.phase === "异常") {
      return;
    }
  }
  console.error("[auto-test] environment check did not become ready");
}

async function collectAutomatedConversationResult(window) {
  const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
  const deadline = Date.now() + 120_000;
  let realQuestionSent = false;
  let snapshot = {};
  while (Date.now() < deadline) {
    await delay(1000);
    const encoded = await window.webContents.executeJavaScript(`JSON.stringify({
      phase: document.querySelector('#phaseBadge')?.textContent || '',
      conversation_id: document.querySelector('#conversationID')?.textContent || '',
      model_mode: document.querySelector('#modelMode')?.value || '',
      subject: [...document.querySelectorAll('.transcript-turn--subject span')].map((item) => item.textContent || ''),
      agent: [...document.querySelectorAll('.transcript-turn--agent span')].map((item) => item.textContent || ''),
      turns: [...document.querySelectorAll('.transcript-turn')].map((item) => ({speaker: item.classList.contains('transcript-turn--subject') ? 'subject' : 'agent', text: item.querySelector('span')?.textContent || ''})),
      events: [...document.querySelectorAll('#eventLog li span')].map((item) => item.textContent || ''),
      checks: [...document.querySelectorAll('#flowChecks .flow-check')].map((item) => ({label: item.querySelector('span')?.textContent || '', detail: item.querySelector('small')?.textContent || '', status: item.classList.contains('flow-check--passed') ? 'passed' : item.classList.contains('flow-check--failed') ? 'failed' : 'pending'}))
    })`);
    snapshot = JSON.parse(encoded);
    console.log(`[auto-test] conversation ${encoded}`);
    if (process.env.SIMULATOR_REAL_E2E === "1" && snapshot.phase === "通话中" && !realQuestionSent) {
      const question = String(process.env.SIMULATOR_REAL_E2E_QUESTION || "请用一句简短的话介绍你自己。 ").trim();
      await window.webContents.executeJavaScript(`(() => { const input = document.querySelector('#textQuestion'); if (input) input.value = ${JSON.stringify(question)}; document.querySelector('#sendTextButton')?.click(); })()`);
      realQuestionSent = true;
      console.log("[real-e2e] text question sent");
    }
    const subjectIndex = snapshot.turns?.findIndex((turn) => turn.speaker === "subject") ?? -1;
    const hasAgentReply = subjectIndex >= 0 && snapshot.turns.slice(subjectIndex + 1).some((turn) => turn.speaker === "agent");
    if (hasAgentReply) {
      const hardwarePage = await window.webContents.executeJavaScript(`Boolean(document.querySelector('#flowChecks'))`);
      const waitForPlatformStop = hardwarePage && process.env.SIMULATOR_AUTO_WAIT_FOR_PLATFORM_STOP === "1";
      if (!waitForPlatformStop) await window.webContents.executeJavaScript(`document.querySelector('#stopButton')?.click()`);
      if (hardwarePage) {
        const stopDeadline = Date.now() + 30_000;
        while (Date.now() < stopDeadline) {
          await delay(500);
          const phase = await window.webContents.executeJavaScript(`document.querySelector('#phaseBadge')?.textContent || ''`);
          if (phase === "已完成" || phase === "异常") break;
        }
        const finalEncoded = await window.webContents.executeJavaScript(`JSON.stringify({
          phase: document.querySelector('#phaseBadge')?.textContent || '',
          conversation_id: document.querySelector('#conversationID')?.textContent || '',
          model_mode: document.querySelector('#modelMode')?.value || '',
          turns: [...document.querySelectorAll('.transcript-turn')].map((item) => ({speaker: item.classList.contains('transcript-turn--subject') ? 'subject' : 'agent', text: item.querySelector('span')?.textContent || ''})),
          events: [...document.querySelectorAll('#eventLog li span')].map((item) => item.textContent || ''),
          checks: [...document.querySelectorAll('#flowChecks .flow-check')].map((item) => ({label: item.querySelector('span')?.textContent || '', detail: item.querySelector('small')?.textContent || '', status: item.classList.contains('flow-check--passed') ? 'passed' : item.classList.contains('flow-check--failed') ? 'failed' : 'pending'}))
        })`);
        snapshot = JSON.parse(finalEncoded);
        snapshot.result = snapshot.phase === "已完成" ? "PASS" : "ERROR";
      } else {
        snapshot.result = "PASS";
      }
      break;
    }
    if (snapshot.phase === "异常") {
      snapshot.result = "ERROR";
      break;
    }
  }
  if (!snapshot.result) snapshot.result = "TIMEOUT";
  const resultPath = process.env.SIMULATOR_AUTO_RESULT_PATH;
  if (resultPath) {
    fs.writeFileSync(path.resolve(resultPath), JSON.stringify(snapshot, null, 2), "utf8");
  }
  await delay(4000);
  app.quit();
}

function ensureAllowedAPIURL(value) {
  const parsed = new URL(String(value || ""));
  const loopback = parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost" || parsed.hostname === "[::1]";
  const deployedTestServer = parsed.protocol === "https:" && parsed.hostname === "121.41.46.238" && parsed.port === "";
  if ((!loopback || (parsed.protocol !== "http:" && parsed.protocol !== "https:")) && !deployedTestServer) {
    throw new Error("测试设备只允许连接本机平台或已部署的测试服务器");
  }
  return parsed.origin;
}

function configure(input) {
  const apiURL = ensureAllowedAPIURL(input?.apiURL);
  const deviceID = String(input?.deviceID || "").trim();
  const deviceSecret = String(input?.deviceSecret || "") || loadDefaultDeviceSecret();
  if (!/^[0-9a-f-]{36}$/i.test(deviceID)) {
    throw new Error("设备 ID 必须是 UUID");
  }
  if (deviceSecret.length < 32) {
    throw new Error("未找到有效的设备密钥。请使用云端设备启动脚本，或在设备签名密钥中输入至少32个字符");
  }
  deviceConfig = { apiURL, deviceID, deviceSecret };
  return { apiURL, deviceID };
}

function loadDefaultDeviceSecret() {
  const environmentSecret = String(process.env.SIMULATOR_DEFAULT_DEVICE_SECRET || "").trim();
  if (environmentSecret) return environmentSecret;
  const candidates = [];
  const localAppData = String(process.env.LOCALAPPDATA || "").trim();
  const userProfile = String(process.env.USERPROFILE || "").trim();
  const portableDirectory = String(process.env.PORTABLE_EXECUTABLE_DIR || "").trim();
  if (localAppData) {
    candidates.push(path.join(localAppData, "DataTerminalHardwareAgent", "server-device-secret"));
    candidates.push(path.join(localAppData, "DataTerminalVoiceDevice", "server-device-secret"));
  }
  if (userProfile) candidates.push(path.join(userProfile, "AppData", "Local", "DataTerminalVoiceDevice", "server-device-secret"));
  try {
    const home = app.getPath("home");
    if (home) candidates.push(path.join(home, "AppData", "Local", "DataTerminalVoiceDevice", "server-device-secret"));
  } catch { /* app path is unavailable before ready */ }
  if (portableDirectory) candidates.push(path.join(portableDirectory, ".server-device-secret"));
  candidates.push(path.join(path.dirname(process.execPath), ".server-device-secret"));

  for (const secretPath of new Set(candidates)) {
    try {
      const stats = fs.statSync(secretPath);
      if (!stats.isFile() || stats.size < 32 || stats.size > 4096) continue;
      const value = fs.readFileSync(secretPath, "utf8").trim();
      if (value.length >= 32) return value;
    } catch { /* try the next fixed credential location */ }
  }
  return "";
}

ipcMain.handle("sim:get-runtime-defaults", () => ({
  apiURL: process.env.SIMULATOR_DEFAULT_API_URL || "https://121.41.46.238",
  deviceID: process.env.SIMULATOR_DEFAULT_DEVICE_ID || "10000000-0000-0000-0000-000000000512",
  deviceSecret: "",
  deviceSecretConfigured: loadDefaultDeviceSecret().length >= 32,
}));

function hardwareCredentialPath() {
  return path.join(app.getPath("userData"), "volc-hardware-device-credential.json");
}

function readSavedHardwareMetadata() {
  try {
    const stored = JSON.parse(fs.readFileSync(hardwareCredentialPath(), "utf8"));
    if (!stored.instanceID || !stored.productKey || !stored.deviceName || !stored.encryptedDeviceSecret) return undefined;
    return stored;
  } catch { return undefined; }
}

function loadSavedHardwareCredential(identity) {
  if (!safeStorage.isEncryptionAvailable()) return undefined;
  try {
    const stored = JSON.parse(fs.readFileSync(hardwareCredentialPath(), "utf8"));
    if (stored.schemaVersion !== 3 || stored.instanceID !== identity.instanceID || stored.productKey !== identity.productKey || stored.deviceName !== identity.deviceName) return undefined;
    const secret = safeStorage.decryptString(Buffer.from(stored.encryptedDeviceSecret, "base64"));
    if (secret.length < 16) return undefined;
    return { deviceSecret: secret, hardwareID: String(stored.hardwareID || identity.hardwareID || "") };
  } catch { return undefined; }
}

function saveHardwareCredential(identity, deviceSecret, metadata = {}) {
  if (!safeStorage.isEncryptionAvailable()) return false;
  const target = hardwareCredentialPath();
  fs.mkdirSync(path.dirname(target), { recursive: true });
  const payload = {
    schemaVersion: 3,
    instanceID: identity.instanceID,
    productKey: identity.productKey,
    deviceName: identity.deviceName,
    hardwareID: identity.hardwareID,
    platformDeviceID: String(deviceConfig?.deviceID || ""),
    credentialRef: String(metadata.credentialRef || ""),
    credentialVersion: Number(metadata.credentialVersion || 1),
    encryptedDeviceSecret: safeStorage.encryptString(deviceSecret).toString("base64"),
    updatedAt: new Date().toISOString(),
  };
  const temporary = `${target}.${process.pid}.tmp`;
  fs.writeFileSync(temporary, `${JSON.stringify(payload, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
  fs.renameSync(temporary, target);
  return true;
}

function hardwareIdentity(input) {
  const instanceID = String(input?.instanceID || "").trim();
  const productKey = String(input?.productKey || "").trim();
  const deviceName = String(input?.deviceName || "").trim();
  const hardwareID = String(input?.hardwareID || "").trim();
  if (!instanceID || instanceID.length > 200) throw new Error("实例 ID 不能为空或过长");
  if (!productKey || productKey.length > 200) throw new Error("Product Key 不能为空或过长");
  if (!/^[a-zA-Z0-9_\-.:@]{1,128}$/.test(deviceName)) throw new Error("火山设备名称格式不正确");
  if (!hardwareID || hardwareID.length > 200) throw new Error("Hardware ID 不能为空或过长");
  return { instanceID, productKey, deviceName, hardwareID };
}

ipcMain.handle("sim:get-hardware-runtime-defaults", () => {
  const candidateMetadata = readSavedHardwareMetadata();
  const legacyMock = candidateMetadata && [candidateMetadata.instanceID, candidateMetadata.productKey, candidateMetadata.deviceName, candidateMetadata.hardwareID]
    .some((value) => String(value || "").toLowerCase().includes("mock") || String(value || "").toLowerCase().includes("e2e"));
  const savedMetadata = automatedUI || !legacyMock ? candidateMetadata : undefined;
  const instanceID = String(process.env.SIMULATOR_VOLC_INSTANCE_ID || savedMetadata?.instanceID || "").trim();
  const productKey = String(process.env.SIMULATOR_VOLC_PRODUCT_KEY || savedMetadata?.productKey || "").trim();
  const deviceName = String(process.env.SIMULATOR_VOLC_DEVICE_NAME || savedMetadata?.deviceName || "windows-hardware-agent-test").trim();
  const hardwareID = String(process.env.SIMULATOR_VOLC_HARDWARE_ID || savedMetadata?.hardwareID || `windows-${crypto.createHash("sha256").update(app.getPath("userData")).digest("hex").slice(0, 24)}`).trim();
  const modelMode = String(process.env.SIMULATOR_VOLC_MODEL_MODE || "llm").trim().toLowerCase() === "s2s" ? "s2s" : "llm";
  const saved = instanceID && productKey ? loadSavedHardwareCredential({ instanceID, productKey, deviceName, hardwareID }) : undefined;
  return { instanceID, productKey, deviceName, hardwareID, modelMode, deviceCredentialConfigured: Boolean(saved) };
});

ipcMain.handle("sim:configure-hardware", async (_event, input) => {
  if (!deviceConfig) throw new Error("请先连接平台");
  const requestedHardwareID = String(input?.hardwareID || "").trim();
  if (!requestedHardwareID || requestedHardwareID.length > 200) throw new Error("Hardware ID 不能为空或过长");
  const automatedTest = process.env.SIMULATOR_AUTO_TEST === "1";
  let provisioned;
  if (automatedTest) {
    provisioned = {
      instance_id: String(process.env.SIMULATOR_VOLC_INSTANCE_ID || "").trim(),
      product_key: String(process.env.SIMULATOR_VOLC_PRODUCT_KEY || "").trim(),
      device_name: String(process.env.SIMULATOR_VOLC_DEVICE_NAME || "").trim(),
      hardware_id: String(process.env.SIMULATOR_VOLC_HARDWARE_ID || requestedHardwareID).trim(),
      device_secret: String(process.env.SIMULATOR_VOLC_DEVICE_SECRET || "").trim(),
      credential_source: "isolated_test_override",
      credential_version: 1,
      credential_ref: "test-only",
    };
  } else {
    provisioned = await deviceRequest("POST", "/device/v3/hardware-agent-credentials:provision", {
      hardware_id: requestedHardwareID,
    }, `windows-hardware-provision-${nonce()}`);
  }
  const identity = hardwareIdentity({
    instanceID: provisioned?.instance_id,
    productKey: provisioned?.product_key,
    deviceName: provisioned?.device_name,
    hardwareID: provisioned?.hardware_id,
  });
  const deviceSecret = String(provisioned?.device_secret || "").trim();
  if (deviceSecret.length < 16 || deviceSecret.length > 4096) throw new Error("Device Secret 长度不正确");
  const persisted = automatedTest ? false : saveHardwareCredential(identity, deviceSecret, {
    credentialRef: provisioned?.credential_ref,
    credentialVersion: provisioned?.credential_version,
  });
  if (!automatedTest && !persisted) throw new Error("Windows 安全存储不可用，拒绝保存 Device Secret");
  hardwareConfig = { ...identity, deviceSecret };
  // 首次预配会由平台发布产品级默认 Bot/传输配置，并可能推进配置版本。
  // 设备必须重新拉取版本，后续创建会话时不能继续上报预配前的旧 revision。
  if (!automatedTest) {
    const configuration = await deviceRequest("GET", "/device/v2/config");
    desiredConfigRevision = Number(configuration?.revision || desiredConfigRevision || 1);
  }
  return {
    ...identity,
    registered: String(provisioned?.credential_source || "").includes("dynamic_registration"),
    persisted,
    credentialSource: String(provisioned?.credential_source || "platform_provisioning"),
    credentialVersion: Number(provisioned?.credential_version || 1),
    configRevision: desiredConfigRevision,
  };
});

function nonce() {
  return crypto.randomBytes(16).toString("hex");
}

function signedHeaders(method, requestURI, body) {
  if (!deviceConfig) throw new Error("请先连接本地平台");
  const timestamp = new Date().toISOString();
  const requestNonce = nonce();
  const digest = crypto.createHash("sha256").update(body).digest("hex");
  const canonical = [method.toUpperCase(), requestURI, timestamp, requestNonce, digest].join("\n");
  const signature = crypto.createHmac("sha256", deviceConfig.deviceSecret).update(canonical).digest("base64url");
  return {
    "X-Device-Id": deviceConfig.deviceID,
    "X-Device-Timestamp": timestamp,
    "X-Device-Nonce": requestNonce,
    "X-Device-Content-SHA256": digest,
    "X-Device-Signature": signature,
  };
}

async function deviceRequest(method, requestPath, payload, idempotencyKey) {
  if (!deviceConfig) throw new Error("请先连接本地平台");
  const target = new URL(requestPath, `${deviceConfig.apiURL}/`);
  const body = payload === undefined ? "" : JSON.stringify(payload);
  const headers = signedHeaders(method, `${target.pathname}${target.search}`, body);
  headers.Accept = "application/json";
  if (body) headers["Content-Type"] = "application/json";
  if (idempotencyKey) headers["Idempotency-Key"] = idempotencyKey;
  const response = await fetch(target, { method, headers, body: body || undefined });
  const text = await response.text();
  let parsed;
  try {
    parsed = text ? JSON.parse(text) : {};
  } catch {
    parsed = { message: text };
  }
  if (!response.ok) {
    const code = parsed?.error?.code || parsed?.code || `HTTP_${response.status}`;
    const message = parsed?.error?.message || parsed?.message || "本地平台请求失败";
    throw new Error(`${code}: ${message}`);
  }
  return parsed?.data ?? parsed;
}

ipcMain.handle("sim:configure", (_event, input) => configure(input));

ipcMain.handle("sim:probe", async () => {
  const query = new URLSearchParams({
    firmware_version: "0.3.2-windows-hardware-agent",
    board_rev: "windows-x64",
    rtc_sdk_version: "web-4.69.0-electron",
    codec: "opus",
    sample_rate: "48000",
    network: "windows-local",
    device_time: new Date().toISOString(),
  });
  const bootstrap = await deviceRequest("GET", `/device/v2/bootstrap?${query.toString()}`);
  const configuration = await deviceRequest("GET", "/device/v2/config");
  desiredConfigRevision = Number(configuration.revision || bootstrap?.device?.config_revision || 1);
  return { bootstrap, configuration, desiredConfigRevision };
});

const rtcWebEndpoints = [
  "access.rtc.volcvideo.com",
  "access2-hl.rtc.volcvideo.com",
  "common.rtc.volcvideo.com",
  "rtcg-access.volcvideos.com",
  "rtcg.volcvideos.com",
  "web-log-report.rtc.volcvideo.com",
  "web-log-report.volcvideos.com",
];

function probeTLSEndpoint(hostname) {
  return new Promise((resolve) => {
    const socket = tls.connect({ host: hostname, port: 443, servername: hostname, rejectUnauthorized: true });
    let finished = false;
    const finish = (result) => {
      if (finished) return;
      finished = true;
      socket.destroy();
      resolve(result);
    };
    socket.setTimeout(5_000, () => finish({ hostname, ok: false, error: "连接超时" }));
    socket.once("secureConnect", () => finish({ hostname, ok: true }));
    socket.once("error", (error) => finish({ hostname, ok: false, error: String(error?.code || error?.message || "连接失败") }));
  });
}

ipcMain.handle("sim:probe-rtc-network", async () => {
  const endpoints = await Promise.all(rtcWebEndpoints.map(probeTLSEndpoint));
  return { endpoints };
});

ipcMain.handle("sim:probe-hardware-network", async () => {
  const endpoints = await Promise.all([
    probeTLSEndpoint("ai-gateway.vei.volces.com"),
    probeTLSEndpoint("iot-cn-shanghai.iot.volces.com"),
  ]);
  return { endpoints };
});

ipcMain.handle("sim:get-automation-audio", async () => {
  const configuredPath = String(process.env.SIMULATOR_AUTOMATED_AUDIO_PATH || "").trim();
  if (!configuredPath) return undefined;
  const resolvedPath = path.resolve(configuredPath);
  const stats = fs.statSync(resolvedPath);
  if (!stats.isFile() || stats.size < 1 || stats.size > 10 * 1024 * 1024) {
    throw new Error("自动验证音频必须是 1 字节到 10MB 的文件");
  }
  const extension = path.extname(resolvedPath).toLowerCase();
  const mime = extension === ".mp3" ? "audio/mpeg" : extension === ".ogg" ? "audio/ogg" : "audio/wav";
  return {
    data_url: `data:${mime};base64,${fs.readFileSync(resolvedPath).toString("base64")}`,
    source_name: path.basename(resolvedPath),
  };
});

ipcMain.handle("sim:create-conversation", async () => deviceRequest("POST", "/device/v2/conversations", {
  device_time: new Date().toISOString(),
  monotonic_ms: Math.max(0, Math.round(performance.now())),
  capabilities: {
    rtc: true,
    audio_tracks: ["near", "far"],
    upload_resume: true,
    rtc_credential_renewal: true,
  },
  network: { type: "windows-local" },
  requested_goal: "open_conversation",
}, `windows-create-${nonce()}`));

ipcMain.handle("sim:create-hardware-agent-session", async () => deviceRequest("POST", "/device/v3/agent-sessions", {
  device_time: new Date().toISOString(),
  monotonic_ms: Math.max(0, Math.round(performance.now())),
  capabilities: {
    hardware_agent: true,
    sdk_version: "1.1.0-windows-standard-protocol",
    transports: ["low_load"],
    input_audio_format: "pcm_s16le_16000_mono",
    output_audio_format: "pcm_s16le_16000_mono",
    server_event_callback: false,
    transcript_upload: true,
    dynamic_session_config: true,
    credential_rotation: true,
    near_pcm_recording: false,
    far_pcm_recording: false,
  },
  network: { type: "windows-local" },
  requested_goal: "open_conversation",
  config_revision: desiredConfigRevision,
}, `windows-hardware-create-${nonce()}`));

function emitHardwareEvent(event) {
  if (!mainWindow || mainWindow.isDestroyed()) return;
  mainWindow.webContents.send("sim:hardware-provider-event", event);
}

function allowedHardwareGatewayURL() {
  const configured = String(process.env.SIMULATOR_HARDWARE_GATEWAY_URL || "wss://ai-gateway.vei.volces.com/v1/realtime").trim();
  const parsed = new URL(configured);
  const official = parsed.protocol === "wss:" && parsed.hostname === "ai-gateway.vei.volces.com";
  const local = (parsed.protocol === "ws:" || parsed.protocol === "wss:") && ["127.0.0.1", "localhost", "[::1]"].includes(parsed.hostname);
  if (!official && !local) throw new Error("硬件智能体网关只允许火山官方地址或本机测试地址");
  return parsed.toString();
}

async function invokeHardwareMemoryTool(event) {
  const client = hardwareClient;
  const platformSession = activeHardwarePlatformSession;
  if (!client || !platformSession) return;
  const callID = String(event.call_id || "");
  const functionName = String(client.pendingCalls.get(callID) || "").toLowerCase();
  if (!["memory_search", "search_memory", "retrieve_memory"].includes(functionName)) return;
  let argumentsValue = {};
  try { argumentsValue = JSON.parse(String(event.arguments || "{}")); } catch { /* invalid input is handled below */ }
  const query = String(argumentsValue.query || argumentsValue.keyword || argumentsValue.text || "").trim();
  const limit = Math.max(1, Math.min(5, Number(argumentsValue.limit || 3)));
  try {
    if (!query) throw new Error("记忆工具缺少 query 参数");
    const baseURL = new URL(deviceConfig.apiURL);
    const target = new URL(platformSession.session_config.tool_url, `${baseURL.origin}/`);
    if (target.origin !== baseURL.origin) throw new Error("记忆工具地址必须与平台同源");
    const response = await fetch(target, {
      method: "POST",
      headers: {
        Accept: "application/json",
        Authorization: `Bearer ${platformSession.session_config.tool_scope_token}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ query, limit }),
    });
    const raw = await response.text();
    let body;
    try { body = raw ? JSON.parse(raw) : {}; } catch { body = { message: raw }; }
    if (!response.ok) throw new Error(body?.error?.message || body?.message || `HTTP ${response.status}`);
    const result = body?.data ?? body;
    client.completeFunctionCall(callID, result);
    emitHardwareEvent({ type: "platform.memory_search.completed", call_id: callID, query, result_count: result?.items?.length || 0, degraded: Boolean(result?.degraded) });
  } catch (error) {
    client.completeFunctionCall(callID, { items: [], degraded: true, error: error.message });
    emitHardwareEvent({ type: "platform.memory_search.failed", call_id: callID, message: error.message });
  }
}

ipcMain.handle("sim:connect-hardware-agent", async (_event, input) => {
  if (!deviceConfig) throw new Error("请先连接平台");
  if (!hardwareConfig) throw new Error("请先完成火山设备鉴权配置");
  if (hardwareClient) throw new Error("已有硬件智能体连接，请先结束");
  const platformSession = input?.platformSession;
  if (!platformSession?.runtime?.bot_id || !platformSession?.session_config?.dialog_id) throw new Error("平台硬件会话配置不完整");
  if (platformSession.runtime.transport !== "low_load") throw new Error("Windows 标准协议测试程序只接受设备绑定为 low_load 的会话");
  const modelMode = String(input?.modelMode || "llm").trim().toLowerCase();
  if (!new Set(["llm", "s2s"]).has(modelMode)) throw new Error("智能体模型类型必须为 llm 或 s2s");
  activeHardwarePlatformSession = platformSession;
  const client = new HardwareAgentClient({
    gatewayURL: allowedHardwareGatewayURL(),
    emit: (event) => {
      emitHardwareEvent(event);
      if (event.type === "response.function_call_arguments.done") void invokeHardwareMemoryTool(event);
    },
  });
  hardwareClient = client;
  try {
    return await client.connect({
      ...hardwareConfig,
      botID: platformSession.runtime.bot_id,
      sessionConfig: platformSession.session_config,
      modelMode,
    });
  } catch (error) {
    hardwareClient = null;
    activeHardwarePlatformSession = null;
    throw error;
  }
});

ipcMain.on("sim:hardware-agent-audio", (_event, bytes) => {
  try { hardwareClient?.sendAudio(Buffer.from(bytes)); }
  catch (error) { emitHardwareEvent({ type: "transport.audio_error", message: error.message }); }
});

ipcMain.handle("sim:hardware-agent-text", (_event, input) => {
  if (!hardwareClient) throw new Error("火山硬件智能体连接未就绪");
  hardwareClient.sendText(input?.text, Number(input?.interruptMode || 1));
  return { accepted: true };
});

ipcMain.handle("sim:close-hardware-agent", (_event, input) => {
  const client = hardwareClient;
  hardwareClient = null;
  activeHardwarePlatformSession = null;
  client?.close(Number(input?.code || 1000), String(input?.reason || "device session ended").slice(0, 100));
  return { closed: true };
});

ipcMain.handle("sim:save-hardware-report", async (_event, report) => {
  const result = await dialog.showSaveDialog(mainWindow, {
    title: "导出硬件对话智能体测试报告",
    defaultPath: `hardware-agent-test-${new Date().toISOString().replace(/[:.]/g, "-")}.json`,
    filters: [{ name: "JSON 测试报告", extensions: ["json"] }],
  });
  if (result.canceled || !result.filePath) return { saved: false };
  const redact = (value) => {
    if (Array.isArray(value)) return value.map(redact);
    if (!value || typeof value !== "object") return value;
    const output = {};
    for (const [key, item] of Object.entries(value)) {
      if (/secret|signature|authorization|tool_scope_token|systemmessages|system_role|system_prompt|authorized_context|speaking_style|instructions/i.test(key)) output[key] = "[REDACTED]";
      else output[key] = redact(item);
    }
    return output;
  };
  const safeReport = redact(JSON.parse(JSON.stringify(report)));
  fs.writeFileSync(result.filePath, `${JSON.stringify(safeReport, null, 2)}\n`, "utf8");
  return { saved: true, path: result.filePath };
});

ipcMain.handle("sim:hardware-agent-event", async (_event, input) => deviceRequest(
  "POST",
  `/device/v3/agent-sessions/${encodeURIComponent(input.conversationID)}/events`,
  {
    event_id: input.eventID || `windows-hardware-event-${nonce()}`,
    sequence_no: Number(input.sequenceNo),
    event_type: input.eventType,
    occurred_at: new Date().toISOString(),
    provider_session_ref: input.providerSessionRef,
    session_nonce: input.sessionNonce,
    ...(input.eventType === "session_started" ? {
      provider_connection_ref: input.providerConnectionRef,
      bot_id: input.botID,
      transport: input.transport,
      config_digest: input.configDigest,
      dynamic_config_applied: input.dynamicConfigApplied,
    } : {}),
    ...(input.errorCode ? { error_code: input.errorCode } : {}),
  },
));

ipcMain.handle("sim:activate-conversation", async (_event, input) => deviceRequest(
  "POST",
  `/device/v2/conversations/${encodeURIComponent(input.conversationID)}/activate`,
  {
    joined_at: new Date().toISOString(),
    room_id: input.roomID,
    rtc_user_id: input.userID,
    rtc_join_result: "success",
    config_revision: desiredConfigRevision,
    connection_reference: "windows-electron-web-rtc",
  },
  `windows-activate-${nonce()}`,
));

ipcMain.handle("sim:get-conversation", async (_event, conversationID) => deviceRequest(
  "GET",
  `/device/v2/conversations/${encodeURIComponent(conversationID)}`,
));

ipcMain.handle("sim:heartbeat", async (_event, input) => deviceRequest(
  "POST",
  `/device/v2/conversations/${encodeURIComponent(input.conversationID)}/heartbeat`,
  {
    sequence_no: input.sequenceNo,
    device_time: new Date().toISOString(),
    monotonic_ms: Math.max(0, Math.round(performance.now())),
    conversation_status: "ACTIVE",
    rtc: { joined: true, uplink: true, downlink: true },
    network: { type: "windows-local" },
    firmware_version: "0.3.2-windows-hardware-agent",
    reported_config_revision: desiredConfigRevision,
    rtc_credential_expires_at: input.credentialExpiresAt,
    recording_queue: { pending_segments: 0, failed_segments: 0 },
    command_results: [],
  },
));

ipcMain.handle("sim:submit-transcript-batch", async (_event, input) => {
  const conversationID = String(input?.conversationID || "");
  const turns = Array.isArray(input?.turns) ? input.turns : [];
  if (!conversationID || turns.length === 0) {
    throw new Error("通话编号和最终话轮不能为空");
  }
  const payload = { turns };
  const digest = crypto.createHash("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 32);
  return deviceRequest(
    "POST",
    `/${input?.hardwareAgent ? "device/v3/agent-sessions" : "device/v2/conversations"}/${encodeURIComponent(conversationID)}/turns:batch`,
    payload,
    `windows-turns-${digest}`,
  );
});

ipcMain.handle("sim:stop-conversation", async (_event, input) => deviceRequest(
  "POST",
  `/device/v2/conversations/${encodeURIComponent(input.conversationID)}/stop`,
  {
    reason: input.reason || "windows_user_hangup",
    device_time: new Date().toISOString(),
    last_heartbeat_sequence: input.lastHeartbeatSequence || 0,
    rtc_left: true,
    recording: { near_segments: Number(input.nearSegments || 0), far_segments: Number(input.farSegments || 0) },
  },
  `windows-stop-${nonce()}`,
));

ipcMain.handle("sim:upload-conversation-recording", async (_event, input) => {
  const conversationID = String(input?.conversationID || "");
  const supplied = Array.isArray(input?.segments) ? input.segments : [];
  if (!conversationID || supplied.length === 0) throw new Error("通话编号和录音分片不能为空");

  const segments = supplied.map((segment) => {
    const bytes = Buffer.from(segment.bytes);
    if (!bytes.length || bytes.length > 64 * 1024 * 1024) throw new Error("单个录音分片必须在 1 字节到 64MiB 之间");
    return {
      track: segment.track,
      sequence_no: Number(segment.sequence_no),
      codec: segment.codec,
      content_type: segment.content_type,
      duration_ms: Number(segment.duration_ms),
      expected_size: bytes.length,
      expected_digest: crypto.createHash("sha256").update(bytes).digest("hex"),
      bytes,
    };
  });
  const manifest = { segments: segments.map(({ bytes: _bytes, ...segment }) => segment) };
  const manifestDigest = crypto.createHash("sha256").update(JSON.stringify(manifest)).digest("hex").slice(0, 40);
  const batch = await deviceRequest(
    "POST",
    `/device/v2/conversations/${encodeURIComponent(conversationID)}/upload-batches`,
    manifest,
    `windows-media-${manifestDigest}`,
  );

  for (const local of segments) {
    const remote = batch.segments?.find((segment) => segment.track === local.track && Number(segment.sequence_no) === local.sequence_no);
    if (!remote) throw new Error(`平台未返回${local.track}轨道第${local.sequence_no}段录音`);
    if (remote.status === "VERIFIED" || remote.status === "VERIFYING") continue;
    if (!remote.upload_url) throw new Error(`平台未签发${local.track}轨道第${local.sequence_no}段上传地址`);
    const response = await fetch(remote.upload_url, { method: "PUT", headers: { "Content-Type": local.content_type }, body: local.bytes });
    if (!response.ok) throw new Error(`录音对象上传失败：HTTP ${response.status}`);
  }

  await deviceRequest("POST", `/device/v2/upload-batches/${encodeURIComponent(batch.id)}/complete`, {});
  const deadline = Date.now() + 90_000;
  while (Date.now() < deadline) {
    const current = await deviceRequest("GET", `/device/v2/upload-batches/${encodeURIComponent(batch.id)}`);
    if (current.status === "COMPLETED") return current;
    if (current.status === "FAILED" || current.status === "EXPIRED") {
      const rejected = current.segments?.find((segment) => segment.status === "REJECTED");
      throw new Error(rejected?.last_error_code || current.last_error_code || `录音批次${current.status}`);
    }
    await new Promise((resolve) => setTimeout(resolve, 750));
  }
  throw new Error("录音已上传，但等待服务器校验超时");
});

app.whenReady().then(() => {
  session.defaultSession.setPermissionCheckHandler((_webContents, permission) => permission === "media");
  session.defaultSession.setPermissionRequestHandler((_webContents, permission, callback) => callback(permission === "media"));
  createWindow();
});

app.on("window-all-closed", () => {
  hardwareClient?.close(1001, "application closed");
  hardwareClient = null;
  activeHardwarePlatformSession = null;
  if (process.platform !== "darwin") app.quit();
});

app.on("activate", () => {
  if (BrowserWindow.getAllWindows().length === 0) createWindow();
});