// entry/src/main/ets/common/AccountStore.ets
// DAV 账号持久化（加密）：
// - 账号列表（含密码）序列化为 JSON 后整体加密，存储为 caldav_vault 偏好中的 data_b64。
// - **首选 HUKS 硬件密钥库**：AES-256-GCM 密钥在 TEE 内生成、**不可导出、不落盘**（只留 keyAlias），
//   密文格式 `huks1:<b64(nonce)>:<b64(密文+tag)>`。这样"整机备份被导出"也解不开 —— 密钥不在备份里。
//   写入前做**自检**：HUKS 密文必须能自解回原文才允许落盘，否则本进程直接回落软件 AES。
// - **回落**：个别设备 HUKS 不可用（初始化/权限异常/加解密不一致）时退回"AES 密钥存偏好"的软件方案
//   （`aes1:` 前缀），宁可安全性降级也不能让"账号存不上"。探测结果在进程内缓存，避免每轮同步重复试错。
//   ⚠️ 清密钥（purgeSoftKey）**必须确认密文已是 `huks1:`**，否则会把仍依赖软件密钥的 `aes1:` 密文解坏。
// - **旧数据迁移**：更早的无前缀软件 AES 密文、旧版明文存储（caldav_account 的 acc_0..n）
//   在首次 loadAll 时读出并就地升级为 HUKS 密文，随后清除偏好中的明文密钥与旧存储。
import { preferences } from '@kit.ArkData';
import { cryptoFramework } from '@kit.CryptoArchitectureKit';
import { huks } from '@kit.UniversalKeystoreKit';
import { util } from '@kit.ArkTS';
import { common } from '@kit.AbilityKit';
import { BusinessError } from '@kit.BasicServicesKit';

export const TYPE_CALDAV: string = 'caldav';
export const TYPE_CARDDAV: string = 'carddav';
export const TYPE_WEBDAV: string = 'webdav';
export const TYPE_KEYS: string[] = [TYPE_CALDAV, TYPE_CARDDAV, TYPE_WEBDAV];

/** 本机事件所属的虚拟日历 key */
export const LOCAL_CAL_KEY: string = 'local';

/** 旧版明文存储（迁移后清除） */
const LEGACY_STORE: string = 'caldav_account';
const LEGACY_COUNT_KEY: string = 'accountCount';

/** 加密存储 */
const VAULT_STORE: string = 'caldav_vault';
/** 旧版"软件 AES 密钥"（明文存偏好）；升级到 HUKS 后会被清除 */
const VAULT_KEY: string = 'key_b64';
const VAULT_DATA: string = 'data_b64';

/** HUKS 密钥别名：固定不变；密钥本体在 TEE 内，应用永远拿不到明文 */
const HUKS_ALIAS: string = 'synccalendar_vault_aes256_gcm';
/** 密文前缀：区分 HUKS 密文 / 软件 AES 密文（无前缀 = 更早的旧格式，按软件 AES 解） */
const PREFIX_HUKS: string = 'huks1:';
const PREFIX_AES: string = 'aes1:';

/**
 * DAV 账号（@Observed 使同步状态变化能刷新列表 UI）
 */
@Observed
export class DavAccount {
  id: string = '';
  type: string = TYPE_CALDAV;
  name: string = '';
  serverUrl: string = '';
  username: string = '';
  password: string = '';
  calendarHrefs: string[] = [];
  calendarNames: string[] = [];
  /** 服务器端定义的日历本颜色（calendar-color），与 calendarHrefs 一一对应，空串表示未定义 */
  calendarColors: string[] = [];
  /** 各日历本写权限（'1'=可写 '0'=只读），与 calendarHrefs 一一对应；空数组表示未知（按可写处理） */
  calendarWritable: string[] = [];
  itemCount: number = 0;
  lastSyncTime: string = '';
}

/** 日历本来源（用于界面显隐与取色） */
export class CalSource {
  calKey: string = '';
  name: string = '';
  color: string = '#007DFF';
  source: string = 'dav'; // 'dav' | 'system' | 'local'
  visible: boolean = true;
  writable: boolean = true; // 只读日历本中的日程只能查看详情，不能编辑
}

