fmode-app/src/app/core/chat-session.service.ts

import { computed, inject, Injectable, signal } from '@angular/core';
import { SessionService } from './session.service';
import { FmodeApi } from './api/fmode-api';
import { ChatThreadRecord, ChatThreadUpsert } from './api/models';
import {
  ChatSession,
  NEW_SESSION_TITLE,
  createSession,
  legacySessionId,
  sessionsOf,
  sortSessions,
  touchSession,
} from './chat-session';

/**
 * 会话（多线程）服务 —— App 侧会话目录的**唯一 owner**
 *
 * ## 职责
 *
 * 维护「线程根 event_id → 会话元信息」的映射，并提供新建 / 重命名 / 归档 / 删除。
 * 消息内容本身仍由 Matrix 房间承载，**本服务只存元信息**。
 *
 * ## 存储（2026-11-01 定稿）
 *
 * | 层 | 角色 |
 * |---|---|
 * | 云端 `FmodeChatThread` | **唯一真相源** |
 * | localStorage（`fmode_chat_sessions_v2_<userId>`） | 渲染缓存 + 删除黑名单；云端不可达时**不展示** |
 *
 * 同步方向是**单向**的：云端 → 本地（`hydrateFromCloud`），
 * 写入操作再单独回写云端。**不存在「本地有、云端没有 → 保留本地」的分支** ——
 * 那正是「删掉的会话又回来 / 云端被灌满 / 同一会话多条」的根因。
 *
 * ## 为什么正文不进平台库
 *
 * 会话正文（含附件）全部在 Matrix 房间里，平台库只存「哪些线程存在、叫什么名字」。
 * 平台库额外存的只有 `lastPreview`（列表用的一行摘要，可丢）。
 * 把正文搬进平台库等于重造一遍 Matrix，收发链路、附件、实时性全要另写一套。
 *
 * @see chat-session.ts 纯函数层（可单测）
 */
@Injectable({ providedIn: 'root' })
export class ChatSessionService {
  private readonly session = inject(SessionService);
  /**
   * 数据访问唯一闸门（云端会话目录读写；失败静默，不影响本地）。
   *
   * 🔴 用 `inject(..., { optional: true })`：本服务在单测/纯本地场景下不注入
   *    FmodeApi 也应可用（云端同步是可选的增强，不是必需依赖）。
   */
  private readonly api = inject(FmodeApi, { optional: true });

  private readonly _all = signal<ChatSession[]>([]);
  /**
   * 同一容器的在途 hydrate（并发去重用）。
   * 🔴 必须声明在类字段区最前面：它被 `hydrateFromCloud` 使用，
   *    若声明在方法之后，类字段初始化顺序会让运行时拿到 undefined。
   */
  private readonly hydrating = new Map<string, Promise<number>>();
  readonly all = this._all.asReadonly();

  /** 按 agent 分组的会话（未归档,已排序） */
  readonly byAgent = computed<Map<string, ChatSession[]>>(() => {
    const m = new Map<string, ChatSession[]>();
    for (const s of this._all()) {
      /*
       * 🔴 **不再在这里丢掉已归档的会话**。
       *
       * 原实现在这一步 `if (s.archived) continue;` —— 归档的会话直接从
       * 映射里消失,于是上层无论怎么判断 `showArchived` 都拿不到它们,
       * 「显示已归档」开关**永远无效**（实测点击无反应）。
       *
       * 归档的取舍交给调用方:默认列表过滤掉,「已归档」目录单独展示。
       */
      const list = m.get(s.agentId) ?? [];
      list.push(s);
      m.set(s.agentId, list);
    }
    for (const [k, v] of m) m.set(k, sortSessions(v));
    return m;
  });

  private loadedFor: string | null = null;

  /**
   * 会话目录是否可信（2026-11-01 用户裁决）。
   *
   * 🔴 **`false` 时列表一律为空**，宁可显示「加载失败，重试」也不展示本地缓存。
   *
   * 为什么改掉「离线展示缓存」：
   *   缓存与云端没有可靠的全序（谁更新说不清），一边展示旧缓存、一边又把本地
   *   回写云端，两端会互相覆盖 —— 这是「删掉的会话又回来 / 云端为空却被灌满」
   *   反复出现的根源。现在只有一条规则：**云端成功返回后列表才可信**。
   *
   * 初始值 `false`：登录后必须先成功拉一次云端，列表才可能出现内容。
   */
  private readonly _ready = signal(false);
  readonly ready = this._ready.asReadonly();

  /** 最近一次云端拉取的失败原因（`null` = 正常）；界面据此给出重试入口 */
  private readonly _error = signal<string | null>(null);
  readonly error = this._error.asReadonly();

  /**
   * 新建会话**推送上云失败**的原因（2026-11-09 用户要求）。
   *
   * 🔴 用户原话：「推送失败要报错」。
   *
   * 原来是静默吞掉的：本地照常显示，但云端没有 ——
   * 用户在 A 浏览器建了会话，B 浏览器永远看不到，而且**A 这边也没有任何提示**，
   * 用户根本不知道这条会话只存在于这一台机器上。
   *
   * 现在：失败就记下来，界面提示「这条会话还没同步到云端」并给重试入口。
   */
  private readonly _pushFailed = signal<string | null>(null);
  readonly pushFailed = this._pushFailed.asReadonly();

  /** 上次云端拉取失败的原因（`null` = 正常）；供调用方判断能否继续 */
  isCloudStale(): boolean {
    return !this._ready();
  }

  /**
   * 用户主动移除过的会话 id。
   *
   * 这些线程在 Matrix 里**仍然存在**（消息没删），但用户不想再看到它们。
   * 扫描重建时必须跳过,否则删了立刻被扫回来。
   */
  private readonly _removed = signal<Set<string>>(new Set());

  /**
   * 云端已软删的线程根（跨设备有效）。
   * 与本地 `_removed` 一起构成「哪些线程不允许重新出现」的黑名单。
   * 注意：目录已不再从 Matrix 扫描重建，它现在的用途是兜住
   * 「云端列表与墓碑不一致」的历史数据。
   */
  private cloudRemoved = new Set<string>();

