/* global wx, console, module, require */

const {
  DEFAULT_AI_PROVIDER,
  DEFAULT_CODEX_SANDBOX_MODE,
  DEFAULT_COPILOT_PERMISSION_MODE,
  normalizeAiProvider,
  normalizeCodexSandboxMode,
  normalizeCopilotPermissionMode
} = require("./aiLaunch");
const { normalizeTerminalFontFamily, pickBtnColor, pickShellAccentColor } = require("./themeStyle");
const { normalizeUiLanguage } = require("./i18n");
const {
  DEFAULT_TERMINAL_RESUME_MINUTES,
  MIN_TERMINAL_RESUME_MINUTES,
  MAX_TERMINAL_RESUME_MINUTES
} = require("./terminalSessionState");
const {
  DEFAULT_TTS_SPEAKABLE_MAX_CHARS,
  MIN_TTS_SPEAKABLE_MAX_CHARS,
  MAX_TTS_SPEAKABLE_MAX_CHARS,
  DEFAULT_TTS_SEGMENT_MAX_CHARS,
  MIN_TTS_SEGMENT_MAX_CHARS,
  MAX_TTS_SEGMENT_MAX_CHARS
} = require("./ttsSettings");

/**
 * 小程序本地存储封装。
 * 约束：
 * 1. 全部走同步 API，保证页面进入时读取行为确定；
 * 2. 结构保持与 Web 端语义一致，便于后续对齐。
 */
const KEYS = {
  servers: "remoteconn.servers.v2",
  settings: "remoteconn.settings.v2",
  logs: "remoteconn.logs.v2",
  records: "remoteconn.records.v2",
  pluginPackages: "remoteconn.plugins.packages.v2",
  pluginRecords: "remoteconn.plugins.records.v2",
  pluginRuntimeLogs: "remoteconn.plugins.runtimeLogs.v2"
};

/**
 * 稳定备份 key 不随业务版本号变化：
 * 1. 正式 key 升级时，可直接从备份恢复；
 * 2. 即使未来继续升 v3/v4，也不需要把备份链条无限拉长。
 */
const BACKUP_KEYS = {
  servers: "remoteconn.backup.servers",
  settings: "remoteconn.backup.settings",
  logs: "remoteconn.backup.logs",
  records: "remoteconn.backup.records",
  pluginPackages: "remoteconn.backup.plugins.packages",
  pluginRecords: "remoteconn.backup.plugins.records",
  pluginRuntimeLogs: "remoteconn.backup.plugins.runtimeLogs"
};

/**
 * 历史 key 候选表：
 * 1. 只在当前正式 key 缺失时尝试；
 * 2. 明确列出已知/合理的旧命名，避免运行时“猜 key”。
 */
const LEGACY_KEYS = {
  servers: ["remoteconn.servers.v1", "remoteconn.servers"],
  settings: ["remoteconn.settings.v1", "remoteconn.settings"],
  logs: ["remoteconn.logs.v1", "remoteconn.logs"],
  records: ["remoteconn.records.v1", "remoteconn.records"],
  pluginPackages: ["remoteconn.plugins.packages.v1", "remoteconn.plugins.packages"],
  pluginRecords: ["remoteconn.plugins.records.v1", "remoteconn.plugins.records"],
  pluginRuntimeLogs: ["remoteconn.plugins.runtimeLogs.v1", "remoteconn.plugins.runtimeLogs"]
};

let storageBootstrapDone = false;
let storageBootstrapInProgress = false;
let syncServiceModule = null;

const DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK = "未分类";
const DEFAULT_VOICE_RECORD_CATEGORIES = ["未分类", "优化", "新需求", "问题", "灵感"];
const DEFAULT_VOICE_RECORD_DEFAULT_CATEGORY = "优化";
const DEFAULT_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES = 200;
const MIN_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES = 20;
const MAX_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES = 5000;

const OPS_SETTING_KEYS = new Set([
  "gatewayUrl",
  "gatewayToken",
  "hostKeyPolicy",
  "credentialMemoryPolicy",
  "gatewayConnectTimeoutMs",
  "waitForConnectedTimeoutMs",
  "terminalBufferMaxEntries",
  "terminalBufferMaxBytes",
  "maskSecrets"
]);