/** 与 UI 无关的调色板 */
export class BookPalette {
  static colors: string[] = [
    '#007DFF', '#FF7D00', '#00B96B', '#9F44FF', '#F5317F', '#00B2C6', '#B58600', '#6D4AFF'
  ];
  static colorFor(index: number): string {
    return BookPalette.colors[index % BookPalette.colors.length];
  }
}

function bytesToB64(u: Uint8Array): string {
  return new util.Base64Helper().encodeToStringSync(u);
}

function b64ToBytes(s: string): Uint8Array {
  return new util.Base64Helper().decodeSync(s);
}

function strToBytes(s: string): Uint8Array {
  return new util.TextEncoder().encodeInto(s);
}

function bytesToStr(u: Uint8Array): string {
  return new util.TextDecoder('utf-8').decodeToString(u);
}

/**
 * 账号加密存储实现。
 *
 * **首选 HUKS（硬件密钥库）**：AES-256-GCM 密钥在 TEE 内生成、**不可导出、不落盘**，
 * 应用侧只持有 keyAlias。因此「整机备份被导出」到其他设备也无法解密（密钥不在备份中、且与设备绑定）。
 *
 * **回落**：HUKS 初始化/调用异常时退回软件 AES（密钥存偏好，`aes1:` 前缀）——
 * 本环境无法真机验证 HUKS，留此安全网可确保"最坏情况 = 与改造前一致"，绝不出现存不上账号。
 * 探测结果缓存在 `huksReady`，避免每轮同步反复试错。
 *
 * 密文自描述（前缀区分算法），便于日后识别与再迁移：
 *   `huks1:<b64(nonce)>:<b64(密文+tag)>` | `aes1:<b64(iv)>:<b64(密文+tag)>` | `<b64(iv)>:<b64(...)>`（更早旧格式）
 */
class Vault {
  /** 软件方案：进程内缓存，避免每轮同步重复读偏好 */
  private static keyB64: string = '';
  /** HUKS 可用性：null=未探测；true=可用；false=已判定不可用（本进程不再重试） */
  private static huksReady: boolean | null = null;

  static async prefs(context: common.Context): Promise<preferences.Preferences> {
    return preferences.getPreferences(context, VAULT_STORE);
  }

  // ==================== HUKS（首选路径） ====================

  /** 生成密钥所用属性（AES-256-GCM，同时具备加密与解密用途） */
  private static genProperties(): huks.HuksParam[] {
    return [
      { tag: huks.HuksTag.HUKS_TAG_ALGORITHM, value: huks.HuksKeyAlg.HUKS_ALG_AES },
      { tag: huks.HuksTag.HUKS_TAG_PURPOSE,
        value: huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT | huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT },
      { tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 },
      { tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, value: huks.HuksCipherMode.HUKS_MODE_GCM },
      { tag: huks.HuksTag.HUKS_TAG_PADDING, value: huks.HuksKeyPadding.HUKS_PADDING_NONE },
      { tag: huks.HuksTag.HUKS_TAG_KEY_ALIAS, value: strToBytes(HUKS_ALIAS) },
      { tag: huks.HuksTag.HUKS_TAG_IS_KEY_ALIAS, value: true }
    ];
  }

  /** 单次加/解密操作属性（NONCE 由调用方追加；GCM 无需 digest/padding 之外参数） */
  private static opProperties(purpose: number): huks.HuksParam[] {
    return [
      { tag: huks.HuksTag.HUKS_TAG_ALGORITHM, value: huks.HuksKeyAlg.HUKS_ALG_AES },
      { tag: huks.HuksTag.HUKS_TAG_PURPOSE, value: purpose },
      { tag: huks.HuksTag.HUKS_TAG_KEY_SIZE, value: huks.HuksKeySize.HUKS_AES_KEY_SIZE_256 },
      { tag: huks.HuksTag.HUKS_TAG_BLOCK_MODE, value: huks.HuksCipherMode.HUKS_MODE_GCM },
      { tag: huks.HuksTag.HUKS_TAG_PADDING, value: huks.HuksKeyPadding.HUKS_PADDING_NONE }
    ];
  }

