import { useStore } from 'zustand';
import { createStore, type StoreApi } from 'zustand/vanilla';
import {
  createConversationReducerState,
  reduceConversationPatch,
  replaceConversationSnapshot,
  type ConversationReducerState,
} from '../../shared/coding-conversation-reducer';
import { AppError } from '@/lib/error-model';
import { queueCodingConversationSessionSync } from '@/lib/agent-session-sync';
import {
  getCodingConversationSnapshot,
  openCodingConversationEvents,
  recoverCodingConversation,
  submitCodingConversationPrompt,
  type SubmitCodingConversationPromptInput,
} from '@/lib/coding-conversations';
import type {
  CodingConversationDraft,
  CodingConversationPatchBatchEvent,
  CodingConversationSnapshotEvent,
  CodingConversationSummary,
  CodingDraftAttachment,
  CodingPromptRequestState,
  ConversationMessageNode,
  ConversationPatchEnvelope,
  ConversationSnapshot,
  PromptAcceptance,
  PromptMode,
} from '@/types/coding-conversation';

export type CodingConversationLoadState =
  | 'empty'
  | 'loading'
  | 'live'
  | 'recovering'
  | 'error';

export type CodingConversationSnapshotLoadMode = 'loading' | 'recovering' | 'silent';

export interface CodingConversationEntry {
  reducer: ConversationReducerState;
  loadState: CodingConversationLoadState;
  error: string | null;
  unread: boolean;
}

export interface SubmitCodingPromptInput {
  conversationId: string;
  mode: PromptMode;
  text?: string;
  attachments?: CodingDraftAttachment[];
  prepareAttachments?(): Promise<CodingDraftAttachment[]>;
}

interface CodingConversationStoreDependencies {
  getSnapshot(conversationId: string): Promise<ConversationSnapshot>;
  openEvents(conversationId?: string): Promise<EventSource>;
  submitPrompt(input: SubmitCodingConversationPromptInput): Promise<PromptAcceptance>;
  recover(conversationId: string): Promise<void>;
  queueSettledSessionSync(snapshot: ConversationSnapshot): void;
  createId(kind: 'request' | 'node'): string;
  preparationTimeoutMs: number;
}

export interface CodingConversationStoreState {
  selectedConversationId: string | null;
  entriesByConversationId: Record<string, CodingConversationEntry>;
  summariesByConversationId: Record<string, CodingConversationSummary>;
  draftsByConversationId: Record<string, CodingConversationDraft>;
  requestsByConversationId: Record<string, Record<string, CodingPromptRequestState>>;
  connectionState: 'disconnected' | 'connecting' | 'live' | 'reconnecting' | 'error';
  globalError: string | null;
  primeConversation(snapshot: ConversationSnapshot): void;
  clearConversationSelection(): void;
  selectConversation(conversationId: string): Promise<void>;
  loadSnapshot(
    conversationId: string,
    mode?: CodingConversationSnapshotLoadMode,
  ): Promise<ConversationSnapshot>;
  recoverConversation(conversationId: string): Promise<void>;
  connectEvents(): Promise<void>;
  disconnectEvents(): void;
  setDraft(conversationId: string, text: string, attachments?: CodingDraftAttachment[]): void;
  markUnread(conversationId: string, unread: boolean): void;
  submitPrompt(input: SubmitCodingPromptInput): Promise<PromptAcceptance>;
  applySnapshotEvent(event: CodingConversationSnapshotEvent): void;
  applyPatchBatchEvent(event: CodingConversationPatchBatchEvent): void;
}

const DEFAULT_DRAFT: CodingConversationDraft = {
  text: '',
  attachments: [],
  revision: 0,
};
const EMPTY_REQUESTS: Record<string, CodingPromptRequestState> = {};

function cloneDraft(draft: CodingConversationDraft): CodingConversationDraft {
  return {
    text: draft.text,
    attachments: draft.attachments.map((attachment) => ({ ...attachment })),
    revision: draft.revision,
  };
}

function emptyEntry(): CodingConversationEntry {
  return {
    reducer: createConversationReducerState(),
    loadState: 'empty',
    error: null,
    unread: false,
  };
}

function errorDetails(error: unknown): { code?: string; message: string } {
  if (error instanceof AppError) {
    return {
      ...(typeof error.details?.backendCode === 'string'
        ? { code: error.details.backendCode }
        : {}),
      message: error.message,
    };
  }
  return { message: error instanceof Error ? error.message : String(error) };
}