const DEFAULT_SETTINGS = {
  // ── 界面主题（用户可调）────────────────────────────────────────────────────
  uiLanguage: "zh-Hans",
  uiThemeMode: "dark",
  uiThemePreset: "tide",
  uiAccentColor: "#5bd2ff",
  uiBgColor: "#192b4d",
  uiTextColor: "#e6f0ff",
  uiBtnColor: pickBtnColor("#192b4d", "#e6f0ff"),

  // ── 连接与服务器默认参数（用户可调）────────────────────────────────────────
  autoReconnect: true,
  syncConfigEnabled: true,
  reconnectLimit: 3,
  backgroundSessionKeepAliveMinutes: DEFAULT_TERMINAL_RESUME_MINUTES,
  defaultAuthType: "password",
  aiDefaultProvider: DEFAULT_AI_PROVIDER,
  aiCodexSandboxMode: DEFAULT_CODEX_SANDBOX_MODE,
  aiCopilotPermissionMode: DEFAULT_COPILOT_PERMISSION_MODE,
  defaultPort: 22,
  defaultProjectPath: "~/workspace",
  defaultTimeoutSeconds: 20,
  defaultHeartbeatSeconds: 15,
  defaultTransportMode: "gateway",

  // ── 终端显示与缓冲 ─────────────────────────────────────────────────────────
  shellThemeMode: "dark",
  shellThemePreset: "tide",
  shellBgColor: "#192b4d",
  shellTextColor: "#e6f0ff",
  shellAccentColor: pickShellAccentColor("#192b4d", "#e6f0ff"),
  shellFontFamily: "JetBrains Mono",
  shellFontSize: 15,
  shellLineHeight: 1.4,
  shellActivationDebugOutline: true,
  showVoiceInputButton: true,
  ttsSpeakableMaxChars: DEFAULT_TTS_SPEAKABLE_MAX_CHARS,
  ttsSegmentMaxChars: DEFAULT_TTS_SEGMENT_MAX_CHARS,
  shellBufferMaxEntries: 5000,
  shellBufferMaxBytes: 4 * 1024 * 1024,
  shellBufferSnapshotMaxLines: DEFAULT_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES,
  unicode11: true,

  // ── 日志 ───────────────────────────────────────────────────────────────────
  logRetentionDays: 30,
  voiceRecordCategories: DEFAULT_VOICE_RECORD_CATEGORIES.slice(),
  voiceRecordDefaultCategory: DEFAULT_VOICE_RECORD_DEFAULT_CATEGORY
};

const NUMBER_RULES = {
  reconnectLimit: { fallback: 3, min: 0, max: 10, integer: true },
  backgroundSessionKeepAliveMinutes: {
    fallback: DEFAULT_TERMINAL_RESUME_MINUTES,
    min: MIN_TERMINAL_RESUME_MINUTES,
    max: MAX_TERMINAL_RESUME_MINUTES,
    integer: true
  },
  defaultPort: { fallback: 22, min: 1, max: 65535, integer: true },
  defaultTimeoutSeconds: { fallback: 20, min: 5, max: 600, integer: true },
  defaultHeartbeatSeconds: { fallback: 15, min: 5, max: 600, integer: true },
  shellFontSize: { fallback: 15, min: 12, max: 22, integer: true },
  shellLineHeight: { fallback: 1.4, min: 1, max: 2, integer: false },
  ttsSpeakableMaxChars: {
    fallback: DEFAULT_TTS_SPEAKABLE_MAX_CHARS,
    min: MIN_TTS_SPEAKABLE_MAX_CHARS,
    max: MAX_TTS_SPEAKABLE_MAX_CHARS,
    integer: true
  },
  ttsSegmentMaxChars: {
    fallback: DEFAULT_TTS_SEGMENT_MAX_CHARS,
    min: MIN_TTS_SEGMENT_MAX_CHARS,
    max: MAX_TTS_SEGMENT_MAX_CHARS,
    integer: true
  },
  shellBufferMaxEntries: { fallback: 5000, min: 100, max: 200000, integer: true },
  shellBufferMaxBytes: { fallback: 4 * 1024 * 1024, min: 1024, max: 50 * 1024 * 1024, integer: true },
  shellBufferSnapshotMaxLines: {
    fallback: DEFAULT_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES,
    min: MIN_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES,
    max: MAX_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES,
    integer: true
  },
  logRetentionDays: { fallback: 30, min: 1, max: 365, integer: true }
};