  /**
   * 确保 HUKS 密钥存在（不存在则生成）。返回当前是否可用。
   * 任何异常都视为"HUKS 不可用"并缓存，后续直接走软件回落，不再反复抛错。
   */
  private static async ensureHuksKey(): Promise<boolean> {
    if (Vault.huksReady === false) {
      return false;
    }
    try {
      const exists: boolean = await huks.isKeyItemExist(HUKS_ALIAS, { properties: Vault.genProperties() });
      if (exists) {
        Vault.huksReady = true;
        return true;
      }
      try {
        await huks.generateKeyItem(HUKS_ALIAS, { properties: Vault.genProperties() });
        console.info('[Vault] 已在 HUKS 中生成账号库密钥');
      } catch (genErr) {
        // 生成失败也可能只是"密钥其实已存在"（isKeyItemExist 属性校验差异 / 并发）：
        // 再确认一次，确认存在就视为可用 —— 否则会误判为"不可用"而静默降级成软件加密。
        const ge = genErr as BusinessError;
        const again: boolean = await huks.isKeyItemExist(HUKS_ALIAS, { properties: Vault.genProperties() });
        if (!again) {
          throw new Error(`HUKS 生成密钥失败(code=${ge.code}): ${ge.message}`);
        }
        console.info('[Vault] HUKS 密钥已存在，直接使用');
      }
      Vault.huksReady = true;
      return true;
    } catch (err) {
      const e = err as BusinessError;
      console.error(`[Vault] HUKS 不可用(code=${e.code})，本次回落软件加密: ${e.message}`);
      Vault.huksReady = false;
      return false;
    }
  }

  /** GCM 附加认证数据（固定常量）：把密文绑定到"账号库"这一用途，防密文被挪作他用 */
  private static aad(): Uint8Array {
    return strToBytes('synccalendar-vault-v1');
  }

  /**
   * HUKS 加密（initSession → finishSession 一次性完成）。
   * 本 SDK **没有** `huks.encryptItem` 一次性接口，必须走会话式 API。
   * 返回 `b64(nonce):b64(密文+GCM tag)`（不含前缀）——nonce 在加密时显式指定，
   * 故返回数据为「密文 + AEAD(16B)」，nonce 由我们单独保存。
   */
  private static async huksEncrypt(plain: string): Promise<string> {
    const nonce: Uint8Array = cryptoFramework.createRandom().generateRandomSync(12).data;
    const props: huks.HuksParam[] = Vault.opProperties(huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_ENCRYPT);
    props.push({ tag: huks.HuksTag.HUKS_TAG_NONCE, value: nonce });
    props.push({ tag: huks.HuksTag.HUKS_TAG_ASSOCIATED_DATA, value: Vault.aad() });
    const session: huks.HuksSessionHandle = await huks.initSession(HUKS_ALIAS, { properties: props });
    const result: huks.HuksReturnResult =
      await huks.finishSession(session.handle, { properties: props, inData: strToBytes(plain) });
    const buf: Uint8Array | undefined = result.outData;
    if (buf === undefined || buf.length === 0) {
      throw new Error('HUKS 加密返回空数据');
    }
    return `${bytesToB64(nonce)}:${bytesToB64(buf)}`;
  }

  /** HUKS 解密（nonce 与密文分开传递）；失败抛异常由上层统一兜底 */
  private static async huksDecrypt(nonceB64: string, cipherB64: string): Promise<string | null> {
    const props: huks.HuksParam[] = Vault.opProperties(huks.HuksKeyPurpose.HUKS_KEY_PURPOSE_DECRYPT);
    props.push({ tag: huks.HuksTag.HUKS_TAG_NONCE, value: b64ToBytes(nonceB64) });
    props.push({ tag: huks.HuksTag.HUKS_TAG_ASSOCIATED_DATA, value: Vault.aad() });
    const session: huks.HuksSessionHandle = await huks.initSession(HUKS_ALIAS, { properties: props });
    const result: huks.HuksReturnResult =
      await huks.finishSession(session.handle, { properties: props, inData: b64ToBytes(cipherB64) });
    const buf: Uint8Array | undefined = result.outData;
    return buf === undefined ? null : bytesToStr(buf);
  }

