import { create } from 'zustand';
import {
  confirmImageWorkspaceGeneration,
  createImageWorkspaceConversation,
  createImageWorkspaceTurnId,
  createImageWorkspaceProject,
  deleteImageWorkspaceProject,
  fetchImageWorkspace,
  fetchImageWorkspaceConversation,
  fetchImageWorkspaceProject,
  fetchImageWorkspaceTasks,
  ImageWorkspaceApiError,
  openImageWorkspaceTaskEvents,
  renameImageWorkspaceProject,
  sendImageWorkspaceMessage,
  updateImageWorkspaceGenerationQuote,
} from '@/lib/image-workspace';
import { useAuthStore } from '@/stores/auth';
import { setDesktopBackgroundLease } from '@/lib/host-api';
import {
  IMAGE_WORKSPACE_UNAVAILABLE_CODE,
  type DesignAssistantDeltaEvent,
  type DesignConversation,
  type DesignConversationSnapshotEvent,
  type DesignDeleteWorkspaceResult,
  type DesignGenerationTask,
  type DesignGenerationParameters,
  type DesignGenerationQuote,
  type DesignGenerationTaskUpdatedEvent,
  type DesignMessage,
  type DesignWorkspace,
  type DesignWorkspaceBootstrap,
  type DesignWorkspaceSummary,
} from '../../shared/image-workspace';

export type ImageWorkspaceLoadStatus =
  | 'idle'
  | 'loading'
  | 'ready'
  | 'unavailable'
  | 'error'
  | 'auth-required';

export type ImageWorkspaceTaskStreamState = 'idle' | 'connecting' | 'connected' | 'degraded';

export type PendingDesignTurn = {
  workspaceId: string;
  conversationId: string;
  clientTurnId: string;
  turnRevision: number;
  userText: string | null;
  assistantText: string;
  lastChunkIndex: number;
  createdAt: string;
};

type ImageWorkspaceState = {
  status: ImageWorkspaceLoadStatus;
  bootstrap: DesignWorkspaceBootstrap | null;
  activeWorkspaceId: string | null;
  activeConversationId: string | null;
  workspace: DesignWorkspace | null;
  conversation: DesignConversation | null;
  creatingConversation: boolean;
  deletingWorkspaceId: string | null;
  tasks: DesignGenerationTask[];
  pendingTurn: PendingDesignTurn | null;
  loadingOlderMessages: boolean;
  olderMessagesError: string | null;
  taskStreamState: ImageWorkspaceTaskStreamState;
  error: string | null;
  load: () => Promise<DesignWorkspaceBootstrap | null>;
  createProject: (title: string) => Promise<DesignWorkspace>;
  createConversation: (title?: string) => Promise<DesignConversation>;
  renameProject: (workspaceId: string, title: string) => Promise<DesignWorkspace>;
  deleteProject: (workspaceId: string) => Promise<DesignDeleteWorkspaceResult>;
  selectProject: (workspaceId: string) => Promise<void>;
  selectConversation: (conversationId: string) => Promise<void>;
  refreshWorkspace: () => Promise<DesignWorkspace | null>;
  refreshConversation: () => Promise<DesignConversation | null>;
  loadOlderMessages: () => Promise<DesignConversation | null>;
  refreshTasks: () => Promise<DesignGenerationTask[]>;
  connectTaskStream: () => void;
  markTaskStreamNeedsReconciliation: () => void;
  disconnectTaskStream: () => void;
  sendMessage: (message: string, attachmentAssetIds?: string[]) => Promise<DesignConversation>;
  updateGenerationQuote: (
    quoteId: string,
    finalPrompt: string,
    generationParameters: DesignGenerationParameters,
  ) => Promise<DesignGenerationQuote>;
  confirmGeneration: (
    quoteId: string,
    finalPrompt: string,
    generationParameters: DesignGenerationParameters,
  ) => Promise<DesignConversation>;
  reset: () => void;
};

let inFlightLoad: Promise<DesignWorkspaceBootstrap | null> | null = null;
const TASK_FALLBACK_POLL_INTERVAL_MS = 15_000;
const CONFIRMED_TASK_RECONCILE_ATTEMPTS = 5;
const CONFIRMED_TASK_RECONCILE_INTERVAL_MS = 250;
let activeTaskEventSource: EventSource | null = null;
let activeTaskEventWorkspaceId: string | null = null;
let activeTaskEventConversationId: string | null = null;
const pendingTaskEventConnections = new Map<string, symbol>();
let taskFallbackTimer: ReturnType<typeof setInterval> | null = null;
const taskEventRevisions = new Map<string, number>();
let workspaceLoadGeneration = 0;
let conversationSelectionGeneration = 0;
let projectDeletionGeneration = 0;
let generationQuoteUpdateSequence = 0;
let reconcileTaskStateOnNextConnect = false;

function updateBackgroundLease(input: {
  id: string;
  kind: string;
  active: boolean;
}): void {
  try {
    void Promise.resolve(setDesktopBackgroundLease(input)).catch(() => undefined);
  } catch {
    // Renderer-only tests and embedded previews may not expose lifecycle IPC.
  }
}

function taskRevisionKey(workspaceId: string, taskId: string): string {
  return `${workspaceId}:${taskId}`;
}

function taskStreamKey(workspaceId: string, conversationId: string): string {
  return `${workspaceId}:${conversationId}`;
}

function stopFallbackPolling(): void {
  if (taskFallbackTimer !== null) clearInterval(taskFallbackTimer);
  taskFallbackTimer = null;
}

function closeTaskEventSource(): void {
  stopFallbackPolling();
  if (activeTaskEventSource) {
    activeTaskEventSource.onopen = null;
    activeTaskEventSource.onerror = null;
    activeTaskEventSource.close();
  }
  activeTaskEventSource = null;
  activeTaskEventWorkspaceId = null;
  activeTaskEventConversationId = null;
  taskEventRevisions.clear();
}

