import assert from 'node:assert/strict'
import { testTerminalHostPlugin } from './test-terminal-host-plugin'
import { createServer } from 'node:http'
import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { pathToFileURL } from 'node:url'
import { build } from 'esbuild'
import type { ChatMessage, ToolCallRecord } from '../src/shared/types'

interface TimelineEntry {
  kind: 'branch' | 'prompt'
  sessionId: string
  entryId?: string
  text?: string
}

interface TestState {
  userData: string
  home: string
  handlers: Map<string, (...args: unknown[]) => unknown>
  dialogPaths: string[]
  nativeMessages: Map<string, Array<{ entryId: string; text: string }>>
  failBranchIds: Set<string>
  timeline: TimelineEntry[]
  pendingPrompts: Array<{ sessionId: string; complete: () => void }>
  holdSessions: Set<string>
  activePrompts: number
  maxActivePrompts: number
  nextNativeId: number
  speechStatus: number
  speechRequests: Array<{ path: string; authorization: string | undefined; contentType: string | undefined; body: string }>
  events: unknown[]
}

interface TestBundle {
  registerIpc(getWindow: () => unknown): void
  disposeOmpKernels(): Promise<void>
  sessions: {
    appendMessage(sessionId: string, message: ChatMessage): Promise<void>
    getMessages(sessionId: string): Promise<ChatMessage[]>
    getPendingNativeBranch(sessionId: string): Promise<string | undefined>
    setPendingNativeBranch(sessionId: string, entryId: string | undefined): Promise<void>
  }
  attachments: {
    getAttachment(id: string): Promise<{ path?: string; name: string }>
  }
}

const TEST_STATE_KEY = '__YCODE_CONVERSATION_IPC_REGRESSION__'

function wait(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms))
}

async function waitUntil(predicate: () => boolean | Promise<boolean>, message: string): Promise<void> {
  for (let attempt = 0; attempt < 250; attempt++) {
    if (await predicate()) return
    await wait(10)
  }
  assert.fail(`Timed out: ${message}`)
}

async function waitForAssistant(
  invoke: (channel: string, ...args: unknown[]) => Promise<unknown>,
  sessionId: string,
  predicate: (message: ChatMessage) => boolean = (message) => message.status === 'done'
): Promise<ChatMessage[]> {
  for (let attempt = 0; attempt < 250; attempt++) {
    const messages = await invoke('session:messages', sessionId) as ChatMessage[]
    const last = messages.findLast((message) => message.role === 'assistant')
    if (last && predicate(last)) return messages
    await wait(10)
  }
  const messages = await invoke('session:messages', sessionId) as ChatMessage[]
  assert.fail(`Timed out waiting for assistant state: ${JSON.stringify(messages.at(-1))}`)
}

function assistant(messages: ChatMessage[]): ChatMessage {
  const found = messages.findLast((message) => message.role === 'assistant')
  assert.ok(found, 'expected an assistant message')
  return found
}

function invokeFor(state: TestState) {
  return (channel: string, ...args: unknown[]): Promise<unknown> => {
    const handler = state.handlers.get(channel)
    if (!handler) throw new Error(`Missing IPC handler: ${channel}`)
    return Promise.resolve().then(() => handler({}, ...args))
  }
}

function message(id: string, role: 'user' | 'assistant', content: string, extras: Partial<ChatMessage> = {}): ChatMessage {
  return { id, role, content, createdAt: Date.now(), status: 'done', ...extras }
}

function seedNativeHistory(state: TestState, sessionId: string, entries: Array<[string, string]>): void {
  state.nativeMessages.set(sessionId, entries.map(([entryId, text]) => ({ entryId, text })))
}

function nativePath(userData: string, sessionId: string): string {
  return join(userData, 'omp-sessions', `session-${encodeURIComponent(sessionId)}.jsonl`)
}