  /**
   * 清除偏好里的旧"软件 AES 密钥"（密文已升级为 HUKS 后调用）。
   * 目的：不再让可解密的密钥留在偏好（也就不会随备份外泄）。
   */
  static async purgeSoftKey(context: common.Context): Promise<void> {
    try {
      const store: preferences.Preferences = await Vault.prefs(context);
      const had: string = await store.get(VAULT_KEY, '') as string;
      if (had === '') {
        return;
      }
      store.delete(VAULT_KEY);
      await store.flush();
      Vault.keyB64 = '';
      console.info('[Vault] 已清除偏好中的旧 AES 密钥（密文已由 HUKS 保护）');
    } catch (err) {
      // 清理失败不影响功能，下次启动再试
    }
  }

  /**
   * 【逃生舱 · 内部实现】清空账号库：删除偏好中的账号密文与软件密钥，并尽力删除 HUKS 密钥。
   *
   * 用途：账号库**存在但解不开**时（例如密钥丢失、HUKS 密钥失效），`canReadExisting()` 会拒绝
   * 任何写入 —— 用户既看不到账号，也加不了新账号，只能"清除整个应用数据"才能恢复。
   * 本方法提供一条更窄的出路：**只清账号，不动设置与日程**。
   *
   * ⚠️ 仅供 `AccountStore.resetVault()` 在**用户显式二次确认后**调用，**绝不自动触发**
   *    （自动清理会破坏 `canReadExisting` 的防覆盖保护）。
   */
  static async clearVault(context: common.Context): Promise<void> {
    const store: preferences.Preferences = await Vault.prefs(context);
    store.delete(VAULT_DATA);
    store.delete(VAULT_KEY);
    await store.flush();
    Vault.keyB64 = '';
    try {
      await huks.deleteKeyItem(HUKS_ALIAS, { properties: Vault.genProperties() });
      console.info('[Vault] 已删除 HUKS 账号库密钥');
    } catch (err) {
      // 密钥不存在或删除失败都不影响"重置"的目的（密文已删，重新添加时会重新生成）
      const e = err as BusinessError;
      console.error(`[Vault] 删除 HUKS 密钥失败(code=${e.code}): ${e.message}`);
    }
    Vault.huksReady = null; // 让后续重新探测
    console.info('[Vault] 账号库已清空');
  }

  // ==================== 软件 AES（回落路径） ====================

  /**
   * 读取**已存在**的软件 AES 密钥；不存在返回 null。
   *
   * ⚠️ 解密路径必须用这个：早期 `softKey()` 在解密时若发现密钥缺失，会"顺手生成一把新密钥"，
   * 于是旧密文被一把错误的新密钥去解 → 表现为"账号突然全没了，而且再也加不上"。
   */
  private static async softKeyExisting(context: common.Context): Promise<cryptoFramework.SymKey | null> {
    if (Vault.keyB64 === '') {
      const store: preferences.Preferences = await Vault.prefs(context);
      Vault.keyB64 = await store.get(VAULT_KEY, '') as string;
    }
    if (Vault.keyB64 === '') {
      return null;
    }
    return cryptoFramework.createSymKeyGenerator('AES256').convertKey({ data: b64ToBytes(Vault.keyB64) });
  }

  /**
   * 获取（或首次生成）软件 AES-256 密钥；进程内缓存 keyB64。
   * **仅加密路径可调用**（只有加密时才允许"没有就新建一把"）。
   *
   * ⚠️ 仅作为 HUKS 不可用时的回落：此方案下密钥与密文同存 caldav_vault，
   * 对"备份被导出"无防护（`backup_config.json` 已把 preferences 排除出备份以缓解）。
   */
  private static async softKey(context: common.Context): Promise<cryptoFramework.SymKey> {
    const existing: cryptoFramework.SymKey | null = await Vault.softKeyExisting(context);
    if (existing !== null) {
      return existing;
    }
    const gen: cryptoFramework.SymKeyGenerator =
      cryptoFramework.createSymKeyGenerator('AES256');
    const key: cryptoFramework.SymKey = await gen.generateSymKey();
    Vault.keyB64 = bytesToB64(key.getEncoded().data);
    const store: preferences.Preferences = await Vault.prefs(context);
    await store.put(VAULT_KEY, Vault.keyB64);
    await store.flush();
    return key;
  }

