const fs = require("node:fs");
const path = require("node:path");
const { randomUUID, constants, verify } = require("node:crypto");
const express = require("express");
const multer = require("multer");

const BASE_FOLDER = "ReinLoop_GUI";
const VOLUME_REQUEST_TTL_MS = Number(process.env.VOLUME_REQUEST_TTL_MS || 300000);
const DOWNLOAD_URL_TTL_MS = Number(process.env.DOWNLOAD_URL_TTL_MS || process.env.DOWNLOAD_TOKEN_TTL_MS || 300000);
const DEVICE_TOKEN_TTL_MS = Number(process.env.DEVICE_TOKEN_TTL_MS || 15 * 60 * 1000);
const IDENTIFICATION_RETENTION_MS = Number(process.env.IDENTIFICATION_RETENTION_MS || 30 * 24 * 60 * 60 * 1000);
const DEVICE_HEARTBEAT_TTL_MS = 30_000;
const CONFIG_SCHEMAS = {
  volume: {
    q_in_val: "number", dt: "number", xa_full: "number", p_max: "number",
    fit_low: "number", fit_high: "number", T_delta: "number", num_runs: "integer"
  },
  identification: {
    q_in_val: "number", dt: "number", n_order: "integer", t_c: "number",
    levels: "array", dead_area: "number", xa_full: "number", V_val: "number",
    repeat: "integer"
  }
};

function normalizeRelativePath(value, fallback = "") {
  const normalized = String(value || fallback).trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
  if (!normalized || normalized.split("/").some((part) => !part || part === "." || part === "..")) {
    throw new Error("目录格式无效");
  }
  return normalized;
}

function normalizeFileName(value) {
  const fileName = path.basename(String(value || "").trim());
  if (!fileName || fileName === "." || fileName === "..") throw new Error("缺少有效的 fileName");
  return fileName;
}

function normalizeDeviceId(value) {
  if (typeof value !== "string") throw new Error("缺少有效的 deviceId");
  const deviceId = value.trim().replace(/\\/g, "/");
  const parts = deviceId.split("/");
  if (!deviceId || parts.length !== 2 || parts.some((part) => !/^[a-z0-9][a-z0-9_-]{1,63}$/.test(part))) {
    throw new Error("deviceId 格式无效");
  }
  return deviceId;
}

function controlDataDeviceId(folder) {
  const parts = String(folder || "").split("/");
  if (parts.length < 3 || parts[2] !== "data_record") return null;
  return normalizeDeviceId(parts.slice(0, 2).join("/"));
}

function isControlDataRecord(record, deviceId) {
  if (!record || typeof record.folder !== "string") return false;
  const prefix = `${deviceId}/data_record`;
  return record.folder === prefix || record.folder.startsWith(`${prefix}/`);
}

function parseLicenseTimestamp(value, fieldName) {
  const text = String(value || "").trim();
  const matched = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2})$/.exec(text);
  if (!matched) throw new Error(`${fieldName} 必须是 YYYY-MM-DD HH:MM 格式`);
  const [, year, month, day, hour, minute] = matched.map(Number);
  const wallClock = new Date(Date.UTC(year, month - 1, day, hour, minute));
  if (
    wallClock.getUTCFullYear() !== year || wallClock.getUTCMonth() !== month - 1 ||
    wallClock.getUTCDate() !== day || wallClock.getUTCHours() !== hour ||
    wallClock.getUTCMinutes() !== minute
  ) {
    throw new Error(`${fieldName} 无效`);
  }
  const utcMs = Date.UTC(year, month - 1, day, hour - 8, minute);
  return new Date(utcMs);
}

function parseSignedLicense(content, publicKeyPath) {
  if (!publicKeyPath) throw new Error("服务器未配置 LICENSE_PUBLIC_KEY_PATH");
  const parts = String(content || "").split("|");
  if (parts.length !== 2 || !parts.every(Boolean)) throw new Error("许可证格式无效");
  const [payloadBase64, signatureBase64] = parts;
  let payload;
  let signature;
  try {
    payload = JSON.parse(Buffer.from(payloadBase64, "base64").toString("utf8"));
    signature = Buffer.from(signatureBase64, "base64");
  } catch {
    throw new Error("许可证内容解析失败");
  }
  const publicKey = fs.readFileSync(publicKeyPath);
  const valid = verify("sha256", Buffer.from(payloadBase64), {
    key: publicKey,
    padding: constants.RSA_PKCS1_PSS_PADDING,
    saltLength: constants.RSA_PSS_SALTLEN_AUTO
  }, signature);
  if (!valid) throw new Error("许可证签名验证失败");
  return payload;
}

function licenseContentsMatch(record, event) {
  return ["companyId", "productionLineId", "customer", "issued", "expiry", "features", "license"]
    .every((field) => record[field] === event[field]);
}

function normalizeCode(value, fieldName) {
  const code = String(value || "").trim().toLowerCase();
  if (!/^[a-z0-9][a-z0-9_-]{1,63}$/.test(code)) {
    throw new Error(`${fieldName}只能包含 2-64 位小写字母、数字、下划线或连字符`);
  }
  return code;
}

function publicLicense(record, includeContent = false) {
  const result = { ...record };
  if (!includeContent) delete result.license;
  return result;
}

function validateConfigParameters(configType, parameters) {
  const schema = CONFIG_SCHEMAS[configType];
  if (!schema) return `未知 configType: ${configType}`;
  if (!parameters || typeof parameters !== "object" || Array.isArray(parameters)) return "parameters 必须是对象";
  const expected = Object.keys(schema);
  const actual = Object.keys(parameters);
  const missing = expected.filter((field) => !actual.includes(field));
  const extra = actual.filter((field) => !expected.includes(field));
  if (missing.length) return `缺少字段: ${missing.join(", ")}`;
  if (extra.length) return `包含不允许的字段: ${extra.join(", ")}`;
  for (const [field, type] of Object.entries(schema)) {
    const value = parameters[field];
    if (type === "array" && (!Array.isArray(value) || !value.length)) return `${field} 必须是非空数组`;
    if (type === "number" && !Number.isFinite(value)) return `${field} 必须是数字`;
    if (type === "integer" && !Number.isInteger(value)) return `${field} 必须是整数`;
  }
  if (configType === "identification") {
    const { levels } = parameters;
    if (levels.length < 2 || (levels.length & (levels.length - 1)) !== 0) {
      return "levels 长度必须是大于等于 2 的 2 的整数次幂";
    }
    if (levels.some((value) => !Number.isFinite(value) || value < 0 || value > 100)) {
      return "levels 中的开度必须是 0 到 100 的有限数字";
    }
    if (parameters.q_in_val < 0) return "q_in_val 不能小于 0";
    if (parameters.dt <= 0 || parameters.t_c < parameters.dt) return "必须满足 0 < dt <= t_c";
    if (parameters.n_order < 2) return "n_order 必须大于等于 2";
    if (parameters.repeat <= 0) return "repeat 必须是正整数";
    if (parameters.dead_area < 0 || parameters.xa_full <= parameters.dead_area) {
      return "必须满足 0 <= dead_area < xa_full";
    }
    if (parameters.xa_full < 1000) return "xa_full 不能小于 1000";
    if (parameters.V_val <= 0) return "V_val 必须大于 0";
  }
  return null;
}