async function buildBundle(tempRoot: string, state: TestState, name: string): Promise<TestBundle> {
  const ipcEntry = join(process.cwd(), 'src', 'main', 'ipc.ts')
  const sessionsEntry = join(process.cwd(), 'src', 'main', 'sessions.ts')
  const attachmentsEntry = join(process.cwd(), 'src', 'main', 'attachments.ts')
  const outfile = join(tempRoot, `${name}.mjs`)
  const stateKey = JSON.stringify(TEST_STATE_KEY)
  await build({
    stdin: {
      contents: [
        `export { registerIpc, disposeOmpKernels } from ${JSON.stringify(ipcEntry)};`,
        `export * as sessions from ${JSON.stringify(sessionsEntry)};`,
        `export * as attachments from ${JSON.stringify(attachmentsEntry)};`
      ].join('\n'),
      resolveDir: process.cwd(),
      sourcefile: `${name}.ts`,
      loader: 'ts'
    },
    outfile,
    bundle: true,
    external: ['node-pty'],
    platform: 'node',
    format: 'esm',
    banner: { js: `import { createRequire as createTestRequire } from 'node:module'; const require = createTestRequire(import.meta.url);` },
    logLevel: 'silent',
    plugins: [
      testTerminalHostPlugin,
      {
        name: 'conversation-ipc-electron-and-omp-mocks',
        setup(pluginBuild) {
          pluginBuild.onResolve({ filter: /^electron$/ }, () => ({ path: 'electron', namespace: 'mock-electron' }))
          pluginBuild.onLoad({ filter: /.*/, namespace: 'mock-electron' }, () => ({
            loader: 'js',
            contents: `
              const state = globalThis[${stateKey}];
              export const app = {
                getPath: (name) => name === 'userData' ? state.userData : name === 'home' ? state.home : state.userData,
                getName: () => 'YCode', getVersion: () => '0.1.0'
              };
              export const safeStorage = {
                isEncryptionAvailable: () => false,
                encryptString: (value) => Buffer.from(value),
                decryptString: (value) => value.toString()
              };
              export const ipcMain = { handle: (name, handler) => state.handlers.set(name, handler) };
              export const dialog = {
                showOpenDialog: async (...args) => ({ canceled: false, filePaths: state.dialogPaths.splice(0) }),
                showSaveDialog: async () => ({ canceled: true, filePath: undefined })
              };
              export const shell = { openPath: async () => '' };
              export class BrowserWindow {}
              export class WebContentsView {}
            `
          }))
          pluginBuild.onResolve({ filter: /^\.\/omp$/ }, () => ({ path: 'omp', namespace: 'mock-omp' }))
          pluginBuild.onLoad({ filter: /.*/, namespace: 'mock-omp' }, () => ({
            loader: 'js',
            contents: `
              import { EventEmitter } from 'node:events';
              import { basename } from 'node:path';
              const state = globalThis[${stateKey}];
              export class OmpKernel extends EventEmitter {
                constructor(_exe, _workspace, _profile, sessionPath) {
                  super();
                  this.sessionId = decodeURIComponent(basename(sessionPath).replace(/^session-/, '').replace(/\\.jsonl$/, ''));
                  if (!state.nativeMessages.has(this.sessionId)) state.nativeMessages.set(this.sessionId, []);
                }
                setHostTools() { return Promise.resolve({ type: 'response', success: true, data: { toolNames: [] } }); }
                send(command) {
                  if (command.type === 'get_branch_messages') {
                    return Promise.resolve({ type: 'response', success: true, data: { messages: [...(state.nativeMessages.get(this.sessionId) || [])] } });
                  }
                  if (command.type === 'branch') {
                    const entryId = String(command.entryId || '');
                    state.timeline.push({ kind: 'branch', sessionId: this.sessionId, entryId });
                    if (state.failBranchIds.has(entryId)) return Promise.resolve({ type: 'response', success: false, error: 'mock branch failure' });
                    const entries = state.nativeMessages.get(this.sessionId) || [];
                    const index = entries.findIndex((entry) => entry.entryId === entryId);
                    if (index < 0) return Promise.resolve({ type: 'response', success: false, error: 'Invalid entry ID for branching' });
                    state.nativeMessages.set(this.sessionId, entries.slice(0, index));
                  }
                  return Promise.resolve({ type: 'response', success: true, data: {} });
                }
                branch(entryId) { return this.send({ type: 'branch', entryId }); }
                prompt(text) {
                  state.timeline.push({ kind: 'prompt', sessionId: this.sessionId, text });
                  const entryId = 'native-prompt-' + (++state.nextNativeId);
                  const entries = state.nativeMessages.get(this.sessionId) || [];
                  entries.push({ entryId, text });
                  state.nativeMessages.set(this.sessionId, entries);
                  state.activePrompts++;
                  state.maxActivePrompts = Math.max(state.maxActivePrompts, state.activePrompts);
                  const complete = () => {
                    state.activePrompts--;
                    this.emit('event', { type: 'message_update', assistantMessageEvent: { type: 'text_delta', delta: 'reply:' + text } });
                    this.emit('event', { type: 'agent_end', yielded: true });
                  };
                  if (state.holdSessions.has(this.sessionId)) state.pendingPrompts.push({ sessionId: this.sessionId, complete });
                  else setImmediate(complete);
                  return Promise.resolve({ type: 'response', success: true });
                }
                abort() {
                  setImmediate(() => this.emit('event', { type: 'prompt_result', status: 'aborted' }));
                  return Promise.resolve({ type: 'response', success: true });
                }
                respondToHostTool() { return Promise.resolve(); }
                dispose() { return Promise.resolve(); }
              }
              export const detectOmpPath = () => 'mock-omp';
              export const getOmpInfo = () => ({ available: true, exePath: 'mock-omp', profile: 'ycode', model: 'ycode/test' });
            `
          }))
          pluginBuild.onResolve({ filter: /^\.\/agent\/loop$/ }, () => ({ path: 'agent-loop', namespace: 'mock-agent-loop' }))
          pluginBuild.onLoad({ filter: /.*/, namespace: 'mock-agent-loop' }, () => ({
            loader: 'js',
            contents: `export async function runTurn() { throw new Error('unexpected non-OMP fallback'); }`
          }))
          pluginBuild.onResolve({ filter: /^\.\/gateway$/ }, () => ({ path: 'gateway', namespace: 'mock-gateway' }))
          pluginBuild.onLoad({ filter: /.*/, namespace: 'mock-gateway' }, () => ({
            loader: 'js', contents: 'export class Gateway { constructor() {} }'
          }))
        }
      }
    ]
  })
  return await import(pathToFileURL(outfile).href) as TestBundle
}