function parseTaskUpdatedEvent(event: Event): DesignGenerationTaskUpdatedEvent | null {
  const data = (event as MessageEvent<unknown>).data;
  if (typeof data !== 'string') return null;
  try {
    const payload = JSON.parse(data) as Partial<DesignGenerationTaskUpdatedEvent>;
    if (payload.type !== 'design.generation_task.updated'
      || typeof payload.id !== 'string'
      || typeof payload.workspaceId !== 'string'
      || !Number.isInteger(payload.workspaceViewRevision)
      || !payload.generationTask
      || typeof payload.generationTask.taskId !== 'string'
      || payload.generationTask.workspaceId !== payload.workspaceId) {
      return null;
    }
    return payload as DesignGenerationTaskUpdatedEvent;
  } catch {
    return null;
  }
}

function parseConversationSnapshotEvent(event: Event): DesignConversationSnapshotEvent | null {
  const data = (event as MessageEvent<unknown>).data;
  if (typeof data !== 'string') return null;
  try {
    const payload = JSON.parse(data) as Partial<DesignConversationSnapshotEvent>;
    if (payload.type !== 'design.conversation.snapshot'
      || typeof payload.id !== 'string'
      || typeof payload.workspaceId !== 'string'
      || typeof payload.conversationId !== 'string'
      || !Number.isInteger(payload.workspaceViewRevision)
      || !payload.conversation
      || payload.conversation.workspaceId !== payload.workspaceId
      || payload.conversation.conversationId !== payload.conversationId
      || !Array.isArray(payload.conversation.messages)
      || !Array.isArray(payload.generationTasks)
      || !payload.generationTasks.every((task) => (
        typeof task?.taskId === 'string' && task.workspaceId === payload.workspaceId
      ))) {
      return null;
    }
    return payload as DesignConversationSnapshotEvent;
  } catch {
    return null;
  }
}

function parseAssistantDeltaEvent(event: Event): DesignAssistantDeltaEvent | null {
  const data = (event as MessageEvent<unknown>).data;
  if (typeof data !== 'string') return null;
  try {
    const payload = JSON.parse(data) as Partial<DesignAssistantDeltaEvent>;
    if (payload.type !== 'design.assistant.delta'
      || typeof payload.id !== 'string'
      || typeof payload.workspaceId !== 'string'
      || typeof payload.conversationId !== 'string'
      || typeof payload.clientTurnId !== 'string'
      || !Number.isInteger(payload.turnRevision)
      || Number(payload.turnRevision) < 1
      || !Number.isInteger(payload.chunkIndex)
      || Number(payload.chunkIndex) < 0
      || typeof payload.delta !== 'string'
      || payload.delta.length === 0
      || payload.delta.length > 128) {
      return null;
    }
    return payload as DesignAssistantDeltaEvent;
  } catch {
    return null;
  }
}

function sortTasks(tasks: DesignGenerationTask[]): DesignGenerationTask[] {
  return [...tasks].sort((left, right) => (
    right.createdAt.localeCompare(left.createdAt) || right.taskId.localeCompare(left.taskId)
  ));
}

function mostRecentlyUpdatedWorkspace(
  workspaces: DesignWorkspaceSummary[],
): DesignWorkspaceSummary | null {
  return workspaces.reduce<DesignWorkspaceSummary | null>((latest, workspace) => {
    if (!latest || workspace.updatedAt > latest.updatedAt) return workspace;
    return latest;
  }, null);
}

function mergeTasks(
  current: DesignGenerationTask[],
  incoming: DesignGenerationTask[],
): DesignGenerationTask[] {
  const tasksById = new Map(current.map((task) => [task.taskId, task]));
  for (const task of incoming) {
    const existing = tasksById.get(task.taskId);
    if (!existing || existing.updatedAt <= task.updatedAt) tasksById.set(task.taskId, task);
  }
  return sortTasks([...tasksById.values()]);
}

function unavailable(error: unknown): boolean {
  return error instanceof ImageWorkspaceApiError
    && (error.status === 501 || error.code === IMAGE_WORKSPACE_UNAVAILABLE_CODE);
}

function authenticationRequired(error: unknown): boolean {
  return error instanceof ImageWorkspaceApiError && error.code === 'AUTH_REQUIRED';
}

function messageOf(error: unknown): string {
  return error instanceof Error ? error.message : String(error);
}

function toSummary(workspace: DesignWorkspace): DesignWorkspaceSummary {
  const { conversations: _conversations, ...summary } = workspace;
  return summary;
}

function upsertSummary(
  bootstrap: DesignWorkspaceBootstrap | null,
  workspace: DesignWorkspace,
): DesignWorkspaceBootstrap | null {
  if (!bootstrap) return null;
  const summary = toSummary(workspace);
  const workspaces = bootstrap.workspaces.filter(
    (item) => item.workspaceId !== workspace.workspaceId,
  );
  return {
    ...bootstrap,
    workspaces: [summary, ...workspaces],
  };
}

function upsertConversation(
  workspace: DesignWorkspace | null,
  conversation: DesignConversation,
): DesignWorkspace | null {
  if (!workspace || workspace.workspaceId !== conversation.workspaceId) return workspace;
  const conversations = workspace.conversations.filter(
    (item) => item.conversationId !== conversation.conversationId,
  );
  const { messages: _messages, ...summary } = conversation;
  return {
    ...workspace,
    conversationCount: Math.max(workspace.conversationCount, conversations.length + 1),
    conversations: [summary, ...conversations],
  };
}

function createPendingTurn(
  conversation: DesignConversation,
  clientTurnId: string,
  userText: string,
): PendingDesignTurn {
  return {
    workspaceId: conversation.workspaceId,
    conversationId: conversation.conversationId,
    clientTurnId,
    turnRevision: conversation.turnRevision + 1,
    userText,
    assistantText: '',
    lastChunkIndex: -1,
    createdAt: new Date().toISOString(),
  };
}

