import { describe, it, expect } from 'vitest'
import {
  buildPhaseConfigCss,
  cssVarNameForPhase,
  cssVarRefForPhase,
  FALLBACK_HEX,
  getPhaseEntry,
  isValidHexColor,
  phaseConfigKeyForIntakePriority,
  phaseConfigKeyForIntakeStatus,
  resolvePhaseHex,
  type PhaseConfigEntry,
} from '@/lib/intake/phase-config'

const ENTRY = (
  key: string,
  hex: string,
  active: boolean = true,
): PhaseConfigEntry => ({
  phase_key: key,
  label_de: key,
  label_en: null,
  color_hex: hex,
  sort_order: 0,
  is_active: active,
})

describe('phase-config — hex validation', () => {
  it('accepts well-formed 6-digit hex', () => {
    expect(isValidHexColor('#037493')).toBe(true)
    expect(isValidHexColor('#abcdef')).toBe(true)
    expect(isValidHexColor('#000000')).toBe(true)
  })
  it('rejects invalid hex', () => {
    expect(isValidHexColor('0066B1')).toBe(false)
    expect(isValidHexColor('#0066B')).toBe(false)
    expect(isValidHexColor('#0066B11')).toBe(false)
    expect(isValidHexColor('#ZZZZZZ')).toBe(false)
    expect(isValidHexColor('rgb(0,0,0)')).toBe(false)
  })
})

describe('phase-config — key builders', () => {
  it('builds intake_status_<status> keys', () => {
    expect(phaseConfigKeyForIntakeStatus('backlog')).toBe('intake_status_backlog')
    expect(phaseConfigKeyForIntakeStatus('promoted')).toBe('intake_status_promoted')
  })
  it('builds intake_priority_<priority> keys', () => {
    expect(phaseConfigKeyForIntakePriority('escalation')).toBe('intake_priority_escalation')
  })
})

describe('phase-config — CSS variable naming', () => {
  it('replaces underscores with dashes', () => {
    expect(cssVarNameForPhase('intake_status_backlog')).toBe('--phase-intake-status-backlog')
  })
  it('produces var() references with fallback', () => {
    const ref = cssVarRefForPhase('intake_priority_high', '#FFCC00')
    expect(ref).toBe('var(--phase-intake-priority-high, #FFCC00)')
  })
})

describe('phase-config — CSS generation', () => {
  it('emits valid :root block with active entries only', () => {
    const css = buildPhaseConfigCss([
      ENTRY('intake_status_backlog', '#037493', true),
      ENTRY('intake_status_review', '#003D6B', false),
      ENTRY('intake_priority_high', '#FFCC00', true),
    ])
    expect(css).toContain(':root {')
    expect(css).toContain('  --phase-intake-status-backlog: #037493;')
    expect(css).toContain('  --phase-intake-priority-high: #FFCC00;')
    expect(css).not.toContain('--phase-intake-status-review')
    expect(css.trim().endsWith('}')).toBe(true)
  })

  it('skips entries with invalid hex', () => {
    const css = buildPhaseConfigCss([
      ENTRY('intake_status_backlog', 'not-a-hex'),
      ENTRY('intake_priority_low', '#6B7A8D'),
    ])
    expect(css).not.toContain('intake-status-backlog')
    expect(css).toContain('--phase-intake-priority-low: #6B7A8D;')
  })
})

describe('phase-config — hex resolution with fallback', () => {
  it('returns active entry color when present', () => {
    const entries = [ENTRY('intake_priority_high', '#FF0000', true)]
    expect(resolvePhaseHex(entries, 'intake_priority_high')).toBe('#FF0000')
  })
  it('falls back to FALLBACK_HEX when entry missing', () => {
    expect(resolvePhaseHex([], 'intake_priority_escalation')).toBe(
      FALLBACK_HEX.intake_priority_escalation,
    )
  })
  it('falls back when entry inactive', () => {
    const entries = [ENTRY('intake_status_archived', '#FF0000', false)]
    expect(resolvePhaseHex(entries, 'intake_status_archived')).toBe(
      FALLBACK_HEX.intake_status_archived,
    )
  })
  it('falls back when entry has malformed hex', () => {
    const entries = [ENTRY('intake_status_backlog', 'not-a-hex', true)]
    expect(resolvePhaseHex(entries, 'intake_status_backlog')).toBe(
      FALLBACK_HEX.intake_status_backlog,
    )
  })
  it('uses default-blue when no fallback known', () => {
    expect(resolvePhaseHex([], 'custom_unknown_key')).toBe('#037493')
  })
})

describe('phase-config — FALLBACK_HEX coverage', () => {
  it('covers all 5 intake_status keys', () => {
    for (const s of ['backlog', 'review', 'promoted', 'rejected', 'archived'] as const) {
      expect(FALLBACK_HEX[`intake_status_${s}`]).toMatch(/^#[0-9A-Fa-f]{6}$/)
    }
  })
  it('covers all 4 intake_priority keys', () => {
    for (const p of ['low', 'normal', 'high', 'escalation'] as const) {
      expect(FALLBACK_HEX[`intake_priority_${p}`]).toMatch(/^#[0-9A-Fa-f]{6}$/)
    }
  })
})

describe('phase-config — getPhaseEntry', () => {
  it('returns active entry', () => {
    const entries = [ENTRY('intake_status_backlog', '#037493', true)]
    expect(getPhaseEntry(entries, 'intake_status_backlog')?.color_hex).toBe('#037493')
  })
  it('returns null for inactive', () => {
    const entries = [ENTRY('intake_status_backlog', '#037493', false)]
    expect(getPhaseEntry(entries, 'intake_status_backlog')).toBeNull()
  })
  it('returns null for missing key', () => {
    expect(getPhaseEntry([], 'intake_status_backlog')).toBeNull()
  })
})