function register(bundle: TestBundle, state: TestState): (channel: string, ...args: unknown[]) => Promise<unknown> {
  state.handlers.clear()
  bundle.registerIpc(() => ({
    isDestroyed: () => false,
    webContents: { isDestroyed: () => false, send: (_channel: string, event: unknown) => state.events.push(event) }
  }))
  return invokeFor(state)
}

async function testConcurrency(bundle: TestBundle, state: TestState, invoke: ReturnType<typeof invokeFor>): Promise<void> {
  const first = await invoke('session:create', 'concurrent one') as { id: string }
  const second = await invoke('session:create', 'concurrent two') as { id: string }
  state.holdSessions.add(first.id)
  state.holdSessions.add(second.id)

  const firstSend = await invoke('chat:send', { sessionId: first.id, text: 'concurrent-first' }) as {
    modelId?: string
    modelName?: string
  }
  await assert.rejects(invoke('chat:send', { sessionId: first.id, text: 'must-not-append' }), /正在运行/)
  await invoke('chat:send', { sessionId: second.id, text: 'concurrent-second' })

  await waitUntil(() => state.pendingPrompts.filter((item) => item.sessionId === first.id || item.sessionId === second.id).length === 2,
    'both sessions should reach OMP concurrently')
  const firstMessages = await invoke('session:messages', first.id) as ChatMessage[]
  assert.equal(firstSend.modelId, assistant(firstMessages).modelId,
    'chat:send returns the frozen model ID used by the persisted assistant message')
  assert.equal(firstSend.modelName, assistant(firstMessages).modelName,
    'chat:send returns the frozen model name used by the persisted assistant message')
  assert.deepEqual(firstMessages.filter((item) => item.role === 'user').map((item) => item.content), ['concurrent-first'],
    'a duplicate same-session send must not append a second user message')
  assert.ok(state.maxActivePrompts >= 2, 'different sessions should be able to run in parallel')

  const held = state.pendingPrompts.splice(0)
  state.holdSessions.clear()
  held.forEach((item) => item.complete())
  const doneFirst = await waitForAssistant(invoke, first.id)
  const doneSecond = await waitForAssistant(invoke, second.id)
  assert.equal(assistant(doneFirst).status, 'done')
  assert.equal(assistant(doneSecond).status, 'done')
  const metadata = (await invoke('session:list')) as Array<{ id: string; title: string }>
  assert.equal(metadata.find((item) => item.id === first.id)?.title, 'concurrent-first', 'first send should set its title')
}

async function seedActionHistory(
  bundle: TestBundle,
  state: TestState,
  action: 'edit' | 'resend' | 'regenerate'
): Promise<{ sessionId: string; targetUserId: string; targetAssistantId: string }> {
  const invoke = invokeFor(state)
  const session = await invoke('session:create', `action-${action}`) as { id: string }
  const targetUserId = `${action}-user-target`
  const targetAssistantId = `${action}-assistant-target`
  const history = [
    message(`${action}-user-before`, 'user', 'first prompt', { nativeEntryId: `${action}-native-before` }),
    message(`${action}-assistant-before`, 'assistant', 'first reply'),
    message(targetUserId, 'user', 'old prompt', { nativeEntryId: `${action}-native-target` }),
    message(targetAssistantId, 'assistant', 'old reply')
  ]
  for (const item of history) await bundle.sessions.appendMessage(session.id, item)
  seedNativeHistory(state, session.id, [
    [`${action}-native-before`, 'first prompt'],
    [`${action}-native-target`, 'old prompt']
  ])
  return { sessionId: session.id, targetUserId, targetAssistantId }
}

