import test from 'node:test'
import assert from 'node:assert/strict'
import { loadModule } from './load.mjs'

const { CUSTOMER_TABS, customerStage, isArchived, filterCustomers, stageCounts, customerBadges, stageLabel, customerEyebrow, customerTitle, kundenartFehlt, kundenartFehltAnzahl } =
  await loadModule('src/lib/customerList.js')

const A = { $id: 'a', name: 'Alpha GmbH', code: 'K-1', location: 'Kaiserslautern', email: 'info@alpha.de', contactName: 'Anna Alt', customerStatus: 'customer' }
const B = { $id: 'b', name: 'Beta', customerStatus: 'lead' }
const C = { $id: 'c', name: 'Gamma', customerStatus: 'lost' }
const D = { $id: 'd', name: 'Delta' } // Bestandsdaten ohne Status gelten als fester Kunde
const E = { $id: 'e', name: 'Epsilon', customerStatus: 'lead', archived: true, importantCustomer: true }
const F = { $id: 'f', name: 'Zeta', customerStatus: 'customer', archived: true }
const ALL = [A, B, C, D, E, F]
const ids = (list) => list.map((c) => c.$id)

test('CUSTOMER_TABS, customerStage, isArchived', () => {
  assert.deepEqual(CUSTOMER_TABS, [
    { id: 'customer', label: 'Feste Kunden' }, { id: 'lead', label: 'Leads' }, { id: 'lost', label: 'Abgesagt' },
    { id: 'archived', label: 'Archiviert' }, { id: 'all', label: 'Alle' },
  ])
  assert.equal(customerStage({ customerStatus: 'LEAD' }), 'lead')
  assert.equal(customerStage({ customerStatus: 'Lost' }), 'lost')
  for (const c of [{}, { customerStatus: '' }, { customerStatus: 'sonstwas' }, null, undefined]) assert.equal(customerStage(c), 'customer')
  assert.equal(isArchived({ archived: true }), true)
  for (const c of [{}, { archived: false }, null, undefined]) assert.equal(isArchived(c), false)
})

test('filterCustomers: jeder Reiter', () => {
  assert.deepEqual(ids(filterCustomers(ALL, { stage: 'customer' })), ['a', 'd'])
  assert.deepEqual(ids(filterCustomers(ALL, { stage: 'lead' })), ['b'])
  assert.deepEqual(ids(filterCustomers(ALL, { stage: 'lost' })), ['c'])
  assert.deepEqual(ids(filterCustomers([{ $id: 'x', customerStatus: 'lost', archived: true }], { stage: 'lost' })), [])
  assert.deepEqual(ids(filterCustomers(ALL, { stage: 'archived' })), ['e', 'f'])
  assert.deepEqual(ids(filterCustomers(ALL, { stage: 'all' })), ['a', 'b', 'c', 'd'])
  assert.deepEqual(ids(filterCustomers(ALL)), ['a', 'd'])
  assert.deepEqual(ids(filterCustomers(ALL, { stage: 'x' })), [])
  assert.deepEqual(filterCustomers(undefined, { stage: 'all' }), [])
})

test('filterCustomers: Suche in Name, Code, Standort, E-Mail, Ansprechpartner und Telefon', () => {
  const find = (search, stage = 'all') => ids(filterCustomers(ALL, { stage, search }))
  for (const s of ['ALPHA', 'k-1', 'kaisers', 'info@alpha', 'anna']) assert.deepEqual(find(s), ['a'], s)
  assert.deepEqual(find('xyz'), [])
  assert.deepEqual(ids(filterCustomers([{ $id: 'p', phone: '0631 12345' }], { stage: 'all', search: '0631 123' })), ['p'])
  assert.deepEqual(find('eta', 'lead'), ['b'])
  assert.deepEqual(find(''), ['a', 'b', 'c', 'd'])
  assert.deepEqual(ids(filterCustomers([{ $id: 'n' }], { stage: 'all', search: 'undefined' })), [])
})