  /**
   * 每个会话上一次把元信息推到云端的时间（节流用，见 `noteMessage`）。
   *
   * 放在内存里而不是持久化：它只用于「别太频繁地打接口」，
   * 刷新后重新计时即可，不影响任何数据的正确性。
   */
  private readonly lastPushAt = new Map<string, number>();

  /**
   * 本地已建、但还没确认推到云端的会话 id。
   *
   * 用途很窄：`hydrateFromCloud` 整体替换列表时，这些会话在云端还不存在，
   * 必须保留 —— 否则「新建对话 → 换 URL → 重新拉取云端」会把刚建的会话抹掉。
   * 推送成功后立即移除，避免长期存在。
   */
  private readonly _pendingPush = new Set<string>();
  /** 首次落库的进行中 Promise（供 `commitNow` 等待，避免重复请求） */
  private readonly _commitWait = new Map<string, Promise<void>>();

  /**
   * 从 localStorage 载入（Shell 启动时调用一次;重复调用幂等）。
   *
   * 🔴 **按用户区分载入状态**:存储键含用户 id,换账号登录后必须重新载入,
   *    否则会把上一个账号的会话列表显示给新用户（越权 + 串号）。
   *    用户 id 变化时清空内存态再读。
   */
  load(): void {
    /*
     * 🔴 未登录（key 为 null）时**不读也不写**:
     *    内存里此刻可能是上一个账号的会话,必须清空,
     *    否则登录页/切换账号的瞬间会把别人的对话闪出来。
     */
    const key = this.key();
    if (key === null) {
      if (this.loadedFor !== null) this._all.set([]);
      this.loadedFor = null;
      return;
    }
    if (this.loadedFor === key) return;
    const switchingUser = this.loadedFor !== null;
    this.loadedFor = key;
    if (switchingUser) this._all.set([]);
    try {
      const raw = localStorage.getItem(key);
      if (!raw) return;
      const parsed = JSON.parse(raw) as unknown;
      if (!Array.isArray(parsed)) return;
      // 逐条校验 —— 坏数据不应该让整个列表消失
      const list = parsed.filter(isSession).map(normalize);
      this._all.set(sortSessions(list));
      // 恢复「已移除」黑名单
      const removedRaw = localStorage.getItem(`${key}_removed`);
      if (removedRaw) {
        const arr = JSON.parse(removedRaw) as unknown;
        if (Array.isArray(arr)) {
          this._removed.set(new Set(arr.filter((x): x is string => typeof x === 'string')));
        }
      }
    } catch {
      /* 隐私模式 / 坏 JSON：降级为内存态 */
    }
  }

  /**
   * 清空内存态（登出时调用）。
   *
   * 🔴 `_ready` 必须一起复位：否则登出再登录后，列表会凭「上一次登录的成功状态」
   *    直接被视为可信，在新一轮云端拉取完成前就渲染出（可能属于别人的）内容。
   */
  reset(): void {
    this.loadedFor = null;
    this._all.set([]);
    this._ready.set(false);
    this._error.set(null);
    this.cloudRemoved = new Set();
    this._removed.set(new Set());
  }

  // ================= 云端同步（2026-11-01 重写：单向 云端 → 本地） =================

  /**
   * 从云端拉取会话目录（**唯一真相源**，本地只是渲染缓存）。
   *
   * ## 唯一规则
   *
   * **云端成功返回 → 本地该容器的会话直接等于云端返回的集合**；
   * 云端失败 → 列表清空并标记不可用（`ready = false`），界面显示「加载失败，重试」，
   * **绝不展示旧缓存、也绝不把本地数据反推回云端**。
   *
   * 为什么不再做「合并」：
   *   线上反复出现「删掉的会话又回来 / 云端为空却被灌满 / 同一会话七八条」，
   *   根因都是两端各写一半，再用「只补不覆盖」之类的规则去猜谁对。
   *   只要允许本地影响云端，就必须维护一套合并规则，而合并规则本身会出错。
   *   改成单向同步后，冲突面直接归零。
   *
   * @returns 本次新增的会话条数（调用方一般不关心）
   */
  async hydrateFromCloud(agentId: string, keepId?: string): Promise<number> {
    /*
     * 🔴 并发去重（2026-11-03）：
     *    会话列表页、抽屉、会话详情页会**同时**触发预热，
     *    同一个容器被拉 2~4 次（实测每次 2 条请求：活跃 + 含已删）。
     *    同容器已有在途请求时直接复用，请求量减半以上。
     *
     *    不用缓存结果 —— 请求完成后立即释放，保证下次进入拿到最新数据。
     */
    const inflight = this.hydrating.get(agentId);
    if (inflight) return inflight;
    const task = this.hydrateOnce(agentId, keepId).finally(() => {
      this.hydrating.delete(agentId);
    });
    this.hydrating.set(agentId, task);
    return task;
  }