async function testActionBranch(
  bundle: TestBundle,
  state: TestState,
  action: 'edit' | 'resend' | 'regenerate'
): Promise<void> {
  const invoke = invokeFor(state)
  const seeded = await seedActionHistory(bundle, state, action)
  const timelineStart = state.timeline.length
  const fromMessageId = action === 'regenerate' ? seeded.targetAssistantId : seeded.targetUserId
  await invoke('chat:send', {
    sessionId: seeded.sessionId,
    text: `${action}-replacement`,
    action,
    fromMessageId
  })
  const messages = await waitForAssistant(invoke, seeded.sessionId)
  const activity = state.timeline.slice(timelineStart).filter((item) => item.sessionId === seeded.sessionId)
  const branchIndex = activity.findIndex((item) => item.kind === 'branch' && item.entryId === `${action}-native-target`)
  const promptIndex = activity.findIndex((item) => item.kind === 'prompt' && item.text?.split(/\r?\n/, 1)[0] === `${action}-replacement`)
  assert.ok(branchIndex >= 0 && promptIndex > branchIndex, `${action} must branch by native entryId before prompting`)
  assert.equal(activity[promptIndex].text, [`${action}-replacement`, messages[2].capabilityContext].filter(Boolean).join('\n\n'),
    'native prompt must include the exact persisted turn context without changing the user text')
  assert.match(activity[promptIndex].text ?? '', /<ycode-agent-mode mode="craft">/, 'native prompt declares the frozen craft mode')
  assert.equal(messages.length, 4, `${action} should keep the old prefix and replace the selected suffix`)
  assert.deepEqual(messages.slice(0, 2).map((item) => item.content), ['first prompt', 'first reply'])
  assert.equal(messages[2].content, `${action}-replacement`)
  assert.ok(messages[2].nativeEntryId?.startsWith('native-prompt-'), 'new user message should receive the returned native entryId')
  assert.equal(await bundle.sessions.getPendingNativeBranch(seeded.sessionId), undefined,
    'successful native entry lookup should clear the pending branch marker')

  const archiveDirectory = join(state.userData, 'session-branches', encodeURIComponent(seeded.sessionId))
  const archiveFiles = await readdir(archiveDirectory)
  assert.equal(archiveFiles.length, 1, `${action} should archive the replaced branch`)
  const archive = JSON.parse(await readFile(join(archiveDirectory, archiveFiles[0]), 'utf8')) as {
    reason: string
    session: { messages: ChatMessage[] }
  }
  assert.equal(archive.reason, action)
  assert.equal(archive.session.messages.length, 4, 'archive should preserve the full pre-action conversation')
}

async function testActionBranchFailure(bundle: TestBundle, state: TestState): Promise<void> {
  const invoke = invokeFor(state)
  const seeded = await seedActionHistory(bundle, state, 'edit')
  const before = await bundle.sessions.getMessages(seeded.sessionId)
  state.failBranchIds.add('edit-native-target')
  await assert.rejects(invoke('chat:send', {
    sessionId: seeded.sessionId,
    text: 'must-not-append-on-branch-failure',
    action: 'edit',
    fromMessageId: seeded.targetUserId
  }), /branch failure/)
  state.failBranchIds.delete('edit-native-target')
  assert.deepEqual(await bundle.sessions.getMessages(seeded.sessionId), before,
    'failed native branching must not archive or append a replacement user message')
  assert.equal(await bundle.sessions.getPendingNativeBranch(seeded.sessionId), undefined,
    'failed action branch should restore the prior marker')
}

async function testInterruptedResend(bundle: TestBundle, state: TestState): Promise<void> {
  const invoke = invokeFor(state)
  for (const nativeAccepted of [false, true]) {
    const session = await invoke('session:create', 'interrupted-resend') as { id: string }
    await bundle.sessions.appendMessage(session.id, message('prefix-user', 'user', 'earlier', { nativeEntryId: 'prefix-native' }))
    await bundle.sessions.appendMessage(session.id, message('prefix-assistant', 'assistant', 'earlier reply'))
    await bundle.sessions.appendMessage(session.id, message('interrupted-user', 'user', 'interrupted prompt'))
    await bundle.sessions.appendMessage(session.id, message('interrupted-assistant', 'assistant', 'partial', { status: 'cancelled', interrupted: true }))
    seedNativeHistory(state, session.id, [['prefix-native', 'earlier'], ...(nativeAccepted ? [['unbound-native', 'interrupted prompt'] as [string, string]] : [])])
    const start = state.timeline.length
    await invoke('chat:send', { sessionId: session.id, text: 'interrupted prompt', action: 'resend', fromMessageId: 'interrupted-user' })
    const result = await waitForAssistant(invoke, session.id)
    assert.equal(result.length, 4)
    assert.equal(result[2].content, 'interrupted prompt')
    const branches = state.timeline.slice(start).filter((entry) => entry.kind === 'branch')
    assert.equal(branches.length, nativeAccepted ? 1 : 0)
    if (nativeAccepted) assert.equal(branches[0].entryId, 'unbound-native', 'recover the accepted native user without truncating its preceding context')
    assert.ok(result[2].nativeEntryId?.startsWith('native-prompt-'))
  }
}

function writeTool(id: string, path: string, oldContent: string | null, newContent: string): ToolCallRecord {
  return {
    id,
    name: 'write_file',
    args: { path },
    argsRaw: JSON.stringify({ path }),
    status: 'ok',
    output: 'write complete',
    result: { path, oldContent, newContent }
  }
}