function summaryOf(entry: CodingConversationEntry): CodingConversationSummary | null {
  const snapshot = entry.reducer.snapshot;
  if (!snapshot) return null;
  return {
    conversationId: snapshot.conversation.id,
    title: snapshot.conversation.title,
    runStatus: snapshot.run.status,
    runError: snapshot.run.error ?? null,
    workerStatus: snapshot.worker.status,
    model: snapshot.conversation.model,
    unread: entry.unread,
  };
}

function summariesWithEntry(
  summaries: Record<string, CodingConversationSummary>,
  entry: CodingConversationEntry,
): Record<string, CodingConversationSummary> {
  const next = summaryOf(entry);
  if (!next) return summaries;
  const current = summaries[next.conversationId];
  if (current
    && current.title === next.title
    && current.runStatus === next.runStatus
    && current.runError === next.runError
    && current.workerStatus === next.workerStatus
    && current.model === next.model
    && current.unread === next.unread) {
    return summaries;
  }
  return { ...summaries, [next.conversationId]: next };
}

function requestIdsInSnapshot(snapshot: ConversationSnapshot): Set<string> {
  return new Set(snapshot.nodes.flatMap((node) => (
    node.kind === 'message' && node.clientRequestId ? [node.clientRequestId] : []
  )));
}

function withoutReconciledRequests(
  requests: Record<string, CodingPromptRequestState> | undefined,
  snapshot: ConversationSnapshot,
): Record<string, CodingPromptRequestState> {
  const reconciled = requestIdsInSnapshot(snapshot);
  const requestUncertaintySettled = snapshot.run.status === 'idle' || snapshot.run.status === 'error';
  if (!requests || (reconciled.size === 0 && !requestUncertaintySettled)) return requests ?? {};
  return Object.fromEntries(
    Object.entries(requests).filter(([clientRequestId, request]) => (
      !reconciled.has(clientRequestId)
      && !(request.status === 'uncertain' && requestUncertaintySettled)
    )),
  );
}

function withReconciledOptimisticNodeIds(
  snapshot: ConversationSnapshot,
  requests: Record<string, CodingPromptRequestState> | undefined,
): ConversationSnapshot {
  if (!requests) return snapshot;
  let changed = false;
  const nodes = snapshot.nodes.map((node) => {
    if (node.kind !== 'message' || !node.clientRequestId) return node;
    const nodeId = requests[node.clientRequestId]?.nodeId;
    if (!nodeId || node.id === nodeId) return node;
    changed = true;
    return { ...node, id: nodeId };
  });
  return changed ? { ...snapshot, nodes } : snapshot;
}

function optimisticNode(
  nodeId: string,
  clientRequestId: string,
  draft: CodingConversationDraft,
): ConversationMessageNode {
  return {
    kind: 'message',
    id: nodeId,
    clientRequestId,
    role: 'user',
    status: 'optimistic',
    blocks: [
      ...(draft.text ? [{
        kind: 'text' as const,
        id: `${nodeId}:text`,
        text: draft.text,
        status: 'complete' as const,
      }] : []),
      ...draft.attachments.map((attachment, index) => ({
        kind: 'image' as const,
        id: `${nodeId}:attachment:${index}`,
        attachmentId: attachment.attachmentId,
        mime: attachment.mime,
      })),
    ],
  };
}

function withOptimisticNode(
  reducer: ConversationReducerState,
  node: ConversationMessageNode,
): ConversationReducerState {
  const snapshot = reducer.snapshot;
  if (!snapshot) return reducer;
  return replaceConversationSnapshot(reducer, {
    ...snapshot,
    nodes: [...snapshot.nodes, node],
  });
}

function withRejectedNode(
  reducer: ConversationReducerState,
  nodeId: string | undefined,
): ConversationReducerState {
  const snapshot = reducer.snapshot;
  if (!snapshot || !nodeId) return reducer;
  return replaceConversationSnapshot(reducer, {
    ...snapshot,
    nodes: snapshot.nodes.map((node) => (
      node.kind === 'message' && node.id === nodeId
        ? { ...node, status: 'error' as const }
        : node
    )),
  });
}

function withUnreconciledOptimisticNodes(
  reducer: ConversationReducerState,
  requests: Record<string, CodingPromptRequestState>,
): ConversationReducerState {
  const snapshot = reducer.snapshot;
  if (!snapshot) return reducer;
  const existingRequestIds = requestIdsInSnapshot(snapshot);
  const nodes = Object.values(requests).flatMap((request) => (
    request.nodeId
      && request.status !== 'rejected'
      && !existingRequestIds.has(request.clientRequestId)
      ? [optimisticNode(request.nodeId, request.clientRequestId, request.submittedDraft)]
      : []
  ));
  if (nodes.length === 0) return reducer;
  return replaceConversationSnapshot(reducer, {
    ...snapshot,
    nodes: [...snapshot.nodes, ...nodes],
  });
}