test('stageCounts: dieselbe Filterfunktion wie die Liste', () => {
  assert.deepEqual(stageCounts(ALL), { customer: 2, lead: 1, lost: 1, archived: 2, all: 4 })
  assert.deepEqual(stageCounts(ALL, 'eta'), { customer: 0, lead: 1, lost: 0, archived: 1, all: 1 })
  assert.deepEqual(stageCounts([]), { customer: 0, lead: 0, lost: 0, archived: 0, all: 0 })
})

test('customerBadges: Reihenfolge, Töne, Option stage', () => {
  assert.deepEqual(customerBadges(E), [
    { key: 'important', label: 'Wichtig', tone: 'warn' },
    { key: 'lead', label: 'Lead', tone: 'muted' },
    { key: 'archived', label: 'Archiviert', tone: 'plain' },
  ])
  assert.deepEqual(customerBadges(C), [{ key: 'lost', label: 'Abgesagt', tone: 'danger' }])
  for (const c of [A, D, null]) assert.deepEqual(customerBadges(c), [])
  assert.deepEqual(customerBadges(E, { stage: false }).map((b) => b.key), ['important', 'archived'])
})

test('stageLabel, customerEyebrow, customerTitle', () => {
  assert.deepEqual(['customer', 'lead', 'lost'].map(stageLabel), ['Fester Kunde', 'Lead', 'Abgesagt'])
  assert.equal(customerEyebrow(A), 'K-1 · Fester Kunde')
  assert.equal(customerEyebrow(B), 'Lead')
  assert.equal(customerEyebrow({ code: '  ', customerStatus: 'lost' }), 'Abgesagt')
  assert.equal(customerTitle(A), 'Alpha GmbH')
  assert.equal(customerTitle({ email: 'x@y.de' }), 'x@y.de')
  assert.equal(customerTitle({}), '–')
})

const KA = [
  { $id: 'k1', name: 'Eins', customerStatus: 'customer', kundenart: 'unternehmen' },
  { $id: 'k2', name: 'Zwei', customerStatus: 'customer' },
  { $id: 'k3', name: 'Drei', customerStatus: 'lead', kundenart: '' },
  { $id: 'k4', name: 'Vier', customerStatus: 'lead', kundenart: 'privat' },
  { $id: 'k5', name: 'Fünf', customerStatus: 'lost' },
  { $id: 'k6', name: 'Sechs', customerStatus: 'customer', archived: true },
  { $id: 'k7', name: 'Sieben', customerStatus: 'customer', kundenart: ' unternehmen' },
]
test('kundenartFehlt und kundenartFehltAnzahl: Lead und fester Kunde, ohne Archiv und Abgesagte', () => {
  assert.equal(kundenartFehlt({}), true); assert.equal(kundenartFehlt({ kundenart: 'privat' }), false); assert.equal(kundenartFehlt(null), true)
  assert.equal(kundenartFehltAnzahl(KA), 3) // k2, k3, k7
  assert.equal(kundenartFehltAnzahl([]), 0)
})
test('filterCustomers mit nurKundenartFehlt: je Reiter, mit Suche; ohne Schalter unverändert', () => {
  const f = (opts) => ids(filterCustomers(KA, opts))
  assert.deepEqual(f({ stage: 'customer', nurKundenartFehlt: true }), ['k2', 'k7'])
  assert.deepEqual(f({ stage: 'lead', nurKundenartFehlt: true }), ['k3'])
  assert.deepEqual(f({ stage: 'lost', nurKundenartFehlt: true }), ['k5'])
  assert.deepEqual(f({ stage: 'archived', nurKundenartFehlt: true }), ['k6'])
  assert.deepEqual(f({ stage: 'all', nurKundenartFehlt: true }), ['k2', 'k3', 'k5', 'k7'])
  assert.deepEqual(f({ stage: 'all', search: 'zwei', nurKundenartFehlt: true }), ['k2'])
  assert.deepEqual(f({ stage: 'customer' }), ['k1', 'k2', 'k7'])
})
test('stageCounts mit nurKundenartFehlt: dieselbe Filterfunktion wie die Liste', () => {
  assert.deepEqual(stageCounts(KA, '', { nurKundenartFehlt: true }), { customer: 2, lead: 1, lost: 1, archived: 1, all: 4 })
  assert.deepEqual(stageCounts(KA), { customer: 3, lead: 2, lost: 1, archived: 1, all: 6 })
})