import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
import { eventBus } from '@/lib/events/bus'
import { makeTransaction, makeInvoice, makeCustomer, makeFiscalPeriod } from '@/tests/helpers'

// Mock the service client
const mockInsert = vi.fn().mockResolvedValue({ error: null })
vi.mock('@/lib/auth/api-keys', () => ({
  createServiceClientNoCookies: () => ({
    from: () => ({
      insert: mockInsert,
    }),
  }),
}))

// Import after mocks
import { registerEventLogHandler } from '../event-log-handler'

describe('event-log-handler', () => {
  let unsubscribers: (() => void)[]

  beforeEach(() => {
    vi.clearAllMocks()
    eventBus.clear()
    mockInsert.mockResolvedValue({ error: null })
    unsubscribers = registerEventLogHandler()
  })

  afterEach(() => {
    unsubscribers.forEach(unsub => unsub())
  })

  it('persists invoice.created event with correct entity_id', async () => {
    const invoice = makeInvoice({ id: 'inv-123' })

    await eventBus.emit({
      type: 'invoice.created',
      payload: { invoice, userId: 'user-1', companyId: 'company-1' },
    })

    expect(mockInsert).toHaveBeenCalledTimes(1)
    expect(mockInsert).toHaveBeenCalledWith(
      expect.objectContaining({
        user_id: 'user-1',
        company_id: 'company-1',
        event_type: 'invoice.created',
        entity_id: 'inv-123',
      })
    )

    // Data should NOT contain userId (it's in its own column)
    const insertedData = mockInsert.mock.calls[0][0].data
    expect(insertedData).not.toHaveProperty('userId')
    expect(insertedData).toHaveProperty('invoice')
  })

  it('persists customer.created event', async () => {
    const customer = makeCustomer({ id: 'cust-456' })

    await eventBus.emit({
      type: 'customer.created',
      payload: { customer, userId: 'user-1', companyId: 'company-1' },
    })

    expect(mockInsert).toHaveBeenCalledTimes(1)
    expect(mockInsert).toHaveBeenCalledWith(
      expect.objectContaining({
        user_id: 'user-1',
        company_id: 'company-1',
        event_type: 'customer.created',
        entity_id: 'cust-456',
      })
    )
  })

  it('batch-inserts transaction.synced as individual rows', async () => {
    const tx1 = makeTransaction({ id: 'tx-1' })
    const tx2 = makeTransaction({ id: 'tx-2' })
    const tx3 = makeTransaction({ id: 'tx-3' })

    await eventBus.emit({
      type: 'transaction.synced',
      payload: { transactions: [tx1, tx2, tx3], userId: 'user-1', companyId: 'company-1' },
    })

    expect(mockInsert).toHaveBeenCalledTimes(1)
    const rows = mockInsert.mock.calls[0][0]
    expect(rows).toHaveLength(3)
    expect(rows[0]).toMatchObject({ event_type: 'transaction.synced', entity_id: 'tx-1', company_id: 'company-1' })
    expect(rows[1]).toMatchObject({ event_type: 'transaction.synced', entity_id: 'tx-2', company_id: 'company-1' })
    expect(rows[2]).toMatchObject({ event_type: 'transaction.synced', entity_id: 'tx-3', company_id: 'company-1' })
  })

  it('does NOT persist journal_entry.drafted (excluded noise event)', async () => {
    await eventBus.emit({
      type: 'journal_entry.drafted',
      payload: { entry: {} as never, userId: 'user-1', companyId: 'company-1' },
    })

    expect(mockInsert).not.toHaveBeenCalled()
  })

  it('does NOT persist receipt.extracted (excluded noise event)', async () => {
    await eventBus.emit({
      type: 'receipt.extracted',
      payload: { receipt: {} as never, documentId: null, confidence: 0.9, userId: 'user-1', companyId: 'company-1' },
    })

    expect(mockInsert).not.toHaveBeenCalled()
  })

  it('does NOT persist supplier_invoice.received (excluded noise event)', async () => {
    await eventBus.emit({
      type: 'supplier_invoice.received',
      payload: { inboxItem: {} as never, userId: 'user-1', companyId: 'company-1' },
    })

    expect(mockInsert).not.toHaveBeenCalled()
  })

  it('does NOT persist supplier_invoice.extracted (excluded noise event)', async () => {
    await eventBus.emit({
      type: 'supplier_invoice.extracted',
      payload: { inboxItem: {} as never, confidence: 0.9, userId: 'user-1', companyId: 'company-1' },
    })

    expect(mockInsert).not.toHaveBeenCalled()
  })

  it('does not throw when persistence fails', async () => {
    mockInsert.mockResolvedValue({ error: { message: 'DB down' } })

    // Should not throw
    await eventBus.emit({
      type: 'customer.created',
      payload: { customer: makeCustomer(), userId: 'user-1', companyId: 'company-1' },
    })

    expect(mockInsert).toHaveBeenCalledTimes(1)
  })

  it('persists period.locked with period entity_id', async () => {
    const period = makeFiscalPeriod({ id: 'period-1' })

    await eventBus.emit({
      type: 'period.locked',
      payload: { period, userId: 'user-1', companyId: 'company-1' },
    })

    expect(mockInsert).toHaveBeenCalledWith(
      expect.objectContaining({
        event_type: 'period.locked',
        entity_id: 'period-1',
        company_id: 'company-1',
      })
    )
  })

  it('skips insert when companyId is missing from payload', async () => {
    await eventBus.emit({
      type: 'customer.created',
      // deliberate bypass of TS types to simulate a future caller forgetting companyId
      payload: { customer: makeCustomer(), userId: 'user-1' } as never,
    })

    expect(mockInsert).not.toHaveBeenCalled()
  })

  it('skips batch insert when companyId is missing from payload', async () => {
    await eventBus.emit({
      type: 'transaction.synced',
      payload: { transactions: [makeTransaction({ id: 'tx-1' })], userId: 'user-1' } as never,
    })

    expect(mockInsert).not.toHaveBeenCalled()
  })
})