async function seedWriteHistory(
  bundle: TestBundle,
  state: TestState,
  title: string,
  path: string,
  targetEntryId: string,
  currentFile: string
): Promise<string> {
  await writeFile(path, currentFile, 'utf8')
  const session = await invokeFor(state)('session:create', title) as { id: string }
  await bundle.sessions.appendMessage(session.id, message(`${title}-user`, 'user', 'write prompt', { nativeEntryId: targetEntryId }))
  await bundle.sessions.appendMessage(session.id, message(`${title}-assistant`, 'assistant', 'write answer', {
    tools: [writeTool(`${title}-write`, path, 'before', 'after')]
  }))
  seedNativeHistory(state, session.id, [[targetEntryId, 'write prompt']])
  return session.id
}

async function testFeedbackAndRevert(bundle: TestBundle, state: TestState, workspace: string): Promise<{
  markerSessionId: string
  markerEntryId: string
}> {
  const invoke = invokeFor(state)
  const feedbackSession = await invoke('session:create', 'feedback') as { id: string }
  const feedbackUser = message('feedback-user', 'user', 'feedback request')
  const feedbackAssistant = message('feedback-assistant', 'assistant', 'feedback response')
  await bundle.sessions.appendMessage(feedbackSession.id, feedbackUser)
  await bundle.sessions.appendMessage(feedbackSession.id, feedbackAssistant)
  await invoke('chat:feedback', feedbackSession.id, feedbackAssistant.id, 'like')
  assert.equal((await bundle.sessions.getMessages(feedbackSession.id))[1].feedback, 'like')
  await assert.rejects(invoke('chat:feedback', feedbackSession.id, feedbackUser.id, 'dislike'), /助手消息/)
  await assert.rejects(invoke('chat:feedback', feedbackSession.id, 'missing', 'like'), /助手消息/)
  await assert.rejects(invoke('chat:feedback', feedbackSession.id, feedbackAssistant.id, 'bad'), /反馈值无效/)

  const conflictPath = join(workspace, 'conflict.txt')
  const conflictId = await seedWriteHistory(bundle, state, 'conflict-revert', conflictPath, 'native-conflict-target', 'external edit')
  const conflictBefore = await bundle.sessions.getMessages(conflictId)
  await assert.rejects(invoke('chat:revert', conflictId, 'conflict-revert-user'), /外部修改/)
  assert.equal(await readFile(conflictPath, 'utf8'), 'external edit', 'revert conflict must preserve the externally edited file')
  assert.deepEqual(await bundle.sessions.getMessages(conflictId), conflictBefore, 'conflict should leave history intact')
  assert.equal(await bundle.sessions.getPendingNativeBranch(conflictId), undefined)

  const rejectedPath = join(workspace, 'branch-failure.txt')
  const rejectedId = await seedWriteHistory(bundle, state, 'failed-revert', rejectedPath, 'native-failed-revert', 'after')
  state.failBranchIds.add('native-failed-revert')
  await assert.rejects(invoke('chat:revert', rejectedId, 'failed-revert-user'), /恢复失败/)
  state.failBranchIds.delete('native-failed-revert')
  assert.equal(await readFile(rejectedPath, 'utf8'), 'after', 'failed native branch must undo the file restore')
  assert.equal((await bundle.sessions.getMessages(rejectedId)).length, 2, 'failed native branch must preserve history')
  assert.equal(await bundle.sessions.getPendingNativeBranch(rejectedId), undefined)

  const readOnlyId = await invoke('session:create', 'read-only-revert') as { id: string }
  await bundle.sessions.appendMessage(readOnlyId.id, message('read-only-user', 'user', 'read only'))
  await bundle.sessions.appendMessage(readOnlyId.id, message('read-only-assistant', 'assistant', 'read', {
    tools: [{ id: 'read-tool', name: 'read_file', args: {}, argsRaw: '{}', status: 'ok' }]
  }))
  await assert.rejects(invoke('chat:revert', readOnlyId.id, 'read-only-user'), /没有可恢复/)

  const unknownPath = join(workspace, 'unknown-write.txt')
  await writeFile(unknownPath, 'after', 'utf8')
  const unknownId = await invoke('session:create', 'unknown-write-revert') as { id: string }
  await bundle.sessions.appendMessage(unknownId.id, message('unknown-write-user', 'user', 'unknown write', {
    nativeEntryId: 'native-unknown-write'
  }))
  await bundle.sessions.appendMessage(unknownId.id, message('unknown-write-assistant', 'assistant', 'unknown', {
    tools: [{
      id: 'unknown-write-tool', name: 'delete_file', args: {}, argsRaw: '{}', status: 'ok',
      result: { path: unknownPath, oldContent: 'before', newContent: 'after' }
    }]
  }))
  await assert.rejects(invoke('chat:revert', unknownId.id, 'unknown-write-user'), /无法完整回滚/)
  assert.equal(await readFile(unknownPath, 'utf8'), 'after', 'unrecognized writes must not be treated as reversible')

  const markerPath = join(workspace, 'persist-revert.txt')
  const markerSessionId = await seedWriteHistory(bundle, state, 'pending-revert', markerPath, 'native-revert-target', 'after')
  await invoke('chat:revert', markerSessionId, 'pending-revert-user')
  assert.equal(await readFile(markerPath, 'utf8'), 'before', 'known complete host write should be restored')
  assert.deepEqual(await bundle.sessions.getMessages(markerSessionId), [], 'successful revert should truncate the active history prefix')
  const markerEntryId = await bundle.sessions.getPendingNativeBranch(markerSessionId)
  assert.equal(markerEntryId, 'native-revert-target', 'successful revert should persist a replay marker')
  const revertArchiveDirectory = join(state.userData, 'session-branches', encodeURIComponent(markerSessionId))
  const revertArchiveFiles = await readdir(revertArchiveDirectory)
  assert.equal(revertArchiveFiles.length, 1, 'revert should archive its abandoned branch')
  const revertArchive = JSON.parse(await readFile(join(revertArchiveDirectory, revertArchiveFiles[0]), 'utf8')) as {
    reason: string
    session: { messages: ChatMessage[] }
  }
  assert.equal(revertArchive.reason, 'revert')
  assert.equal(revertArchive.session.messages.length, 2, 'revert archive should preserve the messages removed from the active history')
  const stored = JSON.parse(await readFile(join(state.userData, 'sessions.json'), 'utf8')) as {
    sessions: Array<{ id: string; pendingNativeBranchId?: string }>
  }
  assert.equal(stored.sessions.find((item) => item.id === markerSessionId)?.pendingNativeBranchId, markerEntryId,
    'pending native branch marker should be present on disk')
  return { markerSessionId, markerEntryId: markerEntryId! }
}

