import { describe, it, expect, afterAll, beforeEach, vi } from 'vitest'
import JSZip from 'jszip'
import { exportProcessor } from '@app/lib/queue/processors/exports'
import { ExportJobName } from '@app/lib/queue/types'
import { buildPrisma, cleanupTestDb, createTestUser } from '../test-helper'

// Intercept all Resend calls
vi.mock('@app/lib/mail', () => ({
  sendEmail: vi.fn().mockResolvedValue({
    data: { id: 'fake-email-id' },
    error: null,
  }),
}))

import { sendEmail } from '@app/lib/mail'
const mockedSendEmail = vi.mocked(sendEmail)

const db = buildPrisma()

const buildJob = (data: unknown, overrides: Record<string, unknown> = {}) =>
  ({
    name: ExportJobName.Data,
    data,
    attemptsMade: 0,
    opts: { attempts: 3 },
    ...overrides,
  }) as any

async function attachmentFromLastEmail() {
  const calls = mockedSendEmail.mock.calls
  const [payload] = calls[calls.length - 1]
  const [attachment] = payload.attachments!

  return { payload, attachment }
}

afterAll(() => db.$disconnect())
beforeEach(async () => {
  await cleanupTestDb(db)
  mockedSendEmail.mockClear()
  mockedSendEmail.mockResolvedValue({ data: { id: 'fake-email-id' }, error: null } as any)
})

describe('exportProcessor', () => {
  it('emails a zip with the profile CSV and a manifest', async () => {
    const user = await createTestUser(db, {
      email: 'export@example.com',
      firstName: 'Ana',
      lastName: 'Silva',
    })

    await exportProcessor(buildJob({ userId: user.id }))

    expect(mockedSendEmail).toHaveBeenCalledOnce()

    const { payload, attachment } = await attachmentFromLastEmail()
    expect(payload.to).toBe('export@example.com')
    expect(payload.subject).toBe('Seus dados do nexo')
    expect(attachment.filename).toMatch(/^nexo-dados-\d{4}-\d{2}-\d{2}\.zip$/)

    const zip = await JSZip.loadAsync(attachment.content)
    expect(Object.keys(zip.files).sort()).toEqual(['leia-me.md', 'profile.csv'])

    const csv = await zip.file('profile.csv')!.async('string')
    expect(csv.startsWith('\ufeff')).toBe(true)

    const lines = csv.slice(1).split('\r\n').filter(Boolean)
    expect(lines).toHaveLength(2)
    expect(lines[0]).toContain('Nome')
    expect(lines[0]).toContain('Email')

    const [row] = lines.slice(1)
    expect(row).toContain('"Ana"')
    expect(row).toContain('"Silva"')
    expect(row).toContain('"export@example.com"')
    expect(row).toContain('"Sim"') // notifications default to enabled
    expect(row).toContain('"Não"') // freshly created users are inactive

    // Secrets must never travel in the export
    const lower = csv.toLowerCase()
    expect(lower).not.toContain('senha')
    expect(lower).not.toContain('token')
    expect(lower).not.toContain('push')
    expect(lower).not.toContain('avatar')

    const manifest = await zip.file('leia-me.md')!.async('string')
    expect(manifest).toContain('`profile.csv`')
    expect(manifest).toContain('1 registro')
    expect(manifest).toContain('_id')
  })

  it('preserves commas, quotes and newlines inside a field', async () => {
    const user = await createTestUser(db, {
      email: 'quoted@example.com',
      lastName: 'Silva, "S"\nJunior',
    })

    await exportProcessor(buildJob({ userId: user.id }))

    const { attachment } = await attachmentFromLastEmail()
    const zip = await JSZip.loadAsync(attachment.content)
    const csv = await zip.file('profile.csv')!.async('string')

    expect(csv).toContain('"Silva, ""S""\nJunior"')
  })

  it('sends the failure email only on the final attempt', async () => {
    const user = await createTestUser(db, { email: 'fail@example.com' })
    mockedSendEmail
      .mockRejectedValueOnce(new Error('boom'))
      .mockResolvedValueOnce({ data: { id: 'fake-email-id' }, error: null })

    await expect(
      exportProcessor(buildJob({ userId: user.id }, { attemptsMade: 2, opts: { attempts: 3 } }))
    ).rejects.toThrow('boom')

    expect(mockedSendEmail).toHaveBeenCalledTimes(2)
    expect(mockedSendEmail.mock.calls[1][0].subject).toBe(
      'Não conseguimos exportar seus dados'
    )
  })

  it('does not send the failure email on a non-final attempt', async () => {
    const user = await createTestUser(db, { email: 'retry@example.com' })
    mockedSendEmail.mockRejectedValueOnce(new Error('boom'))

    await expect(
      exportProcessor(buildJob({ userId: user.id }, { attemptsMade: 0, opts: { attempts: 3 } }))
    ).rejects.toThrow('boom')

    expect(mockedSendEmail).toHaveBeenCalledOnce()
  })

  it('throws for unknown job names', async () => {
    await expect(
      exportProcessor({ name: 'export:unknown', data: {} } as any)
    ).rejects.toThrow('Unknown export job')
  })
})