function mergePendingUserMessage(
  conversation: DesignConversation,
  pendingTurn: PendingDesignTurn | null,
): DesignConversation {
  if (!pendingTurn
    || pendingTurn.userText === null
    || pendingTurn.workspaceId !== conversation.workspaceId
    || pendingTurn.conversationId !== conversation.conversationId
    || conversation.turnRevision < pendingTurn.turnRevision) {
    return conversation;
  }
  const alreadyPersisted = conversation.messages.some((message) => (
    message.role === 'user'
    && message.turnRevision === pendingTurn.turnRevision
    && message.text === pendingTurn.userText
  ));
  if (alreadyPersisted) return conversation;

  const userMessage: DesignMessage = {
    id: `${pendingTurn.clientTurnId}:user`,
    role: 'user',
    kind: 'user',
    text: pendingTurn.userText,
    quickReplies: [],
    generationQuote: null,
    turnRevision: pendingTurn.turnRevision,
    createdAt: pendingTurn.createdAt,
  };
  const insertionIndex = conversation.messages.findIndex(
    (message) => message.turnRevision >= pendingTurn.turnRevision,
  );
  const messages = [...conversation.messages];
  messages.splice(insertionIndex < 0 ? messages.length : insertionIndex, 0, userMessage);
  return { ...conversation, messages };
}

function mergeConversationMessagePages(
  current: DesignConversation | null,
  incoming: DesignConversation,
  source: 'latest' | 'older',
): DesignConversation {
  if (!current
    || current.conversationId !== incoming.conversationId
    || current.workspaceId !== incoming.workspaceId) {
    return incoming;
  }
  const messagesById = new Map<string, DesignMessage>();
  const messageSources = source === 'older'
    ? [incoming.messages, current.messages]
    : [current.messages, incoming.messages];
  for (const messages of messageSources) {
    for (const message of messages) messagesById.set(message.id, message);
  }
  const messages = [...messagesById.values()].sort((left, right) => (
    left.turnRevision - right.turnRevision
    || (left.role === right.role ? left.id.localeCompare(right.id) : left.role === 'user' ? -1 : 1)
    || left.createdAt.localeCompare(right.createdAt)
  ));
  return {
    ...incoming,
    messages,
    messagePage: source === 'older'
      ? incoming.messagePage
      : current.messagePage ?? incoming.messagePage,
  };
}

function replaceGenerationQuote(
  conversation: DesignConversation,
  previousQuoteId: string,
  quote: DesignGenerationQuote,
): DesignConversation {
  let changed = false;
  const messages = conversation.messages.map((message) => {
    if (message.generationQuote?.quoteId !== previousQuoteId) return message;
    changed = true;
    return { ...message, generationQuote: quote };
  });
  return changed ? { ...conversation, messages } : conversation;
}