function snapshotIsOlder(
  current: ConversationSnapshot | null,
  incoming: ConversationSnapshot,
): boolean {
  if (!current) return false;
  if (incoming.cursor.workerGeneration !== current.cursor.workerGeneration) {
    return incoming.cursor.workerGeneration < current.cursor.workerGeneration;
  }
  return incoming.cursor.seq < current.cursor.seq;
}

function defaultDependencies(): CodingConversationStoreDependencies {
  return {
    getSnapshot: getCodingConversationSnapshot,
    openEvents: openCodingConversationEvents,
    submitPrompt: submitCodingConversationPrompt,
    recover: recoverCodingConversation,
    queueSettledSessionSync: queueCodingConversationSessionSync,
    createId: () => crypto.randomUUID(),
    preparationTimeoutMs: 10_000,
  };
}

function withPreparedOptimisticNode(
  reducer: ConversationReducerState,
  nodeId: string | undefined,
  clientRequestId: string,
  draft: CodingConversationDraft,
): ConversationReducerState {
  const snapshot = reducer.snapshot;
  if (!snapshot || !nodeId) return reducer;
  return replaceConversationSnapshot(reducer, {
    ...snapshot,
    nodes: snapshot.nodes.map((node) => (
      node.kind === 'message' && node.id === nodeId
        ? optimisticNode(nodeId, clientRequestId, draft)
        : node
    )),
  });
}

function withPreparationDeadline<T>(promise: Promise<T>, timeoutMs: number): Promise<T> {
  let timer: ReturnType<typeof setTimeout> | undefined;
  return new Promise<T>((resolve, reject) => {
    timer = setTimeout(() => {
      reject(new Error('本地 Agent 准备超时，请重试。'));
    }, timeoutMs);
    promise.then(resolve, reject);
  }).finally(() => {
    if (timer !== undefined) clearTimeout(timer);
  });
}

function validPatchBatchRange(event: CodingConversationPatchBatchEvent): boolean {
  if (event.type !== 'patch-batch'
    || !event.conversationId
    || !Number.isSafeInteger(event.workerGeneration)
    || event.workerGeneration < 0
    || !Array.isArray(event.items)
    || event.items.length === 0
    || event.fromSeq !== event.items[0]?.seq
    || event.toSeq !== event.items.at(-1)?.seq) {
    return false;
  }
  return event.items.every((item, index) => (
    item !== null
    && typeof item === 'object'
    && Number.isSafeInteger(item.seq)
    && item.seq >= 0
    && (index === 0 || item.seq === event.items[index - 1].seq + 1)
  ));
}

function completesOrdinaryPrompt(
  event: CodingConversationPatchBatchEvent,
  current: ConversationSnapshot,
): boolean {
  let mode = current.run.mode;
  let observedActiveRun = current.run.status !== 'idle';
  for (const item of event.items) {
    if (item.patch.op !== 'run.state') continue;
    if (item.patch.run.mode) mode = item.patch.run.mode;
    if (item.patch.run.status !== 'idle') observedActiveRun = true;
    if (observedActiveRun
      && mode === 'prompt'
      && item.patch.run.status === 'idle'
      && item.patch.run.terminalReason === 'completed') {
      return true;
    }
  }
  return false;
}

function taskHasSettled(snapshot: ConversationSnapshot): boolean {
  return snapshot.run.status === 'error'
    || (snapshot.run.status === 'idle' && snapshot.run.terminalReason !== undefined);
}

function newlyNeedsUserAttention(
  current: ConversationSnapshot | null,
  next: ConversationSnapshot | null,
): boolean {
  if (!next) return false;
  const currentPendingInteractions = new Set(
    current?.pendingInteractions
      .filter((interaction) => interaction.status === 'pending')
      .map((interaction) => interaction.id) ?? [],
  );
  if (next.pendingInteractions.some((interaction) => (
    interaction.status === 'pending' && !currentPendingInteractions.has(interaction.id)
  ))) {
    return true;
  }
  if (!taskHasSettled(next)) return false;
  return !current
    || !taskHasSettled(current)
    || current.run.runId !== next.run.runId
    || current.run.terminalReason !== next.run.terminalReason;
}