  private async hydrateOnce(agentId: string, keepId?: string): Promise<number> {
    /*
     * 🔴 先确保本地缓存已载入：生产由页面在进入路由时调用 load()，
     *    但云端恢复不应依赖调用顺序（测试/深链进入都可能没调过）。
     *    load() 幂等，重复调用无副作用。
     */
    this.load();
    const key = this.key();
    const api = this.api;
    if (!key || this.loadedFor !== key || !api) return 0;

    let live: ChatThreadRecord[];
    let deleted: ChatThreadRecord[];
    try {
      /*
       * 两份列表分开拉（2026-11-09 实测确认语义）：
       *   · `fetchChatThreads(agentId)`                  → **仅活跃**会话
       *   · `fetchChatThreads(agentId, {includeDeleted})` → **仅已软删**会话
       *
       * 🔴 参数名叫 includeDeleted，但实测返回的是**只含已删**的记录，
       *    而不是「活跃 + 已删」。实测证据（2026-11-09）：
       *    默认 list = 2 条，includeDeleted = 41 条，两个集合**完全不相交**。
       *    原实现把它当「并集」用，导致墓碑里混入了错误数据。
       */
      [live, deleted] = await Promise.all([
        api.fetchChatThreads(agentId),
        api.fetchChatThreads(agentId, { includeDeleted: true }).catch(() => [] as ChatThreadRecord[]),
      ]);
    } catch (e) {
      /*
       * 云端不可达 → **列表不可信**（用户裁决：宁可不显示，也不显示可能过期的缓存）。
       * 内存里留着旧内容没有意义 —— 界面依据 `ready()` 直接渲染「加载失败」。
       */
      this._ready.set(false);
      this._error.set(e instanceof Error && e.message ? e.message : '会话目录加载失败');
      return 0;
    }

    /*
     * 🔴 云端墓碑（2026-11-09）：只用于「URL 直达已删会话时拒绝打开」。
     *
     * 原先 `cloudRemoved` 存了但**从没被任何地方读取**。现在它是
     * `openReal` 判定「这条会话已被删除」的权威依据。
     *
     * 🔴 刻意**不**并入 `_removed`：后者会持久化到 localStorage，
     *    并入后一旦云端某次返回异常，本地就会永久拉黑一批正常会话。
     *    墓碑是「本次会话周期内」的判定依据，重新拉取时自然刷新。
     */
    this.cloudRemoved = new Set(deleted.map((d) => d.threadRoot));
    const prev = new Map(
      this._all()
        .filter((s) => s.agentId === agentId)
        .map((s) => [s.id, s]),
    );

    /*
     * 云端列表 → 本地会话。逐条以云端为准，本地只提供两个**可丢失**的字段：
     *   · `lastPreview`：云端为空时用本地兜底（纯展示，不参与任何判定）
     *   · `titleLocked`：用户改过名的标记（改名会立刻推云端，正常情况下两边一致）
     */
    const next: ChatSession[] = [];
    for (const r of live) {
      // 墓碑挡住：用户明确删过这条线程，即使云端还挂着也不显示
      if (this._removed().has(r.threadRoot)) continue;
      const local = prev.get(r.threadRoot);
      next.push({
        id: r.threadRoot,
        roomId: r.roomId,
        agentId: r.agentId || agentId,
        title: r.title || NEW_SESSION_TITLE,
        titleLocked: r.titleLocked || local?.titleLocked,
        createdAt: local?.createdAt ?? (r.lastMessageAt || Date.now()),
        updatedAt: Math.max(r.lastMessageAt || 0, local?.updatedAt ?? 0),
        archived: r.archived,
        messageCount: r.messageCount,
        lastPreview: r.lastPreview || local?.lastPreview,
        /*
         * 工作区归属（2026-11-01 改为云端为准）。
         *
         * 🔴 此前只从本地缓存捡（`local?.workspaceId`）—— 云端重建列表时
         *    本地没这条（换设备/清缓存/刚新建还没落盘）就掉回「日常对话」，
         *    用户看到的就是「新建到工作区却跑到日常里」。
         *    现在云端有值就用云端；云端为空才回落到本地（兼容旧数据）。
         */
        workspaceId: r.workspaceId || local?.workspaceId || null,
        /*
         * 群会话形态（2026-11-05）：云端为准，缺失回落本地。
         * 🔴 缺省 = dm —— 存量数据没有这个字段，不能因此被当成群聊。
         */
        kind: r.kind || local?.kind || undefined,
        memberIds: r.memberIds?.length ? r.memberIds : local?.memberIds,
        /*
         * 成果链接数组（2026-11-09）：**云端为准，空数组也算数**。
         *
         * 🔴 原来写成 `r.deliverableUrls?.length ? r.deliverableUrls : local?.xxx`，
         *    云端清空后（`[]` 长度为 0）会回退到**本地旧值** ——
         *    用户清掉脏数据、刷新页面，错误成果还在（实测反馈）。
         *
         * 现在：云端明确返回了数组（含空数组）就以它为准；
         *       只有字段**完全缺失**（老数据）才用本地兜底。
         */
        deliverableUrls: Array.isArray(r.deliverableUrls)
          ? r.deliverableUrls
          : local?.deliverableUrls,
      });
    }

    /*
     * 用「该容器」的云端结果**整体替换**本地该容器的条目，其它容器不动。
     * 这里没有任何「本地有、云端没有 → 保留」的分支 —— 那正是脏数据来源。
     *
     * 🔴 唯一例外：**还没同步到云端的本地新建会话**（2026-11-01）。
     *
     *     `create()` 之后是异步推云端的，而新建对话紧接着就会换 URL → 重新
     *     `open()` → 又拉一次云端。那一刻云端列表里还没有这条，
     *     若按「云端没有就丢弃」处理，刚建出来的会话**当场消失**
     *     （用户实测：点了新建，聊天区是新的但左侧列表没有内容）。
     *
     *     只保留「本地有、且明确处于待同步状态」的条目，范围极小，
     *     不会重新引入「本地脏数据灌回列表」的问题。
     */
    const pending = this._all().filter(
      (s) => s.agentId === agentId && this._pendingPush.has(s.id) && !next.some((n) => n.id === s.id),
    );
    /*
     * 🔴 正在打开的那条会话（`keepId`）即使云端列表里没有，也不能被整体替换抹掉
     * （2026-11-06 实测）。
     *
     * 场景：刷新页面 → URL 指定会话 → 本地目录里有它、云端这一轮还没返回它
     *     （刚发出、推送在途；演示态则根本没有云端）→ 整表替换后它消失 →
     *     `open()` 里 `_sessionId` 悬空 → 页面渲染成「还没有对话」，输入区整块消失。
     * 范围极小：只是「调用方明确正在打开」的那一条，不是「本地有的都保留」。
     */
    /*
     * 🔴 `keep` 必须**排除已经在 `pending` 里的条目**（2026-11-08）。
     *
     * 刚新建、还没推上云的会话会同时满足两个条件：
     *   · 在 `_pendingPush` 里  → 被 `pending` 收一次
     *   · 正是 `keepId`（正在打开）→ 被 `keep` 再收一次
     * 两个数组拼在一起 → 同一个 id 在 `_all` 里存**两份**，
     * 左栏就出现两条一模一样的会话（用户实测）。
     *
     * 判据加 `!this._pendingPush.has(keepId)`，让每条只进一次。
     */
    /*
     * 🔴 「正在打开」的空会话**不保留**（2026-11-08，「新建会话带出旧数据」图39）。
     *
     * 云端列表里没有它时，原逻辑会把它捡回来。但如果它一条消息都没发过
     * （`messageCount` 为 0），它只是一个「新建对话」空壳 ——
     * 而 `pruneEmpty()` 的职责正是把这类空壳收敛成**最多一条**。
     * 捡回来等于把刚清掉的空壳重新塞进列表，用户看到的就是
     * 「新建了一次，列表里却多出好几条一模一样的旧对话」。
     *
     * 非空会话（发过消息、只是在等云端回写）仍然保留，这一点不变。
     */
    const keep =
      keepId &&
      !next.some((n) => n.id === keepId) &&
      !this._removed().has(keepId) &&
      !this._pendingPush.has(keepId) &&
      (this.byId(keepId)?.messageCount ?? 0) > 0 && !this._pendingPush.has(keepId)
        ? this._all().filter((s) => s.id === keepId && s.agentId === agentId)
        : [];
    const others = this._all().filter((s) => s.agentId !== agentId);
    /*
     * 最后再按 id 去重一次（兜底）：任何合并路径都不该产生重复 id。
     * 两个数组若有交集，后面的会覆盖前面的 —— 保留先出现的即可。
     */
    const merged = new Map<string, (typeof next)[number]>();
    for (const s of [...others, ...next, ...pending, ...keep]) merged.set(s.id, s);
    this._all.set(sortSessions([...merged.values()]));
    this.persist();
    this._ready.set(true);
    this._error.set(null);

    const before = new Set(prev.keys());
    let added = 0;
    for (const s of next) if (!before.has(s.id)) added++;
    return added;
  }

