import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
import { randomUUID } from 'node:crypto'

// Capture calls to sendToSessionParticipant so we can assert the 3-min warning event.
vi.mock('../../src/plugins/websocket.js', () => ({
  sendToUser: vi.fn(() => true),
  sendToSessionParticipant: vi.fn(() => true),
  registerWebSocketPlugin: vi.fn(),
  registerWebSocketRoute: vi.fn(),
  isUserOnlineWs: vi.fn(() => true),
  getSessionConnections: vi.fn(() => ({})),
}))

vi.mock('../../src/services/notification.service.js', () => ({
  sendPushNotification: vi.fn(async () => true),
  registerDeviceToken: vi.fn(async () => {}),
}))

// Real DB queries don't settle under fake timers (they're real socket I/O, not
// microtasks). Stub getDb() with a tagged-template-compatible mock so onThreeMinuteWarning's
// `SELECT expires_at FROM chat_sessions WHERE id = ${sessionId}` resolves synchronously.
vi.mock('../../src/db/client.js', () => {
  const fakeSql = () => Promise.resolve([{ expires_at: null }])
  fakeSql.unsafe = () => Promise.resolve([])
  fakeSql.array = (arr) => arr
  fakeSql.json = (v) => v
  return { getDb: () => fakeSql }
})

vi.mock('../../src/plugins/valkey.js', () => {
  const noopPipeline = { sadd: () => noopPipeline, srem: () => noopPipeline, set: () => noopPipeline, get: () => noopPipeline, del: () => noopPipeline, exec: async () => [] }
  return {
    publish: vi.fn(async () => {}),
    subscribe: vi.fn(() => () => {}),
    onValkeyReady: vi.fn(),
    getValkeyClient: vi.fn(() => ({ setex: vi.fn(async () => 'OK') })),
    getValkeyPub: vi.fn(),
    getValkeySub: vi.fn(),
    sadd: vi.fn(async () => 1),
    srem: vi.fn(async () => 1),
    sismember: vi.fn(async () => false),
    smembers: vi.fn(async () => []),
    sdiff: vi.fn(async () => []),
    scard: vi.fn(async () => 0),
    set: vi.fn(async () => 'OK'),
    get: vi.fn(async () => null),
    del: vi.fn(async () => 1),
    incr: vi.fn(async () => 1),
    decr: vi.fn(async () => 0),
    exists: vi.fn(async () => 0),
    pipeline: vi.fn(() => noopPipeline),
    multi: vi.fn(() => noopPipeline),
  }
})

const { sendToSessionParticipant } = await import('../../src/plugins/websocket.js')
const { startSessionTimer, clearSessionTimer } = await import('../../src/services/session-timer.service.js')
const { WsMessage, UserType } = await import('../../src/constants.js')

describe('session-timer 3-minute warning (Phase 4)', () => {
  beforeEach(() => {
    vi.useFakeTimers()
    sendToSessionParticipant.mockClear()
  })

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

  it('emits session_warning kind:three_minutes_left exactly once at the 3-min mark', async () => {
    // Real UUID — onThreeMinuteWarning runs a Postgres SELECT against chat_sessions.id
    // which is uuid-typed; string ids throw a parse error before we hit the row check.
    const sessionId = randomUUID()
    const expiresAt = new Date(Date.now() + 5 * 60_000) // 5 minutes from now

    startSessionTimer(sessionId, expiresAt)

    // Advance 1 min 59 s — well before the 2-min mark when the 3-min warning fires.
    await vi.advanceTimersByTimeAsync(60_000 + 59_000)
    const warnCallsEarly = sendToSessionParticipant.mock.calls.filter(
      ([, , data]) => data?.type === WsMessage.SESSION_WARNING,
    )
    expect(warnCallsEarly).toHaveLength(0)

    // Cross the 3-min-left threshold. 5 min total - 3 min = warning fires at t=2:00.
    await vi.advanceTimersByTimeAsync(2_000)
    // sendToSessionParticipant signature: (sessionId, userType, data)
    const warnCalls = sendToSessionParticipant.mock.calls.filter(
      ([, , data]) => data?.type === WsMessage.SESSION_WARNING,
    )
    expect(warnCalls).toHaveLength(1)
    const [calledSessionId, userType, data] = warnCalls[0]
    expect(calledSessionId).toBe(sessionId)
    expect(userType).toBe(UserType.CUSTOMER)
    expect(data.kind).toBe('three_minutes_left')
    expect(data.session_id).toBe(sessionId)

    // Cleanup before expiry hits.
    clearSessionTimer(sessionId)
  })

  it('does NOT re-fire the 3-min warning when the timer is rescheduled (e.g. extension)', async () => {
    const sessionId = randomUUID()
    const initial = new Date(Date.now() + 5 * 60_000)
    startSessionTimer(sessionId, initial)

    // Cross the 3-min mark on the original schedule.
    await vi.advanceTimersByTimeAsync(2 * 60_000 + 1_000)
    let warnCalls = sendToSessionParticipant.mock.calls.filter(
      ([, , data]) => data?.type === WsMessage.SESSION_WARNING,
    )
    expect(warnCalls).toHaveLength(1)

    // Extension reschedules — give a new 5-min window. The 3-min warning must NOT fire again.
    const extended = new Date(Date.now() + 5 * 60_000)
    startSessionTimer(sessionId, extended)
    await vi.advanceTimersByTimeAsync(2 * 60_000 + 1_000)

    warnCalls = sendToSessionParticipant.mock.calls.filter(
      ([, , data]) => data?.type === WsMessage.SESSION_WARNING,
    )
    expect(warnCalls).toHaveLength(1) // still 1, no double-fire

    clearSessionTimer(sessionId)
  })
})