import { describe, it, expect } from 'vitest'
import { assessManufacturingCapability } from '../manufacturing-capability'
import { PRIMARY_FIELD_MAPPINGS } from '../mapper'
import { buildQafRow } from './fixtures'

describe('assessManufacturingCapability', () => {
  it('empty input -> not eligible, stepCount 0, empty coverage, no warnings', () => {
    const result = assessManufacturingCapability([])
    expect(result).toEqual({ eligible: false, stepCount: 0, fieldCoverage: {}, warnings: [] })
  })

  it('rows without any prozessbezeichnung -> not eligible, stepCount 0, warning', () => {
    const result = assessManufacturingCapability([buildQafRow(), buildQafRow({ prozessbezeichnung: '   ' })])
    expect(result.eligible).toBe(false)
    expect(result.stepCount).toBe(0)
    expect(result.fieldCoverage).toEqual({})
    expect(result.warnings).toEqual([expect.objectContaining({ code: 'no_eligible_rows' })])
  })

  it('one row with a process name -> eligible', () => {
    const result = assessManufacturingCapability([buildQafRow({ prozessbezeichnung: 'Fantasieschritt 1' })])
    expect(result.eligible).toBe(true)
    expect(result.stepCount).toBe(1)
    expect(result.warnings).toEqual([])
  })

  it('eligibility is capability-based — any sheet/template family counts, not just a specific one', () => {
    // No template/sheet hint is passed at all — assessManufacturingCapability
    // only looks at whether rows carry a process name, per architecture.md.
    const result = assessManufacturingCapability([buildQafRow({ prozessbezeichnung: 'Fantasieschritt' })])
    expect(result.eligible).toBe(true)
  })

  it('partial field coverage is a fraction over eligible steps only (excluded rows do not count)', () => {
    const rows = [
      buildQafRow({ prozessbezeichnung: 'A', zykluszeit: 10 }),
      buildQafRow({ prozessbezeichnung: 'B', zykluszeit: null }),
      buildQafRow({ prozessbezeichnung: '' }), // excluded — must not affect the denominator
    ]
    const result = assessManufacturingCapability(rows)
    expect(result.stepCount).toBe(2)
    expect(result.fieldCoverage.zykluszeit).toBe(0.5)
    expect(result.fieldCoverage.mss).toBe(0)
  })

  it('full coverage -> 1 for every primary field', () => {
    const row = buildQafRow({
      prozessbezeichnung: 'A',
      zykluszeit: 1,
      teileProZyklus: 1,
      anzahlMA: 1,
      bezeichnungAnlage: 'Presse',
      standort: 'Werk',
      beschaffungswaehrung: 'EUR',
      ausschuss: 1,
      ausschusskosten: 1,
      mss: 1,
      lohnkosten: 1,
      ruestkosten: 1,
      fk: 1,
    })
    const result = assessManufacturingCapability([row])
    for (const { source } of PRIMARY_FIELD_MAPPINGS) {
      expect(result.fieldCoverage[source]).toBe(1)
    }
  })

  it('is a pure function — no DB access, same input always gives the same output', () => {
    const rows = [buildQafRow({ prozessbezeichnung: 'A', zykluszeit: 5 })]
    const first = assessManufacturingCapability(rows)
    const second = assessManufacturingCapability(rows)
    expect(first).toEqual(second)
  })
})