  /**
   * 把本地会话（该 agent 下）补推到云端。
   *
   * 正常路径下每次变更（新建 / 改名 / 归档 / 计数）都已单独推送，
   * 这里只在云端刚恢复可用时兜底补齐「推送失败留下的缺口」。
   *
   * 🔴 云端不可用（`ready=false`）时不推送 —— 此时列表根本不可信，
   *    写上去就等于把本地残留灌进云端（历史上发生过）。
   */
  async pushAll(agentId: string): Promise<void> {
    if (!this.api || !this._ready()) return;
    const list = this._all().filter((s) => s.agentId === agentId && !s.legacy);
    if (list.length === 0) return;
    await this.trySync(() => this.api!.upsertChatThreads(list.map(toUpsert)));
    // 整批推成功后，这些会话云端已存在，撤销「待同步」标记
    for (const s of list) this._pendingPush.delete(s.id);
    // 补齐成功 → 清掉「未同步」的错误提示（2026-11-09）
    if (this._pushFailed()) this._pushFailed.set(null);
  }

  /**
   * 统一的「云端失败不影响本地」包装。
   *
   * 🔴 只吞异常、不改本地状态：写入失败时本地照常可用，下次 `hydrateFromCloud`
   *    会以云端为准把差异抹平。**这里不允许出现「失败就改本地」的补偿逻辑** ——
   *    那正是两端互相覆盖的来源。
   */
  private async trySync(fn: () => Promise<void>): Promise<void> {
    try {
      await fn();
    } catch {
      /* 离线 / 未开通：本地继续可用，下次拉取时以云端为准 */
    }
  }

  /** 单条推送到云端（新建 / 变更后调用） */
  private pushOne(s: ChatSession | undefined): void {
    if (!s || s.legacy) return;
    /*
     * 「待同步」标记只在**本地新建、云端尚无**时使用。
     *
     * 🔴 `pushOne` 也用于「已落库会话的内容更新」（noteMessage 节流推送），
     *    若在这里无条件 add，那条会话会**永远**处于待同步状态 ——
     *    noteMessage 的节流判断 `_pendingPush.has(id)` 恒为真，
     *    于是每条消息都打一次接口（实测：节流完全失效）。
     *    所以只有 `create()` 会主动登记，这里只负责推送与撤销。
     */
    void (async () => {
      try {
        await this.api!.upsertChatThreads([toUpsert(s)]);
        this._pendingPush.delete(s.id);
        // 成功一次就把之前的失败提示清掉
        if (this._pushFailed()) this._pushFailed.set(null);
      } catch (e) {
        /*
         * 推送失败 → **必须让用户知道**（2026-11-09 用户要求）。
         *
         * 原来这里是静默吞掉的。后果：这条会话只存在于当前这台机器上，
         * 换浏览器永远看不到，而用户完全不知情，会以为「同步慢」而反复操作。
         *
         * 保留 `_pendingPush` 标记 —— 下次 hydrate 或 pushAll 会自动补推。
         */
        const msg = e instanceof Error && e.message ? e.message : '网络异常';
        this._pushFailed.set(`会话「${s.title || '新对话'}」尚未同步到云端：${msg}`);
      }
    })();
  }

  /**
   * 拉取**所有容器**的会话目录（左栏在没进过任何容器时也要能列出对话）。
   *
   * 逐容器并发拉取；任意一个失败就整体视为失败（`ready=false`）——
   * 只显示拉成功的部分会造成「有的对话突然不见了」，比整体重试更让人困惑。
   *
   * 并发度做了限制（每批 5 个），避免容器多时一次打满平台接口。
   */
  async reloadAll(agentIds: string[]): Promise<void> {
    if (!this.api) return;
    const list = [...new Set(agentIds)].filter(Boolean);
    if (list.length === 0) return;
    let failed = 0;
    let lastErr: unknown = null;
    for (let i = 0; i < list.length; i += 5) {
      const batch = list.slice(i, i + 5);
      const results = await Promise.allSettled(batch.map((a) => this.hydrateFromCloud(a)));
      for (const r of results) {
        if (r.status === 'rejected') {
          failed++;
          lastErr = r.reason;
        }
      }
    }
    if (failed > 0) {
      this._ready.set(false);
      this._error.set(
        lastErr instanceof Error && lastErr.message ? lastErr.message : '会话目录加载失败',
      );
    }
  }

