/**
 * Event dispatch strategy used by the event service.
 *
 * `emit` runs synchronous listeners without awaiting them, `parallel` awaits
 * all listeners together, `serial` awaits them in order until one bails,
 * `bail` stops on the first synchronous bail value, and `waterfall` composes
 * listeners around a final `next` callback.
 */
export type DispatchMode = 'emit' | 'parallel' | 'serial' | 'bail' | 'waterfall'

declare module './context.ts' {
  export interface Context {
    /** 同步广播，忽略返回值 */
    emit(name: K, ...args: Parameters): void
    /** 并发等待所有 listener */
    parallel(name: K, ...args: Parameters): Promise
    /** 串行等待，首个 bail 值终止 */
    serial(name: K, ...args: Parameters): Promisify<ReturnType>
    /** 同步 bail */
    bail(name: K, ...args: Parameters): ReturnType
    /** 中间件链，next() 传递 */
    waterfall(name: K, ...args: Parameters): ReturnType
    /** 注册 listener，fiber 卸载时自动移除 */
    on(name: K, listener: Events[K], options?: boolean | EventOptions): () => boolean
    /** 一次性 listener */
    once(name: K, listener: Events[K], options?: boolean | EventOptions): () => boolean
  }
}

register(label: string, hooks: Hook[], callback: any, options: EventOptions): () => void {
  const method = options.prepend ? 'unshift' : 'push'
  return this.ctx.fiber.effect(() => {
    hooks[method]({ ctx: this.ctx, callback, ...options })
    return () => this.unregister(hooks, callback)
  }, label)
}

declare module '@deepseek-ai/cordis' {
  interface Events {
    /**
     * 创建公告：session 发布时触发。同步抛出可 veto 并回滚；
     * detach 请求在 dispatch 期间被延迟。
     * @mode emit
     */
    'session/created'(this: Scoped<Session>, session: Session): void

    /**
     * 销毁通知：session 离开 store 时触发一次，包括发布回滚。
     * @mode emit
     */
    'session/disposed'(this: Scoped<Session>, session: Session): void

    /**
     * 追加 feed：post-commit 的 fire-and-forget 通知。
     * listener 在事件 commit 后运行，失败被隔离。
     * @mode emit
     */
    'session/event'(this: Scoped<Session>, session: Session, event: SessionEvent): void

    /**
     * 持久化检查点：所有 listener 并行运行，调用者等待全部完成。
     * @mode parallel
     */
    'session/flush'(this: Scoped<Session>, session: Session): Promise<void> | void
  }
}

export const KNOWN_SESSION_EVENT_TYPES: ReadonlySet<string> = new Set([
  'agent-preset/selected',
  'agent/inbox/spliced',
  'approval/asked',
  'approval/decided',
  'approval/policy',
  'assistant/chunk',
  'assistant/message',
  'command/done',
  'command/run',
  'compaction/end',
  'compaction/prune',
  'compaction/start',
  'compaction/summary',
  'feedback/record',
  'goal/change',
  'hook/invoked',
  'hook/result',
  'llm/retry',
  'llm/retry-started',
  'permission/preset',
  'plan/mode',
  'request/context',
  'request/header',
  'sandbox/mode',
  'schedule/change',
  'session/end-seed',
  'session/title',
  'session/title-llm-request',
  'step/end',
  'step/start',
  'subagent/descriptor',
  'todo/write',
  'tool-workflow/agent-end',
  'tool-workflow/agent-start',
  'tool-workflow/run-end',
  'tool-workflow/run-start',
  'tool/call',
  'tool/code-dispatch',
  'tool/code-dispatch-start',
  'tool/result',
  'turn/end',
  'turn/start',
  'user/message',
  'web/deepseek-search-llm-request',
])

append(
  type: T,
  data: SessionEventMap[T],
  ...opts: T extends SurfaceEventType ? [opts: SurfaceIntent] : []
): SessionEvent {
  // 1. JSON 序列化验证 — 非 JSON 安全数据直接拒绝
  const dataSnapshot = snapshotJsonValue(data)
  if (dataSnapshot === undefined) {
    throw new Error(`session event "${type}" carries non-JSON-serializable data`)
  }
  // 2. Surface 元数据验证
  const surfaceMetadataSnapshot = snapshotJsonValue(surfaceMetadata)
  // 3. 构建不可变事件对象
  const event = deepFreeze({
    type,
    seq: this.log.length,
    time: Date.now(),
    data: dataSnapshot,
    ...(surfaceMetadataSnapshot as { surfaceOp?: unknown; sourceEventSeqs?: unknown }),
  } as unknown as SessionEvent)
  // 4. Surface 状态机验证
  this.surfaceManager.validateNext(event as SessionEvent)
  // 5. 推入日志，通知 observer
  this.log.push(event as SessionEvent)
  this.eventsSnapshot = undefined
  if (callbacks !== undefined && entry !== undefined) {
    invokeContainedSessionObservers(entry.emitCtx, 'session/event', entry.id, callbackArgs, callbacks)
  }
  return event
}