export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) => {
  const pendingAssistantDeltas: DesignAssistantDeltaEvent[] = [];
  let assistantDeltaFlushTimer: ReturnType<typeof setTimeout> | null = null;

  const applyAssistantDelta = (
    state: ImageWorkspaceState,
    delta: DesignAssistantDeltaEvent,
  ): ImageWorkspaceState => {
    if (state.activeWorkspaceId !== delta.workspaceId
      || state.activeConversationId !== delta.conversationId
      || (state.conversation?.turnRevision ?? 0) >= delta.turnRevision) {
      return state;
    }
    const pending = state.pendingTurn;
    if (!pending) {
      if (delta.chunkIndex !== 0) return state;
      return {
        ...state,
        pendingTurn: {
          workspaceId: delta.workspaceId,
          conversationId: delta.conversationId,
          clientTurnId: delta.clientTurnId,
          turnRevision: delta.turnRevision,
          userText: null,
          assistantText: delta.delta,
          lastChunkIndex: delta.chunkIndex,
          createdAt: new Date().toISOString(),
        },
      };
    }
    if (pending.workspaceId !== delta.workspaceId
      || pending.conversationId !== delta.conversationId
      || pending.clientTurnId !== delta.clientTurnId
      || pending.turnRevision !== delta.turnRevision
      || delta.chunkIndex !== pending.lastChunkIndex + 1) {
      return state;
    }
    return {
      ...state,
      pendingTurn: {
        ...pending,
        assistantText: `${pending.assistantText}${delta.delta}`,
        lastChunkIndex: delta.chunkIndex,
      },
    };
  };

  const flushAssistantDeltas = () => {
    assistantDeltaFlushTimer = null;
    if (pendingAssistantDeltas.length === 0) return;
    const queued = pendingAssistantDeltas.splice(0, pendingAssistantDeltas.length);
    set((state) => queued.reduce(applyAssistantDelta, state));
  };

  const queueAssistantDelta = (delta: DesignAssistantDeltaEvent) => {
    pendingAssistantDeltas.push(delta);
    if (assistantDeltaFlushTimer === null) {
      assistantDeltaFlushTimer = setTimeout(flushAssistantDeltas, 50);
    }
  };

  const stopTaskStream = () => {
    pendingAssistantDeltas.length = 0;
    if (assistantDeltaFlushTimer !== null) clearTimeout(assistantDeltaFlushTimer);
    assistantDeltaFlushTimer = null;
    closeTaskEventSource();
    set({ taskStreamState: 'idle' });
  };

  const startFallbackPolling = () => {
    if (taskFallbackTimer !== null) return;
    taskFallbackTimer = setInterval(() => {
      if (get().taskStreamState !== 'degraded' || !get().activeWorkspaceId) return;
      void get().refreshWorkspace()
        .catch(() => null)
        .then(() => get().refreshConversation().catch(() => null))
        .then(() => get().refreshTasks().catch(() => []));
    }, TASK_FALLBACK_POLL_INTERVAL_MS);
  };

  const startTaskStream = (workspaceId: string, conversationId: string) => {
    if (activeTaskEventWorkspaceId === workspaceId
      && activeTaskEventConversationId === conversationId
      && get().taskStreamState !== 'idle') return;
    closeTaskEventSource();
    activeTaskEventWorkspaceId = workspaceId;
    activeTaskEventConversationId = conversationId;
    set({ taskStreamState: 'connecting' });
    const connectionKey = taskStreamKey(workspaceId, conversationId);
    if (pendingTaskEventConnections.has(connectionKey)) return;
    const connectionAttempt = Symbol(connectionKey);
    pendingTaskEventConnections.set(connectionKey, connectionAttempt);
    void openImageWorkspaceTaskEvents(workspaceId, conversationId).then((source) => {
      if (pendingTaskEventConnections.get(connectionKey) !== connectionAttempt) {
        source.close();
        return;
      }
      pendingTaskEventConnections.delete(connectionKey);
      if (get().activeWorkspaceId !== workspaceId
        || get().activeConversationId !== conversationId) {
        source.close();
        return;
      }
      activeTaskEventSource = source;
      source.addEventListener('design.assistant.delta', (event) => {
        const delta = parseAssistantDeltaEvent(event);
        if (!delta
          || delta.workspaceId !== activeTaskEventWorkspaceId
          || delta.conversationId !== activeTaskEventConversationId) return;
        queueAssistantDelta(delta);
      });
      source.addEventListener('design.conversation.snapshot', (event) => {
        const snapshot = parseConversationSnapshotEvent(event);
        if (!snapshot
          || snapshot.workspaceId !== activeTaskEventWorkspaceId
          || snapshot.conversationId !== activeTaskEventConversationId) return;
        set((state) => {
          if (state.activeWorkspaceId !== snapshot.workspaceId
            || state.activeConversationId !== snapshot.conversationId) return state;
          const tasksById = new Map(state.tasks.map((task) => [task.taskId, task]));
          for (const task of snapshot.generationTasks) {
            const key = taskRevisionKey(snapshot.workspaceId, task.taskId);
            const knownRevision = taskEventRevisions.get(key) ?? 0;
            const existing = tasksById.get(task.taskId);
            if (snapshot.workspaceViewRevision >= knownRevision
              && (!existing || existing.updatedAt <= task.updatedAt)) {
              tasksById.set(task.taskId, task);
            }
            taskEventRevisions.set(
              key,
              Math.max(knownRevision, snapshot.workspaceViewRevision),
            );
          }
          const conversation = !state.conversation
            || snapshot.conversation.turnRevision >= state.conversation.turnRevision
            ? snapshot.conversation
            : state.conversation;
          const resolvedConversation = mergeConversationMessagePages(
            state.conversation,
            mergePendingUserMessage(conversation, state.pendingTurn),
            'latest',
          );
          const workspace = upsertConversation(
            state.workspace
              ? {
                  ...state.workspace,
                  viewRevision: Math.max(
                    state.workspace.viewRevision,
                    snapshot.workspaceViewRevision,
                  ),
                }
              : null,
            resolvedConversation,
          );
          const bootstrap = workspace?.workspaceId === snapshot.workspaceId
            ? upsertSummary(state.bootstrap, workspace)
            : state.bootstrap;
          const pendingTurn = state.pendingTurn?.workspaceId === snapshot.workspaceId
            && state.pendingTurn.conversationId === snapshot.conversationId
            && resolvedConversation.turnRevision >= state.pendingTurn.turnRevision
            ? null
            : state.pendingTurn;
          return {
            tasks: sortTasks([...tasksById.values()]),
            workspace,
            conversation: resolvedConversation,
            bootstrap,
            pendingTurn,
          };
        });
      });
      source.addEventListener('design.generation_task.updated', (event) => {
        const update = parseTaskUpdatedEvent(event);
        if (!update || update.workspaceId !== activeTaskEventWorkspaceId) return;
        set((state) => {
          if (state.activeWorkspaceId !== update.workspaceId) return state;
          const key = taskRevisionKey(update.workspaceId, update.generationTask.taskId);
          const knownRevision = taskEventRevisions.get(key) ?? 0;
          if (update.workspaceViewRevision <= knownRevision) return state;
          const existing = state.tasks.find(
            (candidate) => candidate.taskId === update.generationTask.taskId,
          );
          if (existing && existing.updatedAt > update.generationTask.updatedAt) return state;
          taskEventRevisions.set(key, update.workspaceViewRevision);
          const tasks = sortTasks([
            update.generationTask,
            ...state.tasks.filter((candidate) => candidate.taskId !== update.generationTask.taskId),
          ]);
          const workspace = state.workspace?.workspaceId === update.workspaceId
            ? {
                ...state.workspace,
                viewRevision: Math.max(
                  state.workspace.viewRevision,
                  update.workspaceViewRevision,
                ),
              }
            : state.workspace;
          const bootstrap = state.bootstrap
            ? {
                ...state.bootstrap,
                workspaces: state.bootstrap.workspaces.map((candidate) => (
                  candidate.workspaceId === update.workspaceId
                    ? {
                        ...candidate,
                        viewRevision: Math.max(
                          candidate.viewRevision,
                          update.workspaceViewRevision,
                        ),
                      }
                    : candidate
                )),
              }
            : null;
          return { tasks, workspace, bootstrap };
        });
      });
      source.onopen = () => {
        if (activeTaskEventSource !== source) return;
        stopFallbackPolling();
        set({ taskStreamState: 'connected' });
      };
      source.onerror = () => {
        if (activeTaskEventSource !== source) return;
        set({ taskStreamState: 'degraded' });
        startFallbackPolling();
      };
    }).catch(() => {
      if (pendingTaskEventConnections.get(connectionKey) !== connectionAttempt) return;
      pendingTaskEventConnections.delete(connectionKey);
      if (get().activeWorkspaceId !== workspaceId
        || get().activeConversationId !== conversationId) return;
      set({ taskStreamState: 'degraded' });
      startFallbackPolling();
    });
  };

  const handleRequestError = (error: unknown): string => {
    const message = messageOf(error);
    if (authenticationRequired(error)) {
      projectDeletionGeneration += 1;
      stopTaskStream();
      useAuthStore.getState().invalidateSession();
      set({
        status: 'auth-required',
        bootstrap: null,
        activeWorkspaceId: null,
        activeConversationId: null,
        workspace: null,
        conversation: null,
        creatingConversation: false,
        deletingWorkspaceId: null,
        tasks: [],
        pendingTurn: null,
        taskStreamState: 'idle',
        error: message,
      });
    }
    return message;
  };

  const refreshWorkspaceTasks = async (
    workspaceId: string,
  ): Promise<DesignGenerationTask[]> => {
    const requestedViewRevision = get().workspace?.workspaceId === workspaceId
      ? get().workspace?.viewRevision ?? 0
      : 0;
    const tasks = await fetchImageWorkspaceTasks(workspaceId);
    const currentWorkspace = get().workspace;
    if (get().activeWorkspaceId === workspaceId
      && currentWorkspace?.workspaceId === workspaceId
      && currentWorkspace.viewRevision === requestedViewRevision) {
      set((state) => ({ tasks: mergeTasks(state.tasks, tasks) }));
    }
    return tasks;
  };

  const applyWorkspace = (workspace: DesignWorkspace): DesignWorkspace => {
    set((state) => {
      return {
        status: 'ready',
        bootstrap: upsertSummary(state.bootstrap, workspace),
        activeWorkspaceId: workspace.workspaceId,
        workspace,
        error: null,
      };
    });
    return workspace;
  };

  const applyConversation = (
    conversation: DesignConversation,
    source: 'latest' | 'older' = 'latest',
  ): DesignConversation => {
    let applied = conversation;
    set((state) => {
      if (state.conversation?.conversationId === conversation.conversationId
        && (state.conversation.turnRevision > conversation.turnRevision
          || (state.conversation.turnRevision === conversation.turnRevision
            && state.conversation.updatedAt > conversation.updatedAt))) {
        applied = state.conversation;
        return state;
      }
      const resolvedConversation = mergeConversationMessagePages(
        state.conversation,
        mergePendingUserMessage(conversation, state.pendingTurn),
        source,
      );
      applied = resolvedConversation;
      const pendingTurn = state.pendingTurn?.workspaceId === resolvedConversation.workspaceId
        && state.pendingTurn.conversationId === resolvedConversation.conversationId
        && resolvedConversation.turnRevision >= state.pendingTurn.turnRevision
        ? null
        : state.pendingTurn;
      return {
        workspace: upsertConversation(state.workspace, resolvedConversation),
        activeConversationId: resolvedConversation.conversationId,
        conversation: resolvedConversation,
        pendingTurn,
        loadingOlderMessages: false,
        olderMessagesError: null,
        error: null,
      };
    });
    return applied;
  };

  const loadWorkspace = async (workspaceId: string): Promise<void> => {
    const loadGeneration = ++workspaceLoadGeneration;
    conversationSelectionGeneration += 1;
    const workspace = await fetchImageWorkspaceProject(workspaceId);
    if (loadGeneration !== workspaceLoadGeneration
      || get().activeWorkspaceId !== workspaceId) return;
    const currentConversationId = get().activeConversationId;
    const conversationId = workspace.conversations.some(
      (item) => item.conversationId === currentConversationId,
    )
      ? currentConversationId
      : workspace.conversations[0]?.conversationId ?? null;
    set((state) => ({
      status: 'ready',
      bootstrap: upsertSummary(state.bootstrap, workspace),
      activeWorkspaceId: workspaceId,
      activeConversationId: conversationId,
      workspace,
      conversation: null,
      tasks: [],
      pendingTurn: null,
      loadingOlderMessages: false,
      olderMessagesError: null,
      error: null,
    }));
    void fetchImageWorkspaceTasks(workspaceId).then((tasks) => {
      if (loadGeneration !== workspaceLoadGeneration
        || get().activeWorkspaceId !== workspaceId) return;
      set({ tasks: sortTasks(tasks) });
    }).catch(() => undefined);
    if (!conversationId) return;
    const selectionGeneration = ++conversationSelectionGeneration;
    const conversation = await fetchImageWorkspaceConversation(workspaceId, conversationId);
    if (loadGeneration !== workspaceLoadGeneration
      || selectionGeneration !== conversationSelectionGeneration
      || get().activeWorkspaceId !== workspaceId
      || get().activeConversationId !== conversationId) return;
    applyConversation(conversation);
    startTaskStream(workspaceId, conversationId);
  };

  const recoverRevisionConflict = async (error: unknown): Promise<never> => {
    if (error instanceof ImageWorkspaceApiError
      && (error.code === 'conversation_revision_conflict'
        || error.code === 'workspace_revision_conflict')) {
      await get().refreshConversation().catch(() => null);
      throw new ImageWorkspaceApiError(
        409,
        error.code,
        '设计会话已更新，内容已刷新，请重新提交',
      );
    }
    throw error;
  };

  return {
    status: 'idle',
    bootstrap: null,
    activeWorkspaceId: null,
    activeConversationId: null,
    workspace: null,
    conversation: null,
    creatingConversation: false,
    deletingWorkspaceId: null,
    tasks: [],
    pendingTurn: null,
    loadingOlderMessages: false,
    olderMessagesError: null,
    taskStreamState: 'idle',
    error: null,

    load: () => {
      if (inFlightLoad) return inFlightLoad;
      set({ status: 'loading', error: null });
      inFlightLoad = (async () => {
        try {
          const bootstrap = await fetchImageWorkspace();
          const currentId = get().activeWorkspaceId;
          const activeWorkspaceId = bootstrap.workspaces.some(
            (workspace) => workspace.workspaceId === currentId,
          )
            ? currentId
            : bootstrap.workspaces[0]?.workspaceId ?? null;
          stopTaskStream();
          set({
            status: 'ready',
            bootstrap,
            activeWorkspaceId,
            activeConversationId: null,
            workspace: null,
            conversation: null,
            tasks: [],
            pendingTurn: null,
            taskStreamState: 'idle',
            error: null,
          });
          if (activeWorkspaceId) await loadWorkspace(activeWorkspaceId);
          return bootstrap;
        } catch (error) {
          const message = handleRequestError(error);
          if (!authenticationRequired(error)) {
            stopTaskStream();
            set({
              status: unavailable(error) ? 'unavailable' : 'error',
              bootstrap: null,
              activeWorkspaceId: null,
              activeConversationId: null,
              workspace: null,
              conversation: null,
              tasks: [],
              pendingTurn: null,
              taskStreamState: 'idle',
              error: message,
            });
          }
          return null;
        } finally {
          inFlightLoad = null;
        }
      })();
      return inFlightLoad;
    },

    createProject: async (title) => {
      try {
        const workspace = applyWorkspace(await createImageWorkspaceProject(title));
        const conversationId = workspace.conversations[0]?.conversationId ?? null;
        set({
          activeConversationId: conversationId,
          conversation: null,
          tasks: [],
          pendingTurn: null,
        });
        if (conversationId) {
          const selectionGeneration = ++conversationSelectionGeneration;
          const conversation = await fetchImageWorkspaceConversation(
            workspace.workspaceId,
            conversationId,
          );
          if (selectionGeneration === conversationSelectionGeneration
            && get().activeWorkspaceId === workspace.workspaceId
            && get().activeConversationId === conversationId) {
            applyConversation(conversation);
            startTaskStream(workspace.workspaceId, conversationId);
          }
        }
        return workspace;
      } catch (error) {
        set({ error: handleRequestError(error) });
        throw error;
      }
    },

    createConversation: async (title = '新会话') => {
      if (get().creatingConversation) {
        throw new Error('正在创建新会话，请稍候');
      }
      const workspaceId = get().activeWorkspaceId;
      if (!workspaceId) throw new Error('请先选择设计项目');
      set({ creatingConversation: true });
      try {
        const conversation = await createImageWorkspaceConversation(workspaceId, title);
        if (get().activeWorkspaceId !== workspaceId) return conversation;
        conversationSelectionGeneration += 1;
        stopTaskStream();
        set({
          activeConversationId: conversation.conversationId,
          conversation: null,
          pendingTurn: null,
          loadingOlderMessages: false,
          olderMessagesError: null,
          taskStreamState: 'idle',
          error: null,
        });
        applyConversation(conversation);
        startTaskStream(workspaceId, conversation.conversationId);
        void get().refreshWorkspace().catch(() => null);
        return conversation;
      } catch (error) {
        set({ error: handleRequestError(error) });
        throw error;
      } finally {
        set({ creatingConversation: false });
      }
    },

    renameProject: async (workspaceId, title) => {
      try {
        return applyWorkspace(await renameImageWorkspaceProject(workspaceId, title));
      } catch (error) {
        set({ error: handleRequestError(error) });
        throw error;
      }
    },

    deleteProject: async (workspaceId) => {
      const state = get();
      if (state.deletingWorkspaceId) {
        const error = new Error('正在删除设计项目，请稍候');
        set({ error: error.message });
        throw error;
      }
      const deletionGeneration = ++projectDeletionGeneration;
      const isCurrentDeletion = (): boolean => (
        deletionGeneration === projectDeletionGeneration
        && get().deletingWorkspaceId === workspaceId
      );
      set({ deletingWorkspaceId: workspaceId, error: null });
      try {
        const result = await deleteImageWorkspaceProject(workspaceId);
        if (!isCurrentDeletion()) return result;
        const current = get();
        const remainingWorkspaces = current.bootstrap?.workspaces.filter(
          (workspace) => workspace.workspaceId !== workspaceId,
        ) ?? [];
        const bootstrap = current.bootstrap
          ? { ...current.bootstrap, workspaces: remainingWorkspaces }
          : null;

        if (current.activeWorkspaceId !== workspaceId) {
          set({ bootstrap, error: null });
          return result;
        }

        workspaceLoadGeneration += 1;
        conversationSelectionGeneration += 1;
        reconcileTaskStateOnNextConnect = false;
        stopTaskStream();
        const nextWorkspaceId = mostRecentlyUpdatedWorkspace(remainingWorkspaces)?.workspaceId
          ?? null;
        set({
          status: 'ready',
          bootstrap,
          activeWorkspaceId: nextWorkspaceId,
          activeConversationId: null,
          workspace: null,
          conversation: null,
          creatingConversation: false,
          tasks: [],
          pendingTurn: null,
          taskStreamState: 'idle',
          error: null,
        });
        if (nextWorkspaceId) {
          try {
            await loadWorkspace(nextWorkspaceId);
          } catch (error) {
            if (get().activeWorkspaceId === nextWorkspaceId) {
              set({ error: handleRequestError(error) });
            }
          }
        }
        return result;
      } catch (error) {
        if (isCurrentDeletion()) set({ error: handleRequestError(error) });
        throw error;
      } finally {
        if (isCurrentDeletion()) set({ deletingWorkspaceId: null });
      }
    },

    selectProject: async (workspaceId) => {
      if (!get().bootstrap?.workspaces.some((item) => item.workspaceId === workspaceId)) return;
      stopTaskStream();
      set({
        activeWorkspaceId: workspaceId,
        activeConversationId: null,
        workspace: null,
        conversation: null,
        creatingConversation: false,
        tasks: [],
        pendingTurn: null,
        loadingOlderMessages: false,
        olderMessagesError: null,
        taskStreamState: 'idle',
        error: null,
      });
      const loadPromise = loadWorkspace(workspaceId);
      const loadGeneration = workspaceLoadGeneration;
      try {
        await loadPromise;
      } catch (error) {
        if (loadGeneration === workspaceLoadGeneration
          && get().activeWorkspaceId === workspaceId) {
          set({ error: handleRequestError(error) });
        }
      }
    },

    selectConversation: async (conversationId) => {
      const state = get();
      const workspaceId = state.activeWorkspaceId;
      if (!workspaceId
        || !state.workspace?.conversations.some(
          (item) => item.conversationId === conversationId,
        )) return;
      const selectionGeneration = ++conversationSelectionGeneration;
      stopTaskStream();
      set({
        activeConversationId: conversationId,
        conversation: null,
        pendingTurn: null,
        loadingOlderMessages: false,
        olderMessagesError: null,
        taskStreamState: 'idle',
        error: null,
      });
      try {
        const conversation = await fetchImageWorkspaceConversation(workspaceId, conversationId);
        if (selectionGeneration !== conversationSelectionGeneration
          || get().activeWorkspaceId !== workspaceId
          || get().activeConversationId !== conversationId) return;
        applyConversation(conversation);
        startTaskStream(workspaceId, conversationId);
      } catch (error) {
        if (selectionGeneration === conversationSelectionGeneration
          && get().activeWorkspaceId === workspaceId
          && get().activeConversationId === conversationId) {
          set({ error: handleRequestError(error) });
        }
      }
    },

    refreshWorkspace: async () => {
      const workspaceId = get().activeWorkspaceId;
      if (!workspaceId) return null;
      try {
        const refreshed = await fetchImageWorkspaceProject(workspaceId);
        if (get().activeWorkspaceId !== workspaceId) return null;
        const current = get().workspace;
        if (current?.workspaceId === workspaceId
          && current.viewRevision > refreshed.viewRevision) {
          return current;
        }
        return applyWorkspace(refreshed);
      } catch (error) {
        set({ error: handleRequestError(error) });
        throw error;
      }
    },

    refreshConversation: async () => {
      const workspaceId = get().activeWorkspaceId;
      const conversationId = get().activeConversationId;
      if (!workspaceId || !conversationId) return null;
      try {
        const refreshed = await fetchImageWorkspaceConversation(workspaceId, conversationId);
        if (get().activeWorkspaceId !== workspaceId
          || get().activeConversationId !== conversationId) return null;
        const current = get().conversation;
        if (current?.conversationId === conversationId
          && current.turnRevision > refreshed.turnRevision) {
          return current;
        }
        return applyConversation(refreshed);
      } catch (error) {
        set({ error: handleRequestError(error) });
        throw error;
      }
    },

    loadOlderMessages: async () => {
      const workspaceId = get().activeWorkspaceId;
      const conversation = get().conversation;
      const before = conversation?.messagePage?.nextBefore;
      if (!workspaceId || !conversation || !conversation.messagePage?.hasOlder || !before) {
        return conversation ?? null;
      }
      const conversationId = conversation.conversationId;
      const selectionGeneration = conversationSelectionGeneration;
      set({ loadingOlderMessages: true, olderMessagesError: null });
      try {
        const older = await fetchImageWorkspaceConversation(workspaceId, conversationId, before);
        if (selectionGeneration !== conversationSelectionGeneration
          || get().activeWorkspaceId !== workspaceId
          || get().activeConversationId !== conversationId) return null;
        return applyConversation(older, 'older');
      } catch (error) {
        if (selectionGeneration === conversationSelectionGeneration
          && get().activeWorkspaceId === workspaceId
          && get().activeConversationId === conversationId) {
          set({
            loadingOlderMessages: false,
            olderMessagesError: handleRequestError(error),
          });
        }
        return null;
      }
    },

    refreshTasks: async () => {
      const workspaceId = get().activeWorkspaceId;
      if (!workspaceId) {
        set({ tasks: [] });
        return [];
      }
      try {
        return await refreshWorkspaceTasks(workspaceId);
      } catch (error) {
        set({ error: handleRequestError(error) });
        throw error;
      }
    },

    connectTaskStream: () => {
      const workspaceId = get().activeWorkspaceId;
      const conversationId = get().activeConversationId;
      const shouldReconcile = reconcileTaskStateOnNextConnect;
      reconcileTaskStateOnNextConnect = false;
      if (shouldReconcile && get().taskStreamState === 'degraded') {
        closeTaskEventSource();
      }
      if (workspaceId && conversationId) startTaskStream(workspaceId, conversationId);
      if (!workspaceId || !conversationId || !shouldReconcile) return;
      void Promise.all([
        get().refreshConversation(),
        get().refreshTasks(),
      ]).catch(() => undefined);
    },

    markTaskStreamNeedsReconciliation: () => {
      reconcileTaskStateOnNextConnect = true;
    },

    disconnectTaskStream: stopTaskStream,

    sendMessage: async (message, attachmentAssetIds = []) => {
      const workspace = get().workspace;
      const conversation = get().conversation;
      const userText = message.trim();
      const clientTurnId = createImageWorkspaceTurnId();
      if (!workspace || !conversation) throw new Error('请先选择设计会话');
      const leaseId = `canvas:${workspace.workspaceId}:${clientTurnId}`;
      updateBackgroundLease({ id: leaseId, kind: 'canvas-generation', active: true });
      try {
        set({
          pendingTurn: createPendingTurn(conversation, clientTurnId, userText),
          error: null,
        });
        const updated = attachmentAssetIds.length > 0
          ? await sendImageWorkspaceMessage(
              workspace.workspaceId,
              conversation.conversationId,
              conversation.turnRevision,
              userText,
              clientTurnId,
              attachmentAssetIds,
            )
          : await sendImageWorkspaceMessage(
              workspace.workspaceId,
              conversation.conversationId,
              conversation.turnRevision,
              userText,
              clientTurnId,
            );
        if (get().activeWorkspaceId === workspace.workspaceId
          && get().activeConversationId === conversation.conversationId) {
          applyConversation(updated);
          await get().refreshTasks().catch(() => []);
        }
        return updated;
      } catch (error) {
        if (get().activeWorkspaceId !== workspace.workspaceId
          || get().activeConversationId !== conversation.conversationId) throw error;
        const errorMessage = handleRequestError(error);
        set((state) => ({
          error: errorMessage,
          pendingTurn: state.pendingTurn?.clientTurnId === clientTurnId
            ? null
            : state.pendingTurn,
        }));
        return await recoverRevisionConflict(error);
      } finally {
        updateBackgroundLease({ id: leaseId, kind: 'canvas-generation', active: false });
      }
    },

    updateGenerationQuote: async (quoteId, finalPrompt, generationParameters) => {
      const workspace = get().workspace;
      const conversation = get().conversation;
      if (!workspace || !conversation) throw new Error('请先选择设计会话');
      const updateSequence = ++generationQuoteUpdateSequence;
      const requestedWorkspaceId = workspace.workspaceId;
      const requestedConversationId = conversation.conversationId;
      try {
        const updatedQuote = await updateImageWorkspaceGenerationQuote(
          requestedWorkspaceId,
          quoteId,
          finalPrompt,
          generationParameters,
        );
        if (updateSequence !== generationQuoteUpdateSequence) return updatedQuote;
        if (get().activeWorkspaceId !== requestedWorkspaceId
          || get().activeConversationId !== requestedConversationId) {
          return updatedQuote;
        }
        set((state) => {
          if (!state.conversation
            || state.conversation.conversationId !== requestedConversationId) return state;
          const conversationWithQuote = replaceGenerationQuote(
            state.conversation,
            quoteId,
            updatedQuote,
          );
          if (conversationWithQuote === state.conversation) return state;
          const workspaceWithQuote = upsertConversation(
            state.workspace,
            conversationWithQuote,
          );
          return {
            conversation: conversationWithQuote,
            workspace: workspaceWithQuote,
            bootstrap: workspaceWithQuote
              ? upsertSummary(state.bootstrap, workspaceWithQuote)
              : state.bootstrap,
            error: null,
          };
        });
        return updatedQuote;
      } catch (error) {
        if (updateSequence === generationQuoteUpdateSequence
          && get().activeWorkspaceId === requestedWorkspaceId
          && get().activeConversationId === requestedConversationId) {
          set({ error: handleRequestError(error) });
        }
        throw error;
      }
    },

    confirmGeneration: async (quoteId, finalPrompt, generationParameters) => {
      const workspace = get().workspace;
      const conversation = get().conversation;
      if (!workspace || !conversation) throw new Error('请先选择设计会话');
      const clientTurnId = createImageWorkspaceTurnId();
      const leaseId = `canvas:${workspace.workspaceId}:${clientTurnId}`;
      updateBackgroundLease({ id: leaseId, kind: 'canvas-generation', active: true });
      const requestWorkspaceLoadGeneration = workspaceLoadGeneration;
      const requestConversationSelectionGeneration = conversationSelectionGeneration;
      const isActiveConfirmationWorkspace = (): boolean => (
        get().activeWorkspaceId === workspace.workspaceId
      );
      const isCurrentConfirmationConversation = (): boolean => (
        isActiveConfirmationWorkspace()
        && requestWorkspaceLoadGeneration === workspaceLoadGeneration
        && requestConversationSelectionGeneration === conversationSelectionGeneration
        && get().activeConversationId === conversation.conversationId
      );
      try {
        set({
          pendingTurn: createPendingTurn(conversation, clientTurnId, '确认生成'),
          error: null,
        });
        const updated = finalPrompt === undefined || generationParameters === undefined
          ? await confirmImageWorkspaceGeneration(
              workspace.workspaceId,
              conversation.conversationId,
              conversation.turnRevision,
              quoteId,
              clientTurnId,
            )
          : await confirmImageWorkspaceGeneration(
              workspace.workspaceId,
              conversation.conversationId,
              conversation.turnRevision,
              quoteId,
              clientTurnId,
              finalPrompt,
              generationParameters,
            );
        if (isCurrentConfirmationConversation()) applyConversation(updated);
        if (!isActiveConfirmationWorkspace()) return updated;
        let confirmedTaskVisible = get().tasks.some((task) => task.quoteId === quoteId);
        for (
          let attempt = 0;
          !confirmedTaskVisible && attempt < CONFIRMED_TASK_RECONCILE_ATTEMPTS;
          attempt += 1
        ) {
          if (!isActiveConfirmationWorkspace()) return updated;
          const refreshed = await refreshWorkspaceTasks(workspace.workspaceId);
          if (!isActiveConfirmationWorkspace()) return updated;
          confirmedTaskVisible = refreshed.some((task) => task.quoteId === quoteId)
            || get().tasks.some((task) => task.quoteId === quoteId);
          if (!confirmedTaskVisible && attempt + 1 < CONFIRMED_TASK_RECONCILE_ATTEMPTS) {
            await new Promise<void>((resolve) => {
              setTimeout(resolve, CONFIRMED_TASK_RECONCILE_INTERVAL_MS);
            });
          }
        }
        if (!confirmedTaskVisible) {
          throw new ImageWorkspaceApiError(
            502,
            'generation_task_not_visible',
            '生成已确认，但任务列表同步超时。请刷新项目查看，不要重复确认。',
          );
        }
        return updated;
      } catch (error) {
        if (!isActiveConfirmationWorkspace()) throw error;
        const taskVisibilityAlreadyReconciled = error instanceof ImageWorkspaceApiError
          && error.code === 'generation_task_not_visible';
        let confirmedTaskVisible = get().tasks.some((task) => task.quoteId === quoteId);
        if (!taskVisibilityAlreadyReconciled && !confirmedTaskVisible) {
          const refreshed = await refreshWorkspaceTasks(workspace.workspaceId).catch(() => []);
          if (!isActiveConfirmationWorkspace()) throw error;
          confirmedTaskVisible = refreshed.some((task) => task.quoteId === quoteId)
            || get().tasks.some((task) => task.quoteId === quoteId);
        }
        if (confirmedTaskVisible) {
          if (!isCurrentConfirmationConversation()) return conversation;
          const refreshedConversation = await fetchImageWorkspaceConversation(
            workspace.workspaceId,
            conversation.conversationId,
          ).catch(() => null);
          if (!isCurrentConfirmationConversation()) return conversation;
          const recoveredConversation = refreshedConversation
            ? applyConversation(refreshedConversation)
            : get().conversation;
          if (recoveredConversation?.conversationId === conversation.conversationId) {
            set((state) => ({
              error: null,
              pendingTurn: state.pendingTurn?.clientTurnId === clientTurnId
                ? null
                : state.pendingTurn,
            }));
            return recoveredConversation;
          }
        }
        if (!isCurrentConfirmationConversation()) throw error;
        const errorMessage = handleRequestError(error);
        set((state) => ({
          error: errorMessage,
          pendingTurn: state.pendingTurn?.clientTurnId === clientTurnId
            ? null
            : state.pendingTurn,
        }));
        return await recoverRevisionConflict(error);
      } finally {
        updateBackgroundLease({ id: leaseId, kind: 'canvas-generation', active: false });
      }
    },

    reset: () => {
      inFlightLoad = null;
      workspaceLoadGeneration += 1;
      conversationSelectionGeneration += 1;
      projectDeletionGeneration += 1;
      generationQuoteUpdateSequence += 1;
      reconcileTaskStateOnNextConnect = false;
      stopTaskStream();
      pendingTaskEventConnections.clear();
      set({
        status: 'idle',
        bootstrap: null,
        activeWorkspaceId: null,
        activeConversationId: null,
        workspace: null,
        conversation: null,
        creatingConversation: false,
        deletingWorkspaceId: null,
        tasks: [],
        pendingTurn: null,
        loadingOlderMessages: false,
        olderMessagesError: null,
        taskStreamState: 'idle',
        error: null,
      });
    },
  };
});