import { describe, expect, test } from 'bun:test'
import {
  deriveShortMessageId,
  INTERRUPT_MESSAGE,
  INTERRUPT_MESSAGE_FOR_TOOL_USE,
  CANCEL_MESSAGE,
  REJECT_MESSAGE,
  NO_RESPONSE_REQUESTED,
  SYNTHETIC_MESSAGES,
  isSyntheticMessage,
  getLastAssistantMessage,
  hasToolCallsInLastAssistantTurn,
  createAssistantMessage,
  createAssistantAPIErrorMessage,
  createUserMessage,
  createUserInterruptionMessage,
  prepareUserContent,
  createToolResultStopMessage,
  extractTag,
  isNotEmptyMessage,
  deriveUUID,
  normalizeMessages,
  normalizeMessagesForAPI,
  isClassifierDenial,
  buildYoloRejectionMessage,
  buildClassifierUnavailableMessage,
  AUTO_REJECT_MESSAGE,
  DONT_ASK_REJECT_MESSAGE,
  SYNTHETIC_MODEL,
  normalizeContentFromAPI,
} from '../messages'
import type {
  Message,
  AssistantMessage,
  UserMessage,
} from '../../types/message'
import { TaskGetTool } from '@claude-code-best/builtin-tools/tools/TaskGetTool/TaskGetTool.js'
import { TaskUpdateTool } from '@claude-code-best/builtin-tools/tools/TaskUpdateTool/TaskUpdateTool.js'

// ─── Helpers ─────────────────────────────────────────────────────────────

function makeAssistantMsg(
  contentBlocks: Array<{ type: string; text?: string; [key: string]: any }>,
): AssistantMessage {
  return createAssistantMessage({
    content: contentBlocks as any,
  })
}

function makeUserMsg(text: string): UserMessage {
  return createUserMessage({ content: text })
}

// ─── deriveShortMessageId ───────────────────────────────────────────────

describe('deriveShortMessageId', () => {
  test('returns 6-char string', () => {
    const id = deriveShortMessageId('550e8400-e29b-41d4-a716-446655440000')
    expect(id).toHaveLength(6)
  })

  test('is deterministic for same input', () => {
    const uuid = 'a0b1c2d3-e4f5-6789-abcd-ef0123456789'
    expect(deriveShortMessageId(uuid)).toBe(deriveShortMessageId(uuid))
  })

  test('produces different IDs for different UUIDs', () => {
    const id1 = deriveShortMessageId('00000000-0000-0000-0000-000000000001')
    const id2 = deriveShortMessageId('ffffffff-ffff-ffff-ffff-ffffffffffff')
    expect(id1).not.toBe(id2)
  })
})

// ─── Constants ──────────────────────────────────────────────────────────

describe('message constants', () => {
  test('SYNTHETIC_MESSAGES contains expected messages', () => {
    expect(SYNTHETIC_MESSAGES.has(INTERRUPT_MESSAGE)).toBe(true)
    expect(SYNTHETIC_MESSAGES.has(INTERRUPT_MESSAGE_FOR_TOOL_USE)).toBe(true)
    expect(SYNTHETIC_MESSAGES.has(CANCEL_MESSAGE)).toBe(true)
    expect(SYNTHETIC_MESSAGES.has(REJECT_MESSAGE)).toBe(true)
    expect(SYNTHETIC_MESSAGES.has(NO_RESPONSE_REQUESTED)).toBe(true)
  })

  test('SYNTHETIC_MODEL is <synthetic>', () => {
    expect(SYNTHETIC_MODEL).toBe('<synthetic>')
  })
})

// ─── Message factories ──────────────────────────────────────────────────

describe('createAssistantMessage', () => {
  test('creates assistant message with string content', () => {
    const msg = createAssistantMessage({ content: 'hello' })
    expect(msg.type).toBe('assistant')
    expect(msg.message!.role).toBe('assistant')
    expect(msg.message!.content![0] as any).toBeTruthy()
    expect((msg.message!.content![0] as any).text).toBe('hello')
  })

  test('creates assistant message with content blocks', () => {
    const blocks = [{ type: 'text' as const, text: 'hello' }]
    const msg = createAssistantMessage({ content: blocks as any })
    expect(msg.type).toBe('assistant')
    expect(msg.message.content).toHaveLength(1)
  })

  test('generates unique uuid per call', () => {
    const msg1 = createAssistantMessage({ content: 'a' })
    const msg2 = createAssistantMessage({ content: 'b' })
    expect(msg1.uuid).not.toBe(msg2.uuid)
  })

  test('has isApiErrorMessage false', () => {
    const msg = createAssistantMessage({ content: 'test' })
    expect(msg.isApiErrorMessage).toBe(false)
  })
})