  /** 某 agent 下的会话（默认不含归档） */
  listFor(agentId: string, opts: { includeArchived?: boolean } = {}): ChatSession[] {
    return sessionsOf(this._all(), agentId, opts);
  }

  /** 按 id 取（含归档 —— 归档会话仍可通过链接打开） */
  byId(id: string): ChatSession | undefined {
    return this._all().find((s) => s.id === id);
  }

  /** 某 agent 最近的会话（默认会话 = 上次聊的） */
  latestFor(agentId: string): ChatSession | undefined {
    return this.listFor(agentId)[0];
  }

  /**
   * 新建会话（**不触网**）。
   *
   * 线程根由本地生成 —— 实测容器接受客户端自造的 event_id
   * （`docs/03-interface/容器会话与线程机制-20261028.md` §六）,
   * 所以新建是纯本地操作,即时可用。
   */
  /**
   * 在**本地**新建一条会话（2026-11-01 用户裁决：本地先建，落库推迟）。
   *
   * 🔴 不再一创建就写云端。原因：
   *    · 用户点「新建对话」后，左侧要**立刻**出现「新建对话」并选中；
   *    · 但此时还没有任何消息 —— 若立刻写云端，就产生了一条 0 消息的云端记录，
   *      发不发消息都留在那儿，反复点击会让云端越积越多。
   *    · 现在：本地先建（界面立即可见），**首次发消息时**才真正 upsert 到云端。
   *
   * 未落库的会话由 `_pendingPush` 标记，`hydrateFromCloud` 拉云端时不会把它冲掉。
   */
  create(roomId: string, agentId: string, title?: string): ChatSession {
    const s = createSession({ roomId, agentId, title });
    this._pendingPush.add(s.id);
    this._all.update((list) => sortSessions([s, ...list]));
    this.persist();
    return s;
  }

  /**
   * 新建**群会话**（2026-11-05，本地先建，与单聊同规则）。
   *
   * 群会话不是真实 Matrix 房间 —— 它只是展示容器，真正的收发在各成员的 DM 里。
   * `roomId` 沿用首个成员房间，满足存量字段必填与路由形态。
   *
   * @param memberIds 至少 2 个容器 id（调用方已校验）
   */
  createGroup(roomId: string, memberIds: string[], title: string, workspaceId: string | null = null): ChatSession {
    const s = createSession({ roomId, agentId: memberIds[0], title });
    s.kind = 'group';
    s.memberIds = [...memberIds];
    s.workspaceId = workspaceId;
    this._pendingPush.add(s.id);
    this._all.update((list) => sortSessions([s, ...list]));
    this.persist();
    return s;
  }

  /**
   * 把一条**本地已有**的会话真正落库到云端（首次发消息时调用）。
   *
   * 与 `create()` 的分工：`create` 只管本地可见性，本方法负责持久化。
   */
  commit(id: string): void {
    const s = this.byId(id);
    if (!s || s.legacy) return;
    this.pushOne(s);
  }

  /**
   * 这条会话是否**还没落过库**（需要走强顺序的 `commitNow`）。
   *
   * 判据：仍在待推送集合里 = 本地新建、云端尚无记录。
   * 已落库的会话后续更新走 `commit()` 的节流推送即可。
   */
  needsCommit(id: string): boolean {
    return this._pendingPush.has(id);
  }

  /**
   * 让「历史遗留会话」存在于列表中（幂等）。
   *
   * 只有当房间里**确实存在无 thread 的旧消息**时才调用 —— 没有旧消息就不该
   * 凭空多出一个空会话。调用方（`ChatService`）负责这个判断。
   *
   * @returns `created` 表示本次是否新建;调用方据此决定要不要「首次打开就选中它」
   */
  adoptLegacy(
    roomId: string,
    agentId: string,
    preview?: string,
  ): { session: ChatSession; created: boolean } {
    const id = legacySessionId(roomId);
    const existing = this.byId(id);
    if (existing) return { session: existing, created: false };
    const now = Date.now();
    const s: ChatSession = {
      id,
      roomId,
      agentId,
      title: '历史对话',
      titleLocked: true, // 历史会话不改名
      createdAt: now,
      updatedAt: 0, // 真实时间由首条消息的 noteMessage 推进
      archived: false,
      legacy: true,
      lastPreview: preview,
      messageCount: 0,
    };
    this._all.update((list) => sortSessions([s, ...list]));
    this.persist();
    return { session: s, created: true };
  }

  /**
   * 接纳一个本地不认识的会话 id（如通过链接直接打开 `/chat/:id/:sessionId`）。
   *
   * 用于:线程确实存在于 Matrix（历史消息能读到),但本机没存过元信息。
   * 标题先给占位,等第一条消息进来会由 `noteMessage` 推导 —— 在此之前**不编造**。
   */
  adopt(input: {
    id: string;
    roomId: string;
    agentId: string;
    title?: string;
    /** 消息数（缺省 0 = 新建空会话）；按地址恢复已有会话时传 ≥1，避免被空壳清理 */
    messageCount?: number;
    /**
     * 最后一条消息的时间（2026-11-07）。
     *
     * 🔴 **不要缺省用 `now`**：`adopt` 的触发点是「按地址打开一条目录里没有的会话」，
     *    几乎每次刷新都会命中。原来写 `updatedAt: now`，等于每打开一次就把该会话
     *    推到左栏第一位 —— 用户反馈「只是点开看看，它就跳到最上头了」。
     *    调用方应传入该线程真实的消息时间；实在拿不到才由本方法兜底。
     */
    lastMessageAt?: number;
    createdAt?: number;
  }): ChatSession {
    const existing = this.byId(input.id);
    if (existing) {
      /*
       * 已存在时也要补正时间：如果它此前被按 `now` 收养过，这里用真实时间纠正，
       * 否则那个虚高的值会通过 `hydrateFromCloud` 的 `Math.max` 永久保留。
       * 只在**有真实时间且更早**时下调，绝不把已确认的时间往后推。
       */
      if (input.lastMessageAt && input.lastMessageAt < existing.updatedAt) {
        const fixed: ChatSession = {
          ...existing,
          createdAt: Math.min(existing.createdAt, input.createdAt ?? existing.createdAt),
          updatedAt: input.lastMessageAt,
        };
        this._all.update((list) => sortSessions(list.map((s) => (s.id === fixed.id ? fixed : s))));
        this.persist();
        return fixed;
      }
      return existing;
    }
    // 兜底：没有真实时间时用当前时间（新建会话就是这个语义）
    const now = Date.now();
    const s: ChatSession = {
      id: input.id,
      roomId: input.roomId,
      agentId: input.agentId,
      title: input.title ?? NEW_SESSION_TITLE,
      createdAt: input.createdAt ?? now,
      updatedAt: input.lastMessageAt ?? now,
      archived: false,
      messageCount: input.messageCount ?? 0,
    };
    this._all.update((list) => sortSessions([s, ...list]));
    this.persist();
    return s;
  }

