import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { PROTOCOL_VERSION } from '@agentclientprotocol/sdk'
import { makeBridgeHarness, textResponse, toolCallResponse, type BridgeHarness } from './harness.ts'
import { SessionId } from '@deepseek-ai/dsh-session'
import { encodeSessionReferenceUri, formatSessionReferenceMention } from '@deepseek-ai/dsh-session-reference'

/**
 * End-to-end bridge specs over an in-memory transport: a real
 * ClientSideConnection drives the bridge's AgentSideConnection, so every
 * assertion exercises actual JSON-RPC framing and the harness event taxonomy.
 */
describe('acp bridge', () => {
  let storageDir: string
  let harness: BridgeHarness | undefined

  beforeEach(async () => {
    storageDir = await mkdtemp(join(tmpdir(), 'acp-test-'))
  })

  afterEach(async () => {
    // e2e/integration tests own their resources (docs/testing.md): dispose even on
    // failure so a flaky run never leaks a context or persistence dir.
    if (harness) await harness.dispose()
    harness = undefined
    await rm(storageDir, { recursive: true, force: true })
  })

  it('initialize negotiates the protocol version and advertises capabilities', async () => {
    harness = await makeBridgeHarness({ storageDir })
    const res = await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    expect(res.protocolVersion).toBe(PROTOCOL_VERSION)
    expect(res.agentCapabilities?.loadSession).toBe(true)
    expect(res.agentCapabilities?.promptCapabilities).toMatchObject({ image: false, audio: false })
    expect(res.agentInfo).toEqual({ name: 'deepseek-harness-acp', version: '0.0.1' })
  })

  it('session/new creates a session and a full prompt turn streams text then settles end_turn', async () => {
    harness = await makeBridgeHarness({ storageDir, script: [textResponse('hello there')] })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    expect(sessionId).toBeTruthy()

    const res = await harness.client.prompt({ sessionId, prompt: [{ type: 'text', text: 'hi' }] })
    expect(res.stopReason).toBe('end_turn')

    // The streamed text arrived as agent_message_chunk updates.
    const text = harness.updates
      .filter(u => u.sessionUpdate === 'agent_message_chunk')
      .map(u => (u.content.type === 'text' ? u.content.text : ''))
      .join('')
    expect(text).toBe('hello there')
  })

  it('routes ask_user_question through ACP form elicitation and continues with the selected option', async () => {
    harness = await makeBridgeHarness({
      storageDir,
      withAskUser: true,
      script: [
        toolCallResponse('ask-1', 'ask_user_question', {
          questions: [{
            id: 'language',
            header: 'Project config',
            question: 'Which language should I use?',
            options: [
              { label: 'TypeScript', description: 'Good for UI apps' },
              { label: 'Python', description: 'Good for scripts' },
            ],
          }],
        }),
        textResponse('Python it is.'),
      ],
    })
    harness.onElicitation = () => ({ action: 'accept', content: { choice: 'Python' } })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })

    const result = await harness.client.prompt({ sessionId, prompt: [{ type: 'text', text: 'ask me' }] })

    expect(result.stopReason).toBe('end_turn')
    expect(harness.elicitationRequests).toHaveLength(1)
    expect(harness.elicitationRequests[0]).toMatchObject({
      sessionId,
      mode: 'form',
      message: 'Which language should I use?',
      requestedSchema: {
        title: 'Project config',
        properties: {
          choice: {
            oneOf: [
              { const: 'TypeScript', title: 'TypeScript: Good for UI apps' },
              { const: 'Python', title: 'Python: Good for scripts' },
            ],
          },
          custom: { type: 'string' },
        },
        required: [],
      },
    })
    const toolResult = harness.ctx.agents.get(SessionId(sessionId))!.session.events.find(event => event.type === 'tool/result')
    const toolResultBlock = toolResult?.type === 'tool/result' ? toolResult.data.content[0] : undefined
    const toolResultText = toolResultBlock?.type === 'text' ? toolResultBlock.text : undefined
    expect(toolResultText).toBe('{"answers":[{"id":"language","selected":["Python"]}]}')
  })

  it('routes optionless ask_user_question through an ACP free-form answer field', async () => {
    harness = await makeBridgeHarness({
      storageDir,
      withAskUser: true,
      script: [
        toolCallResponse('ask-1', 'ask_user_question', {
          questions: [{ id: 'name', question: 'What should I name it?' }],
        }),
        textResponse('Name recorded.'),
      ],
    })
    harness.onElicitation = () => ({ action: 'accept', content: { custom: 'apollo' } })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })

    await harness.client.prompt({ sessionId, prompt: [{ type: 'text', text: 'ask me' }] })

    expect(harness.elicitationRequests[0]).toMatchObject({
      requestedSchema: {
        properties: { custom: { type: 'string', title: 'What should I name it?' } },
        required: ['custom'],
      },
    })
    const toolResult = harness.ctx.agents.get(SessionId(sessionId))!.session.events.find(event => event.type === 'tool/result')
    expect(JSON.stringify(toolResult)).toContain('apollo')
  })

  it('supports ACP custom answers alongside choices', async () => {
    harness = await makeBridgeHarness({ storageDir, withAskUser: true })
    harness.onElicitation = () => ({ action: 'accept', content: { custom: 'Use Zig' } })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    const agent = harness.ctx.agents.get(SessionId(sessionId))!

    const result = await harness.ctx.userInteraction.ask({
      agent,
      questions: [{
        id: 'language',
        question: 'Which language?',
        detail: 'Choose the implementation language for this project.',
        options: [{ label: 'TypeScript' }],
      }],
    })

    expect(result).toEqual({ answers: [{ id: 'language', selected: [], custom: 'Use Zig' }] })
    expect(harness.elicitationRequests[0]).toMatchObject({
      message: 'Which language?\n\nChoose the implementation language for this project.',
      requestedSchema: {
        properties: {
          choice: {
            title: 'Which language?',
            description: 'Choose one option, or fill a custom answer below.',
            oneOf: [{ const: 'TypeScript', title: 'TypeScript' }],
          },
          custom: { type: 'string' },
        },
        required: [],
      },
    })
  })

  it('treats ACP custom answers as overriding selected choices', async () => {
    harness = await makeBridgeHarness({ storageDir, withAskUser: true })
    harness.onElicitation = () => ({ action: 'accept', content: { choice: 'TypeScript', custom: 'Use Zig' } })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    const agent = harness.ctx.agents.get(SessionId(sessionId))!

    await expect(harness.ctx.userInteraction.ask({
      agent,
      questions: [{
        id: 'language',
        question: 'Which language?',
        options: [{ label: 'TypeScript' }],
      }],
    })).resolves.toEqual({ answers: [{ id: 'language', selected: [], custom: 'Use Zig' }] })
  })

  it('supports ACP multi-select answers', async () => {
    harness = await makeBridgeHarness({ storageDir, withAskUser: true })
    harness.onElicitation = () => ({ action: 'accept', content: { choice: ['Tests', 'Docs'] } })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    const agent = harness.ctx.agents.get(SessionId(sessionId))!

    await expect(harness.ctx.userInteraction.ask({
      agent,
      questions: [{
        id: 'targets',
        question: 'Pick',
        options: [{ label: 'Tests' }, { label: 'Docs' }],
        multiSelect: true,
      }],
    })).resolves.toEqual({ answers: [{ id: 'targets', selected: ['Tests', 'Docs'] }] })
  })

  it('reports ACP ask-user routing and answer failures as structured errors', async () => {
    harness = await makeBridgeHarness({ storageDir, withAskUser: true })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    const agent = harness.ctx.agents.get(SessionId(sessionId))!

    await expect(harness.ctx.userInteraction.ask({ questions: [{ id: 'x', question: 'No agent?' }] }))
      .rejects.toMatchObject({ name: 'UserInteractionError', code: 'NO_AGENT' })
    const impostor = { session: { id: agent.session.id } } as typeof agent
    await expect(harness.ctx.userInteraction.ask({ agent: impostor, questions: [{ id: 'x', question: 'No session?' }] }))
      .rejects.toMatchObject({ code: 'NO_SESSION' })

    harness.onElicitation = () => ({ action: 'cancel' })
    await expect(harness.ctx.userInteraction.ask({ agent, questions: [{ id: 'x', question: 'Cancel?' }] }))
      .rejects.toMatchObject({ code: 'ASK_CANCELLED' })

    harness.onElicitation = () => ({ action: 'accept', content: {} })
    await expect(harness.ctx.userInteraction.ask({ agent, questions: [{ id: 'x', question: 'Empty?' }] }))
      .rejects.toMatchObject({ code: 'NO_ANSWER' })

    harness.onElicitation = () => { throw new Error('client boom') }
    await expect(harness.ctx.userInteraction.ask({ agent, questions: [{ id: 'x', question: 'Client fails?' }], signal: new AbortController().signal }))
      .rejects.toMatchObject({ code: 'ASK_FAILED' })
  })

  it('aborts ACP ask-user requests before and while waiting for elicitation', async () => {
    harness = await makeBridgeHarness({ storageDir, withAskUser: true })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    const agent = harness.ctx.agents.get(SessionId(sessionId))!

    const alreadyAborted = new AbortController()
    alreadyAborted.abort()
    await expect(harness.ctx.userInteraction.ask({ agent, questions: [{ id: 'x', question: 'Already?' }], signal: alreadyAborted.signal }))
      .rejects.toMatchObject({ code: 'ASK_ABORTED' })

    let abortedReads = 0
    const racingAbort = {
      get aborted() { return abortedReads++ > 0 },
      addEventListener() {},
      removeEventListener() {},
      dispatchEvent() { return false },
      onabort: null,
      reason: undefined,
      throwIfAborted() {},
    } as AbortSignal
    await expect(harness.ctx.userInteraction.ask({ agent, questions: [{ id: 'x', question: 'Raced?' }], signal: racingAbort }))
      .rejects.toMatchObject({ code: 'ASK_ABORTED' })

    let release: ((value: { action: 'accept'; content: { custom: string } }) => void) | undefined
    harness.onElicitation = () => new Promise((resolve) => { release = resolve })
    const pendingAbort = new AbortController()
    const ask = harness.ctx.userInteraction.ask({ agent, questions: [{ id: 'x', question: 'Pending?' }], signal: pendingAbort.signal })
    await new Promise(resolve => setImmediate(resolve))
    pendingAbort.abort()

    await expect(ask).rejects.toMatchObject({ code: 'ASK_ABORTED' })
    release?.({ action: 'accept', content: { custom: 'too late' } })
  })

  it('allows multiple concurrent sessions, each with a distinct id', async () => {
    harness = await makeBridgeHarness({ storageDir, script: [] })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const a = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    const b = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    expect(a.sessionId).toBeTruthy()
    expect(b.sessionId).toBeTruthy()
    expect(a.sessionId).not.toBe(b.sessionId)
    // Both agents are live and independently registered.
    expect(harness.ctx.agents.get(SessionId(a.sessionId))).toBeDefined()
    expect(harness.ctx.agents.get(SessionId(b.sessionId))).toBeDefined()
  })

  it('rejects a non-absolute cwd but accepts any absolute cwd (per-session workspace)', async () => {
    harness = await makeBridgeHarness({ storageDir })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    // Relative cwd is still rejected (it becomes the session header / bash workdir).
    await expect(harness.client.newSession({ cwd: 'relative/path', mcpServers: [] }))
      .rejects.toThrow(/absolute/)
    // An absolute cwd that differs from the server launch dir is now ACCEPTED —
    // the per-session cwd is honored (routed to the bash workdir), so the server
    // no longer has to launch in the workspace.
    const res = await harness.client.newSession({ cwd: '/tmp', mcpServers: [] })
    expect(res.sessionId).toBeTruthy()
    // The session header records that cwd, so its bash tools run there.
    expect(harness.ctx.agents.get(SessionId(res.sessionId))!.session.header.cwd).toBe('/tmp')
  })

  it('rejects non-empty additionalDirectories', async () => {
    harness = await makeBridgeHarness({ storageDir })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    await expect(harness.client.newSession({ cwd: process.cwd(), mcpServers: [], additionalDirectories: ['/x'] }))
      .rejects.toThrow(/additionalDirectories/)
  })

  it('rejects an empty prompt without hanging', async () => {
    harness = await makeBridgeHarness({ storageDir, script: [] })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    await expect(harness.client.prompt({ sessionId, prompt: [{ type: 'text', text: '   ' }] }))
      .rejects.toThrow(/empty prompt/)
  })

  it('rejects image content in a prompt (text-only capabilities)', async () => {
    harness = await makeBridgeHarness({ storageDir, script: [] })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    await expect(harness.client.prompt({
      sessionId,
      prompt: [{ type: 'image', mimeType: 'image/png', data: 'AA==' }],
    })).rejects.toThrow(/text/)
  })

  it('accepts a resource_link prompt by rendering the link into the text sent to the agent', async () => {
    harness = await makeBridgeHarness({ storageDir, script: [textResponse('ok')] })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    const result = await harness.client.prompt({
      sessionId,
      prompt: [
        { type: 'text', text: 'fix the bug in' },
        { type: 'resource_link', uri: 'file:///x.ts', name: 'x.ts' },
      ],
    })
    expect(result.stopReason).toBe('end_turn')
    const user = harness.ctx.agents.get(SessionId(sessionId))!.session.events.find(event => event.type === 'user/message')
    expect(JSON.stringify(user)).toContain('resource_link')
  })

  it('rejects canonical session references when the optional capability is not mounted', async () => {
    harness = await makeBridgeHarness({ storageDir, script: [] })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    await expect(harness.client.prompt({
      sessionId,
      prompt: [{ type: 'resource_link', uri: encodeSessionReferenceUri(SessionId('source')), name: 'source' }],
    })).rejects.toThrow(/session reference capability unavailable/)
    expect(harness.ctx.agents.get(SessionId(sessionId))?.session.events).toHaveLength(0)
  })

  it('reports malformed inline session references at the ACP request boundary', async () => {
    harness = await makeBridgeHarness({ storageDir, script: [] })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    await expect(harness.client.prompt({
      sessionId,
      prompt: [{ type: 'text', text: 'use dsh-session:IiJ' }],
    })).rejects.toThrow(/invalid session reference/)
    expect(harness.ctx.agents.get(SessionId(sessionId))?.session.events).toHaveLength(0)
  })

  it('injects ACP session references before sending the direct prompt', async () => {
    harness = await makeBridgeHarness({ storageDir, withSessionReferences: true, script: [textResponse('ok')] })
    const source = harness.ctx.sessions.create(SessionId('source'), { meta: { cwd: '/source' } })
    source.append('user/message', {
      content: [{ type: 'text', text: 'source background' }],
      source: { kind: 'user' },
    }, { surfaceOp: 'append' })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    const mention = formatSessionReferenceMention({ sessionId: source.id, label: 'source-inline' })
    const result = await harness.client.prompt({
      sessionId,
      prompt: [
        { type: 'text', text: `use ${mention} and ` },
        { type: 'resource_link', uri: encodeSessionReferenceUri(source.id), name: 'source-link' },
      ],
    })
    expect(result.stopReason).toBe('end_turn')

    const target = harness.ctx.agents.get(SessionId(sessionId))!.session
    const context = target.events.find(event =>
      event.type === 'user/message' && event.data.source.kind === 'session-reference')
    expect(context?.type === 'user/message' && context.data.source).toMatchObject({
      kind: 'session-reference',
      references: [{ sessionId: 'source', label: 'source-inline' }],
    })
    const user = target.events.find(event =>
      event.type === 'user/message' && event.data.source.kind === 'user')
    expect(user?.type === 'user/message' && user.data.content).toEqual([
      { type: 'text', text: 'use @source-inline and @source-link' },
    ])
    const request = JSON.stringify(harness.adapter.requests[0]?.messages)
    expect(request).toContain('untrusted, read-only snapshot')
    expect(request).toContain('source background')
    expect(request.indexOf('source background')).toBeLessThan(request.indexOf('use @source-inline and @source-link'))
  })

  it('rejects a failed referenced-session read before starting a turn', async () => {
    harness = await makeBridgeHarness({ storageDir, withSessionReferences: true, script: [] })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    await expect(harness.client.prompt({
      sessionId,
      prompt: [{ type: 'resource_link', uri: encodeSessionReferenceUri(SessionId('missing')), name: 'missing' }],
    })).rejects.toThrow(/preparation failed/)
    expect(harness.ctx.agents.get(SessionId(sessionId))?.session.events).toHaveLength(0)
  })

  it('cancels reference preparation before a turn is created', async () => {
    harness = await makeBridgeHarness({ storageDir, withSessionReferences: true, script: [] })
    const source = harness.ctx.sessions.create(SessionId('source'))
    const snapshot = await harness.ctx.sessionQuery.readSurface(source.id)
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    let releaseRead: (() => void) | undefined
    const readSurface = vi.spyOn(harness.ctx.sessionQuery, 'readSurface').mockImplementationOnce(async () => {
      await new Promise<void>((resolve) => { releaseRead = resolve })
      return snapshot
    })
    const pending = harness.client.prompt({
      sessionId,
      prompt: [{ type: 'resource_link', uri: encodeSessionReferenceUri(source.id), name: 'source' }],
    })
    await vi.waitFor(() => { expect(releaseRead).toBeTypeOf('function') })
    await harness.client.cancel({ sessionId })
    await expect(pending).resolves.toEqual({ stopReason: 'cancelled' })
    expect(harness.ctx.agents.get(SessionId(sessionId))?.session.events).toHaveLength(0)
    releaseRead?.()
    await Promise.resolve()
    readSurface.mockRestore()
  })

  it('rejects a prompt for an unknown session', async () => {
    harness = await makeBridgeHarness({ storageDir })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    await expect(harness.client.prompt({ sessionId: 'nope', prompt: [{ type: 'text', text: 'hi' }] }))
      .rejects.toThrow(/unknown session/)
  })

  it('negotiates an unsupported protocol version down to the supported one', async () => {
    harness = await makeBridgeHarness({ storageDir })
    const res = await harness.client.initialize({ protocolVersion: 999, clientCapabilities: {} })
    expect(res.protocolVersion).toBe(PROTOCOL_VERSION)
  })

  it('a cancel for an unknown/absent session is a silent no-op', async () => {
    harness = await makeBridgeHarness({ storageDir })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    // No session created yet — cancel must not throw.
    await expect(harness.client.cancel({ sessionId: 'nope' })).resolves.toBeUndefined()
  })

  it('authenticate is a no-op (no auth methods advertised)', async () => {
    harness = await makeBridgeHarness({ storageDir })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    await expect(harness.client.authenticate({ methodId: 'whatever' })).resolves.toBeDefined()
  })

  it('renders the deployment persona into ACP-created agents\' requests', async () => {
    harness = await makeBridgeHarness({
      storageDir,
      script: [textResponse('ok')],
      persona: 'be terse',
    })
    await harness.client.initialize({ protocolVersion: PROTOCOL_VERSION, clientCapabilities: {} })
    // Create + prompt so the system-prompt plugin's persona section reaches
    // the model request of an agent the BRIDGE created (session/new).
    const { sessionId } = await harness.client.newSession({ cwd: process.cwd(), mcpServers: [] })
    await harness.client.prompt({ sessionId, prompt: [{ type: 'text', text: 'hi' }] })
    expect(harness.adapter.requests[0]?.system).toContain('be terse')
  })
})