import type { Spec } from "@json-render/core";
import type { AgentApiClient } from "../api/client";
import { AnswerViewStateApiError, type AnswerViewStateRecord, type AnswerViewStateWrite } from "../api/answer-view-state";
import { normalizeAnswerViewState, type AnswerViewState } from "../answer-ui/answer-view-state";

export type AnswerViewSaveStatus = "loading" | "saving" | "saved" | "unsaved" | "conflict";
export type AnswerViewSnapshot = {
  state: AnswerViewState; status: AnswerViewSaveStatus; error?: string;
};
type PendingWrite = { payload: AnswerViewStateWrite; change: number };
export type AnswerViewEntry = {
  readonly sessionId: string; readonly messageId: string; readonly blockId: string;
  spec: Spec; snapshot: AnswerViewSnapshot; remote?: AnswerViewStateRecord;
  dirty: Map<string, number>; change: number; listeners: Set<() => void>;
  loading?: Promise<void>; saving?: Promise<void>; pending?: PendingWrite;
  conflict?: AnswerViewStateRecord; timer?: ReturnType<typeof setTimeout>;
  started: boolean; released: boolean;
};

// This cache belongs to one authenticated workbench/project, never to the module.
export class AnswerViewStateScope {
  private entries = new Map<string, AnswerViewEntry>();
  private disposed = false;
  private invalidIdentity?: string;
  private leases = 0;
  constructor(readonly scope: string, private readonly client: Pick<AgentApiClient, "getAnswerViewState" | "putAnswerViewState">) {}
  retain() { this.leases++; }
  release() { this.leases--; queueMicrotask(() => { if (this.leases === 0) this.dispose(); }); }
  dispose = () => {
    this.disposed = true;
    for (const entry of this.entries.values()) { clearTimeout(entry.timer); entry.listeners.clear(); }
    this.entries.clear();
  };
  entry(sessionId: string, messageId: string, blockId: string, spec: Spec): AnswerViewEntry {
    const key = JSON.stringify([this.scope, sessionId, messageId, blockId]);
    let entry = this.entries.get(key);
    if (!entry) {
      entry = { sessionId, messageId, blockId, spec, snapshot: { state: normalizeAnswerViewState(spec), status: this.invalidIdentity ? "unsaved" : "loading", error: this.invalidIdentity },
        dirty: new Map(), change: 0, listeners: new Set(), started: false, released: false };
      this.entries.set(key, entry);
    }
    entry.spec = spec;
    return entry;
  }
  subscribe(entry: AnswerViewEntry, listener: () => void, enabled = true) {
    entry.listeners.add(listener);
    entry.released = false;
    if (enabled && !entry.started) { entry.started = true; void this.restore(entry); }
    return () => {
      entry.listeners.delete(listener);
      if (!entry.listeners.size) {
        entry.released = true;
        clearTimeout(entry.timer);
        // Preserve the captured entry and client when the active session changes.
        if (entry.started && !entry.snapshot.error && !entry.conflict) void this.save(entry);
      }
    };
  }
  update(entry: AnswerViewEntry, state: AnswerViewState, paths: string[]) {
    if (this.disposed || !paths.length) return;
    entry.change++;
    for (const path of paths) entry.dirty.set(path, entry.change);
    this.publish(entry, { ...entry.snapshot, state: normalizeAnswerViewState(entry.spec, state), status: entry.conflict ? "conflict" : entry.snapshot.status === "unsaved" ? "unsaved" : entry.loading ? "loading" : entry.saving ? "saving" : "unsaved" });
    if (!entry.started) return;
    // One bounded re-read on the first user edit can recover a final-message save race.
    if (!entry.remote && !entry.loading && entry.change === 1) { void this.restore(entry); return; }
    if (entry.remote && !entry.pending && !entry.conflict && !entry.saving) this.schedule(entry);
  }
  retry(entry: AnswerViewEntry) {
    if (this.disposed || !entry.started || entry.conflict) return;
    if (!entry.remote) void this.restore(entry);
    else void this.save(entry);
  }
  reload(entry: AnswerViewEntry) {
    if (this.disposed) return;
    // The UI explicitly confirms replacing local edits before calling this.
    entry.dirty.clear(); entry.pending = undefined;
    const current = entry.conflict;
    entry.conflict = undefined;
    if (current) {
      entry.remote = current;
      this.publish(entry, { state: normalizeAnswerViewState(entry.spec, current), status: "saved" });
    } else void this.restore(entry);
  }
  resave(entry: AnswerViewEntry) {
    if (this.disposed || !entry.conflict) return;
    entry.remote = entry.conflict;
    entry.conflict = undefined; entry.pending = undefined;
    entry.snapshot = { ...entry.snapshot, state: normalizeAnswerViewState(entry.spec, entry.snapshot.state) };
    // Explicit intent: keep every field in the visible local draft.
    entry.change++;
    for (const path of statePaths(entry.snapshot.state)) entry.dirty.set(path, entry.change);
    void this.save(entry);
  }
  private publish(entry: AnswerViewEntry, snapshot: AnswerViewSnapshot) {
    if (this.disposed) return;
    entry.snapshot = snapshot;
    entry.listeners.forEach((listener) => listener());
  }
  private fail(entry: AnswerViewEntry, error: unknown) {
    if (this.disposed) return;
    if (error instanceof AnswerViewStateApiError && error.code === "ANSWER_VIEW_IDENTITY_CHANGED") {
      this.invalidIdentity = error.message;
      for (const cached of this.entries.values()) {
        cached.dirty.clear(); cached.pending = undefined; cached.remote = undefined; cached.conflict = undefined;
        this.publish(cached, { state: normalizeAnswerViewState(cached.spec), status: "unsaved", error: error.message });
      }
      this.dispose();
    } else this.publish(entry, { ...entry.snapshot, status: "unsaved", error: errorMessage(error) });
  }
  private schedule(entry: AnswerViewEntry) {
    clearTimeout(entry.timer);
    entry.timer = setTimeout(() => void this.save(entry), 500);
  }
  private async restore(entry: AnswerViewEntry) {
    if (this.disposed || !entry.started || entry.loading || entry.saving) return;
    this.publish(entry, { ...entry.snapshot, status: "loading", error: undefined });
    const task = (async () => {
      try {
        const remote = await this.client.getAnswerViewState(entry.sessionId, entry.messageId, entry.blockId);
        if (this.disposed) return;
        checkIdentity(entry, remote);
        entry.remote = remote;
        const restored = normalizeAnswerViewState(entry.spec, remote);
        const state = normalizeAnswerViewState(entry.spec, mergeDirty(restored, entry.snapshot.state, entry.dirty.keys()));
        this.publish(entry, { state, status: entry.dirty.size ? "unsaved" : "saved" });
      } catch (error) {
        this.fail(entry, error);
      }
    })();
    entry.loading = task;
    await task;
    entry.loading = undefined;
    if (!this.disposed && entry.remote && entry.dirty.size) {
      if (entry.released) void this.save(entry); else this.schedule(entry);
    }
  }
  private async save(entry: AnswerViewEntry) {
    clearTimeout(entry.timer);
    if (this.disposed || !entry.started || entry.loading || entry.saving || entry.conflict || !entry.remote || !entry.dirty.size) return;
    const pending = entry.pending ?? {
      payload: { message_id: entry.messageId, block_id: entry.blockId, schema_digest: entry.remote.schema_digest,
        expected_revision: entry.remote.revision, request_id: crypto.randomUUID(),
        nodes: structuredClone(entry.snapshot.state.nodes), block: { ...entry.snapshot.state.block } },
      change: entry.change,
    };
    if (new TextEncoder().encode(JSON.stringify(pending.payload)).byteLength > 32 * 1024) {
      this.publish(entry, { ...entry.snapshot, status: "unsaved", error: "交互状态超过 32 KiB，当前草稿仅保留在内存中。" });
      return;
    }
    entry.pending = pending;
    this.publish(entry, { ...entry.snapshot, status: "saving", error: undefined });
    let succeeded = false;
    const task = (async () => {
      try {
        const remote = await this.client.putAnswerViewState(entry.sessionId, pending.payload);
        if (this.disposed) return;
        checkIdentity(entry, remote);
        entry.remote = remote; entry.pending = undefined;
        for (const [path, change] of entry.dirty) if (change <= pending.change) entry.dirty.delete(path);
        const state = normalizeAnswerViewState(entry.spec, mergeDirty(normalizeAnswerViewState(entry.spec, remote), entry.snapshot.state, entry.dirty.keys()));
        this.publish(entry, { state, status: entry.dirty.size ? "unsaved" : "saved" });
        succeeded = true;
      } catch (error) {
        if (error instanceof AnswerViewStateApiError && error.status === 409 && error.current
          && error.current.message_id === entry.messageId && error.current.block_id === entry.blockId) {
          entry.conflict = error.current;
          this.publish(entry, { ...entry.snapshot, status: "conflict", error: error.code === "ANSWER_VIEW_SCHEMA_CHANGED"
            ? "回答内容已更新，当前草稿尚未保存。" : "另一个窗口已更新交互状态，当前草稿尚未保存。" });
        } else this.fail(entry, error);
      }
    })();
    entry.saving = task;
    await task;
    entry.saving = undefined;
    if (!this.disposed && succeeded && entry.dirty.size) {
      if (entry.released) void this.save(entry); else this.schedule(entry);
    }
  }
}
function checkIdentity(entry: AnswerViewEntry, remote: AnswerViewStateRecord) {
  if (remote.message_id !== entry.messageId || remote.block_id !== entry.blockId) throw new Error("交互状态身份不匹配，请重试");
}
function errorMessage(error: unknown) {
  return error instanceof Error ? error.message : "交互状态未保存，请重试";
}
function statePaths(state: AnswerViewState) {
  return ["/block/evidenceFilter", ...Object.keys(state.nodes).map((key) => `/nodes/${key}`)];
}
export function mergeDirty(restored: AnswerViewState, local: AnswerViewState, paths: Iterable<string>): AnswerViewState {
  const result = structuredClone(restored);
  for (const path of paths) {
    const keys = path.split("/").slice(1).map((key) => key.replaceAll("~1", "/").replaceAll("~0", "~"));
    if (!keys.length || !["nodes", "block"].includes(keys[0])) continue;
    let source: unknown = local;
    let target = result as unknown as Record<string, unknown>;
    for (const key of keys.slice(0, -1)) {
      source = source && typeof source === "object" && Object.hasOwn(source, key) ? (source as Record<string, unknown>)[key] : undefined;
      if (!Object.hasOwn(target, key) || !target[key] || typeof target[key] !== "object") {
        Object.defineProperty(target, key, { value: {}, enumerable: true, configurable: true, writable: true });
      }
      target = target[key] as Record<string, unknown>;
    }
    const field = keys.at(-1)!;
    const value = source && typeof source === "object" && Object.hasOwn(source, field) ? (source as Record<string, unknown>)[field] : undefined;
    if (value === undefined) delete target[field]; else Object.defineProperty(target, field, { value: structuredClone(value), enumerable: true, configurable: true, writable: true });
  }
  return result;
}