import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import { ref, type Ref } from 'vue'
import { useHumanChallenge } from '../useHumanChallenge'

// Mock global fetch
const mockFetch = vi.fn()
vi.stubGlobal('fetch', mockFetch)

function makeChallengeData(overrides: Record<string, unknown> = {}) {
  return {
    type: 'bitcoin_trivia',
    label: 'Bitcoin Trivia',
    prompt: 'Who is Satoshi Nakamoto?',
    roundNumber: 1,
    timeoutMs: 10000,
    scoring: 'factual',
    choices: [],
    ...overrides,
  }
}

describe('useHumanChallenge', () => {
  let fightId: Ref<string>
  let myBotId: Ref<string | null>

  beforeEach(() => {
    vi.useFakeTimers()
    vi.clearAllMocks()
    fightId = ref('fight-1') as Ref<string>
    myBotId = ref<string | null>('bot-1')
    mockFetch.mockResolvedValue({
      ok: true,
      status: 200,
      json: () => Promise.resolve({}),
    })
  })

  afterEach(() => {
    vi.useRealTimers()
  })

  it('applyChallenge sets challenge state correctly', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    const data = makeChallengeData({ roundNumber: 3, choices: ['A', 'B', 'C'] })

    hc.applyChallenge(data)

    expect(hc.humanChallenge.value).not.toBeNull()
    expect(hc.humanChallenge.value!.type).toBe('bitcoin_trivia')
    expect(hc.humanChallenge.value!.prompt).toBe('Who is Satoshi Nakamoto?')
    expect(hc.humanChallenge.value!.roundNumber).toBe(3)
    expect(hc.humanChallenge.value!.scoring).toBe('factual')
    expect(hc.humanChoices.value).toEqual(['A', 'B', 'C'])
    expect(hc.humanAnswer.value).toBe('')
    expect(hc.humanSubmitted.value).toBe(false)
    expect(hc.humanTimer.value).toBeGreaterThan(0)
  })

  it('applyChallenge deduplicates same round', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    const data = makeChallengeData({ roundNumber: 1 })

    hc.applyChallenge(data)
    const firstChallenge = hc.humanChallenge.value

    // Apply same round again — should be no-op
    hc.applyChallenge(data)
    expect(hc.humanChallenge.value).toBe(firstChallenge)
  })

  it('applyChallenge allows different round numbers', () => {
    const hc = useHumanChallenge(fightId, myBotId)

    hc.applyChallenge(makeChallengeData({ roundNumber: 1 }))
    expect(hc.humanChallenge.value!.roundNumber).toBe(1)

    hc.applyChallenge(makeChallengeData({ roundNumber: 2, prompt: 'New prompt' }))
    expect(hc.humanChallenge.value!.roundNumber).toBe(2)
    expect(hc.humanChallenge.value!.prompt).toBe('New prompt')
  })

  it('timer counts down each second', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData({ timeoutMs: 8000 }))

    const initialTimer = hc.humanTimer.value

    vi.advanceTimersByTime(1000)
    expect(hc.humanTimer.value).toBe(initialTimer - 1)

    vi.advanceTimersByTime(1000)
    expect(hc.humanTimer.value).toBe(initialTimer - 2)
  })

  it('timeout clears challenge state and submits timeout', async () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData({ timeoutMs: 6000 }))

    // Advance past all timer ticks until timer reaches 0
    const timerVal = hc.humanTimer.value
    vi.advanceTimersByTime(timerVal * 1000)

    expect(hc.humanSubmitted.value).toBe(true)

    // submitTimeout should have been called — verify the fetch
    await vi.runAllTimersAsync()
    expect(mockFetch).toHaveBeenCalledWith(
      '/api/fights/fight-1/respond/bot-1',
      expect.objectContaining({
        method: 'POST',
        body: JSON.stringify({ answer: '', timeout: true }),
      }),
    )
  })

  it('submitHumanAnswer sends answer to API', async () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData())
    hc.humanAnswer.value = 'A cypherpunk legend'

    await hc.submitHumanAnswer()

    expect(hc.humanSubmitted.value).toBe(true)
    expect(mockFetch).toHaveBeenCalledWith(
      '/api/fights/fight-1/respond/bot-1',
      expect.objectContaining({
        method: 'POST',
        body: JSON.stringify({ answer: 'A cypherpunk legend' }),
      }),
    )
  })

  it('submitHumanAnswer does not submit empty answer', async () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData())
    hc.humanAnswer.value = '   '

    await hc.submitHumanAnswer()

    expect(hc.humanSubmitted.value).toBe(false)
    expect(mockFetch).not.toHaveBeenCalled()
  })

  it('submitHumanAnswer does not submit without botId', async () => {
    myBotId.value = null
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData())
    hc.humanAnswer.value = 'test'

    await hc.submitHumanAnswer()

    expect(hc.humanSubmitted.value).toBe(false)
    expect(mockFetch).not.toHaveBeenCalled()
  })

  it('submitChoice sets answer and submits', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData({ choices: ['21M', '42M', '100M'] }))

    hc.submitChoice('21M')

    expect(hc.humanAnswer.value).toBe('21M')
    expect(hc.humanSubmitted.value).toBe(true)
    expect(mockFetch).toHaveBeenCalledWith(
      '/api/fights/fight-1/respond/bot-1',
      expect.objectContaining({
        method: 'POST',
        body: JSON.stringify({ answer: '21M' }),
      }),
    )
  })

  it('submitChoice prevents double-tap', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData({ choices: ['A', 'B'] }))

    hc.submitChoice('A')
    mockFetch.mockClear()

    // Second tap should be ignored
    hc.submitChoice('B')
    expect(hc.humanAnswer.value).toBe('A')
    expect(mockFetch).not.toHaveBeenCalled()
  })

  it('cooldown prevents immediate resubmission', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.startCooldown(3)

    expect(hc.roundCooldown.value).toBe(3)

    vi.advanceTimersByTime(1000)
    expect(hc.roundCooldown.value).toBe(2)

    vi.advanceTimersByTime(1000)
    expect(hc.roundCooldown.value).toBe(1)

    vi.advanceTimersByTime(1000)
    expect(hc.roundCooldown.value).toBe(0)
  })

  it('cooldown applies pending challenge when finished', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    const pendingData = makeChallengeData({ roundNumber: 5 })

    // Queue a pending challenge during cooldown
    hc.startCooldown(2)
    hc.pendingChallengeData.value = { data: pendingData, receivedAt: Date.now() }

    // Advance past cooldown
    vi.advanceTimersByTime(2000)

    expect(hc.roundCooldown.value).toBe(0)
    expect(hc.humanChallenge.value).not.toBeNull()
    expect(hc.humanChallenge.value!.roundNumber).toBe(5)
    expect(hc.pendingChallengeData.value).toBeNull()
  })

  it('resetState clears all state', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData({ choices: ['X'] }))
    hc.humanAnswer.value = 'test answer'

    hc.resetState()

    expect(hc.humanChallenge.value).toBeNull()
    expect(hc.humanAnswer.value).toBe('')
    expect(hc.humanSubmitted.value).toBe(false)
    expect(hc.humanChoices.value).toEqual([])
    expect(hc.roundCooldown.value).toBe(0)
    expect(hc.pendingChallengeData.value).toBeNull()
    expect(hc.entrancePlaying.value).toBe(false)
    expect(hc.animatingRound.value).toBe(false)
  })

  it('handleSSEChallenge queues when entrance is playing', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.entrancePlaying.value = true

    const data = makeChallengeData({ roundNumber: 1 })
    hc.handleSSEChallenge(data)

    // Should be queued, not applied
    expect(hc.humanChallenge.value).toBeNull()
    expect(hc.pendingChallengeData.value).not.toBeNull()
    expect(hc.pendingChallengeData.value!.data).toEqual(data)
  })

  it('handleSSEChallenge applies immediately when not blocked', () => {
    const hc = useHumanChallenge(fightId, myBotId)

    const data = makeChallengeData({ roundNumber: 1 })
    hc.handleSSEChallenge(data)

    expect(hc.humanChallenge.value).not.toBeNull()
    expect(hc.humanChallenge.value!.roundNumber).toBe(1)
  })

  it('setEntrancePlaying applies pending challenge when entrance ends', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.entrancePlaying.value = true

    const data = makeChallengeData({ roundNumber: 2 })
    hc.pendingChallengeData.value = { data, receivedAt: Date.now() }

    hc.setEntrancePlaying(false)

    expect(hc.entrancePlaying.value).toBe(false)
    expect(hc.humanChallenge.value).not.toBeNull()
    expect(hc.humanChallenge.value!.roundNumber).toBe(2)
    expect(hc.pendingChallengeData.value).toBeNull()
  })

  it('applyChallenge guarantees minimum display time', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    // remainingMs of 2000 is below MIN_DISPLAY_MS (5000), so it should clamp up
    hc.applyChallenge(makeChallengeData({ remainingMs: 2000 }))

    // Timer should be at least 5 seconds (MIN_DISPLAY_MS / 1000)
    expect(hc.humanTimer.value).toBeGreaterThanOrEqual(5)
    expect(hc.humanChallenge.value!.remainingMs).toBeGreaterThanOrEqual(5000)
  })

  it('stopHumanPolling clears all interval handles', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData())
    hc.startCooldown(5)

    // This should not throw and should clean up intervals
    hc.stopHumanPolling()

    // Advancing timers should not change state
    const timerVal = hc.humanTimer.value
    const cooldownVal = hc.roundCooldown.value
    vi.advanceTimersByTime(5000)
    expect(hc.humanTimer.value).toBe(timerVal)
    expect(hc.roundCooldown.value).toBe(cooldownVal)
  })

  it('clearChallenge removes challenge but preserves other state', () => {
    const hc = useHumanChallenge(fightId, myBotId)
    hc.applyChallenge(makeChallengeData({ choices: ['A', 'B'] }))
    hc.startCooldown(3)

    hc.clearChallenge()

    expect(hc.humanChallenge.value).toBeNull()
    expect(hc.humanSubmitted.value).toBe(false)
    expect(hc.pendingChallengeData.value).toBeNull()
    // Cooldown should still be running (clearChallenge doesn't touch it)
    expect(hc.roundCooldown.value).toBe(3)
  })
})