describe('createAssistantAPIErrorMessage', () => {
  test('sets isApiErrorMessage to true', () => {
    const msg = createAssistantAPIErrorMessage({ content: 'error' })
    expect(msg.isApiErrorMessage).toBe(true)
  })

  test('includes error details', () => {
    const msg = createAssistantAPIErrorMessage({
      content: 'fail',
      errorDetails: 'rate limited',
    })
    expect(msg.errorDetails).toBe('rate limited')
  })
})

describe('createUserMessage', () => {
  test('creates user message with string content', () => {
    const msg = createUserMessage({ content: 'hello' })
    expect(msg.type).toBe('user')
    expect(msg.message.role).toBe('user')
    expect(msg.message.content).toBe('hello')
  })

  test('generates unique uuid', () => {
    const msg1 = createUserMessage({ content: 'a' })
    const msg2 = createUserMessage({ content: 'b' })
    expect(msg1.uuid).not.toBe(msg2.uuid)
  })

  test('uses provided uuid when given', () => {
    const msg = createUserMessage({
      content: 'test',
      uuid: 'custom-uuid-1234-5678-abcd-ef0123456789',
    })
    expect(msg.uuid).toBe('custom-uuid-1234-5678-abcd-ef0123456789')
  })

  test('sets isMeta flag', () => {
    const msg = createUserMessage({ content: 'test', isMeta: true })
    expect(msg.isMeta).toBe(true)
  })
})

describe('createUserInterruptionMessage', () => {
  test('creates interrupt message without tool use', () => {
    const msg = createUserInterruptionMessage({})
    expect(msg.type).toBe('user')
    expect((msg.message.content as any)[0].text).toBe(INTERRUPT_MESSAGE)
  })

  test('creates interrupt message with tool use', () => {
    const msg = createUserInterruptionMessage({ toolUse: true })
    expect((msg.message.content as any)[0].text).toBe(
      INTERRUPT_MESSAGE_FOR_TOOL_USE,
    )
  })
})

describe('prepareUserContent', () => {
  test('returns string when no preceding blocks', () => {
    const result = prepareUserContent({
      inputString: 'hello',
      precedingInputBlocks: [],
    })
    expect(result).toBe('hello')
  })

  test('returns array when preceding blocks exist', () => {
    const blocks = [{ type: 'image' as const, source: {} } as any]
    const result = prepareUserContent({
      inputString: 'describe this',
      precedingInputBlocks: blocks,
    })
    expect(Array.isArray(result)).toBe(true)
    expect((result as any[]).length).toBe(2)
    expect((result as any[])[1].text).toBe('describe this')
  })
})

describe('createToolResultStopMessage', () => {
  test('creates tool result with error flag', () => {
    const result = createToolResultStopMessage('tool-123')
    expect(result.type).toBe('tool_result')
    expect(result.is_error).toBe(true)
    expect(result.tool_use_id).toBe('tool-123')
    expect(result.content).toBe(CANCEL_MESSAGE)
  })
})