  /** 重命名（锁定标题,之后不会被自动覆盖） */
  rename(id: string, title: string): void {
    const t = title.replace(/\s+/g, ' ').trim();
    if (!t) return;
    this.update(id, { title: t, titleLocked: true });
    void this.trySync(() => this.api!.patchChatThread({ threadRoot: id, title: t }));
  }


  /** 归档 / 取消归档（软删,不物理删除）；同步到云端 */
  archive(id: string, archived = true): void {
    this.update(id, { archived });
    void this.trySync(() => this.api!.patchChatThread({ threadRoot: id, archived }));
  }

  /**
   * 把会话移动到某个工作区（`null` = 日常对话）。
   *
   * 第 3 轮（2026-10-30）接入：`workspaceId` 由 `WorkspaceService` 的工作区 id 提供，
   * 归属只存本地 —— 删除工作区时由调用方把会话退回日常，不会留下悬空引用。
   */
  /**
   * 把会话移动到某个工作区（`null` = 日常对话）。
   *
   * 🔴 2026-11-01 起**同步到云端**：此前只写本地 localStorage，
   *    导致换设备/清缓存后归属丢失，且云端重建列表时会掉回日常对话。
   *    云端用 `''` 表示日常对话（空字符串是合法值，不能用真值判断）。
   */
  moveTo(id: string, workspaceId: string | null): void {
    this.update(id, { workspaceId });
    const cur = this.byId(id);
    if (!cur) return;
    /*
     * 🔴 **未落库的会话只改本地，不发请求**（2026-11-01 用户裁决）。
     *
     * 持久化的唯一前提是「该会话里发过消息」。新建对话刚建出来（还没发消息）时
     * 就被 `startBlank()` 调 `moveTo` 挂到工作区下 —— 若这里直接 upsert，
     * 等于**点一次新建就在云端留一条记录**，连点几次就堆一堆空会话
     * （用户实测：多次新建后，前几次的都持久化了）。
     *
     * 归属先记在本地，等首次发消息触发 `commit()` 时随会话一起落库。
     *
     * 已落库的会话走 upsert（不是 patch）：patch 要求云端已有记录，
     * 「新建 → 立刻移动工作区」时可能还没落地，patch 会 404 被静默吞掉，
     * 归属压根没写进云端 → 下次拉取掉回「日常对话」。
     */
    if (this._pendingPush.has(id)) return;
    void this.trySync(() => this.api!.upsertChatThreads([toUpsert(cur)]));
  }

  /** 某工作区下的会话数（不含归档） */
  countIn(workspaceId: string | null): number {
    return this._all().filter((s) => !s.archived && (s.workspaceId ?? null) === workspaceId).length;
  }

  /**
   * 给会话换一个房间（一房间一会话，2026-11-12）。
   *
   * 场景：新建对话时先在绑定房间建出会话（保证即时可用），
   * 后台再为它开专属房间；房间落地后把 `roomId` 改过去。
   *
   * 与 `moveTo()` 同一纪律：**未落库的会话只改本地**，等首次发消息
   * 随 `commit()` 一起写云端，避免「点一次新建就在云端留一条空记录」。
   */
  setRoomId(id: string, roomId: string): void {
    if (!roomId) return;
    const cur = this.byId(id);
    if (!cur || cur.roomId === roomId) return;
    this.update(id, { roomId });
    if (this._pendingPush.has(id)) return;
    void this.trySync(() => this.api!.upsertChatThreads([toUpsert(this.byId(id)!)]));
  }

  /** 该房间下已有哪些会话（迁房后用于确认「一房间一会话」没被破坏） */
  sessionsInRoom(roomId: string): readonly ChatSession[] {
    return this._all().filter((s) => s.roomId === roomId);
  }

  /**
   * 从列表移除一条会话（**只移除索引，Matrix 里的消息不动**）。
   *
   * 安全性：会话列表只是「有哪些对话」的索引，消息本体在 Matrix 房间里。
   * 移除索引后对话从列表消失，但消息**没有被删除** ——
   * 文案必须说清楚这一点，否则用户会以为内容丢了。
   */
  remove(id: string): void {
    /*
     * 🔴 必须记进「已移除」名单 —— 否则下一次从云端拉取时它会重新出现。
     *
     * 会话目录的真相源是云端表。只删本地索引的话，下次 `hydrateFromCloud`
     * 拉到的还是同一批线程，这条又回来了（实测：删了没效果）。
     * 云端删除失败时，本地黑名单是最后一道兜底。
     */
    const cur = this.byId(id); // 删除前取，删除后取不到 roomId/agentId
    this._removed.update((set) => new Set(set).add(id));
    this._all.update((list) => list.filter((x) => x.id !== id));
    this.persist();
    /*
     * 云端删除索引：物理删除记录 + 留一条墓碑阻止扫描重建。
     * Matrix 房间里的消息**不受影响**（会话正文仍在服务器）。
     */
    void this.trySync(() =>
      this.api!.removeChatThread({ threadRoot: id, roomId: cur?.roomId, agentId: cur?.agentId }),
    );
  }