const THEME_MODE_VALUES = new Set(["dark", "light"]);
const AUTH_TYPE_VALUES = new Set(["password", "key"]);
const HEX_COLOR_REGEX = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;

function normalizeServerTags(value) {
  const source = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
  const seen = new Set();
  const next = [];
  source.forEach((entry) => {
    const normalized = String(entry || "").trim();
    if (!normalized || seen.has(normalized)) return;
    seen.add(normalized);
    next.push(normalized);
  });
  return next;
}

function normalizeVoiceRecordCategories(value) {
  const source = Array.isArray(value) ? value : [];
  const seen = new Set();
  const next = [];

  source.forEach((entry) => {
    const normalized = String(entry || "").trim();
    if (!normalized || seen.has(normalized)) return;
    seen.add(normalized);
    next.push(normalized);
  });

  if (!seen.has(DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK)) {
    next.unshift(DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK);
  }

  return next.slice(0, 10);
}

function normalizeVoiceRecordDefaultCategory(value, categories) {
  const normalized = String(value || "").trim();
  if (normalized && categories.includes(normalized)) {
    return normalized;
  }
  if (categories.includes(DEFAULT_VOICE_RECORD_DEFAULT_CATEGORY)) {
    return DEFAULT_VOICE_RECORD_DEFAULT_CATEGORY;
  }
  return categories[0] || DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK;
}

function normalizeNumber(value, rule) {
  const parsed = Number(value);
  if (!Number.isFinite(parsed)) return rule.fallback;
  const normalized = rule.integer ? Math.round(parsed) : parsed;
  if (normalized < rule.min) return rule.min;
  if (normalized > rule.max) return rule.max;
  return normalized;
}