describe('normalizeContentFromAPI tool input validation', () => {
  test('normalizes valid tool input objects', () => {
    const content = normalizeContentFromAPI(
      [
        {
          type: 'tool_use',
          id: 'toolu_1',
          name: 'TaskGet',
          input: '{"taskId": "1"}',
        } as any,
        {
          type: 'tool_use',
          id: 'toolu_2',
          name: 'TaskUpdate',
          input: '{"status":"completed","taskId":"1"}',
        } as any,
      ],
      [TaskGetTool, TaskUpdateTool] as any,
    )

    expect((content[0] as any).input).toEqual({ taskId: '1' })
    expect((content[1] as any).input).toEqual({
      status: 'completed',
      taskId: '1',
    })
  })

  test('rejects malformed JSON tool inputs', () => {
    for (const input of [
      '{"status": in_progresss", "taskId": "1"}',
      '{"status": completedd", "taskId": "2"}',
      'in_progress',
      '',
    ]) {
      expect(() =>
        normalizeContentFromAPI(
          [
            {
              type: 'tool_use',
              id: 'toolu_1',
              name: 'TaskUpdate',
              input,
            } as any,
          ],
          [TaskUpdateTool] as any,
        ),
      ).toThrow(
        'Model response error: invalid tool call arguments for TaskUpdate. The tool call was not executed.',
      )
    }
  })

  test('rejects non-object JSON tool inputs', () => {
    for (const input of ['null', '[]', '"in_progress"', '1']) {
      expect(() =>
        normalizeContentFromAPI(
          [
            {
              type: 'tool_use',
              id: 'toolu_1',
              name: 'TaskUpdate',
              input,
            } as any,
          ],
          [TaskUpdateTool] as any,
        ),
      ).toThrow(
        'Model response error: invalid tool call arguments for TaskUpdate. The tool call was not executed.',
      )
    }
  })

  test('rejects tool calls without a final name', () => {
    expect(() =>
      normalizeContentFromAPI(
        [
          {
            type: 'tool_use',
            id: 'toolu_1',
            name: '',
            input: '{"taskId":"1"}',
          } as any,
        ],
        [TaskGetTool] as any,
      ),
    ).toThrow(
      'Model response error: invalid tool call without a tool name. The tool call was not executed.',
    )
  })

  test('preserves valid empty object input', () => {
    const content = normalizeContentFromAPI(
      [
        {
          type: 'tool_use',
          id: 'toolu_1',
          name: 'TaskList',
          input: '{}',
        } as any,
      ],
      [] as any,
    )

    expect((content[0] as any).input).toEqual({})
  })
})

// ─── isSyntheticMessage ─────────────────────────────────────────────────

describe('isSyntheticMessage', () => {
  test('identifies interrupt message as synthetic', () => {
    const msg: any = {
      type: 'user',
      message: { content: [{ type: 'text', text: INTERRUPT_MESSAGE }] },
    }
    expect(isSyntheticMessage(msg)).toBe(true)
  })

  test('identifies cancel message as synthetic', () => {
    const msg: any = {
      type: 'user',
      message: { content: [{ type: 'text', text: CANCEL_MESSAGE }] },
    }
    expect(isSyntheticMessage(msg)).toBe(true)
  })

  test('returns false for normal user message', () => {
    const msg: any = {
      type: 'user',
      message: { content: [{ type: 'text', text: 'hello' }] },
    }
    expect(isSyntheticMessage(msg)).toBe(false)
  })

  test('returns false for progress message', () => {
    const msg: any = {
      type: 'progress',
      message: { content: [{ type: 'text', text: INTERRUPT_MESSAGE }] },
    }
    expect(isSyntheticMessage(msg)).toBe(false)
  })

  test('returns false for string content', () => {
    const msg: any = {
      type: 'user',
      message: { content: INTERRUPT_MESSAGE },
    }
    expect(isSyntheticMessage(msg)).toBe(false)
  })
})

// ─── getLastAssistantMessage ────────────────────────────────────────────

describe('getLastAssistantMessage', () => {
  test('returns last assistant message', () => {
    const a1 = makeAssistantMsg([{ type: 'text', text: 'first' }])
    const u = makeUserMsg('mid')
    const a2 = makeAssistantMsg([{ type: 'text', text: 'last' }])
    const result = getLastAssistantMessage([a1, u, a2])
    expect(result).toBe(a2)
  })

  test('returns undefined for empty array', () => {
    expect(getLastAssistantMessage([])).toBeUndefined()
  })

  test('returns undefined when no assistant messages', () => {
    const u = makeUserMsg('hello')
    expect(getLastAssistantMessage([u])).toBeUndefined()
  })
})

// ─── hasToolCallsInLastAssistantTurn ────────────────────────────────────

describe('hasToolCallsInLastAssistantTurn', () => {
  test('returns true when last assistant has tool_use', () => {
    const msg = makeAssistantMsg([
      { type: 'text', text: 'let me check' },
      { type: 'tool_use', id: 't1', name: 'Bash', input: {} },
    ])
    expect(hasToolCallsInLastAssistantTurn([msg])).toBe(true)
  })

  test('returns false when last assistant has only text', () => {
    const msg = makeAssistantMsg([{ type: 'text', text: 'done' }])
    expect(hasToolCallsInLastAssistantTurn([msg])).toBe(false)
  })

  test('returns false for empty messages', () => {
    expect(hasToolCallsInLastAssistantTurn([])).toBe(false)
  })
})