  /** 该线程是否被用户移除过（拉取云端时据此跳过） */
  isRemoved(id: string): boolean {
    return this._removed().has(id);
  }

  /**
   * 该线程是否**已被云端标记为删除**（墓碑）。
   *
   * 与 `isRemoved` 的区别：`isRemoved` 还包含「本机删过但云端还没同步」，
   * 而这里只认云端墓碑 —— 用于「URL 直达已删会话」这种需要权威判断的场景。
   *
   * 注意：`cloudRemoved` 在会话目录**还没加载**时是空的。此时返回 false，
   * 让调用方按原有路径走（不能因为「还没拉到」就拒绝打开任何会话）。
   */
  isCloudRemoved(id: string): boolean {
    return this.cloudRemoved.has(id);
  }

  /**
   * 收敛「新建对话」空壳：**整个列表最多只留一条**。
   *
   * 2026-11-01 用户裁决：
   *   新建对话是「点击即建」（左侧立刻可见并选中），但持久化的唯一前提是
   *   **在该会话里发过消息**。所以：
   *   · 「新建对话」在列表里只能有一条 —— 不论在哪个工作区、哪个容器新建，
   *     一旦新建，**之前所有没发过消息的空会话一律清掉**；
   *   · 不需要等 60 秒，也不需要定时器 —— 新建/切换的那一刻就收敛。
   *
   * 实现上区分两类空壳：
   *   · **从未落库**（`_pendingPush`）→ 删本地即可，不发云端请求（云端本来就没有）；
   *   · **已落库**（发过消息后又被清空）→ 删本地 + 云端软删，否则下次拉取会回来。
   *
   * @param keepId 要保留的那条（通常是刚新建/正在看的会话）
   */
  pruneEmpty(keepId?: string): void {
    const victims = this._all().filter(
      (s) => !s.legacy && s.id !== keepId && (s.messageCount ?? 0) === 0,
    );
    if (victims.length === 0) return;

    const dead = new Set(victims.map((s) => s.id));
    this._all.update((list) => list.filter((x) => !dead.has(x.id)));
    this.persist();

    for (const v of victims) {
      if (this._pendingPush.has(v.id)) {
        // 从没写过云端 → 撤销标记即可，不发请求
        this._pendingPush.delete(v.id);
        continue;
      }
      void this.trySync(() =>
        this.api!.removeChatThread({ threadRoot: v.id, roomId: v.roomId, agentId: v.agentId }),
      );
    }
  }
  /**
   * 直接设置消息计数与最后活动时间。
   *
   * 用于「历史对话」——它的正文是无 thread 的旧消息，
   * 不参与线程扫描的计数统计，只能由调用方按实际条数写入。
   */
  setMessageCount(id: string, count: number, updatedAt?: number): void {
    const patch: Partial<ChatSession> = { messageCount: count };
    if (updatedAt && updatedAt > (this.byId(id)?.updatedAt ?? 0)) patch.updatedAt = updatedAt;
    this.update(id, patch);
  }

  /**
   * 把一条云盘链接记到会话的成果列表里（2026-11-09 用户裁决）。
   *
   * 用户要求：成果按会话存放 —— 会话记录里存该会话成果的在线链接数组。
   *
   * 调用时机：会话里出现带 `cloudUrl` 的附件 / 有新成果上云时。
   * 幂等：同一链接不重复加；已有链接不会被覆盖掉。
   */
  addDeliverableUrl(id: string, ...urls: (string | null | undefined)[]): void {
    const add = urls.map((x) => (x ?? '').trim()).filter((u) => u.length > 0);
    if (add.length === 0) return;
    const cur = this.byId(id);
    if (!cur) return;
    const list = cur.deliverableUrls ?? [];
    const fresh = add.filter((u) => !list.includes(u));
    if (fresh.length === 0) return;
    // 上限 50，与服务端 `_strArr` 的截断一致
    const next = [...list, ...fresh].slice(0, 50);
    this.update(id, { deliverableUrls: next });
    /*
     * 🔴 立刻落库：成果归属是跨设备可见的数据，只留本地没有意义。
     *    `pushOne` 是 fire-and-forget，失败会进 `_pushFailed` 并等下次补推。
     */
    this.pushOne(this.byId(id));
  }

  /**
   * 写入一条消息（更新预览/时间,必要时推导标题）。
   *
   * 由 `ChatService` 在消息到达/发出时调用。
   */
  noteMessage(
    id: string,
    msg: { text?: string; ts: number; fromMe: boolean },
  ): void {
    const cur = this.byId(id);
    if (!cur) return;
    const next = touchSession(cur, msg);
    this.update(id, next);
    /*
     * 🔴 必须把变化推回云端（2026-11-01 修复）。
     *
     * 此前 `noteMessage` **只写本地** —— 标题、消息数、最后时间全留在浏览器里，
     * 云端那条记录一直停在「新对话 / 0 条消息」。
     * 于是换设备、清缓存、甚至只是重新拉一次列表，会话名就退回「新对话」
     * （用户实测：历史会话名称加载不对）。
     *
     * 节流：只在三种关键时刻推送，避免每条消息都打一次接口 ——
     *   ① 该会话**还没落库**（`_pendingPush`）→ 必须立刻写，不节流；
     *   ② 标题变了（首条消息命名成功）；
     *   ③ 距上次推送超过 10 秒（保证消息数与时间不会长期落后）。
     */
    const pending = this._pendingPush.has(id);
    const titleChanged = next.title !== cur.title;
    const due = Date.now() - (this.lastPushAt.get(id) ?? 0) > 10_000;
    if (!this._ready() || (!pending && !titleChanged && !due)) return;
    this.lastPushAt.set(id, Date.now());
    /*
     * 🔴 首次落库（pending）也在这里推，但要能被 `sendText` **等待**（2026-11-09）。
     *
     * 用户要求：第一次发消息时先持久化，**存储成功后才发送**。
     * 做法是把这次推送的 Promise 挂到 `_commitWait`，`commitNow()` 取出来 await；
     * 调用方（群聊等）没有 await 也不会丢 —— 推送照常在后台跑完。
     */
    const session = this.byId(id) ?? next;
    const p = this.pushOneAsync(session);
    if (pending) this._commitWait.set(id, p);
    else void p;
  }