async function testAttachments(bundle: TestBundle, state: TestState, tempRoot: string): Promise<void> {
  const invoke = invokeFor(state)
  const pickedPath = join(tempRoot, 'picked.txt')
  await writeFile(pickedPath, 'picked file content', 'utf8')
  state.dialogPaths.push(pickedPath)
  const picked = await invoke('attachments:pick') as Array<{ id: string; name: string; path?: string; size: number }>
  assert.equal(picked.length, 1)
  assert.equal(picked[0].name, 'picked.txt')
  assert.equal(picked[0].size, Buffer.byteLength('picked file content'))
  assert.ok(picked[0].path && (await readFile(picked[0].path, 'utf8')) === 'picked file content',
    'picker should stage a real copy in user data')

  const staged = await invoke('attachments:stage', {
    name: '../safe-note.txt', mimeType: 'text/plain', dataBase64: Buffer.from('attachment body').toString('base64')
  }) as { id: string; name: string; path?: string; size: number }
  assert.equal(staged.name, 'safe-note.txt', 'staging should discard path components from the supplied filename')
  assert.equal(staged.size, Buffer.byteLength('attachment body'))
  assert.equal((await bundle.attachments.getAttachment(staged.id)).name, 'safe-note.txt')
  assert.equal(await readFile(staged.path!, 'utf8'), 'attachment body')
  await assert.rejects(invoke('attachments:stage', {
    name: 'metadata.json', mimeType: 'text/plain', dataBase64: Buffer.from('no').toString('base64')
  }), /文件名无效/)

  const tamperedMetadata = join(state.userData, 'attachments', staged.id, 'metadata.json')
  await writeFile(tamperedMetadata, JSON.stringify({ ...staged, path: join(tempRoot, 'outside.txt') }), 'utf8')
  const pathChecked = await bundle.attachments.getAttachment(staged.id)
  assert.equal(pathChecked.path, staged.path, 'attachment metadata path must be recomputed inside the staged directory')
  assert.notEqual(pathChecked.path, join(tempRoot, 'outside.txt'))
  await writeFile(tamperedMetadata, JSON.stringify({ ...staged, name: '../outside.txt', path: join(tempRoot, 'outside.txt') }), 'utf8')
  await assert.rejects(bundle.attachments.getAttachment(staged.id), /元数据无效/)
  const sendSession = await invoke('session:create', 'invalid-attachment') as { id: string }
  await assert.rejects(invoke('chat:send', {
    sessionId: sendSession.id, text: 'must not send', attachments: [{ ...staged, id: staged.id }]
  }), /元数据无效/)
  assert.deepEqual(await invoke('session:messages', sendSession.id), [], 'invalid attachment metadata must reject before appending')

  const sendWithAttachment = await invoke('session:create', 'attachment-send') as { id: string }
  await invoke('chat:send', { sessionId: sendWithAttachment.id, text: 'read attachment', attachments: [picked[0]] })
  await waitForAssistant(invoke, sendWithAttachment.id)
  const prompt = state.timeline.findLast((item) => item.kind === 'prompt' && item.sessionId === sendWithAttachment.id)
  assert.ok(prompt?.text?.includes('附件 picked.txt:\npicked file content'), 'OMP prompt should receive staged file contents')

  await assert.rejects(invoke('attachments:remove', picked[0].id), /已用于会话/)
  assert.ok(await readFile(join(state.userData, 'attachments', picked[0].id, 'metadata.json'), 'utf8'),
    'removing a committed attachment should leave the session source intact')
  await invoke('attachments:remove', staged.id)
  await assert.rejects(bundle.attachments.getAttachment(staged.id))
}