describe('normalizeMessagesForAPI parallel task results', () => {
  test('merges consecutive tool_result messages after one assistant turn', () => {
    const assistant = createAssistantMessage({
      content: [
        {
          type: 'tool_use',
          id: 'task-create-1',
          name: 'TaskCreate',
          input: {
            subject: 'one',
            description: 'first',
          },
        },
        {
          type: 'tool_use',
          id: 'task-create-2',
          name: 'TaskCreate',
          input: {
            subject: 'two',
            description: 'second',
          },
        },
      ] as any,
    })
    const result1 = createUserMessage({
      content: [
        {
          type: 'tool_result',
          tool_use_id: 'task-create-1',
          content: 'Task #1 created',
        },
      ] as any,
      toolUseResult: { task: { id: '1', subject: 'one' } },
      sourceToolAssistantUUID: assistant.uuid as any,
    })
    const result2 = createUserMessage({
      content: [
        {
          type: 'tool_result',
          tool_use_id: 'task-create-2',
          content: 'Task #2 created',
        },
      ] as any,
      toolUseResult: { task: { id: '2', subject: 'two' } },
      sourceToolAssistantUUID: assistant.uuid as any,
    })

    const normalized = normalizeMessagesForAPI([assistant, result1, result2])

    expect(normalized).toHaveLength(2)
    expect(normalized[0]!.type).toBe('assistant')
    expect(normalized[1]!.type).toBe('user')
    const content = normalized[1]!.message.content as any[]
    expect(content.map(block => block.tool_use_id)).toEqual([
      'task-create-1',
      'task-create-2',
    ])
  })
})

// ─── extractTag ─────────────────────────────────────────────────────────

describe('extractTag', () => {
  test('extracts simple tag content', () => {
    expect(extractTag('<foo>bar</foo>', 'foo')).toBe('bar')
  })

  test('extracts tag with attributes', () => {
    expect(extractTag('<foo class="a">bar</foo>', 'foo')).toBe('bar')
  })

  test('handles multiline content', () => {
    expect(extractTag('<foo>\nline1\nline2\n</foo>', 'foo')).toBe(
      '\nline1\nline2\n',
    )
  })

  test('returns null for missing tag', () => {
    expect(extractTag('<foo>bar</foo>', 'baz')).toBeNull()
  })

  test('returns null for empty html', () => {
    expect(extractTag('', 'foo')).toBeNull()
  })

  test('returns null for empty tagName', () => {
    expect(extractTag('<foo>bar</foo>', '')).toBeNull()
  })

  test('is case-insensitive', () => {
    expect(extractTag('<FOO>bar</FOO>', 'foo')).toBe('bar')
  })
})

// ─── isNotEmptyMessage ──────────────────────────────────────────────────

describe('isNotEmptyMessage', () => {
  test('returns true for message with text content', () => {
    const msg: any = {
      type: 'user',
      message: { content: 'hello' },
    }
    expect(isNotEmptyMessage(msg)).toBe(true)
  })

  test('returns false for empty string content', () => {
    const msg: any = {
      type: 'user',
      message: { content: '  ' },
    }
    expect(isNotEmptyMessage(msg)).toBe(false)
  })

  test('returns false for empty content array', () => {
    const msg: any = {
      type: 'user',
      message: { content: [] },
    }
    expect(isNotEmptyMessage(msg)).toBe(false)
  })

  test('returns true for progress message', () => {
    const msg: any = {
      type: 'progress',
      message: { content: [] },
    }
    expect(isNotEmptyMessage(msg)).toBe(true)
  })

  test('returns true for multi-block content', () => {
    const msg: any = {
      type: 'user',
      message: {
        content: [
          { type: 'text', text: 'a' },
          { type: 'text', text: 'b' },
        ],
      },
    }
    expect(isNotEmptyMessage(msg)).toBe(true)
  })

  test('returns true for non-text block', () => {
    const msg: any = {
      type: 'user',
      message: {
        content: [{ type: 'tool_use', id: 't1', name: 'Bash', input: {} }],
      },
    }
    expect(isNotEmptyMessage(msg)).toBe(true)
  })

  test('returns false for whitespace-only text block in content array', () => {
    const msg: any = {
      type: 'user',
      message: {
        content: [{ type: 'text', text: '  ' }],
      },
    }
    expect(isNotEmptyMessage(msg)).toBe(false)
  })
})