  /**
   * 等待该会话的**首次落库**完成（2026-11-09 用户要求）。
   *
   * - 若 `noteMessage` 已经发起首次推送 → 直接等那个 Promise，不重复请求
   * - 若还没发起（例如调用方直接 sendText 没走 noteMessage）→ 主动推一次
   *
   * @throws 云端写入失败时抛出，调用方据此把消息标记为失败、不发送
   */
  async commitNow(id: string): Promise<void> {
    const s = this.byId(id);
    if (!s || s.legacy) return;
    if (!this.api) return; // 演示态：无云端

    const inflight = this._commitWait.get(id);
    if (inflight) {
      this._commitWait.delete(id);
      await inflight;
      return;
    }
    await this.pushOneAsync(s);
  }

  /**
   * 推送一条会话并按结果 resolve/reject（`pushOne` 的同步版）。
   *
   * 🔴 `pushOne` 是 fire-and-forget，失败只设提示不抛；首次落库需要抛给调用方，
   *    所以单开一个可 await 的实现，两者共用同一套成功/失败处理。
   */
  private async pushOneAsync(s: ChatSession): Promise<void> {
    if (s.legacy || !this.api) return;
    try {
      await this.api.upsertChatThreads([toUpsert(s)]);
      this._pendingPush.delete(s.id);
      if (this._pushFailed()) this._pushFailed.set(null);
    } catch (e) {
      const msg = e instanceof Error && e.message ? e.message : '网络异常';
      // 保留待同步标记，下次 hydrate / pushAll 自动补推
      this._pushFailed.set(`会话「${s.title || '新对话'}」尚未同步到云端：${msg}`);
      throw new Error(msg);
    }
  }

  /** 取某房间下所有已知会话的线程根（消息过滤用） */
  threadIdsOf(roomId: string): Set<string> {
    return new Set(this._all().filter((s) => s.roomId === roomId).map((s) => s.id));
  }

  /**
   * 按 id 打补丁。
   *
   * 🔴 **值没变就不写**:本方法可能被 effect 调用,无条件写 signal 会造成
   *    「effect → 写 → effect 再跑」的无限循环（冷启动实测页面崩溃）。
   */
  private update(id: string, patch: Partial<ChatSession>): ChatSession | undefined {
    const cur = this.byId(id);
    if (!cur) return undefined;
    const changed = (Object.keys(patch) as (keyof ChatSession)[]).some(
      (k) => cur[k] !== patch[k],
    );
    if (!changed) return cur;
    const result: ChatSession = { ...cur, ...patch };
    this._all.update((list) => sortSessions(list.map((s) => (s.id === id ? result : s))));
    this.persist();
    return result;
  }

  /**
   * 本地存储键（**按用户隔离**）。
   *
   * 🔴 未登录时返回 null,调用方直接跳过读写 ——
   *    绝不能回落到一个共享的 `anon` 键:那样两个未登录会话、
   *    或「登出后再登录另一个账号」的间隙,会把别人的会话显示出来。
   *
   * 🔴 `_v2` 后缀（2026-11-01）：缓存结构语义变了（云端失败时不再展示旧数据、
   *    空会话不再落云端），旧键里的数据按新规则会被当成脏数据，
   *    直接换键即等于**一次性失效**，无需写迁移代码。
   */
  private key(): string | null {
    const uid = this.session.me()?.id;
    return uid ? `fmode_chat_sessions_v2_${uid}` : null;
  }

  private persist(): void {
    const key = this.key();
    // 未登录不落盘 —— 没有 owner 的数据写下去就是下一个账号的串号源
    if (!key) return;
    try {
      localStorage.setItem(
        key,
        JSON.stringify(this._all()),
      );
      // 黑名单单独存 — 它描述的是「用户不想要哪些」,与会话列表同生命周期
      localStorage.setItem(`${key}_removed`, JSON.stringify([...this._removed()]));
    } catch {
      /* 隐私模式：只保留内存态 */
    }
  }
}

/**
 * 会话 → 云端 upsert 载荷（唯一构造点）。
 *
 * 收敛到一处的原因：此前 `pushAll` / `pushOne` / `mergeScanned` 各手写一份同样的
 * 字段表，改一个字段要改三处，漏一处就会出现「某条路径写上去的会话缺字段」。
 */
function toUpsert(s: ChatSession): ChatThreadUpsert {
  return {
    agentId: s.agentId,
    roomId: s.roomId,
    threadRoot: s.id,
    title: s.title,
    messageCount: s.messageCount ?? 0,
    lastMessageAt: s.updatedAt || s.createdAt,
    lastPreview: s.lastPreview,
    // 归属随 upsert 一起上云（'' = 日常对话），否则换设备后层级丢失
    workspaceId: s.workspaceId ?? '',
    // 群会话形态与成员（2026-11-05）：不同步会导致换设备后群聊退化成单聊
    kind: s.kind,
    memberIds: s.memberIds,
    // 本会话的成果链接（2026-11-09）：成果按会话存放
    deliverableUrls: s.deliverableUrls,
  };
}

/** 结构校验：坏数据不得进入列表 */
function isSession(x: unknown): x is ChatSession {
  if (!x || typeof x !== 'object') return false;
  const o = x as Record<string, unknown>;
  return (
    typeof o['id'] === 'string' &&
    typeof o['roomId'] === 'string' &&
    typeof o['agentId'] === 'string' &&
    typeof o['title'] === 'string' &&
    typeof o['createdAt'] === 'number' &&
    typeof o['updatedAt'] === 'number'
  );
}

/** 补齐可选字段,旧版本数据也能读 */
function normalize(s: ChatSession): ChatSession {
  return {
    ...s,
    archived: !!s.archived,
    messageCount: s.messageCount ?? 0,
    workspaceId: s.workspaceId ?? null,
  };
}