  private static gcmParams(iv: Uint8Array, authTag: Uint8Array): cryptoFramework.GcmParamsSpec {
    return {
      algName: 'GcmParamsSpec',
      iv: { data: iv },
      aad: { data: new Uint8Array(0) },
      authTag: { data: authTag }
    };
  }

  /** 软件 AES 加密：返回 `b64(iv):b64(密文+tag)`（不含前缀） */
  private static async softEncrypt(context: common.Context, plain: string): Promise<string> {
    const key: cryptoFramework.SymKey = await Vault.softKey(context);
    const iv: Uint8Array =
      cryptoFramework.createRandom().generateRandomSync(12).data;
    const cipher: cryptoFramework.Cipher =
      cryptoFramework.createCipher('AES256|GCM|NoPadding');
    await cipher.init(cryptoFramework.CryptoMode.ENCRYPT_MODE, key,
      Vault.gcmParams(iv, new Uint8Array(16)));
    const out: cryptoFramework.DataBlob =
      await cipher.doFinal({ data: strToBytes(plain) });
    return `${bytesToB64(iv)}:${bytesToB64(out.data)}`;
  }

  /** 软件 AES 解密（body = `b64(iv):b64(密文+tag)`）；格式不符返回 null */
  private static async softDecrypt(context: common.Context, body: string): Promise<string | null> {
    const sep: number = body.indexOf(':');
    if (sep <= 0) {
      return null;
    }
    const iv: Uint8Array = b64ToBytes(body.substring(0, sep));
    const blob: Uint8Array = b64ToBytes(body.substring(sep + 1));
    if (blob.length <= 16) {
      return null;
    }
    const tag: Uint8Array = blob.slice(blob.length - 16);
    const ct: Uint8Array = blob.slice(0, blob.length - 16);
    const key: cryptoFramework.SymKey | null = await Vault.softKeyExisting(context);
    if (key === null) {
      console.error('[Vault] 软件 AES 密钥缺失，无法解密（不重新生成，避免把可用密文彻底解坏）');
      return null;
    }
    const cipher: cryptoFramework.Cipher =
      cryptoFramework.createCipher('AES256|GCM|NoPadding');
    await cipher.init(cryptoFramework.CryptoMode.DECRYPT_MODE, key,
      Vault.gcmParams(iv, tag));
    const out: cryptoFramework.DataBlob = await cipher.doFinal({ data: ct });
    return bytesToStr(out.data);
  }

  // ==================== 对外统一入口 ====================

  /**
   * 加密：优先 HUKS，失败回落软件 AES；返回带前缀的自描述密文。
   *
   * ⚠️ **落盘前自检**：HUKS 写出的密文必须先能自己解回来，才允许以 `huks1:` 写到偏好。
   * 否则某些设备上 HUKS 行为不一致（能加密却解不开），会把"读不回来的密文"写进账号库 ——
   * 下次启动即表现为"账号全部消失且再也加不上"。自检不通过 → 本进程永久回落软件 AES。
   */
  static async encrypt(context: common.Context, plain: string): Promise<string> {
    if (await Vault.ensureHuksKey()) {
      try {
        const body: string = await Vault.huksEncrypt(plain);
        const sep: number = body.indexOf(':');
        const back: string | null =
          await Vault.huksDecrypt(body.substring(0, sep), body.substring(sep + 1));
        if (back === plain) {
          return PREFIX_HUKS + body;
        }
        console.error('[Vault] HUKS 自检失败（加密后解不回原文），本进程回落软件加密');
        Vault.huksReady = false;
      } catch (err) {
        const e = err as BusinessError;
        console.error(`[Vault] HUKS 加密失败(code=${e.code})，回落软件加密: ${e.message}`);
        Vault.huksReady = false;
      }
    }
    return PREFIX_AES + await Vault.softEncrypt(context, plain);
  }