function normalizeSettings(input) {
  const source = input && typeof input === "object" ? input : {};
  const next = { ...source };

  Object.keys(NUMBER_RULES).forEach((key) => {
    next[key] = normalizeNumber(next[key], NUMBER_RULES[key]);
  });

  next.uiLanguage = normalizeUiLanguage(next.uiLanguage);
  next.uiThemeMode = THEME_MODE_VALUES.has(next.uiThemeMode)
    ? next.uiThemeMode
    : DEFAULT_SETTINGS.uiThemeMode;
  next.shellThemeMode = THEME_MODE_VALUES.has(next.shellThemeMode)
    ? next.shellThemeMode
    : DEFAULT_SETTINGS.shellThemeMode;
  next.shellThemePreset = String(next.shellThemePreset || DEFAULT_SETTINGS.shellThemePreset);
  next.defaultAuthType = AUTH_TYPE_VALUES.has(next.defaultAuthType)
    ? next.defaultAuthType
    : DEFAULT_SETTINGS.defaultAuthType;
  next.aiDefaultProvider = normalizeAiProvider(next.aiDefaultProvider);
  next.aiCodexSandboxMode = normalizeCodexSandboxMode(next.aiCodexSandboxMode);
  next.aiCopilotPermissionMode = normalizeCopilotPermissionMode(next.aiCopilotPermissionMode);
  next.defaultTransportMode = String(next.defaultTransportMode || DEFAULT_SETTINGS.defaultTransportMode);
  next.defaultProjectPath = String(next.defaultProjectPath || DEFAULT_SETTINGS.defaultProjectPath);
  next.uiThemePreset = String(next.uiThemePreset || DEFAULT_SETTINGS.uiThemePreset);
  next.uiAccentColor = HEX_COLOR_REGEX.test(String(next.uiAccentColor || ""))
    ? String(next.uiAccentColor)
    : DEFAULT_SETTINGS.uiAccentColor;
  next.uiBgColor = HEX_COLOR_REGEX.test(String(next.uiBgColor || ""))
    ? String(next.uiBgColor)
    : DEFAULT_SETTINGS.uiBgColor;
  next.uiTextColor = HEX_COLOR_REGEX.test(String(next.uiTextColor || ""))
    ? String(next.uiTextColor)
    : DEFAULT_SETTINGS.uiTextColor;
  next.uiBtnColor = HEX_COLOR_REGEX.test(String(next.uiBtnColor || ""))
    ? String(next.uiBtnColor)
    : pickBtnColor(next.uiBgColor, next.uiTextColor);
  /**
   * 终端字体必须先经过“安全字体”归一：
   * 1. 避免把比例字体直接写入终端运行态；
   * 2. 老版本已保存的不安全字体在这里自动迁回安全等宽字体。
   */
  next.shellFontFamily = normalizeTerminalFontFamily(
    String(next.shellFontFamily || DEFAULT_SETTINGS.shellFontFamily)
  );
  next.shellBgColor = HEX_COLOR_REGEX.test(String(next.shellBgColor || ""))
    ? String(next.shellBgColor)
    : DEFAULT_SETTINGS.shellBgColor;
  next.shellTextColor = HEX_COLOR_REGEX.test(String(next.shellTextColor || ""))
    ? String(next.shellTextColor)
    : DEFAULT_SETTINGS.shellTextColor;
  next.shellAccentColor = HEX_COLOR_REGEX.test(String(next.shellAccentColor || ""))
    ? String(next.shellAccentColor)
    : pickShellAccentColor(next.shellBgColor, next.shellTextColor);
  next.shellActivationDebugOutline =
    next.shellActivationDebugOutline === undefined
      ? DEFAULT_SETTINGS.shellActivationDebugOutline
      : !!next.shellActivationDebugOutline;
  /**
   * 语音输入按钮默认显示：
   * 1. 老版本没有该字段时自动补 true；
   * 2. 统一收敛为布尔值，避免 storage 里残留字符串/数字脏值。
   */
  next.showVoiceInputButton =
    next.showVoiceInputButton === undefined ? DEFAULT_SETTINGS.showVoiceInputButton : !!next.showVoiceInputButton;
  next.unicode11 = !!next.unicode11;
  next.autoReconnect = !!next.autoReconnect;
  // 云端同步开关默认开启，兼容现有“本地 + Gateway”双写行为。
  next.syncConfigEnabled =
    next.syncConfigEnabled === undefined ? DEFAULT_SETTINGS.syncConfigEnabled : !!next.syncConfigEnabled;
  next.voiceRecordCategories = normalizeVoiceRecordCategories(next.voiceRecordCategories);
  next.voiceRecordDefaultCategory = normalizeVoiceRecordDefaultCategory(
    next.voiceRecordDefaultCategory,
    next.voiceRecordCategories
  );

  return next;
}

function sanitizeUserSettings(input) {
  if (!input || typeof input !== "object") return {};
  const next = {};
  Object.keys(input).forEach((key) => {
    if (OPS_SETTING_KEYS.has(key)) return;
    next[key] = input[key];
  });
  return next;
}

function listStorageKeys() {
  try {
    const info = wx.getStorageInfoSync();
    return Array.isArray(info && info.keys) ? info.keys : [];
  } catch {
    return [];
  }
}

function readRaw(key) {
  try {
    const value = wx.getStorageSync(key);
    const keys = listStorageKeys();
    const found = keys.includes(key) || !(value === undefined || value === null || value === "");
    return { found, value };
  } catch (error) {
    console.warn("[storage.read.raw]", key, error);
    return { found: false, value: undefined };
  }
}

function writeRaw(key, value) {
  try {
    wx.setStorageSync(key, value);
    return true;
  } catch (error) {
    console.error("[storage.write.raw]", key, error);
    return false;
  }
}

function hydrateStorageKey(logicalKey) {
  const primaryKey = KEYS[logicalKey];
  const backupKey = BACKUP_KEYS[logicalKey];
  const primary = readRaw(primaryKey);

  if (primary.found) {
    if (backupKey) {
      const backup = readRaw(backupKey);
      if (!backup.found) {
        writeRaw(backupKey, primary.value);
      }
    }
    return;
  }

  if (backupKey) {
    const backup = readRaw(backupKey);
    if (backup.found) {
      writeRaw(primaryKey, backup.value);
      console.info("[storage.restore.backup]", logicalKey, backupKey, "->", primaryKey);
      return;
    }
  }

  const legacyKeys = Array.isArray(LEGACY_KEYS[logicalKey]) ? LEGACY_KEYS[logicalKey] : [];
  for (let i = 0; i < legacyKeys.length; i += 1) {
    const legacyKey = legacyKeys[i];
    const legacy = readRaw(legacyKey);
    if (!legacy.found) continue;
    writeRaw(primaryKey, legacy.value);
    if (backupKey) {
      writeRaw(backupKey, legacy.value);
    }
    console.info("[storage.restore.legacy]", logicalKey, legacyKey, "->", primaryKey);
    return;
  }
}