function createApp({
  store,
  adminToken = process.env.B_ADMIN_TOKEN || "dev-admin-token",
  licensePublicKeyPath = process.env.LICENSE_PUBLIC_KEY_PATH
}) {
  const app = express();
  const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 100 * 1024 * 1024 } });
  const pendingUploads = new Map();
  const pendingDownloads = new Map();
  const pendingDeviceTokens = new Map();

  app.disable("x-powered-by");
  app.use(express.json({ limit: "2mb" }));

  function publicBaseUrl(req) {
    return (process.env.PUBLIC_BASE_URL || `${req.protocol}://${req.get("host")}`).replace(/\/$/, "");
  }

  function requireAdmin(event) {
    if (!adminToken) return "服务器未配置 B_ADMIN_TOKEN";
    return event.adminToken === adminToken ? null : "B端管理令牌无效";
  }

  function logRevokeAction({ event, licenseId, success, errCode = null }) {
    console.info("[license] revoke", {
      time: new Date().toISOString(),
      requestId: event.requestId || null,
      type: "revokeLicense",
      licenseId: licenseId || null,
      result: success ? "success" : "failed",
      errCode
    });
  }

  function normalizeEventCompat(event) {
    if (!event || typeof event !== "object" || Array.isArray(event)) return event;
    const type = String(event.type || event.action || "").trim();
    const legacyRevokeTypes = new Set(["revoke_license", "licenseRevoke", "revoke"]);
    if (!legacyRevokeTypes.has(type) && !(event.action === "revokeLicense" && !event.type)) return event;
    console.warn("[license] legacy revoke request mapped", { type: type || null, requestId: event.requestId || null });
    return {
      ...event,
      type: "revokeLicense",
      licenseId: event.licenseId ?? event.license_id ?? event.id,
      reason: event.reason ?? event.revocationReason,
      adminToken: event.adminToken ?? event.admin_token ?? event.token
    };
  }

  function requestIp(req) {
    return String(req.ip || req.socket?.remoteAddress || "").trim();
  }

  function issueDownloadUrl(req, fileID) {
    const ticket = randomUUID().replace(/-/g, "");
    pendingDownloads.set(ticket, {
      fileID,
      requestIp: requestIp(req),
      expiresAtMs: Date.now() + DOWNLOAD_URL_TTL_MS
    });
    return `${publicBaseUrl(req)}/downloads/${ticket}`;
  }

  function consumeDownloadTicket(req, ticket) {
    const request = pendingDownloads.get(ticket);
    if (!request) return { ok: false, errMsg: "下载链接无效或已失效" };
    pendingDownloads.delete(ticket);
    if (request.expiresAtMs < Date.now()) return { ok: false, errMsg: "下载链接已过期" };
    if (!request.requestIp || request.requestIp !== requestIp(req)) {
      return { ok: false, errMsg: "下载请求来源IP不匹配" };
    }
    return { ok: true, fileID: request.fileID };
  }

  function verifyLicenseRecord(record, deviceId) {
    if (!record) return { success: false, valid: false, status: "not_found" };
    if (deviceId && deviceId !== record.deviceId) {
      return { success: true, valid: false, status: "device_mismatch", licenseId: record.licenseId };
    }
    if (new Date(record.expiryAt || parseLicenseTimestamp(record.expiry, "expiry")) <= new Date()) {
      return { success: true, valid: false, status: "expired", licenseId: record.licenseId };
    }
    return {
      success: true,
      valid: record.status === "active",
      status: record.status,
      licenseId: record.licenseId
    };
  }

  function issueDeviceToken({ deviceId, licenseId }) {
    const token = randomUUID().replace(/-/g, "");
    const expiresAtMs = Date.now() + DEVICE_TOKEN_TTL_MS;
    pendingDeviceTokens.set(token, { deviceId, licenseId, expiresAtMs });
    return { token, expiresAtMs };
  }

  function consumeDeviceContext(event) {
    const deviceToken = String(event.deviceToken || "").trim();
    if (!deviceToken) {
      return { ok: false, errCode: "DEVICE_TOKEN_REQUIRED", errMsg: "缺少 deviceToken" };
    }
    const session = pendingDeviceTokens.get(deviceToken);
    if (!session) {
      return { ok: false, errCode: "DEVICE_TOKEN_INVALID", errMsg: "deviceToken 无效" };
    }
    if (session.expiresAtMs <= Date.now()) {
      pendingDeviceTokens.delete(deviceToken);
      return { ok: false, errCode: "DEVICE_TOKEN_EXPIRED", errMsg: "deviceToken 已过期" };
    }
    return { ok: true, ...session };
  }

//config test-----------------------------------
  function logReceivedConfig({ configType, deviceId, requestId, record, config }) {
    console.info("[config] received", {
      configType,
      deviceId,
      requestId: requestId || null,
      fileID: record.fileID,
      cloudPath: record.cloudPath,
      storagePath: store.resolveStoredFile(record.fileID),
      config
    });
  }

  function logConfigRead({ configType, deviceId, requestId, record }) {
    console.info("[config] read", {
      configType,
      deviceId,
      requestId: requestId || null,
      fileID: record.fileID,
      cloudPath: record.cloudPath,
      storagePath: store.resolveStoredFile(record.fileID)
    });
  }