  /**
   * 解密：按前缀分派（`huks1:` / `aes1:` / 无前缀旧格式）。
   * **任何失败都返回 null**（调用方按"无账号 / 迁移路径"处理，绝不静默清空账号）。
   */
  static async decrypt(context: common.Context, stored: string): Promise<string | null> {
    try {
      if (stored.startsWith(PREFIX_HUKS)) {
        const parts: string[] = stored.substring(PREFIX_HUKS.length).split(':');
        if (parts.length !== 2 || !(await Vault.ensureHuksKey())) {
          return null;
        }
        return await Vault.huksDecrypt(parts[0], parts[1]);
      }
      if (stored.startsWith(PREFIX_AES)) {
        return await Vault.softDecrypt(context, stored.substring(PREFIX_AES.length));
      }
      // 更早的旧格式：无前缀软件 AES 密文
      return await Vault.softDecrypt(context, stored);
    } catch (err) {
      const e = err as BusinessError;
      console.error(`[Vault] 解密失败: ${e.message}`);
      return null;
    }
  }
}

/**
 * 账号持久化：加密 JSON 存储 + 旧版明文自动迁移
 */
export class AccountStore {
  /** 规范化颜色：#RRGGBBAA → #RRGGBB；非法返回空串 */
  static normalizeColor(raw: string): string {
    const v: string = raw.trim();
    if (/^#[0-9A-Fa-f]{8}$/.test(v)) {
      return '#' + v.substring(3, 9);
    }
    if (/^#[0-9A-Fa-f]{6}$/.test(v)) {
      return v.toUpperCase();
    }
    return '';
  }

  private static decodeAccount(raw: string): DavAccount | null {
    const parts: string[] = raw.split('|');
    if (parts.length < 9) {
      return null;
    }
    const acc = new DavAccount();
    acc.type = parts[0] === '' ? TYPE_CALDAV : parts[0];
    acc.name = parts[1];
    acc.serverUrl = parts[2];
    acc.username = parts[3];
    acc.password = parts[4];
    const count: number = Number(parts[5]);
    acc.itemCount = Number.isNaN(count) ? 0 : count;
    acc.lastSyncTime = parts[6];
    acc.calendarHrefs = parts[7] === '' ? [] : parts[7].split(';');
    acc.calendarNames = parts[8] === '' ? [] : parts[8].split(';');
    if (parts.length >= 10) {
      acc.calendarColors = parts[9] === '' ? [] : parts[9].split(';');
    }
    // 兼容旧版本存储（无 id 字段）：加载时为空，由 loadAll 统一补发并持久化
    if (parts.length >= 11) {
      acc.id = parts[10];
    }
    if (parts.length >= 12) {
      acc.calendarWritable = parts[11] === '' ? [] : parts[11].split(';');
    }
    return acc;
  }

  /** 旧版明文账号编码（迁移旧数据时使用） */
  private static encodeLegacyAccount(acc: DavAccount): string {
    const safe = (s: string): string => s.split('|').join('∥');
    const parts: string[] = [
      safe(acc.type),
      safe(acc.name),
      safe(acc.serverUrl),
      safe(acc.username),
      safe(acc.password),
      String(acc.itemCount),
      safe(acc.lastSyncTime),
      acc.calendarHrefs.join(';'),
      acc.calendarNames.join(';'),
      acc.calendarColors.join(';'),
      safe(acc.id),
      acc.calendarWritable.join(';')
    ];
    return parts.join('|');
  }

  /** 从旧版明文存储读取（无则返回 null） */
  private static async loadLegacy(context: common.Context): Promise<DavAccount[] | null> {
    try {
      const store: preferences.Preferences =
        await preferences.getPreferences(context, LEGACY_STORE);
      const count: number = await store.get(LEGACY_COUNT_KEY, 0) as number;
      if (count <= 0) {
        return null;
      }
      const result: DavAccount[] = [];
      for (let i = 0; i < count; i++) {
        const raw = await store.get(`acc_${i}`, '') as string;
        if (raw === '') {
          continue;
        }
        const acc = AccountStore.decodeAccount(raw);
        if (acc !== null) {
          if (acc.id === '') {
            acc.id = `acc${Date.now()}_${i}`;
          }
          result.push(acc);
        }
      }
      return result;
    } catch (err) {
      return null;
    }
  }