async function testSpeech(bundle: TestBundle, state: TestState): Promise<void> {
  const server = createServer((request, response) => {
    const chunks: Buffer[] = []
    request.on('data', (chunk: Buffer) => chunks.push(Buffer.from(chunk)))
    request.on('end', () => {
      state.speechRequests.push({
        path: request.url || '',
        authorization: request.headers.authorization,
        contentType: request.headers['content-type'],
        body: Buffer.concat(chunks).toString('utf8')
      })
      response.writeHead(state.speechStatus, { 'content-type': 'application/json' })
      response.end(state.speechStatus === 200 ? JSON.stringify({ text: 'recognized local audio' }) : JSON.stringify({ error: 'mock failure' }))
    })
  })
  await new Promise<void>((resolve, reject) => {
    server.once('error', reject)
    server.listen(0, '127.0.0.1', resolve)
  })
  try {
    const address = server.address()
    assert.ok(address && typeof address === 'object')
    const speechBaseUrl = `http://127.0.0.1:${address.port}`
    const invoke = invokeFor(state)
    await invoke('config:update', { speechBaseUrl, speechModel: 'local-test-model', apiKey: 'regression-only-key' })
    const audioBase64 = Buffer.from('local fake wav bytes').toString('base64')
    const result = await invoke('speech:transcribe', { audioBase64, mimeType: 'audio/wav' }) as { text: string }
    assert.deepEqual(result, { text: 'recognized local audio' })
    const request = state.speechRequests.at(-1)
    assert.ok(request)
    assert.equal(request.path, '/audio/transcriptions')
    assert.equal(request.authorization, 'Bearer regression-only-key')
    assert.ok(request.contentType?.includes('multipart/form-data; boundary='))
    assert.ok(request.body.includes('name="model"') && request.body.includes('local-test-model'))
    assert.ok(request.body.includes('filename="recording.wav"') && request.body.includes('local fake wav bytes'))

    state.speechStatus = 503
    await assert.rejects(invoke('speech:transcribe', { audioBase64, mimeType: 'audio/wav' }), /转写失败（503）/)
    assert.equal(state.speechRequests.length, 2, 'both transcription requests should stay on the local server')
    assert.ok(state.speechRequests.every((item) => item.path === '/audio/transcriptions'))
  } finally {
    await new Promise<void>((resolve) => server.close(() => resolve()))
  }
}

async function testPendingReplay(
  tempRoot: string,
  bundle: TestBundle,
  state: TestState,
  markerSessionId: string,
  markerEntryId: string
): Promise<TestBundle> {
  // A real OMP cold start loads the old file leaf; branch alone was not persisted.
  seedNativeHistory(state, markerSessionId, [[markerEntryId, 'write prompt']])
  const restarted = await buildBundle(tempRoot, state, 'conversation-ipc-restarted')
  const invoke = register(restarted, state)
  const before = await restarted.sessions.getMessages(markerSessionId)
  assert.deepEqual(before, [], 'restarted session should load the archived active prefix')

  state.failBranchIds.add(markerEntryId)
  await assert.rejects(invoke('chat:send', { sessionId: markerSessionId, text: 'blocked until branch succeeds' }), /恢复已保存的原生会话分支/)
  state.failBranchIds.delete(markerEntryId)
  assert.deepEqual(await restarted.sessions.getMessages(markerSessionId), before,
    'failed pending branch replay must not append a user message')
  assert.equal(await restarted.sessions.getPendingNativeBranch(markerSessionId), markerEntryId,
    'failed pending branch replay must retain its marker for a retry')

  const start = state.timeline.length
  await invoke('chat:send', { sessionId: markerSessionId, text: 'replayed branch prompt' })
  const messages = await waitForAssistant(invoke, markerSessionId)
  const activity = state.timeline.slice(start).filter((item) => item.sessionId === markerSessionId)
  const branch = activity.findIndex((item) => item.kind === 'branch' && item.entryId === markerEntryId)
  const prompt = activity.findIndex((item) => item.kind === 'prompt' && item.text?.split(/\r?\n/, 1)[0] === 'replayed branch prompt')
  assert.ok(branch >= 0 && prompt > branch, 'fresh OMP kernel must replay the saved branch marker before prompt')
  assert.equal(activity[prompt].text, ['replayed branch prompt', messages[0].capabilityContext].filter(Boolean).join('\n\n'),
    'restart prompt retains the exact current turn context')
  assert.match(activity[prompt].text ?? '', /<ycode-agent-mode mode="craft">/, 'restart prompt declares current craft mode')
  assert.equal(messages[0].content, 'replayed branch prompt', 'persisted user content stays exact across restart')
  assert.ok(messages[0].nativeEntryId?.startsWith('native-prompt-'), 'restarted send should map its returned native entryId')
  assert.equal(await restarted.sessions.getPendingNativeBranch(markerSessionId), undefined,
    'new native user entry should clear the marker after successful lookup')
  return restarted
}