function ensureStorageBootstrapped() {
  if (storageBootstrapDone || storageBootstrapInProgress) return;
  storageBootstrapInProgress = true;
  try {
    Object.keys(KEYS).forEach((logicalKey) => {
      hydrateStorageKey(logicalKey);
    });
    storageBootstrapDone = true;
  } finally {
    storageBootstrapInProgress = false;
  }
}

function read(key, fallback) {
  ensureStorageBootstrapped();
  try {
    const { found, value } = readRaw(key);
    if (!found) return fallback;
    return value === undefined || value === null || value === "" ? fallback : value;
  } catch (error) {
    console.warn("[storage.read]", key, error);
    return fallback;
  }
}

function write(key, value) {
  ensureStorageBootstrapped();
  writeRaw(key, value);

  const logicalKey = Object.keys(KEYS).find((name) => KEYS[name] === key);
  if (!logicalKey) return;

  const backupKey = BACKUP_KEYS[logicalKey];
  if (!backupKey) return;

  if (!writeRaw(backupKey, value)) {
    console.error("[storage.write.backup]", key, backupKey);
  }
}

function nowIso() {
  return new Date().toISOString();
}

function loadSyncService() {
  if (syncServiceModule) return syncServiceModule;
  try {
    syncServiceModule = require("./syncService");
  } catch {
    syncServiceModule = null;
  }
  return syncServiceModule;
}

function notifySync(method, ...args) {
  const service = loadSyncService();
  if (!service || typeof service[method] !== "function") return;
  try {
    service[method](...args);
  } catch (error) {
    console.warn(`[storage.sync.${method}]`, error);
  }
}

function normalizeJumpHost(input) {
  const source = input && typeof input === "object" ? input : {};
  const authType =
    source.authType === "privateKey" || source.authType === "certificate" ? source.authType : "password";
  return {
    enabled: source.enabled === true,
    host: String(source.host || "").trim(),
    port: Number(source.port) || 22,
    username: String(source.username || "").trim(),
    authType
  };
}

function normalizeServerAuthType(value) {
  return value === "privateKey" || value === "certificate" ? value : "password";
}

function normalizeServerRecord(server) {
  const source = server && typeof server === "object" ? server : {};
  // 服务器对象要在本地先归一化成“同步可直接上传”的形状。
  // 历史数据里可能残留 authType="key"、null 字段或字符串数字，若原样上传会被网关 schema 拒绝。
  return {
    ...source,
    id: String(source.id || ""),
    name: String(source.name || ""),
    tags: normalizeServerTags(source.tags),
    host: String(source.host || "").trim(),
    port: Number(source.port) || 22,
    username: String(source.username || "").trim(),
    authType: normalizeServerAuthType(source.authType),
    password: String(source.password || ""),
    privateKey: String(source.privateKey || ""),
    passphrase: String(source.passphrase || ""),
    certificate: String(source.certificate || ""),
    projectPath: String(source.projectPath || ""),
    timeoutSeconds: Number(source.timeoutSeconds) || 15,
    heartbeatSeconds: Number(source.heartbeatSeconds) || 10,
    transportMode: String(source.transportMode || "gateway"),
    jumpHost: normalizeJumpHost(source.jumpHost),
    jumpPassword: String(source.jumpPassword || ""),
    jumpPrivateKey: String(source.jumpPrivateKey || ""),
    jumpPassphrase: String(source.jumpPassphrase || ""),
    jumpCertificate: String(source.jumpCertificate || ""),
    sortOrder: Number(source.sortOrder) || 0,
    lastConnectedAt: String(source.lastConnectedAt || ""),
    updatedAt: String(source.updatedAt || source.lastConnectedAt || nowIso())
  };
}