  /** 清除旧版明文存储（迁移完成后调用） */
  private static async clearLegacy(context: common.Context): Promise<void> {
    try {
      const store: preferences.Preferences =
        await preferences.getPreferences(context, LEGACY_STORE);
      const count: number = await store.get(LEGACY_COUNT_KEY, 0) as number;
      for (let i = 0; i < count; i++) {
        store.delete(`acc_${i}`);
      }
      store.delete(LEGACY_COUNT_KEY);
      await store.flush();
    } catch (err) {
      // 清理失败不影响使用，下次迁移再试
    }
  }

  static async loadAll(context: common.Context): Promise<DavAccount[]> {
    // 1) 新加密存储
    try {
      const store: preferences.Preferences = await Vault.prefs(context);
      const data: string = await store.get(VAULT_DATA, '') as string;
      if (data !== '') {
        const plain: string | null = await Vault.decrypt(context, data);
        if (plain !== null) {
          const arr: Array<Record<string, Object>> =
            JSON.parse(plain) as Array<Record<string, Object>>;
          const result: DavAccount[] = [];
          for (const o of arr) {
            const a = new DavAccount();
            a.id = o['id'] !== undefined ? o['id'] as string : '';
            a.type = o['type'] !== undefined ? o['type'] as string : TYPE_CALDAV;
            a.name = o['name'] !== undefined ? o['name'] as string : '';
            a.serverUrl = o['serverUrl'] !== undefined ? o['serverUrl'] as string : '';
            a.username = o['username'] !== undefined ? o['username'] as string : '';
            a.password = o['password'] !== undefined ? o['password'] as string : '';
            a.calendarHrefs = o['calendarHrefs'] !== undefined ? o['calendarHrefs'] as string[] : [];
            a.calendarNames = o['calendarNames'] !== undefined ? o['calendarNames'] as string[] : [];
            a.calendarColors = o['calendarColors'] !== undefined ? o['calendarColors'] as string[] : [];
            a.calendarWritable = o['calendarWritable'] !== undefined ? o['calendarWritable'] as string[] : [];
            a.itemCount = o['itemCount'] !== undefined ? o['itemCount'] as number : 0;
            a.lastSyncTime = o['lastSyncTime'] !== undefined ? o['lastSyncTime'] as string : '';
            if (a.id === '') {
              a.id = `acc${Date.now()}_${result.length}`;
            }
            result.push(a);
          }
          console.info(`[AccountStore] loadAll: ${result.length} 个账号（加密存储）`);
          // 旧格式密文（软件 AES / 更早的无前缀格式）：HUKS 可用时就地升级为 huks1: 密文，
          // 随后清除偏好里的明文密钥 —— 让已有账号也获得"密钥不落盘"的保护。
          // ⚠️ 清密钥必须**以"回读到的密文确实是 huks1:"为前提**：
          // 若 HUKS 不可用，saveAll 写回的仍然是 aes1: 密文，此时清掉 key_b64
          // 会把刚写的密文连同旧账号一起变成永久解不开（账号凭空消失 + 再也存不上）。
          if (!data.startsWith(PREFIX_HUKS)) {
            try {
              await AccountStore.saveAll(context, result, true);
              const now: string = await store.get(VAULT_DATA, '') as string;
              if (now.startsWith(PREFIX_HUKS)) {
                await Vault.purgeSoftKey(context);
                console.info('[AccountStore] 账号密文已升级为 HUKS 保护');
              } else {
                console.info('[AccountStore] HUKS 不可用，维持软件 AES 加密（保留密钥，不清除）');
              }
            } catch (err) {
              // 升级失败不阻断本次读取，下次启动再试
            }
          }
          return result;
        }
        console.error('[AccountStore] 加密账号数据解密失败');
      }
    } catch (err) {
      const e = err as BusinessError;
      console.error(`[AccountStore] 读取加密账号失败: ${e.message}`);
    }

    // 2) 旧版明文存储 → 迁移
    const legacy: DavAccount[] | null = await AccountStore.loadLegacy(context);
    if (legacy !== null) {
      console.info(`[AccountStore] 迁移 ${legacy.length} 个明文账号到加密存储`);
      await AccountStore.saveAll(context, legacy, true);
      await AccountStore.clearLegacy(context);
      return legacy;
    }
    return [];
  }