/** 只有这三种事件类型产生 LLM 消息，可出现在 ordered surface 上 */
export type SurfaceEventType =
  | 'user/message'
  | 'assistant/message'
  | 'tool/result'

/** Surface 操作：append 追加到尾部，replace 替换一段 */
export type SurfaceOp =
  | 'append'
  | { op: 'replace'; start: number; end: number }

deriveMessages(): Message[] {
  const surface = this.surface
  const nodes = surface.nodes
  const generation = surface.replaceGeneration
  if (generation !== this.derivedGeneration) {
    // replace 操作后重建缓存
    this.derived = []
    this.derivedNodes = 0
    this.derivedGeneration = generation
  }
  for (const seq of nodes.slice(this.derivedNodes)) {
    // 每个 surface 节点只投影一次
    const msg = this.deriveEventMessage(this.log[seq]!)
    if (msg) this.derived.push(msg)
  }
  this.derivedNodes = nodes.length
  return [...this.derived]
}

/** Turn 结束原因，merge-extensible 类型 */
export interface TurnEndReasonMap {
  completed: { kind: 'completed' }
  aborted: { kind: 'aborted'; reason: TurnEndCancelCause }
  blocked: { kind: 'blocked' }
  error: { kind: 'error'; error: LlmFailure }
  'max-tokens': { kind: 'max-tokens' }
  interrupted: { kind: 'interrupted' }
}

/** 取消原因 */
export type AgentCancelCause =
  | { readonly kind: 'user' }
  | { readonly kind: 'parent' }
  | { readonly kind: 'hook'; readonly reason: string }
  | { readonly kind: 'disposed' }

export type MuxFrame =
  | { type: 'session/event'; sessionId: SessionId; event: SessionEvent; view?: ToolEventView }
  | { type: 'session/subscribed'; sessionId: SessionId; lastSeq: number }
  | { type: 'approval/requested'; sessionId: SessionId; approvalId: ApprovalRequestId; toolName: string; ... }
  | { type: 'approval/resolved'; sessionId: SessionId; approvalId: ApprovalRequestId; outcome: ApprovalOutcome }
  | { type: 'question/requested'; sessionId: SessionId; questions: AskUserQuestionItem[] }
  | { type: 'question/resolved'; sessionId: SessionId; questionRpcId: RpcId; outcome: 'answered' | 'cancelled' }
  | { type: 'session/queue'; sessionId: SessionId; items: QueuedInboxItem[] }
  | { type: 'session/jobs'; sessionId: SessionId; jobs: JobView[] }
  | { type: 'session/projection'; sessionId: SessionId; key: string; value: unknown; seq: number }
  | { type: 'stream/error'; error: RpcError }

export type HostFrame =
  | { type: 'host/session-added'; sessionId: SessionId; blank: boolean; parentSessionId?: SessionId; origin?: 'subagent'; cwd?: string; agentPreset?: string }
  | { type: 'host/session-removed'; sessionId: SessionId }
  | { type: 'host/session-status'; sessionId: SessionId; running: boolean }
  | { type: 'host/agent-error'; sessionId: SessionId; message: string }
  | { type: 'host/workspace-changed'; workspace: WorkspaceView }
  | { type: 'host/workspace-removed'; workspaceId: WorkspaceView['workspaceId'] }
  | { type: 'host/workspace-order-changed'; workspaceIds: WorkspaceView['workspaceId'][] }
  | { type: 'host/archived-sessions-changed'; archivedSessionIds: SessionId[] }
  | { type: 'host/remote-event'; event: string; args: JsonValue[] }
  | { type: 'stream/error'; error: RpcError }

/**
 * 磁盘格式版本，写入每个 SessionHeader。
 * 当前为 0（未发布状态），无兼容性保证。
 *
 * 版本判断标准：WRITER 发出的变化，而非 READER 能接受的。
 * 只有结构性变化才 bump：header shape、event envelope、
 * core event semantics、surface mechanism。
 * 新增普通 event type 不 bump — 用 SessionEvent.ignorable 保护。
 */
export const SESSION_FORMAT_VERSION = 0