// Loop 8: Coverage-Lese-Boundary — Positiv-, Negativ-, Gegen-Proben.
import { describe, it, expect } from 'vitest'
import { coverageFromPersistedMatrix, CAPABILITY_MODULE_LABELS_DE } from '../coverage-view'
import { CAPABILITY_MODULES } from '../types'

describe('coverageFromPersistedMatrix', () => {
  it('negative: no persisted stand (null/undefined/garbage) → null, NEVER reinterpreted as MISSING', () => {
    expect(coverageFromPersistedMatrix(null)).toBeNull()
    expect(coverageFromPersistedMatrix(undefined)).toBeNull()
    expect(coverageFromPersistedMatrix('kaputt')).toBeNull()
    expect(coverageFromPersistedMatrix({})).toBeNull()
    expect(coverageFromPersistedMatrix({ modules: 'nicht-array' })).toBeNull()
  })

  it('positive: a valid matrix yields all 8 modules in canonical order with translated status', () => {
    const entries = coverageFromPersistedMatrix({
      modules: [
        { module: 'SUMMARY', status: 'AVAILABLE' },
        { module: 'MATERIAL', status: 'PARTIAL' },
        { module: 'RMR', status: 'MISSING' },
      ],
    })
    expect(entries).not.toBeNull()
    expect(entries!.map((e) => e.module)).toEqual([...CAPABILITY_MODULES])
    expect(entries!.find((e) => e.module === 'SUMMARY')?.statusLabelDe).toBe('vorhanden')
    expect(entries!.find((e) => e.module === 'MATERIAL')?.statusLabelDe).toBe('teilweise')
    expect(entries!.find((e) => e.module === 'RMR')?.statusLabelDe).toBe('nicht enthalten')
  })

  it('modules absent from the persisted stand appear as „nicht erhoben" instead of vanishing', () => {
    const entries = coverageFromPersistedMatrix({ modules: [{ module: 'SUMMARY', status: 'AVAILABLE' }] })
    const logistics = entries!.find((e) => e.module === 'LOGISTICS')
    expect(logistics?.status).toBeNull()
    expect(logistics?.statusLabelDe).toBe('nicht erhoben')
  })

  it('counter-probe: a foreign status value passes through visibly instead of crashing or hiding', () => {
    const entries = coverageFromPersistedMatrix({ modules: [{ module: 'SBM', status: 'TURBO' }] })
    const sbm = entries!.find((e) => e.module === 'SBM')
    expect(sbm?.status).toBeNull()
    expect(sbm?.statusLabelDe).toContain('TURBO')
  })

  it('every capability module carries a DE label (Excel/Roadmap terminology)', () => {
    for (const m of CAPABILITY_MODULES) {
      expect(CAPABILITY_MODULE_LABELS_DE[m]).toBeTruthy()
    }
  })

  it('entry present but status missing/mistyped is named broken — NOT „nicht erhoben"', () => {
    const entries = coverageFromPersistedMatrix({ modules: [{ module: 'SBM', status: null }] })
    expect(entries!.find((e) => e.module === 'SBM')?.statusLabelDe).toBe('unbekannt (Status fehlt/ungültig)')
    const entries2 = coverageFromPersistedMatrix({ modules: [{ module: 'SBM', status: 123 }] })
    expect(entries2!.find((e) => e.module === 'SBM')?.statusLabelDe).toBe('unbekannt (Status fehlt/ungültig)')
  })

  it('duplicate module entries are shown as contradictory instead of silently last-wins', () => {
    const entries = coverageFromPersistedMatrix({
      modules: [
        { module: 'SBM', status: 'AVAILABLE' },
        { module: 'SBM', status: 'MISSING' },
      ],
    })
    expect(entries!.find((e) => e.module === 'SBM')?.statusLabelDe).toBe('widersprüchlich (mehrere Einträge)')
  })

  it('foreign module keys (e.g. a future G60) are appended visibly instead of vanishing', () => {
    const entries = coverageFromPersistedMatrix({
      modules: [{ module: 'G60', status: 'AVAILABLE' }],
    })
    const g60 = entries!.find((e) => (e.module as string) === 'G60')
    expect(g60).toBeDefined()
    expect(g60?.statusLabelDe).toBe('vorhanden')
    expect(entries!.length).toBe(CAPABILITY_MODULES.length + 1)
  })
})