  /**
   * 保存全部账号（整体加密写入）。
   * 防御：当前已有账号时，禁止用空列表覆盖（调用方因读取异常拿到空列表再回写，
   * 会把所有账号抹掉）。仅删除账号的合法场景通过 force=true 放行。
   */
  static async saveAll(context: common.Context, accounts: DavAccount[], force: boolean = false): Promise<void> {
    // 防御：先看加密存储里现有数量（空列表覆盖保护）
    let existing: number = -1;
    try {
      const store: preferences.Preferences = await Vault.prefs(context);
      const data: string = await store.get(VAULT_DATA, '') as string;
      if (data !== '') {
        const plain: string | null = await Vault.decrypt(context, data);
        if (plain !== null) {
          existing = (JSON.parse(plain) as Array<Record<string, Object>>).length;
        } else {
          // 有密文但解不开：按"存在数据"处理，宁可拦住空写，也不把账号整体清掉
          existing = 1;
        }
      }
    } catch (err) {
      // 读取失败按"未知"处理，不拦截
      existing = -1;
    }
    if (accounts.length === 0 && existing > 0 && !force) {
      console.error(`[AccountStore] 拒绝用空列表覆盖账号存储（原有 ${existing} 个账号）`);
      throw new Error('账号列表为空，已阻止覆盖存储（保护原有账号数据）');
    }
    const plain: string = JSON.stringify(accounts);
    const enc: string = await Vault.encrypt(context, plain);
    const store: preferences.Preferences = await Vault.prefs(context);
    await store.put(VAULT_DATA, enc);
    await store.flush();
    console.info(`[AccountStore] saveAll: ${accounts.length} 个账号已加密写入`);
  }

  /**
   * 追加一个账号（读全量 → push → 整体加密回写）。
   *
   * 防覆盖保护：回写前先探测"现有存储是否可读"（canReadExisting）。
   * 若存储里有密文却解不开（例如 key_b64 丢失或被重新生成），loadAll 会回落成空数组，
   * 此时 push 一个账号后长度 = 1，会绕过 saveAll 的"空列表覆盖保护"→ 其余账号连同密码全部丢失。
   * 因此遇到该情况直接抛错中止：宁可让用户看到失败提示，也不能静默清空账号。
   */
  static async addAccount(context: common.Context, acc: DavAccount): Promise<void> {
    if (!(await AccountStore.canReadExisting(context))) {
      console.error('[AccountStore] 现有账号存储不可读，已中止 addAccount 以防覆盖');
      throw new Error('读取已有账号失败，为避免覆盖已保存的账号，已中止本次添加');
    }
    const list: DavAccount[] = await AccountStore.loadAll(context);
    list.push(acc);
    await AccountStore.saveAll(context, list);
  }

  /**
   * 【逃生舱】重置账号库：清空本地保存的全部账号、服务器地址与密码。
   *
   * 场景：账号库存在但**解不开**（密钥丢失 / HUKS 密钥失效等），此时 `canReadExisting()`
   * 会拒绝任何写入 —— 表现为"账号消失且再也加不上"，而唯一的原生出路是清除**整个**应用数据
   * （会一并丢掉设置偏好、功能引导标记、本地日程库）。本方法只清账号那一块。
   *
   * ⚠️ **必须由用户在界面上二次确认后调用**；日程数据在 CalDAV 服务器上，重新添加账号
   *    并同步即可恢复，但本地保存的密码会被删除且不可撤销。
   */
  static async resetVault(context: common.Context): Promise<void> {
    await Vault.clearVault(context);
    console.info('[AccountStore] 账号库已重置，可重新添加账号');
  }

  /**
   * 探测"现有账号存储是否可读"，供写前加固使用。
   * - 无密文（全新安装 / 已清空）→ true：可以安全写入
   * - 有密文且能解密 → true
   * - 有密文但解密失败 / 读取异常 → false：**绝不能回写**（否则会整体覆盖、丢失全部账号）
   */
  private static async canReadExisting(context: common.Context): Promise<boolean> {
    try {
      const store: preferences.Preferences = await Vault.prefs(context);
      const data: string = await store.get(VAULT_DATA, '') as string;
      if (data === '') {
        return true;
      }
      return (await Vault.decrypt(context, data)) !== null;
    } catch (err) {
      return false;
    }
  }
}