function createServerSeed() {
  const ts = Date.now();
  const rand = Math.random().toString(36).slice(2, 8);
  const settings = getSettings();
  const defaultAuthType = settings.defaultAuthType === "key" ? "privateKey" : "password";
  return {
    id: `srv-${ts}-${rand}`,
    name: "",
    tags: [],
    host: "",
    port: Number(settings.defaultPort) || 22,
    username: "",
    authType: defaultAuthType,
    password: "",
    privateKey: "",
    passphrase: "",
    certificate: "",
    projectPath: settings.defaultProjectPath || "",
    timeoutSeconds: Number(settings.defaultTimeoutSeconds) || 15,
    heartbeatSeconds: Number(settings.defaultHeartbeatSeconds) || 10,
    transportMode: settings.defaultTransportMode || "gateway",
    jumpHost: normalizeJumpHost(),
    sortOrder: ts,
    lastConnectedAt: "",
    updatedAt: nowIso()
  };
}

function listServers() {
  const rows = read(KEYS.servers, []);
  return Array.isArray(rows)
    ? rows
        .map((item) => normalizeServerRecord({ ...createServerSeed(), ...item }))
        .sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0))
    : [];
}

function saveServers(next, options) {
  write(KEYS.servers, Array.isArray(next) ? next : []);
  const extra = options && typeof options === "object" ? options : {};
  if (!extra.silentSync) {
    notifySync("scheduleServersSync");
  }
}

function upsertServer(server, options) {
  const extra = options && typeof options === "object" ? options : {};
  const rows = listServers();
  const index = rows.findIndex((item) => item.id === server.id);
  const updatedAt = extra.preserveUpdatedAt ? String(server.updatedAt || nowIso()) : nowIso();
  if (index >= 0) {
    rows[index] = normalizeServerRecord({ ...rows[index], ...server, updatedAt });
  } else {
    rows.push(normalizeServerRecord({ ...createServerSeed(), ...server, updatedAt }));
  }
  saveServers(rows, extra);
  return rows;
}

function removeServer(serverId, options) {
  const extra = options && typeof options === "object" ? options : {};
  const rows = listServers().filter((item) => item.id !== serverId);
  saveServers(rows, extra);
  if (!extra.silentSync) {
    notifySync("markServerDeleted", serverId, nowIso());
  }
  return rows;
}

function markServerConnected(serverId) {
  const rows = listServers();
  const index = rows.findIndex((item) => item.id === serverId);
  if (index >= 0) {
    rows[index].lastConnectedAt = nowIso();
    rows[index].updatedAt = nowIso();
    saveServers(rows);
  }
}

function getSettings() {
  return normalizeSettings({ ...DEFAULT_SETTINGS, ...sanitizeUserSettings(read(KEYS.settings, {})) });
}

function saveSettings(next, options) {
  const extra = options && typeof options === "object" ? options : {};
  const previous = getSettings();
  const updatedAt = extra.preserveUpdatedAt
    ? String(next && next.updatedAt ? next.updatedAt : nowIso())
    : nowIso();
  const normalized = normalizeSettings({ ...previous, ...sanitizeUserSettings(next || {}), updatedAt });
  write(KEYS.settings, normalized);
  if (!extra.silentSync) {
    /**
     * 重新打开云端同步时，先强制跑一次 bootstrap：
     * 1. 先把云端最新视图合并回本地；
     * 2. 再补推当前合并结果，避免直接用“关闭期间的本地快照”覆盖远端。
     */
    if (!previous.syncConfigEnabled && normalized.syncConfigEnabled) {
      notifySync("resumeSyncConfig");
    } else {
      notifySync("scheduleSettingsSync");
    }
  }
}

function normalizeRecord(item) {
  const source = item && typeof item === "object" ? item : {};
  const createdAt = String(source.createdAt || nowIso());
  const discarded = source.discarded === true;
  const processed = !discarded && source.processed === true;
  return {
    id: String(source.id || `rec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`),
    content: String(source.content || "").trim(),
    serverId: String(source.serverId || ""),
    createdAt,
    updatedAt: String(source.updatedAt || createdAt),
    category:
      String(source.category || DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK).trim() ||
      DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK,
    contextLabel: String(source.contextLabel || ""),
    processed,
    discarded
  };
}