export function createCodingConversationStore(
  dependencies: Partial<CodingConversationStoreDependencies> = {},
): StoreApi<CodingConversationStoreState> {
  const deps = { ...defaultDependencies(), ...dependencies };
  const snapshotLoads = new Map<string, Promise<ConversationSnapshot>>();
  const recoveryBatches = new Map<string, CodingConversationPatchBatchEvent[]>();
  const recoveryRefreshKeys = new Map<string, string>();
  let eventSource: EventSource | null = null;
  let connectFlight: Promise<void> | null = null;
  let connectionGeneration = 0;
  let store!: StoreApi<CodingConversationStoreState>;

  const bufferRecoveryBatch = (event: CodingConversationPatchBatchEvent) => {
    const buffered = recoveryBatches.get(event.conversationId) ?? [];
    if (buffered.some((candidate) => (
      candidate.workerGeneration === event.workerGeneration
      && candidate.fromSeq === event.fromSeq
      && candidate.toSeq === event.toSeq
    ))) return;
    recoveryBatches.set(
      event.conversationId,
      [...buffered, event].sort((left, right) => (
        left.workerGeneration - right.workerGeneration || left.fromSeq - right.fromSeq
      )),
    );
  };

  const replayRecoveryBatches = (conversationId: string) => {
    const buffered = recoveryBatches.get(conversationId);
    if (!buffered?.length) return;
    const snapshot = selectCodingConversationSnapshot(conversationId)(store.getState());
    if (!snapshot) return;
    const itemsBySeq = new Map<number, CodingConversationPatchBatchEvent['items'][number]>();
    for (const batch of buffered) {
      if (batch.workerGeneration !== snapshot.cursor.workerGeneration) continue;
      for (const item of batch.items) {
        if (item.seq > snapshot.cursor.seq && !itemsBySeq.has(item.seq)) {
          itemsBySeq.set(item.seq, item);
        }
      }
    }
    const items = [...itemsBySeq.values()].sort((left, right) => left.seq - right.seq);
    if (items.length === 0) {
      recoveryBatches.delete(conversationId);
      recoveryRefreshKeys.delete(conversationId);
      return;
    }
    const continuous = items[0].seq === snapshot.cursor.seq + 1
      && items.every((item, index) => index === 0 || item.seq === items[index - 1].seq + 1);
    if (!continuous) {
      const lastSeq = items.at(-1)?.seq ?? items[0].seq;
      const refreshKey = [
        snapshot.cursor.workerGeneration,
        snapshot.cursor.seq,
        items[0].seq,
        lastSeq,
      ].join(':');
      const willRefresh = recoveryRefreshKeys.get(conversationId) !== refreshKey;
      store.setState((state) => {
        const current = state.entriesByConversationId[conversationId] ?? emptyEntry();
        return {
          entriesByConversationId: {
            ...state.entriesByConversationId,
            [conversationId]: {
              ...current,
              loadState: willRefresh ? 'recovering' : 'error',
              error: 'Conversation patch batch is not continuous',
            },
          },
        };
      });
      if (willRefresh) {
        recoveryRefreshKeys.set(conversationId, refreshKey);
        queueMicrotask(() => {
          if (!snapshotLoads.has(conversationId)) {
            void store.getState().loadSnapshot(conversationId, 'recovering').catch(() => undefined);
          }
        });
      }
      return;
    }
    recoveryBatches.delete(conversationId);
    recoveryRefreshKeys.delete(conversationId);
    store.getState().applyPatchBatchEvent({
      type: 'patch-batch',
      conversationId,
      workerGeneration: snapshot.cursor.workerGeneration,
      fromSeq: items[0].seq,
      toSeq: items.at(-1)?.seq ?? items[0].seq,
      items,
    });
  };

  store = createStore<CodingConversationStoreState>((set, get) => ({
    selectedConversationId: null,
    entriesByConversationId: {},
    summariesByConversationId: {},
    draftsByConversationId: {},
    requestsByConversationId: {},
    connectionState: 'disconnected',
    globalError: null,

    primeConversation(snapshot) {
      const conversationId = snapshot.conversation.id;
      set((state) => {
        const current = state.entriesByConversationId[conversationId];
        if (current?.loadState === 'live' || current?.reducer.invalidation) return state;
        const entry: CodingConversationEntry = {
          ...(current ?? emptyEntry()),
          reducer: replaceConversationSnapshot(
            current?.reducer ?? createConversationReducerState(),
            snapshot,
          ),
          loadState: current?.loadState ?? 'empty',
          error: null,
        };
        return {
          entriesByConversationId: {
            ...state.entriesByConversationId,
            [conversationId]: entry,
          },
          summariesByConversationId: summariesWithEntry(
            state.summariesByConversationId,
            entry,
          ),
        };
      });
    },

    clearConversationSelection() {
      set({ selectedConversationId: null });
    },

    async selectConversation(conversationId) {
      set((state) => {
        const current = state.entriesByConversationId[conversationId] ?? emptyEntry();
        const entry = current.unread ? { ...current, unread: false } : current;
        return {
          selectedConversationId: conversationId,
          entriesByConversationId: {
            ...state.entriesByConversationId,
            [conversationId]: entry,
          },
          summariesByConversationId: summariesWithEntry(state.summariesByConversationId, entry),
        };
      });
      const entry = get().entriesByConversationId[conversationId];
      const snapshotFlight = !entry?.reducer.snapshot
        || entry.reducer.invalidation
        || entry.loadState !== 'live'
        ? get().loadSnapshot(
            conversationId,
            entry?.reducer.invalidation ? 'recovering' : 'loading',
          )
        : Promise.resolve(entry.reducer.snapshot);
      await Promise.all([snapshotFlight, get().connectEvents()]);
    },

    loadSnapshot(conversationId, mode = 'loading') {
      const prior = snapshotLoads.get(conversationId);
      if (prior) return prior;
      if (mode !== 'silent') {
        set((state) => {
          const entry = state.entriesByConversationId[conversationId] ?? emptyEntry();
          return {
            entriesByConversationId: {
              ...state.entriesByConversationId,
              [conversationId]: {
                ...entry,
                loadState: mode,
                error: null,
              },
            },
          };
        });
      }
      const flight = withPreparationDeadline(
        deps.getSnapshot(conversationId),
        deps.preparationTimeoutMs,
      )
        .then((snapshot) => {
          get().applySnapshotEvent({
            type: 'snapshot',
            conversationId,
            workerGeneration: snapshot.cursor.workerGeneration,
            seq: snapshot.cursor.seq,
            snapshot,
          });
          return snapshot;
        })
        .catch((error) => {
          if (mode !== 'silent') {
            const failure = errorDetails(error);
            set((state) => {
              const entry = state.entriesByConversationId[conversationId] ?? emptyEntry();
              return {
                entriesByConversationId: {
                  ...state.entriesByConversationId,
                  [conversationId]: { ...entry, loadState: 'error', error: failure.message },
                },
              };
            });
          }
          throw error;
        })
        .finally(() => {
          if (snapshotLoads.get(conversationId) === flight) snapshotLoads.delete(conversationId);
          const entry = get().entriesByConversationId[conversationId];
          if (!entry?.reducer.invalidation) replayRecoveryBatches(conversationId);
        });
      snapshotLoads.set(conversationId, flight);
      return flight;
    },

    async recoverConversation(conversationId) {
      recoveryRefreshKeys.delete(conversationId);
      set((state) => {
        const entry = state.entriesByConversationId[conversationId] ?? emptyEntry();
        return {
          entriesByConversationId: {
            ...state.entriesByConversationId,
            [conversationId]: { ...entry, loadState: 'recovering', error: null },
          },
        };
      });
      try {
        await deps.recover(conversationId);
        await get().loadSnapshot(conversationId, 'recovering');
      } catch (error) {
        const failure = errorDetails(error);
        set((state) => {
          const entry = state.entriesByConversationId[conversationId] ?? emptyEntry();
          return {
            entriesByConversationId: {
              ...state.entriesByConversationId,
              [conversationId]: { ...entry, loadState: 'error', error: failure.message },
            },
          };
        });
        throw error;
      }
    },

    async connectEvents() {
      if (eventSource) return;
      if (connectFlight) return await connectFlight;
      const generation = ++connectionGeneration;
      set({ connectionState: 'connecting', globalError: null });
      let flight: Promise<void>;
      flight = deps.openEvents()
        .then((source) => {
          if (generation !== connectionGeneration) {
            source.close();
            return;
          }
          eventSource = source;
          const parse = <T,>(event: Event): T => JSON.parse((event as MessageEvent<string>).data) as T;
          source.addEventListener('snapshot', (event) => {
            try {
              get().applySnapshotEvent(parse<CodingConversationSnapshotEvent>(event));
            } catch {
              set({ connectionState: 'error', globalError: 'Conversation 事件快照无法读取。' });
            }
          });
          source.addEventListener('patch-batch', (event) => {
            try {
              get().applyPatchBatchEvent(parse<CodingConversationPatchBatchEvent>(event));
            } catch {
              set({ connectionState: 'error', globalError: 'Conversation 事件更新无法读取。' });
            }
          });
          source.onopen = () => {
            if (eventSource === source) set({ connectionState: 'live', globalError: null });
          };
          source.onerror = () => {
            if (eventSource === source) {
              set({
                connectionState: 'reconnecting',
                globalError: 'Conversation 事件连接中断，正在重连。',
              });
            }
          };
        })
        .catch((error) => {
          if (generation !== connectionGeneration) return;
          set({ connectionState: 'error', globalError: errorDetails(error).message });
          throw error;
        })
        .finally(() => {
          if (connectFlight === flight) connectFlight = null;
        });
      connectFlight = flight;
      await flight;
    },

    disconnectEvents() {
      connectionGeneration += 1;
      eventSource?.close();
      eventSource = null;
      connectFlight = null;
      set({ connectionState: 'disconnected', globalError: null });
    },

    setDraft(conversationId, text, attachments = []) {
      set((state) => {
        const current = state.draftsByConversationId[conversationId] ?? DEFAULT_DRAFT;
        return {
          draftsByConversationId: {
            ...state.draftsByConversationId,
            [conversationId]: {
              text,
              attachments: attachments.map((attachment) => ({ ...attachment })),
              revision: current.revision + 1,
            },
          },
        };
      });
    },

    markUnread(conversationId, unread) {
      set((state) => {
        const current = state.entriesByConversationId[conversationId] ?? emptyEntry();
        if (current.unread === unread) return state;
        const entry = { ...current, unread };
        return {
          entriesByConversationId: {
            ...state.entriesByConversationId,
            [conversationId]: entry,
          },
          summariesByConversationId: summariesWithEntry(state.summariesByConversationId, entry),
        };
      });
    },

    async submitPrompt(input) {
      let entry = get().entriesByConversationId[input.conversationId];
      if (!entry?.reducer.snapshot || entry.reducer.invalidation) {
        await get().loadSnapshot(
          input.conversationId,
          entry?.reducer.invalidation ? 'recovering' : 'loading',
        );
        entry = get().entriesByConversationId[input.conversationId];
      }
      if (!entry?.reducer.snapshot) throw new Error('Conversation snapshot is unavailable');

      const existingDraft = get().draftsByConversationId[input.conversationId] ?? DEFAULT_DRAFT;
      const submittedDraft: CodingConversationDraft = {
        text: input.text ?? existingDraft.text,
        attachments: (input.attachments ?? existingDraft.attachments).map((attachment) => ({ ...attachment })),
        revision: existingDraft.revision,
      };
      const clientRequestId = deps.createId('request');
      const nodeId = input.mode === 'prompt' ? deps.createId('node') : undefined;
      const clearedRevision = existingDraft.revision + 1;
      const request: CodingPromptRequestState = {
        clientRequestId,
        mode: input.mode,
        ...(nodeId ? { nodeId } : {}),
        status: 'pending',
        submittedDraft: cloneDraft(submittedDraft),
      };

      set((state) => {
        const currentEntry = state.entriesByConversationId[input.conversationId] ?? emptyEntry();
        const reducer = nodeId
          ? withOptimisticNode(
              currentEntry.reducer,
              optimisticNode(nodeId, clientRequestId, submittedDraft),
            )
          : currentEntry.reducer;
        const nextEntry = { ...currentEntry, reducer, error: null };
        return {
          entriesByConversationId: {
            ...state.entriesByConversationId,
            [input.conversationId]: nextEntry,
          },
          summariesByConversationId: summariesWithEntry(
            state.summariesByConversationId,
            nextEntry,
          ),
          draftsByConversationId: {
            ...state.draftsByConversationId,
            [input.conversationId]: { text: '', attachments: [], revision: clearedRevision },
          },
          requestsByConversationId: {
            ...state.requestsByConversationId,
            [input.conversationId]: {
              ...(state.requestsByConversationId[input.conversationId] ?? {}),
              [clientRequestId]: request,
            },
          },
        };
      });

      try {
        if (input.prepareAttachments) {
          submittedDraft.attachments = (await input.prepareAttachments())
            .map((attachment) => ({ ...attachment }));
          set((state) => {
            const currentEntry = state.entriesByConversationId[input.conversationId] ?? emptyEntry();
            const requests = state.requestsByConversationId[input.conversationId] ?? {};
            const currentRequest = requests[clientRequestId];
            if (!currentRequest) return state;
            const reducer = withPreparedOptimisticNode(
              currentEntry.reducer,
              nodeId,
              clientRequestId,
              submittedDraft,
            );
            const nextEntry = { ...currentEntry, reducer };
            return {
              entriesByConversationId: {
                ...state.entriesByConversationId,
                [input.conversationId]: nextEntry,
              },
              summariesByConversationId: summariesWithEntry(
                state.summariesByConversationId,
                nextEntry,
              ),
              requestsByConversationId: {
                ...state.requestsByConversationId,
                [input.conversationId]: {
                  ...requests,
                  [clientRequestId]: {
                    ...currentRequest,
                    submittedDraft: cloneDraft(submittedDraft),
                  },
                },
              },
            };
          });
        }
        const acceptance = await deps.submitPrompt({
          conversationId: input.conversationId,
          clientRequestId,
          mode: input.mode,
          text: submittedDraft.text,
          attachments: submittedDraft.attachments.map(({ attachmentId }) => ({ attachmentId })),
        });
        set((state) => {
          const requests = state.requestsByConversationId[input.conversationId] ?? {};
          const current = requests[clientRequestId];
          if (!current) return state;
          return {
            requestsByConversationId: {
              ...state.requestsByConversationId,
              [input.conversationId]: {
                ...requests,
                [clientRequestId]: { ...current, status: 'accepted' },
              },
            },
          };
        });
        return acceptance;
      } catch (error) {
        const failure = errorDetails(error);
        const uncertain = failure.code === 'CODING_REQUEST_UNCERTAIN';
        set((state) => {
          const currentEntry = state.entriesByConversationId[input.conversationId] ?? emptyEntry();
          const requests = state.requestsByConversationId[input.conversationId] ?? {};
          const currentRequest = requests[clientRequestId] ?? request;
          const currentDraft = state.draftsByConversationId[input.conversationId] ?? DEFAULT_DRAFT;
          const canRestore = currentDraft.revision === clearedRevision
            && !currentDraft.text
            && currentDraft.attachments.length === 0;
          const reducer = uncertain
            ? currentEntry.reducer
            : withRejectedNode(currentEntry.reducer, nodeId);
          const nextEntry = {
            ...currentEntry,
            reducer,
          };
          return {
            entriesByConversationId: {
              ...state.entriesByConversationId,
              [input.conversationId]: nextEntry,
            },
            summariesByConversationId: summariesWithEntry(
              state.summariesByConversationId,
              nextEntry,
            ),
            draftsByConversationId: canRestore
              ? {
                  ...state.draftsByConversationId,
                  [input.conversationId]: {
                    ...cloneDraft(submittedDraft),
                    revision: clearedRevision + 1,
                  },
                }
              : state.draftsByConversationId,
            requestsByConversationId: {
              ...state.requestsByConversationId,
              [input.conversationId]: {
                ...requests,
                [clientRequestId]: {
                  ...currentRequest,
                  status: uncertain ? 'uncertain' : 'rejected',
                  ...(failure.code ? { errorCode: failure.code } : {}),
                  errorMessage: failure.message,
                },
              },
            },
          };
        });
        throw error;
      }
    },

    applySnapshotEvent(event) {
      const snapshot = event.snapshot;
      if (event.type !== 'snapshot'
        || event.conversationId !== snapshot.conversation.id
        || event.workerGeneration !== snapshot.cursor.workerGeneration
        || event.seq !== snapshot.cursor.seq) {
        return;
      }
      set((state) => {
        const current = state.entriesByConversationId[event.conversationId] ?? emptyEntry();
        if (!current.reducer.invalidation && snapshotIsOlder(current.reducer.snapshot, snapshot)) {
          return state;
        }
        const reconciledSnapshot = withReconciledOptimisticNodeIds(
          snapshot,
          state.requestsByConversationId[event.conversationId],
        );
        const requests = withoutReconciledRequests(
          state.requestsByConversationId[event.conversationId],
          reconciledSnapshot,
        );
        const reducer = withUnreconciledOptimisticNodes(
          replaceConversationSnapshot(current.reducer, reconciledSnapshot),
          requests,
        );
        const entry: CodingConversationEntry = {
          ...current,
          reducer,
          loadState: reducer.invalidation ? 'error' : 'live',
          error: reducer.invalidation?.reason ?? null,
          unread: state.selectedConversationId === event.conversationId ? false : current.unread,
        };
        return {
          entriesByConversationId: {
            ...state.entriesByConversationId,
            [event.conversationId]: entry,
          },
          summariesByConversationId: summariesWithEntry(state.summariesByConversationId, entry),
          requestsByConversationId: {
            ...state.requestsByConversationId,
            [event.conversationId]: requests,
          },
        };
      });
      if (!snapshotLoads.has(event.conversationId)) {
        replayRecoveryBatches(event.conversationId);
      }
    },

    applyPatchBatchEvent(event) {
      const currentBeforeBatch = get().entriesByConversationId[event.conversationId];
      const currentSnapshot = currentBeforeBatch?.reducer.snapshot;
      if (currentSnapshot && event.workerGeneration < currentSnapshot.cursor.workerGeneration) return;
      const validRange = validPatchBatchRange(event);
      const recovering = currentBeforeBatch?.loadState === 'recovering'
        || Boolean(currentBeforeBatch?.reducer.invalidation);
      if (!validRange) {
        if (!snapshotLoads.has(event.conversationId)) {
          void get().loadSnapshot(event.conversationId, 'recovering').catch(() => undefined);
        }
        return;
      }
      let applicableEvent = event;
      if (currentSnapshot
        && event.workerGeneration === currentSnapshot.cursor.workerGeneration
        && event.fromSeq <= currentSnapshot.cursor.seq) {
        const unseenItems = event.items.filter((item) => item.seq > currentSnapshot.cursor.seq);
        if (unseenItems.length === 0) return;
        applicableEvent = {
          ...event,
          fromSeq: unseenItems[0]!.seq,
          toSeq: unseenItems.at(-1)!.seq,
          items: unseenItems,
        };
      }
      if (recovering
        || !currentSnapshot
        || applicableEvent.workerGeneration !== currentSnapshot.cursor.workerGeneration
        || applicableEvent.fromSeq !== currentSnapshot.cursor.seq + 1) {
        bufferRecoveryBatch(applicableEvent);
        if (!snapshotLoads.has(applicableEvent.conversationId)) {
          void get().loadSnapshot(applicableEvent.conversationId, 'recovering').catch(() => undefined);
        }
        return;
      }
      const shouldSyncSettledSession = completesOrdinaryPrompt(applicableEvent, currentSnapshot);
      let recover = false;
      let applied = false;
      set((state) => {
        const current = state.entriesByConversationId[applicableEvent.conversationId] ?? emptyEntry();
        let reducer = current.reducer;
        for (const item of applicableEvent.items) {
          reducer = reduceConversationPatch(reducer, {
            conversationId: applicableEvent.conversationId,
            workerGeneration: applicableEvent.workerGeneration,
            ...(item.runId ? { runId: item.runId } : {}),
            seq: item.seq,
            at: item.at,
            patch: item.patch,
          } satisfies ConversationPatchEnvelope);
          if (reducer.invalidation) {
            recover = true;
            return state;
          }
        }
        if (reducer === current.reducer) return state;
        applied = true;
        const unread = state.selectedConversationId !== applicableEvent.conversationId
          && newlyNeedsUserAttention(current.reducer.snapshot, reducer.snapshot)
            ? true
            : current.unread;
        const entry: CodingConversationEntry = {
          ...current,
          reducer,
          loadState: 'live',
          error: null,
          unread,
        };
        const requests = state.requestsByConversationId[applicableEvent.conversationId] ?? {};
        const nextRequests = reducer.snapshot
          ? withoutReconciledRequests(requests, reducer.snapshot)
          : requests;
        const requestsChanged = Object.keys(nextRequests).length !== Object.keys(requests).length;
        return {
          entriesByConversationId: {
            ...state.entriesByConversationId,
            [applicableEvent.conversationId]: entry,
          },
          summariesByConversationId: summariesWithEntry(state.summariesByConversationId, entry),
          requestsByConversationId: !requestsChanged
            ? state.requestsByConversationId
            : {
                ...state.requestsByConversationId,
                [applicableEvent.conversationId]: nextRequests,
              },
        };
      });
      if (recover) {
        void get().loadSnapshot(applicableEvent.conversationId, 'recovering').catch(() => undefined);
      } else if (applied && shouldSyncSettledSession) {
        const settledSnapshot = selectCodingConversationSnapshot(applicableEvent.conversationId)(get());
        if (settledSnapshot) deps.queueSettledSessionSync(settledSnapshot);
      }
    },
  }));
  return store;
}

export const codingConversationStore = createCodingConversationStore();

export function useCodingConversationStore<T>(
  selector: (state: CodingConversationStoreState) => T,
): T {
  return useStore(codingConversationStore, selector);
}

export const selectCodingConversationSnapshot = (conversationId: string) => (
  state: CodingConversationStoreState,
): ConversationSnapshot | null => (
  state.entriesByConversationId[conversationId]?.reducer.snapshot ?? null
);

export const selectCodingConversationSummary = (conversationId: string) => (
  state: CodingConversationStoreState,
): CodingConversationSummary | null => state.summariesByConversationId[conversationId] ?? null;

export const selectCodingConversationDraft = (conversationId: string) => (
  state: CodingConversationStoreState,
): CodingConversationDraft => state.draftsByConversationId[conversationId] ?? DEFAULT_DRAFT;

export const selectCodingConversationRequests = (conversationId: string) => (
  state: CodingConversationStoreState,
): Record<string, CodingPromptRequestState> => (
  state.requestsByConversationId[conversationId] ?? EMPTY_REQUESTS
);