// ─── deriveUUID ─────────────────────────────────────────────────────────

describe('deriveUUID', () => {
  test('produces deterministic output', () => {
    const parent = '550e8400-e29b-41d4-a716-446655440000' as any
    expect(deriveUUID(parent, 0)).toBe(deriveUUID(parent, 0))
  })

  test('produces different output for different indices', () => {
    const parent = '550e8400-e29b-41d4-a716-446655440000' as any
    expect(deriveUUID(parent, 0)).not.toBe(deriveUUID(parent, 1))
  })

  test('preserves UUID-like length', () => {
    const parent = '550e8400-e29b-41d4-a716-446655440000' as any
    const derived = deriveUUID(parent, 5)
    expect(derived.length).toBe(parent.length)
  })
})

// ─── isClassifierDenial ─────────────────────────────────────────────────

describe('isClassifierDenial', () => {
  test('returns true for classifier denial prefix', () => {
    expect(
      isClassifierDenial(
        'Permission for this action has been denied. Reason: unsafe',
      ),
    ).toBe(true)
  })

  test('returns false for normal content', () => {
    expect(isClassifierDenial('hello world')).toBe(false)
  })
})

// ─── Message builder functions ──────────────────────────────────────────

describe('AUTO_REJECT_MESSAGE', () => {
  test('includes tool name', () => {
    const msg = AUTO_REJECT_MESSAGE('Bash')
    expect(msg).toContain('Bash')
    expect(msg).toContain('denied')
  })
})

describe('DONT_ASK_REJECT_MESSAGE', () => {
  test('includes tool name and dont ask mode', () => {
    const msg = DONT_ASK_REJECT_MESSAGE('Write')
    expect(msg).toContain('Write')
    expect(msg).toContain("don't ask mode")
  })
})

describe('buildYoloRejectionMessage', () => {
  test('includes reason', () => {
    const msg = buildYoloRejectionMessage('potentially destructive')
    expect(msg).toContain('potentially destructive')
    expect(msg).toContain('denied')
  })
})

describe('buildClassifierUnavailableMessage', () => {
  test('includes tool name and model', () => {
    const msg = buildClassifierUnavailableMessage('Bash', 'classifier-v1')
    expect(msg).toContain('Bash')
    expect(msg).toContain('classifier-v1')
    expect(msg).toContain('unavailable')
  })

  test('tells the model to wait and retry later', () => {
    const msg = buildClassifierUnavailableMessage('Bash', 'classifier-v1')
    expect(msg).toContain('Wait briefly and then try this action again.')
    expect(msg).toContain('come back to it later')
  })
})

describe('normalizeMessages', () => {
  test('splits multi-block assistant message into individual messages', () => {
    const msg = makeAssistantMsg([
      { type: 'text', text: 'first' },
      { type: 'text', text: 'second' },
    ])
    const normalized = normalizeMessages([msg])
    expect(normalized.length).toBe(2)
    // Verify each split message contains only one content block
    expect(normalized[0].message.content).toHaveLength(1)
    expect((normalized[0].message.content as any[])[0].text).toBe('first')
    expect(normalized[1].message.content).toHaveLength(1)
    expect((normalized[1].message.content as any[])[0].text).toBe('second')
  })

  test('handles empty array', () => {
    const result = normalizeMessages([] as AssistantMessage[])
    expect(result).toEqual([])
  })

  test('preserves single-block message', () => {
    const msg = makeAssistantMsg([{ type: 'text', text: 'hello' }])
    const normalized = normalizeMessages([msg])
    expect(normalized.length).toBe(1)
  })
})

describe('normalizeMessagesForAPI', () => {
  test('preserves Gemini thought signature metadata on tool_use blocks', () => {
    const assistant = makeAssistantMsg([
      {
        type: 'tool_use',
        id: 'tool-1',
        name: 'Bash',
        input: { command: 'pwd' },
        _geminiThoughtSignature: 'sig-123',
      },
    ])

    const normalized = normalizeMessagesForAPI([assistant])
    const block = (normalized[0] as AssistantMessage).message!
      .content![0] as any

    expect(block.type).toBe('tool_use')
    expect(block._geminiThoughtSignature).toBe('sig-123')
  })
})