async function testColdRecovery(tempRoot: string, state: TestState, bundle: TestBundle): Promise<void> {
  const invoke = invokeFor(state)
  const session = await invoke('session:create', 'cold streaming recovery') as { id: string }
  await bundle.sessions.appendMessage(session.id, message('cold-user', 'user', 'incomplete request', { status: 'done' }))
  await bundle.sessions.appendMessage(session.id, message('cold-assistant', 'assistant', 'partial', {
    requestId: 'cold-run',
    status: 'streaming',
    parts: [{ type: 'text', text: 'partial' }, { type: 'tool', toolId: 'cold-tool' }],
    tools: [{ id: 'cold-tool', name: 'shell', args: {}, argsRaw: '{}', status: 'running', output: 'partial tool output' }]
  }))

  const cold = await buildBundle(tempRoot, state, 'conversation-ipc-cold-recovery')
  const messages = await cold.sessions.getMessages(session.id)
  const recovered = assistant(messages)
  assert.equal(recovered.status, 'cancelled')
  assert.equal(recovered.interrupted, true)
  assert.equal(recovered.tools?.[0].status, 'cancelled')
  assert.equal(recovered.tools?.[0].output, 'partial tool output', 'cold recovery should retain running tool output')
  const disk = JSON.parse(await readFile(join(state.userData, 'sessions.json'), 'utf8')) as {
    sessions: Array<{ id: string; messages: ChatMessage[] }>
  }
  const diskRecovered = disk.sessions.find((item) => item.id === session.id)?.messages.at(-1)
  assert.equal(diskRecovered?.status, 'cancelled', 'cold recovery should persist its terminal status')
  assert.equal(diskRecovered?.tools?.[0].status, 'cancelled')
  assert.equal(diskRecovered?.tools?.[0].output, 'partial tool output')
}

async function main(): Promise<void> {
  const tempRoot = await mkdtemp(join(tmpdir(), 'ycode-conversation-ipc-'))
  const state: TestState = {
    userData: join(tempRoot, 'userData'),
    home: join(tempRoot, 'home'),
    handlers: new Map(),
    dialogPaths: [],
    nativeMessages: new Map(),
    failBranchIds: new Set(),
    timeline: [],
    pendingPrompts: [],
    holdSessions: new Set(),
    activePrompts: 0,
    maxActivePrompts: 0,
    nextNativeId: 0,
    speechStatus: 200,
    speechRequests: [],
    events: []
  }
  await mkdir(state.userData, { recursive: true })
  await mkdir(state.home, { recursive: true })

  const globals = globalThis as typeof globalThis & Record<string, unknown>
  const previousState = globals[TEST_STATE_KEY]
  globals[TEST_STATE_KEY] = state
  const bundles: TestBundle[] = []
  try {
    const bundle = await buildBundle(tempRoot, state, 'conversation-ipc-primary')
    bundles.push(bundle)
    const invoke = register(bundle, state)

    const workspace = join(tempRoot, 'workspace')
    await mkdir(workspace, { recursive: true })
    state.dialogPaths.push(workspace)
    assert.deepEqual(await invoke('workspace:choose'), { root: workspace, changed: true })

    await testConcurrency(bundle, state, invoke)
    for (const action of ['edit', 'resend', 'regenerate'] as const) await testActionBranch(bundle, state, action)
    await testActionBranchFailure(bundle, state)
    await testInterruptedResend(bundle, state)
    await testAttachments(bundle, state, tempRoot)
    await testSpeech(bundle, state)

    const { markerSessionId, markerEntryId } = await testFeedbackAndRevert(bundle, state, workspace)
    const restarted = await testPendingReplay(tempRoot, bundle, state, markerSessionId, markerEntryId)
    bundles.push(restarted)
    await testColdRecovery(tempRoot, state, restarted)
    console.log('conversation-ipc-regression: all checks passed')
  } finally {
    await Promise.all(bundles.map((bundle) => bundle.disposeOmpKernels().catch(() => undefined)))
    globals[TEST_STATE_KEY] = previousState
    await rm(tempRoot, { recursive: true, force: true })
  }
}

void main().catch((error: unknown) => {
  console.error('conversation-ipc-regression failed:', error)
  process.exitCode = 1
})