// KAR-776 (R31/R32) — checkEmployeeDependencies must include the RESTRICT FKs
// projects.project_lead_id / projects.created_by_consultant_id, not only the
// CASCADE deps (assignments / project_consultants). Those RESTRICT FKs hard-block
// a delete at the DB level, so they must gate canHardDelete and be named.
import { describe, it, expect, beforeEach, vi } from 'vitest'

const h = vi.hoisted(() => ({
  state: {
    assignments:         0,
    project_consultants: 0,
    ledRows:    [] as Array<Record<string, unknown>>,
    createdRows: [] as Array<Record<string, unknown>>,
  },
}))

vi.mock('@/lib/supabase/admin', () => ({
  createAdminClient: () => ({
    from: (table: string) => {
      if (table === 'assignments') {
        return { select: () => ({ eq: () => Promise.resolve({ count: h.state.assignments, error: null }) }) }
      }
      if (table === 'project_consultants') {
        return { select: () => ({ eq: () => Promise.resolve({ count: h.state.project_consultants, error: null }) }) }
      }
      if (table === 'projects') {
        return {
          select: () => ({
            eq: (col: string) =>
              col === 'project_lead_id'
                ? Promise.resolve({ data: h.state.ledRows, error: null })
                : Promise.resolve({ data: h.state.createdRows, error: null }),
          }),
        }
      }
      throw new Error(`unexpected table ${table}`)
    },
  }),
}))

import { checkEmployeeDependencies } from '@/lib/employees/dependency-check'

const CID = '11111111-1111-1111-1111-111111111111'

beforeEach(() => {
  h.state = { assignments: 0, project_consultants: 0, ledRows: [], createdRows: [] }
})

describe('checkEmployeeDependencies', () => {
  it('no dependencies → deletable', async () => {
    const r = await checkEmployeeDependencies(CID)
    expect(r.canHardDelete).toBe(true)
    expect(r.total).toBe(0)
    expect(r.leadProjects).toEqual([])
  })

  it('cascade-only deps (assignments) still gate hard-delete but are not lead projects', async () => {
    h.state.assignments = 3
    const r = await checkEmployeeDependencies(CID)
    expect(r.assignmentCount).toBe(3)
    expect(r.canHardDelete).toBe(false)
    expect(r.leadProjects).toEqual([])
  })

  it('project lead is named (for the warning) but does NOT block hard-delete (auto-reassigned)', async () => {
    h.state.ledRows = [{ id: 'p1', supplier_name: 'ACME', project_code: 'P-123' }]
    const r = await checkEmployeeDependencies(CID)
    // leadProjects are reassigned by the delete flow, so they are informational only
    expect(r.canHardDelete).toBe(true)
    expect(r.leadProjects).toEqual([
      { id: 'p1', label: 'ACME (P-123)', isLead: true, isCreator: false },
    ])
    expect(r.total).toBe(1)
  })

  it('project creator only → isCreator flagged', async () => {
    h.state.createdRows = [{ id: 'p2', supplier_name: 'Bosch', project_code: null }]
    const r = await checkEmployeeDependencies(CID)
    expect(r.leadProjects).toEqual([
      { id: 'p2', label: 'Bosch', isLead: false, isCreator: true },
    ])
  })

  it('same project as lead AND creator is deduped to one entry', async () => {
    h.state.ledRows     = [{ id: 'p3', supplier_name: 'Conti', project_code: 'P-9' }]
    h.state.createdRows = [{ id: 'p3', supplier_name: 'Conti', project_code: 'P-9' }]
    const r = await checkEmployeeDependencies(CID)
    expect(r.leadProjects).toHaveLength(1)
    expect(r.leadProjects[0]).toEqual({ id: 'p3', label: 'Conti (P-9)', isLead: true, isCreator: true })
    expect(r.total).toBe(1)
  })

  it('null supplier_name falls back to a placeholder label', async () => {
    h.state.ledRows = [{ id: 'p4', supplier_name: null, project_code: null }]
    const r = await checkEmployeeDependencies(CID)
    expect(r.leadProjects[0].label).toBe('Unbenanntes Projekt')
  })

  it('mixed deps sum into total', async () => {
    h.state.assignments         = 2
    h.state.project_consultants = 1
    h.state.ledRows             = [{ id: 'p5', supplier_name: 'X', project_code: null }]
    const r = await checkEmployeeDependencies(CID)
    expect(r.total).toBe(4)
    expect(r.canHardDelete).toBe(false)
  })
})