//end config test------------------------------------

  async function issueUpload(event, req) {
    const originalFileName = normalizeFileName(event.fileName);
    const folder = normalizeRelativePath(event.folder, "data_record");
    const folderParts = folder.split("/");
    if (folderParts.includes("data_record")) {
      const deviceId = controlDataDeviceId(folder);
      if (!deviceId) {
        return { success: false, errMsg: "控制数据目录必须为 <deviceId>/data_record/ 的子目录" };
      }
    }
    const isModel = folderParts.at(-1) === "model_config";
    const fileName = isModel && event.modelName
      ? normalizeFileName(event.modelName)
      : originalFileName;
    if (isModel && path.extname(fileName).toLowerCase() !== path.extname(originalFileName).toLowerCase()) {
      return { success: false, errMsg: "重命名后的模型扩展名必须与原文件一致" };
    }
    const modelDeviceId = isModel
      ? normalizeDeviceId(folderParts.slice(0, -1).join("/"))
      : null;
    const cloudPath = isModel
      ? `${modelDeviceId}/${fileName}`
      : `${BASE_FOLDER}/${folder}/${fileName}`;
    const fileID = `${isModel ? "model" : "local"}://${cloudPath}`;
    if (isModel && event.overwrite !== true) {
      const database = await store.read();
      const existing = database.fileRecords.find((record) => record.cloudPath === cloudPath);
      if (existing) {
        return {
          success: false,
          conflict: true,
          errMsg: "同名模型已存在",
          existing: {
            ...existing,
            originalFileName: existing.originalFileName || existing.fileName
          }
        };
      }
    }
    const token = randomUUID();
    pendingUploads.set(token, {
      fileName,
      originalFileName: isModel ? originalFileName : undefined,
      folder,
      cloudPath,
      fileID,
      configType: event.configType,
      parameters: event.parameters,
      expiresAt: Date.now() + 10 * 60 * 1000
    });
    return {
      code: 200,
      success: true,
      uploadMetadata: {
        url: `${publicBaseUrl(req)}/upload/${token}`,
        token,
        authorization: token,
        cosFileId: cloudPath,
        fileId: fileID
      },
      fileID,
      cloudPath,
      fileName,
      originalFileName: isModel ? originalFileName : undefined
    };
  }

  async function removeFile(database, fileID) {
    const filePath = store.resolveStoredFile(fileID);
    if (filePath) await fs.promises.rm(filePath, { force: true });
    const before = database.fileRecords.length;
    database.fileRecords = database.fileRecords.filter((record) => record.fileID !== fileID);
    database.panelInbox = database.panelInbox.filter((record) => record.fileID !== fileID);
    database.identificationFiles = database.identificationFiles.filter((record) => record.fileID !== fileID);
    database.volumeConfigs = database.volumeConfigs.filter((record) => record.fileID !== fileID);
    database.panelNotifications = database.panelNotifications.filter((record) => record.fileID !== fileID);
    return before - database.fileRecords.length;
  }

  async function removeDeviceDirectories(deviceId) {
    const segments = String(deviceId || "").split("/");
    if (segments.length !== 2 || !segments[0] || !segments[1]) return 0;
    const [companyCode, lineCode] = segments;
    const targets = [
      path.join(store.modelsDirectory, companyCode, lineCode),
      path.join(store.filesDirectory, "ReinLoop_GUI", companyCode, lineCode)
    ];
    let removed = 0;
    for (const directory of targets) {
      try {
        const stat = await fs.promises.stat(directory);
        if (!stat.isDirectory()) continue;
      } catch (_error) {
        continue;
      }
      await fs.promises.rm(directory, { recursive: true, force: true });
      removed += 1;
    }
    return removed;
  }

  async function removeProductionLineData(database, { companyId, productionLineId, failOnActiveLicense = true }) {
    const line = database.productionLines.find((item) => item.id === productionLineId && item.companyId === companyId);
    if (!line) return { success: false, errMsg: "产线不存在" };

    const activeLicenses = database.licenses.filter((item) =>
      item.companyId === companyId && item.productionLineId === productionLineId && item.status === "active"
    );
    if (failOnActiveLicense && activeLicenses.length) {
      return {
        success: false,
        errMsg: `请先撤销该产线的 ${activeLicenses.length} 个有效许可证后再删除产线`,
        errCode: "ACTIVE_LICENSES_PRESENT"
      };
    }

    const deviceId = line.deviceId;
    const relatedFileIDs = database.fileRecords
      .filter((record) => {
        if (record.fileID.startsWith(`model://${deviceId}/`)) return true;
        const prefix = `${deviceId}/`;
        return record.folder === deviceId || record.folder.startsWith(prefix);
      })
      .map((record) => record.fileID);

    let deletedFileCount = 0;
    for (const fileID of new Set(relatedFileIDs)) {
      deletedFileCount += await removeFile(database, fileID);
    }

    const beforeFeedback = database.identificationFeedback.length;
    database.identificationFeedback = database.identificationFeedback.filter((item) => item.deviceId !== deviceId);
    const deletedFeedback = beforeFeedback - database.identificationFeedback.length;

    const beforeRequests = database.volumeConfigRequests.length;
    database.volumeConfigRequests = database.volumeConfigRequests.filter((item) => item.deviceId !== deviceId);
    const deletedRequests = beforeRequests - database.volumeConfigRequests.length;

    const beforeConfigs = database.volumeConfigs.length;
    database.volumeConfigs = database.volumeConfigs.filter((item) => item.deviceId !== deviceId);
    const deletedConfigs = beforeConfigs - database.volumeConfigs.length;

    const beforeNotifications = database.panelNotifications.length;
    database.panelNotifications = database.panelNotifications.filter((item) => item.deviceId !== deviceId);
    const deletedNotifications = beforeNotifications - database.panelNotifications.length;

    const deletedLicenses = database.licenses.filter((item) =>
      item.companyId === companyId && item.productionLineId === productionLineId
    ).length;
    database.licenses = database.licenses.filter((item) =>
      !(item.companyId === companyId && item.productionLineId === productionLineId)
    );

    const deletedDirectories = await removeDeviceDirectories(deviceId);
    database.productionLines = database.productionLines.filter((item) => item.id !== productionLineId);

    return {
      success: true,
      deletedProductionLineId: productionLineId,
      deletedFiles: deletedFileCount,
      deletedDirectories,
      deletedLicenses,
      deletedFeedback,
      deletedVolumeRequests: deletedRequests,
      deletedVolumeConfigs: deletedConfigs,
      deletedNotifications
    };
  }

  function backfillIdentificationFiles(database) {
    for (const record of database.fileRecords) {
      if (!record.folder.endsWith("/ind_data") || ![".csv", ".json"].includes(path.extname(record.fileName).toLowerCase())) continue;
      if (database.identificationFiles.some((item) => item.fileID === record.fileID)) continue;
      const deviceId = normalizeDeviceId(record.folder.slice(0, -"/ind_data".length));
      const pending = database.panelInbox.some((item) => item.fileID === record.fileID);
      database.identificationFiles.push({
        fileID: record.fileID,
        deviceId,
        fileName: record.fileName,
        mediaType: path.extname(record.fileName).slice(1).toLowerCase(),
        uploadTime: record.uploadTime,
        size: record.size,
        status: pending ? "pending" : "processed",
        processedAt: pending ? null : record.uploadTime,
        expiresAt: pending ? null : new Date(Date.parse(record.uploadTime) + IDENTIFICATION_RETENTION_MS).toISOString()
      });
    }
  }

  function addPanelNotification(database, { deviceId, type, title, message, requestId = null, fileID = null }) {
    const notification = {
      notificationId: store.createId("pn"),
      deviceId,
      type,
      title,
      message,
      requestId,
      fileID,
      createdAtMs: Date.now()
    };
    database.panelNotifications.push(notification);
    return notification;
  }

  function findIdentificationFeedbackRecord(database, deviceId, fileName) {
    if (!deviceId || !fileName) return null;
    const normalizedFileName = String(fileName);
    return database.identificationFeedback.find((item) =>
      item.deviceId === deviceId
      && (item.fileName === normalizedFileName || item.runId === normalizedFileName)
    ) || null;
  }

  function resolveIdentificationRunId(database, record) {
    if (!record) return null;
    if (record.runId) return String(record.runId);
    const feedback = findIdentificationFeedbackRecord(database, record.deviceId, record.fileName);
    if (feedback) return String(feedback.runId);
    if (record.fileName) return String(record.fileName);
    return null;
  }

  function enrichIdentificationFile(database, record) {
    const runId = resolveIdentificationRunId(database, record);
    return runId ? { ...record, runId } : { ...record };
  }

  function enrichNotification(database, notification) {
    if (!notification || notification.type !== "identification_result_ready" || !notification.fileID) {
      return notification;
    }
    const related = database.identificationFiles.find((item) => item.fileID === notification.fileID)
      || database.panelInbox.find((item) => item.fileID === notification.fileID);
    const runId = resolveIdentificationRunId(database, related);
    return runId ? { ...notification, runId } : notification;
  }

  async function purgeExpiredIdentificationFiles() {
    return store.update(async (database) => {
      backfillIdentificationFiles(database);
      const now = Date.now();
      const expired = database.identificationFiles.filter((record) =>
        record.status === "processed" && record.expiresAt && Date.parse(record.expiresAt) <= now
      );
      for (const record of expired) await removeFile(database, record.fileID);
      return expired.length;
    });
  }

  app.locals.purgeExpiredIdentificationFiles = purgeExpiredIdentificationFiles;

  async function dispatch(event, req) {
    switch (event.type) {
      case "listOrganizations": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const database = await store.read();
        const now = Date.now();
        const companies = database.companies.map((company) => ({
          ...company,
          productionLines: database.productionLines
            .filter((line) => line.companyId === company.id)
            .map((line) => ({
              ...line,
              online: Boolean(line.lastSeenAt && now - Date.parse(line.lastSeenAt) <= DEVICE_HEARTBEAT_TTL_MS),
              lastSeenAt: line.lastSeenAt || null
            }))
        }));
        return { success: true, companies };
      }
      case "deviceHeartbeat": {
        const deviceId = normalizeDeviceId(event.deviceId);
        return store.update((database) => {
          const line = database.productionLines.find((item) => item.deviceId === deviceId);
          if (!line) return { success: false, errMsg: "设备未注册" };
          line.lastSeenAt = new Date().toISOString();
          return { success: true, deviceId, lastSeenAt: line.lastSeenAt };
        });
      }
      case "createCompany": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const name = String(event.name || "").trim();
        if (!name) return { success: false, errMsg: "公司名称不能为空" };
        const code = normalizeCode(event.code, "公司编码");
        return store.update((database) => {
          if (database.companies.some((item) => item.code === code)) {
            return { success: false, errMsg: `公司编码 ${code} 已存在` };
          }
          const company = {
            id: store.createId("company"), name, code,
            createdAt: new Date().toISOString()
          };
          database.companies.push(company);
          return { success: true, company };
        });
      }
      case "createProductionLine": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const name = String(event.name || "").trim();
        if (!name) return { success: false, errMsg: "产线名称不能为空" };
        const code = normalizeCode(event.code, "产线编码");
        return store.update((database) => {
          const company = database.companies.find((item) => item.id === event.companyId);
          if (!company) return { success: false, errMsg: "公司不存在" };
          if (database.productionLines.some((item) => item.companyId === company.id && item.code === code)) {
            return { success: false, errMsg: `该公司下产线编码 ${code} 已存在` };
          }
          const productionLine = {
            id: store.createId("line"), companyId: company.id, name, code,
            deviceId: `${company.code}/${code}`,
            createdAt: new Date().toISOString(), lastSeenAt: null
          };
          database.productionLines.push(productionLine);
          return { success: true, productionLine };
        });
      }
      case "deleteProductionLine": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const companyId = String(event.companyId || "").trim();
        const productionLineId = String(event.productionLineId || "").trim();
        if (!companyId || !productionLineId) {
          return { success: false, errMsg: "缺少 companyId 或 productionLineId" };
        }
        return store.update(async (database) => {
          const company = database.companies.find((item) => item.id === companyId);
          if (!company) return { success: false, errMsg: "公司不存在" };
          return removeProductionLineData(database, {
            companyId,
            productionLineId,
            failOnActiveLicense: true
          });
        });
      }
      case "deleteCompany": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const companyId = String(event.companyId || "").trim();
        if (!companyId) return { success: false, errMsg: "缺少 companyId" };
        return store.update(async (database) => {
          const company = database.companies.find((item) => item.id === companyId);
          if (!company) return { success: false, errMsg: "公司不存在" };

          const activeLicenses = database.licenses.filter((item) =>
            item.companyId === companyId && item.status === "active"
          );
          if (activeLicenses.length) {
            return {
              success: false,
              errMsg: `请先撤销该公司的 ${activeLicenses.length} 个有效许可证后再删除公司`,
              errCode: "ACTIVE_LICENSES_PRESENT"
            };
          }

          const lines = database.productionLines.filter((item) => item.companyId === companyId);

          const summary = {
            deletedProductionLines: 0,
            deletedFiles: 0,
            deletedDirectories: 0,
            deletedLicenses: 0,
            deletedFeedback: 0,
            deletedVolumeRequests: 0,
            deletedVolumeConfigs: 0,
            deletedNotifications: 0
          };

          for (const line of lines) {
            const lineDeleted = await removeProductionLineData(database, {
              companyId,
              productionLineId: line.id,
              failOnActiveLicense: false
            });
            if (!lineDeleted.success) return lineDeleted;
            summary.deletedProductionLines += 1;
            summary.deletedFiles += lineDeleted.deletedFiles;
            summary.deletedDirectories += lineDeleted.deletedDirectories;
            summary.deletedLicenses += lineDeleted.deletedLicenses;
            summary.deletedFeedback += lineDeleted.deletedFeedback;
            summary.deletedVolumeRequests += lineDeleted.deletedVolumeRequests;
            summary.deletedVolumeConfigs += lineDeleted.deletedVolumeConfigs;
            summary.deletedNotifications += lineDeleted.deletedNotifications;
          }

          const orphanCompanyLicenses = database.licenses.filter((item) => item.companyId === companyId).length;
          if (orphanCompanyLicenses > 0) {
            summary.deletedLicenses += orphanCompanyLicenses;
            database.licenses = database.licenses.filter((item) => item.companyId !== companyId);
          }

          database.companies = database.companies.filter((item) => item.id !== companyId);
          return { success: true, deletedCompanyId: companyId, ...summary };
        });
      }
      case "createLicense": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const required = ["licenseId", "companyId", "productionLineId", "customer", "issued", "expiry", "license"];
        const missing = required.filter((field) => !String(event[field] || "").trim());
        if (missing.length) return { success: false, errMsg: `缺少必填字段: ${missing.join(", ")}` };
        const licenseId = String(event.licenseId).trim();
        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(licenseId)) {
          return { success: false, errMsg: "licenseId 必须是 UUID" };
        }
        const issuedAt = parseLicenseTimestamp(event.issued, "issued");
        const expiryAt = parseLicenseTimestamp(event.expiry, "expiry");
        if (expiryAt <= issuedAt) return { success: false, errMsg: "expiry 必须晚于 issued" };
        const payload = parseSignedLicense(event.license, licensePublicKeyPath);
        const signedFields = {
          license_id: licenseId,
          company_id: String(event.companyId),
          production_line_id: String(event.productionLineId),
          customer: String(event.customer),
          issued: String(event.issued),
          expiry: String(event.expiry),
          features: String(event.features || "*")
        };
        if (Object.entries(signedFields).some(([field, value]) => payload[field] !== value)) {
          return { success: false, errMsg: "许可证载荷与请求字段不一致" };
        }
        return store.update((database) => {
          const company = database.companies.find((item) => item.id === event.companyId);
          const line = database.productionLines.find((item) => item.id === event.productionLineId && item.companyId === event.companyId);
          if (!company || !line) return { success: false, errMsg: "公司或产线不存在" };
          if (payload.device_id !== line.deviceId) return { success: false, errMsg: "许可证 device_id 与产线不匹配" };
          const existing = database.licenses.find((item) => item.licenseId === licenseId);
          if (existing) {
            return licenseContentsMatch(existing, { ...event, features: event.features || "*" })
              ? { success: true, license: publicLicense(existing), idempotent: true }
              : { success: false, conflict: true, errMsg: "licenseId 已存在且内容不同" };
          }
          const record = {
            licenseId, companyId: company.id,
            productionLineId: line.id, companyName: company.name,
            productionLineName: line.name, deviceId: line.deviceId,
            customer: String(event.customer), issued: String(event.issued),
            expiry: String(event.expiry), issuedAt: issuedAt.toISOString(),
            expiryAt: expiryAt.toISOString(), features: event.features || "*",
            license: String(event.license), status: "active",
            createdAt: new Date().toISOString(), revokedAt: null,
            revocationReason: null
          };
          database.licenses.push(record);
          return { success: true, license: publicLicense(record) };
        });
      }
      case "listLicenses": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const database = await store.read();
        return {
          success: true,
          licenses: database.licenses.map((record) => publicLicense(record))
            .sort((left, right) => right.createdAt.localeCompare(left.createdAt))
        };
      }
      case "getLicense": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const database = await store.read();
        const record = database.licenses.find((item) => item.licenseId === event.licenseId);
        return record
          ? { success: true, license: publicLicense(record, true) }
          : { success: false, errMsg: "许可证不存在" };
      }
      case "revokeLicense": {
        const authError = requireAdmin(event);
        const licenseId = String(event.licenseId || "").trim();
        if (authError) {
          const errCode = authError === "B端管理令牌无效"
            ? "ADMIN_TOKEN_INVALID"
            : "ADMIN_TOKEN_NOT_CONFIGURED";
          const result = { success: false, errMsg: authError, errCode };
          logRevokeAction({ event, licenseId, success: false, errCode: result.errCode });
          return result;
        }
        if (!licenseId) {
          const result = { success: false, errMsg: "licenseId 不能为空", errCode: "LICENSE_ID_REQUIRED" };
          logRevokeAction({ event, licenseId, success: false, errCode: result.errCode });
          return result;
        }
        const result = await store.update((database) => {
          const record = database.licenses.find((item) => item.licenseId === licenseId);
          if (!record) return { success: false, errMsg: "许可证不存在", errCode: "LICENSE_NOT_FOUND" };
          record.status = "revoked";
          record.revokedAt = new Date().toISOString();
          record.revocationReason = String(event.reason || "管理员撤销").trim();
          return { success: true, license: publicLicense(record) };
        });
        logRevokeAction({ event, licenseId, success: result.success, errCode: result.errCode });
        return result;
      }
      case "deleteLicense": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const licenseId = String(event.licenseId || "").trim();
        if (!licenseId) return { success: false, errMsg: "licenseId 不能为空", errCode: "LICENSE_ID_REQUIRED" };
        return store.update((database) => {
          const record = database.licenses.find((item) => item.licenseId === licenseId);
          if (!record) return { success: false, errMsg: "许可证不存在", errCode: "LICENSE_NOT_FOUND" };
          if (record.status === "active") {
            return {
              success: false,
              errMsg: "请先撤销许可证后再删除",
              errCode: "LICENSE_ACTIVE"
            };
          }
          database.licenses = database.licenses.filter((item) => item.licenseId !== licenseId);
          return { success: true, deletedLicenseId: licenseId };
        });
      }
      case "validateLicense": {
        const database = await store.read();
        const record = database.licenses.find((item) => item.licenseId === event.licenseId);
        const deviceId = event.deviceId ? normalizeDeviceId(event.deviceId) : null;
        return verifyLicenseRecord(record, deviceId);
      }
      case "uploadDataFile":
        if (normalizeRelativePath(event.folder, "data_record").endsWith("/model_config")) {
          const authError = requireAdmin(event);
          if (authError) return { success: false, errMsg: authError };
        }
        return issueUpload(event, req);
      case "issueModelUpload": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        return issueUpload({ ...event, folder: `${deviceId}/model_config` }, req);
      }
      case "listModels": {
        const folder = normalizeRelativePath(event.folder, "model_config");
        const database = await store.read();
        const fileList = database.fileRecords
          .filter((record) => record.folder === folder)
          .sort((left, right) => right.uploadTime.localeCompare(left.uploadTime))
          .slice(0, 100);
        return {
          success: true,
          files: fileList.map((record) => record.fileName),
          fileList: fileList.map((record) => ({
            ...record,
            originalFileName: record.originalFileName || record.fileName
          }))
        };
      }
      case "downloadModel": {
        const database = await store.read();
        const record = database.fileRecords.find((item) => item.fileID === event.fileID);
        if (!record || !store.resolveStoredFile(record.fileID)) return { success: false, errMsg: "文件不存在" };
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        return {
          success: true,
          url: issueDownloadUrl(req, record.fileID),
          fileName: record.fileName,
          originalFileName: record.originalFileName || record.fileName
        };
      }
      case "deleteFile":
      case "deleteModel": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        return store.update(async (database) => {
          let records = event.fileID
            ? database.fileRecords.filter((item) => item.fileID === event.fileID)
            : database.fileRecords.filter((item) =>
              item.folder === normalizeRelativePath(event.folder, "model_config") &&
              item.fileName === normalizeFileName(event.fileName)
            );
          if (!event.fileID && records.length > 1) {
            return { success: false, ambiguous: true, errMsg: `发现 ${records.length} 个同名文件，请用 fileID 精确指定`, candidates: records };
          }
          if (!records.length) return { success: false, errMsg: "数据库中未找到对应记录" };
          let deletedCount = 0;
          const fileIDs = [...new Set(records.map((record) => record.fileID))];
          for (const fileID of fileIDs) deletedCount += await removeFile(database, fileID);
          return { success: true, deletedFileID: fileIDs.join(", "), deletedCount };
        });
      }
      case "publishIdentificationConfig": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        const validationError = validateConfigParameters("identification", event.parameters);
        if (validationError) return { success: false, errMsg: validationError };
        return issueUpload({
          fileName: "identification_config.csv",
          folder: `${deviceId}/identification_config`
        }, req);
      }
      case "publishVolumeConfig": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const validationError = validateConfigParameters("volume", event.parameters);
        if (validationError) return { success: false, errMsg: validationError };
        const result = await issueUpload({
          fileName: "volume_config.json",
          folder: process.env.VOLUME_CONFIG_FOLDER || "volume_config",
          configType: "volume",
          parameters: event.parameters
        }, req);
        return { ...result, parameters: event.parameters };
      }
      case "getVolumeConfigFile": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        const database = await store.read();
        const config = database.volumeConfigs.find((item) => item.deviceId === deviceId);
        if (!config) return { success: true, found: false, deviceId };
        const record = database.fileRecords.find((item) => item.fileID === config.fileID);
        if (!record) return { success: true, found: false, deviceId };
        return {
          success: true, found: true, deviceId, fileID: record.fileID,
          fileName: record.fileName, url: issueDownloadUrl(req, record.fileID),
          updatedAtMs: config.updatedAtMs, requestId: config.requestId
        };
      }
      case "getFunctionConfig": {
        if (event.configType !== "volume") return { success: false, errMsg: `未知 configType: ${event.configType}` };
        const database = await store.read();
        const config = database.functionConfigs.find((item) => item.configType === event.configType);
        return config ? { success: true, ...config } : { success: false, notFound: true, errMsg: "参数配置尚未发布" };
      }
      case "getIdentificationConfig": {
        const deviceId = normalizeDeviceId(event.deviceId);
        const database = await store.read();
        const record = database.fileRecords.find((item) => item.folder === `${deviceId}/identification_config` && item.fileName === "identification_config.csv");
        if (!record) return { success: false, errMsg: "服务器尚未配置辨识参数" };
        logConfigRead({ configType: "identification", deviceId, record });
        return { success: true, fileName: record.fileName, fileID: record.fileID, cloudPath: record.cloudPath, url: issueDownloadUrl(req, record.fileID) };
      }
      case "getPendingPanelFile": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        const database = await store.read();
        const message = database.panelInbox.find((item) => {
          if (item.deviceId !== deviceId) return false;
          if (item.mediaType !== "csv") return true;
          return Boolean(findIdentificationFeedbackRecord(database, deviceId, item.fileName));
        });
        if (!message) return { success: true, pending: false };
        const runId = resolveIdentificationRunId(database, message);
        return {
          success: true,
          pending: true,
          fileID: message.fileID,
          fileName: message.fileName,
          runId,
          mediaType: message.mediaType,
          uploadTime: message.uploadTime,
          url: issueDownloadUrl(req, message.fileID)
        };
      }
      case "getPendingPanelNotification": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        const database = await store.read();
        const notification = database.panelNotifications.find((item) => item.deviceId === deviceId);
        return notification
          ? { success: true, pending: true, notification: enrichNotification(database, notification) }
          : { success: true, pending: false };
      }
      case "ackPanelNotification": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        const notificationId = String(event.notificationId || "");
        if (!notificationId) return { success: false, errMsg: "缺少 notificationId" };
        return store.update((database) => {
          const exactMatch = database.panelNotifications.find((item) =>
            item.deviceId === deviceId && item.notificationId === notificationId
          );
          if (exactMatch) {
            database.panelNotifications = database.panelNotifications.filter((item) => item !== exactMatch);
            return { success: true, notificationId, deleted: 1 };
          }

          // 兼容：客户端 deviceId 切换或重连后，允许仅凭 notificationId 完成幂等关闭。
          const fallbackMatch = database.panelNotifications.find((item) => item.notificationId === notificationId);
          if (fallbackMatch) {
            database.panelNotifications = database.panelNotifications.filter((item) => item !== fallbackMatch);
            return {
              success: true,
              notificationId,
              deleted: 1,
              idempotent: true,
              reassignedDeviceId: fallbackMatch.deviceId
            };
          }

          return { success: true, notificationId, deleted: 0, idempotent: true };
        });
      }
      case "ackPanelFile": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        if (!event.fileID) return { success: false, errMsg: "缺少 fileID" };
        return store.update((database) => {
          backfillIdentificationFiles(database);
          const messages = database.panelInbox.filter((item) =>
            item.deviceId === deviceId && item.fileID === String(event.fileID)
          );
          const historyRecord = database.identificationFiles.find((item) =>
            item.deviceId === deviceId && item.fileID === String(event.fileID)
          );
          if (!messages.length && !historyRecord) return { success: false, errMsg: "辨识文件不存在" };
          const processedAt = new Date().toISOString();
          if (historyRecord) {
            historyRecord.status = "processed";
            historyRecord.processedAt = processedAt;
            historyRecord.expiresAt = new Date(Date.now() + IDENTIFICATION_RETENTION_MS).toISOString();
          }
          const before = database.panelInbox.length;
          database.panelInbox = database.panelInbox.filter((item) =>
            !(item.deviceId === deviceId && item.fileID === String(event.fileID))
          );
          return { success: true, processed: true, deleted: before - database.panelInbox.length, processedAt };
        });
      }
      case "listIdentificationFiles": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        await purgeExpiredIdentificationFiles();
        const database = await store.read();
        const page = Math.max(1, Number.parseInt(event.page, 10) || 1);
        const pageSize = Math.min(100, Math.max(1, Number.parseInt(event.pageSize, 10) || 20));
        const files = database.identificationFiles
          .filter((record) => record.deviceId === deviceId)
          .filter((record) => !event.mediaType || record.mediaType === event.mediaType)
          .filter((record) => !event.status || record.status === event.status)
          .sort((left, right) => right.uploadTime.localeCompare(left.uploadTime));
        const offset = (page - 1) * pageSize;
        return {
          success: true,
          files: files.slice(offset, offset + pageSize).map((record) => enrichIdentificationFile(database, record)),
          total: files.length,
          page,
          pageSize
        };
      }
      case "listControlFiles": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        const page = Math.max(1, Number.parseInt(event.page, 10) || 1);
        const pageSize = Math.min(100, Math.max(1, Number.parseInt(event.pageSize, 10) || 20));
        const database = await store.read();
        const files = database.fileRecords
          .filter((record) => isControlDataRecord(record, deviceId))
          .sort((left, right) => right.uploadTime.localeCompare(left.uploadTime));
        const offset = (page - 1) * pageSize;
        return {
          success: true,
          files: files.slice(offset, offset + pageSize).map((record) => ({
            fileID: record.fileID,
            fileName: record.fileName,
            uploadTime: record.uploadTime,
            size: record.size
          })),
          total: files.length,
          page,
          pageSize
        };
      }
      case "getControlFileDownload": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        if (!event.fileID) return { success: false, errMsg: "缺少 fileID" };
        const database = await store.read();
        const record = database.fileRecords.find((item) => item.fileID === String(event.fileID));
        if (!record || !controlDataDeviceId(record.folder) || !store.resolveStoredFile(record.fileID)) {
          return { success: false, errMsg: "控制数据文件不存在或不属于控制数据目录" };
        }
        try {
          await fs.promises.access(store.resolveStoredFile(record.fileID));
        } catch {
          return { success: false, errMsg: "控制数据文件不存在" };
        }
        return {
          success: true,
          fileID: record.fileID,
          fileName: record.fileName,
          uploadTime: record.uploadTime,
          size: record.size,
          url: issueDownloadUrl(req, record.fileID)
        };
      }
      case "deleteControlFile": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        if (!event.fileID) return { success: false, errMsg: "缺少 fileID" };
        return store.update(async (database) => {
          const record = database.fileRecords.find((item) => item.fileID === String(event.fileID));
          if (!record || !controlDataDeviceId(record.folder)) {
            return { success: false, errMsg: "控制数据文件不存在或不属于控制数据目录" };
          }
          const deletedCount = await removeFile(database, record.fileID);
          return deletedCount
            ? { success: true, deletedCount }
            : { success: false, errMsg: "控制数据文件不存在" };
        });
      }
      case "getIdentificationFileDownload": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const database = await store.read();
        const historyRecord = database.identificationFiles.find((item) => item.fileID === event.fileID);
        const fileRecord = database.fileRecords.find((item) => item.fileID === event.fileID);
        if (!historyRecord || !fileRecord || !store.resolveStoredFile(fileRecord.fileID)) {
          return { success: false, errMsg: "辨识文件不存在" };
        }
        const runId = resolveIdentificationRunId(database, historyRecord);
        return {
          success: true,
          fileID: fileRecord.fileID,
          fileName: fileRecord.fileName,
          runId,
          mediaType: historyRecord.mediaType,
          url: issueDownloadUrl(req, fileRecord.fileID)
        };
      }
      case "deleteIdentificationFile": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        if (!event.fileID) return { success: false, errMsg: "缺少 fileID" };
        return store.update(async (database) => {
          if (!database.identificationFiles.some((item) => item.fileID === event.fileID)) {
            return { success: false, errMsg: "辨识文件不存在" };
          }
          const deletedCount = await removeFile(database, event.fileID);
          return { success: true, deletedCount };
        });
      }
      case "registerIdentificationResult": {
        const deviceId = normalizeDeviceId(event.deviceId);
        if (!event.runId) return { success: false, errMsg: "缺少 deviceId 或 runId" };
        return store.update((database) => {
          const record = { deviceId, runId: String(event.runId), fileName: event.fileName || String(event.runId), status: "waiting_feedback", result: null, updateTime: new Date().toISOString() };
          database.identificationFeedback = database.identificationFeedback.filter((item) => item.deviceId !== deviceId);
          database.identificationFeedback.push(record);
          return { success: true, runId: record.runId, status: record.status };
        });
      }
      case "getIdentificationFeedback": {
        const deviceId = normalizeDeviceId(event.deviceId);
        if (!event.runId) return { success: false, errMsg: "缺少 deviceId 或 runId" };
        const database = await store.read();
        const record = database.identificationFeedback.find((item) => item.deviceId === deviceId && item.runId === String(event.runId));
        if (!record || record.status !== "feedback_ready") return { success: true, ready: false };
        return { success: true, ready: true, result: record.result, runId: record.runId };
      }
      case "setIdentificationFeedback": {
        const authError = requireAdmin(event);
        if (authError) return { success: false, errMsg: authError };
        const deviceId = normalizeDeviceId(event.deviceId);
        if (event.result !== 0 && event.result !== 1) return { success: false, errMsg: "result 必须是数字 0/1" };
        return store.update((database) => {
          const record = database.identificationFeedback.find((item) => item.deviceId === deviceId);
          if (!record) return { success: false, errMsg: "当前没有待审核的辨识结果" };
          if (event.runId && String(event.runId) !== record.runId) return { success: false, errMsg: "runId 与当前待审核结果不一致" };
          record.status = "feedback_ready";
          record.result = event.result;
          record.updateTime = new Date().toISOString();
          return { success: true, runId: record.runId, fileName: record.fileName, result: record.result };
        });
      }
      case "ackIdentificationFeedback": {
        const deviceId = normalizeDeviceId(event.deviceId);
        if (!event.runId) return { success: false, errMsg: "缺少 deviceId 或 runId" };
        return store.update((database) => {
          const before = database.identificationFeedback.length;
          database.identificationFeedback = database.identificationFeedback.filter((item) => !(item.deviceId === deviceId && item.runId === String(event.runId)));
          return { success: true, deleted: before - database.identificationFeedback.length };
        });
      }
      case "createVolumeConfigRequest": {
        const deviceId = normalizeDeviceId(event.deviceId);
        return store.update(async (database) => {
          const previous = database.volumeConfigRequests.filter((item) => item.deviceId === deviceId);
          for (const record of previous) if (record.configFileID) await removeFile(database, record.configFileID);
          database.volumeConfigRequests = database.volumeConfigRequests.filter((item) => item.deviceId !== deviceId);
          const createdAtMs = Date.now();
          const record = { deviceId, requestId: `${createdAtMs}-${randomUUID().slice(0, 10)}`, status: "waiting_upload", createdAtMs, expiresAtMs: createdAtMs + VOLUME_REQUEST_TTL_MS, configFileID: null, configFileName: null, uploadedAtMs: null, updateTime: new Date().toISOString() };
          database.volumeConfigRequests.push(record);
          addPanelNotification(database, {
            deviceId,
            type: "volume_request_started",
            title: "产线请求容积测试配置",
            message: "请完成容积测试配置并提交。",
            requestId: record.requestId
          });
          return { success: true, requestId: record.requestId, createdAtMs, expiresAtMs: record.expiresAtMs };
        });
      }
      case "getPendingVolumeConfigRequest": {
        const deviceId = normalizeDeviceId(event.deviceId);
        return store.update(async (database) => {
          const record = database.volumeConfigRequests.find((item) => item.deviceId === deviceId && item.status === "waiting_upload");
          if (!record) return { success: true, pending: false };
          if (Date.now() > record.expiresAtMs) {
            database.volumeConfigRequests = database.volumeConfigRequests.filter((item) => item !== record);
            return { success: true, pending: false, expired: true };
          }
          return { success: true, pending: true, requestId: record.requestId, createdAtMs: record.createdAtMs, expiresAtMs: record.expiresAtMs };
        });
      }
      case "submitVolumeConfigFile": {
        const deviceId = normalizeDeviceId(event.deviceId);
        if (!event.requestId || !event.fileID) return { success: false, errMsg: "缺少 deviceId、requestId 或 fileID" };
        return store.update((database) => {
          const record = database.volumeConfigRequests.find((item) => item.deviceId === deviceId && item.requestId === String(event.requestId));
          if (!record) return { success: false, errMsg: "容积参数请求不存在" };
          if (record.status !== "waiting_upload" || Date.now() > record.expiresAtMs) return { success: false, errMsg: "容积参数请求已失效" };
          const fileName = event.fileName || "volume_measurement.json";
          const expectedFolder = `${deviceId}/volume_config_requests/${record.requestId}`;
          const fileRecord = database.fileRecords.find((item) => item.fileID === String(event.fileID) && item.folder === expectedFolder && item.fileName === fileName);
          if (!fileRecord) return { success: false, errMsg: "上传文件不属于本次容积参数请求" };
          record.status = "ready";
          record.configFileID = fileRecord.fileID;
          record.configFileName = fileName;
          record.uploadedAtMs = Date.now();
          record.updateTime = new Date().toISOString();
          database.volumeConfigs = database.volumeConfigs.filter((item) => item.deviceId !== deviceId);
          database.volumeConfigs.push({
            deviceId,
            fileID: fileRecord.fileID,
            fileName: fileRecord.fileName,
            requestId: record.requestId,
            updatedAtMs: record.uploadedAtMs
          });
          return { success: true, requestId: record.requestId, uploadedAtMs: record.uploadedAtMs };
        });
      }
      case "getVolumeConfigRequest": {
        const deviceId = normalizeDeviceId(event.deviceId);
        if (!event.requestId) return { success: false, errMsg: "缺少 deviceId 或 requestId" };
        const database = await store.read();
        const record = database.volumeConfigRequests.find((item) => item.deviceId === deviceId && item.requestId === String(event.requestId));
        if (!record || Date.now() > record.expiresAtMs) return { success: true, ready: false, expired: true };
        if (record.status !== "ready") return { success: true, ready: false, expired: false };
        const fileRecord = database.fileRecords.find((item) => item.fileID === record.configFileID);
        if (!fileRecord) return { success: false, errMsg: "容积配置文件记录不存在" };
        logConfigRead({ configType: "volume", deviceId, requestId: record.requestId, record: fileRecord });
        return { success: true, ready: true, expired: false, requestId: record.requestId, fileName: record.configFileName, fileID: fileRecord.fileID, cloudPath: fileRecord.cloudPath, uploadedAtMs: record.uploadedAtMs, url: issueDownloadUrl(req, record.configFileID) };
      }
      case "ackVolumeConfigRequest": {
        const deviceId = normalizeDeviceId(event.deviceId);
        if (!event.requestId) return { success: false, errMsg: "缺少 deviceId 或 requestId" };
        return store.update(async (database) => {
          const records = database.volumeConfigRequests.filter((item) => item.deviceId === deviceId && item.requestId === String(event.requestId));
          for (const record of records) {
            const isLatest = database.volumeConfigs.some((item) => item.fileID === record.configFileID);
            if (record.configFileID && !isLatest) await removeFile(database, record.configFileID);
          }
          database.volumeConfigRequests = database.volumeConfigRequests.filter((item) => !records.includes(item));
          return { success: true, deleted: records.length };
        });
      }
      default:
        return { success: false, errMsg: "无效的 type 字段" };
    }
  }

  async function dispatchDevice(event, req) {
    if (event.type === "deviceAuth") {
      const licenseId = String(event.licenseId || "").trim();
      if (!licenseId) return { success: false, errCode: "LICENSE_ID_REQUIRED", errMsg: "缺少 licenseId" };
      const deviceId = normalizeDeviceId(event.deviceId);
      const database = await store.read();
      const record = database.licenses.find((item) => item.licenseId === licenseId);
      const validation = verifyLicenseRecord(record, deviceId);
      if (!validation.valid) {
        const errCodeMap = {
          not_found: "LICENSE_NOT_FOUND",
          device_mismatch: "DEVICE_ID_MISMATCH",
          expired: "LICENSE_EXPIRED",
          revoked: "LICENSE_REVOKED"
        };
        return {
          success: false,
          errCode: errCodeMap[validation.status] || "LICENSE_INVALID",
          errMsg: `许可证不可用: ${validation.status}`
        };
      }
      const issued = issueDeviceToken({ deviceId, licenseId });
      return {
        success: true,
        deviceId,
        licenseId,
        deviceToken: issued.token,
        expiresAtMs: issued.expiresAtMs
      };
    }

    const context = consumeDeviceContext(event);
    if (!context.ok) return { success: false, errCode: context.errCode, errMsg: context.errMsg };
    const deviceId = context.deviceId;

    switch (event.type) {
      case "deviceHeartbeat":
      case "registerIdentificationResult":
      case "getIdentificationFeedback":
      case "ackIdentificationFeedback":
      case "createVolumeConfigRequest":
      case "getPendingVolumeConfigRequest":
      case "submitVolumeConfigFile":
      case "getVolumeConfigRequest":
      case "ackVolumeConfigRequest":
      case "getIdentificationConfig":
        return dispatch({ ...event, deviceId }, req);
      case "uploadDataFile": {
        const folder = normalizeRelativePath(event.folder, "data_record");
        const devicePrefix = `${deviceId}/`;
        if (!folder.startsWith(devicePrefix)) {
          return { success: false, errMsg: "设备接口仅允许访问当前 deviceId 目录" };
        }
        if (folder.endsWith("/model_config")) {
          return { success: false, errMsg: "设备接口不允许上传模型" };
        }
        return dispatch({ ...event, folder }, req);
      }
      case "listModels": {
        const folder = `${deviceId}/model_config`;
        return dispatch({ ...event, folder }, req);
      }
      case "downloadModel": {
        if (!event.fileID) return { success: false, errMsg: "缺少 fileID" };
        const database = await store.read();
        const record = database.fileRecords.find((item) => item.fileID === event.fileID);
        if (!record || !store.resolveStoredFile(record.fileID)) return { success: false, errMsg: "文件不存在" };
        if (record.folder !== `${deviceId}/model_config`) {
          return { success: false, errMsg: "设备接口无权下载该模型" };
        }
        return {
          success: true,
          url: issueDownloadUrl(req, record.fileID),
          fileName: record.fileName,
          originalFileName: record.originalFileName || record.fileName
        };
      }
      default:
        return { success: false, errMsg: "无效的 type 字段" };
    }
  }

  app.get("/health", (req, res) => res.json({ success: true, service: "reinloop-server" }));

  app.post("/upload/:token", upload.single("file"), async (req, res, next) => {
    try {
      const pending = pendingUploads.get(req.params.token);
      if (!pending || pending.expiresAt < Date.now()) return res.status(403).json({ success: false, errMsg: "上传凭证无效或已过期" });
      if (!req.file) return res.status(400).json({ success: false, errMsg: "缺少 file 表单字段" });
      const destination = store.resolveStoredFile(pending.fileID);
      await fs.promises.mkdir(path.dirname(destination), { recursive: true });
      await fs.promises.writeFile(destination, req.file.buffer);
      await store.update((database) => {
        const record = { _id: store.createId("file"), fileName: pending.fileName, originalFileName: pending.originalFileName, folder: pending.folder, cloudPath: pending.cloudPath, fileID: pending.fileID, uploadTime: new Date().toISOString(), size: req.file.size };
        database.fileRecords = database.fileRecords.filter((item) => item.cloudPath !== pending.cloudPath);
        database.fileRecords.push(record);
        const folderParts = pending.folder.split("/");
        const extension = path.extname(pending.fileName).toLowerCase();
        if (folderParts.at(-1) === "ind_data" && [".csv", ".json"].includes(extension)) {
          const deviceId = normalizeDeviceId(folderParts.slice(0, -1).join("/"));
          const message = {
            deviceId,
            fileID: pending.fileID,
            fileName: pending.fileName,
            mediaType: extension.slice(1),
            uploadTime: record.uploadTime
          };
          database.panelInbox = database.panelInbox.filter((item) => item.fileID !== pending.fileID);
          database.panelInbox.push(message);
          database.identificationFiles = database.identificationFiles.filter((item) => item.fileID !== pending.fileID);
          database.identificationFiles.push({
            ...message,
            size: record.size,
            status: "pending",
            processedAt: null,
            expiresAt: null
          });
          addPanelNotification(database, {
            deviceId,
            type: "identification_result_ready",
            title: "系统辨识结果已返回",
            message: "新的系统辨识 CSV 或 JSON 数据已进入暂存。",
            fileID: pending.fileID
          });
        }
        if (folderParts.at(-1) === "V_config" && extension === ".json") {
          const deviceId = normalizeDeviceId(folderParts.slice(0, -1).join("/"));
          addPanelNotification(database, {
            deviceId,
            type: "volume_result_ready",
            title: "容积测试结果已返回",
            message: "容积测试结果 JSON 已上传，可打开查看。",
            fileID: pending.fileID
          });
        }
        if (pending.configType && pending.parameters) {
          const config = {
            configType: pending.configType,
            parameters: pending.parameters,
            version: Date.now(),
            updateTime: new Date().toISOString()
          };
          database.functionConfigs = database.functionConfigs.filter(
            (item) => item.configType !== pending.configType
          );
          database.functionConfigs.push(config);
        }
      });
      const folderParts = pending.folder.split("/");
      if (folderParts.at(-1) === "identification_config") {
        logReceivedConfig({
          configType: "identification",
          deviceId: folderParts.slice(0, -1).join("/"),
          record: { fileID: pending.fileID, cloudPath: pending.cloudPath },
          config: req.file.buffer.toString("utf8").trim()
        });
      } else if (folderParts.at(-2) === "volume_config_requests") {
        let config;
        try {
          config = JSON.parse(req.file.buffer.toString("utf8"));
        } catch {
          config = "<invalid JSON>";
        }
        logReceivedConfig({
          configType: "volume",
          deviceId: folderParts.slice(0, -2).join("/"),
          requestId: folderParts.at(-1),
          record: { fileID: pending.fileID, cloudPath: pending.cloudPath },
          config
        });
      }
      pendingUploads.delete(req.params.token);
      res.status(204).end();
    } catch (error) {
      next(error);
    }
  });

  app.get("/downloads/:ticket", async (req, res, next) => {
    try {
      const ticket = String(req.params.ticket || "").trim();
      if (!ticket) return res.status(403).json({ success: false, errMsg: "下载链接无效或已失效" });
      const consumed = consumeDownloadTicket(req, ticket);
      if (!consumed.ok) return res.status(403).json({ success: false, errMsg: consumed.errMsg });
      const fileID = consumed.fileID;
      const database = await store.read();
      const record = database.fileRecords.find((item) => item.fileID === fileID);
      const filePath = record && store.resolveStoredFile(fileID);
      if (!record || !filePath) return res.status(404).json({ success: false, errMsg: "文件不存在" });
      await fs.promises.access(filePath);
      res.download(filePath, record.fileName);
    } catch (error) {
      if (error.code === "ENOENT") return res.status(404).json({ success: false, errMsg: "文件不存在" });
      next(error);
    }
  });

  app.get("/files/:fileID", (req, res) => {
    res.status(403).json({ success: false, errMsg: "旧下载链接已停用，请先通过 API 获取临时下载链接" });
  });

  const apiHandler = async (req, res) => {
    try {
      res.json(await dispatch(normalizeEventCompat(req.body || {}), req));
    } catch (error) {
      res.status(400).json({ success: false, errMsg: error.message });
    }
  };
  app.post("/", apiHandler);

  const deviceApiHandler = async (req, res) => {
    try {
      res.json(await dispatchDevice(normalizeEventCompat(req.body || {}), req));
    } catch (error) {
      res.status(400).json({ success: false, errMsg: error.message });
    }
  };
  app.post("/device", deviceApiHandler);

  app.use((error, req, res, next) => {
    console.error(error);
    res.status(500).json({ success: false, errMsg: "服务器内部错误" });
  });

  return app;
}

module.exports = { createApp, validateConfigParameters };