import { describe, it, expect, vi, beforeEach } from 'vitest'

vi.mock('next/cache', () => ({ revalidatePath: vi.fn() }))
vi.mock('next/headers', () => ({ cookies: vi.fn().mockResolvedValue({}) }))
vi.mock('iron-session', () => ({
  getIronSession: vi.fn().mockResolvedValue({ userId: 'user-1', isDemo: false }),
}))
vi.mock('@/lib/session', () => ({
  sessionOptions: { cookieName: 'test', password: 'test' },
}))
vi.mock('@/lib/product-access', () => ({
  productAccessFilter: vi.fn().mockReturnValue({}),
  getAccessibleProduct: vi.fn().mockResolvedValue({ id: 'product-1', user_id: 'user-1' }),
}))
vi.mock('@/lib/prisma', () => ({
  prisma: {
    sprint: {
      findFirst: vi.fn(),
      create: vi.fn(),
      update: vi.fn(),
    },
  },
}))

import { prisma } from '@/lib/prisma'
import { createSprintAction, updateSprintDatesAction } from '@/actions/sprints'

const mockSprint = prisma as unknown as { sprint: { findFirst: ReturnType<typeof vi.fn>; create: ReturnType<typeof vi.fn>; update: ReturnType<typeof vi.fn> } }

function makeFormData(data: Record<string, string | null>) {
  const fd = new FormData()
  for (const [k, v] of Object.entries(data)) {
    if (v !== null) fd.append(k, v)
  }
  return fd
}

describe('createSprintAction — date validation', () => {
  beforeEach(() => {
    vi.clearAllMocks()
    mockSprint.sprint.findFirst.mockResolvedValue(null)
    mockSprint.sprint.create.mockResolvedValue({ id: 'sprint-1' })
  })

  it('accepts valid start_date + end_date', async () => {
    const fd = makeFormData({ productId: 'product-1', sprint_goal: 'Doel', start_date: '2026-05-01', end_date: '2026-05-14' })
    const result = await createSprintAction(undefined, fd)
    expect(result.success).toBe(true)
    expect(mockSprint.sprint.create).toHaveBeenCalledWith(
      expect.objectContaining({ data: expect.objectContaining({ start_date: new Date('2026-05-01'), end_date: new Date('2026-05-14') }) })
    )
  })

  it('rejects end_date before start_date', async () => {
    const fd = makeFormData({ productId: 'product-1', sprint_goal: 'Doel', start_date: '2026-05-14', end_date: '2026-05-01' })
    const result = await createSprintAction(undefined, fd) as { code?: number; fieldErrors?: Record<string, string[]> }
    expect(result.code).toBe(422)
    expect(result.fieldErrors?.end_date?.[0]).toContain('Einddatum')
  })

  it('accepts no dates (both optional)', async () => {
    const fd = makeFormData({ productId: 'product-1', sprint_goal: 'Doel', start_date: '', end_date: '' })
    const result = await createSprintAction(undefined, fd)
    expect(result.success).toBe(true)
  })
})

describe('updateSprintDatesAction — date validation', () => {
  beforeEach(() => {
    vi.clearAllMocks()
    mockSprint.sprint.findFirst.mockResolvedValue({ id: 'sprint-1', product_id: 'product-1' })
    mockSprint.sprint.update.mockResolvedValue({})
  })

  it('saves valid dates', async () => {
    const fd = makeFormData({ id: 'sprint-1', start_date: '2026-05-01', end_date: '2026-05-14' })
    const result = await updateSprintDatesAction(undefined, fd)
    expect(result.success).toBe(true)
  })

  it('rejects end_date before start_date', async () => {
    const fd = makeFormData({ id: 'sprint-1', start_date: '2026-05-10', end_date: '2026-05-05' })
    const result = await updateSprintDatesAction(undefined, fd) as { code?: number; fieldErrors?: Record<string, string[]> }
    expect(result.code).toBe(422)
    expect(result.fieldErrors?.end_date?.[0]).toContain('Einddatum')
  })

  it('blocks demo users', async () => {
    const { getIronSession } = await import('iron-session')
    vi.mocked(getIronSession).mockResolvedValueOnce({ userId: 'user-1', isDemo: true } as never)
    const fd = makeFormData({ id: 'sprint-1', start_date: '', end_date: '' })
    const result = await updateSprintDatesAction(undefined, fd)
    expect(result.error).toBe('Niet beschikbaar in demo-modus')
  })
})