function dropExpiredLogs(rows) {
  const list = Array.isArray(rows) ? rows : [];
  const retentionDays = getSettings().logRetentionDays;
  const ttlMs = Number(retentionDays) * 24 * 60 * 60 * 1000;
  if (!Number.isFinite(ttlMs) || ttlMs <= 0) return list;

  const now = Date.now();
  return list.filter((item) => {
    const startAt = +new Date(item.startAt || 0);
    if (!Number.isFinite(startAt) || startAt <= 0) return true;
    return now - startAt <= ttlMs;
  });
}

function listLogs() {
  const rows = read(KEYS.logs, []);
  const cleaned = dropExpiredLogs(rows);
  if (Array.isArray(rows) && cleaned.length !== rows.length) {
    write(KEYS.logs, cleaned);
  }
  return Array.isArray(cleaned)
    ? cleaned.slice().sort((a, b) => +new Date(b.startAt) - +new Date(a.startAt))
    : [];
}

function appendLog(entry) {
  const rows = listLogs();
  rows.unshift({
    id: entry.id || `log-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
    startAt: entry.startAt || nowIso(),
    endAt: entry.endAt || "",
    serverId: entry.serverId || "",
    status: entry.status || "connected",
    summary: entry.summary || ""
  });
  write(KEYS.logs, rows);
}

function listRecords() {
  const rows = read(KEYS.records, []);
  if (!Array.isArray(rows)) return [];
  let dirty = false;
  const normalized = rows
    .map((item) => {
      const next = normalizeRecord(item);
      if (
        !item ||
        item.updatedAt !== next.updatedAt ||
        item.category !== next.category ||
        item.contextLabel !== next.contextLabel ||
        item.processed !== next.processed ||
        item.discarded !== next.discarded ||
        item.content !== next.content ||
        item.serverId !== next.serverId
      ) {
        dirty = true;
      }
      return next;
    })
    .sort((a, b) => +new Date(b.createdAt) - +new Date(a.createdAt));
  if (dirty) {
    write(KEYS.records, normalized);
  }
  return normalized;
}

function saveRecords(next, options) {
  write(KEYS.records, Array.isArray(next) ? next.map((item) => normalizeRecord(item)) : []);
  const extra = options && typeof options === "object" ? options : {};
  if (!extra.silentSync) {
    notifySync("scheduleRecordsSync");
  }
}

function addRecord(content, serverId, options) {
  const text = String(content || "").trim();
  if (!text) return null;
  const rows = listRecords();
  const extra = options && typeof options === "object" ? options : {};
  const timestamp = nowIso();
  const discarded = extra.discarded === true;
  const processed = !discarded && extra.processed === true;
  const next = {
    id: `rec-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
    content: text,
    serverId: serverId || "",
    createdAt: timestamp,
    updatedAt: timestamp,
    category:
      String(extra.category || DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK).trim() ||
      DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK,
    contextLabel: String(extra.contextLabel || ""),
    processed,
    discarded
  };
  rows.unshift(next);
  saveRecords(rows);
  return next;
}

function updateRecord(payload) {
  const source = payload && typeof payload === "object" ? payload : {};
  const recordId = String(source.id || "").trim();
  const content = String(source.content || "").trim();
  if (!recordId || !content) return null;
  const rows = listRecords();
  const index = rows.findIndex((item) => item.id === recordId);
  if (index < 0) return null;
  const current = rows[index];
  let nextProcessed = Object.prototype.hasOwnProperty.call(source, "processed")
    ? source.processed === true
    : current.processed === true;
  let nextDiscarded = Object.prototype.hasOwnProperty.call(source, "discarded")
    ? source.discarded === true
    : current.discarded === true;
  /**
   * 闪念终态互斥规则与 normalizeRecord 保持一致：
   * 1. 只要本次结果里 discarded 为 true，就强制关掉 processed；
   * 2. 否则若 processed 为 true，再回头关掉 discarded；
   * 3. 这样“已废弃”不会被历史 processed 残值反向吞掉。
   */
  if (nextDiscarded) {
    nextProcessed = false;
  } else if (nextProcessed) {
    nextDiscarded = false;
  }
  const next = {
    ...current,
    content,
    category:
      String(source.category || current.category || DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK).trim() ||
      DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK,
    processed: nextProcessed,
    discarded: nextDiscarded,
    updatedAt: nowIso()
  };
  rows[index] = next;
  saveRecords(rows);
  return next;
}

function searchRecords(input) {
  const source = input && typeof input === "object" ? input : {};
  const keyword = String(source.keyword || "")
    .trim()
    .toLowerCase();
  const category = String(source.category || "").trim();
  return listRecords().filter((item) => {
    if (category && item.category !== category) return false;
    if (!keyword) return true;
    return [item.content, item.category, item.contextLabel, item.createdAt]
      .join(" ")
      .toLowerCase()
      .includes(keyword);
  });
}

function removeRecord(recordId, options) {
  const extra = options && typeof options === "object" ? options : {};
  const rows = listRecords().filter((item) => item.id !== recordId);
  saveRecords(rows, extra);
  if (!extra.silentSync) {
    notifySync("markRecordDeleted", recordId, nowIso());
  }
  return rows;
}

function listPluginPackages() {
  const rows = read(KEYS.pluginPackages, []);
  return Array.isArray(rows) ? rows : [];
}

function getPluginPackage(pluginId) {
  const id = String(pluginId || "");
  return listPluginPackages().find((item) => item && item.manifest && item.manifest.id === id) || null;
}

function savePluginPackages(next) {
  write(KEYS.pluginPackages, Array.isArray(next) ? next : []);
}

function upsertPluginPackage(pluginPackage) {
  if (!pluginPackage || !pluginPackage.manifest || !pluginPackage.manifest.id) {
    throw new Error("插件包格式非法");
  }
  const rows = listPluginPackages();
  const index = rows.findIndex(
    (item) => item && item.manifest && item.manifest.id === pluginPackage.manifest.id
  );
  if (index >= 0) {
    rows[index] = pluginPackage;
  } else {
    rows.push(pluginPackage);
  }
  savePluginPackages(rows);
}

function removePluginPackage(pluginId) {
  const id = String(pluginId || "");
  const rows = listPluginPackages().filter((item) => item && item.manifest && item.manifest.id !== id);
  savePluginPackages(rows);
}

function listPluginRecords() {
  const rows = read(KEYS.pluginRecords, []);
  return Array.isArray(rows) ? rows : [];
}

function savePluginRecords(next) {
  write(KEYS.pluginRecords, Array.isArray(next) ? next : []);
}

function listPluginRuntimeLogs() {
  const rows = read(KEYS.pluginRuntimeLogs, []);
  return Array.isArray(rows) ? rows : [];
}

function savePluginRuntimeLogs(next) {
  write(KEYS.pluginRuntimeLogs, Array.isArray(next) ? next : []);
}

function readPluginData(pluginId) {
  const id = String(pluginId || "").trim();
  if (!id) return {};
  return read(`remoteconn.plugins.data.${id}.v2`, {});
}

function writePluginData(pluginId, value) {
  const id = String(pluginId || "").trim();
  if (!id) return;
  write(`remoteconn.plugins.data.${id}.v2`, value && typeof value === "object" ? value : {});
}

module.exports = {
  createServerSeed,
  listServers,
  saveServers,
  upsertServer,
  removeServer,
  markServerConnected,
  getSettings,
  saveSettings,
  listLogs,
  appendLog,
  listRecords,
  addRecord,
  updateRecord,
  saveRecords,
  searchRecords,
  removeRecord,
  listPluginPackages,
  getPluginPackage,
  savePluginPackages,
  upsertPluginPackage,
  removePluginPackage,
  listPluginRecords,
  savePluginRecords,
  listPluginRuntimeLogs,
  savePluginRuntimeLogs,
  readPluginData,
  writePluginData,
  DEFAULT_VOICE_RECORD_CATEGORY_FALLBACK,
  DEFAULT_VOICE_RECORD_CATEGORIES,
  DEFAULT_VOICE_RECORD_DEFAULT_CATEGORY,
  DEFAULT_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES,
  MIN_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES,
  MAX_TERMINAL_BUFFER_SNAPSHOT_MAX_LINES,
  normalizeVoiceRecordCategories,
  normalizeVoiceRecordDefaultCategory
};