#import "../../pallete.typ": palette
#import "../tabler.typ"
#let _testCases = state("9ca8f801-3bfd-4a72-a716-966aec564315", ())
#let _testResults = state("7372165e-6204-43a2-8780-46a41d7e2841", ())

#let defectClassToString(defectClass) = {
  if (defectClass == 4) {
    return "kritischer Mangel"
  }
  if (defectClass == 3) {
    return "schwerer Mangel"
  }
  if (defectClass == 2) {
    return "leichter Mangel"
  }
  if (defectClass == 1) {
    return "belangloser Mangel"
  }

  return "mängelfrei"
}

#let case(
  // Welcher Usercase oder requirement der testfall testet.
  requirement: [],
  description: [],
  precondition: [],
  steps: [],
  result: [],
) = {
  // style
  // show table.cell.where(x: 0): strong
  // show table.cell.where(y: 0): it => strong(delta: -300, it)


  _testCases.update(cases => {
    cases.push((
      requirement: requirement,
      description: description,
      precondition: precondition,
      steps: steps,
      result: result,
    ))
    return cases
  })

  context {
    let id = "TC-" + str(_testCases.get().len())
    [
      #figure(
        tabler.sideways(
          columns: (auto, 1fr, 10em),
          [ID / Bezeichnung],
          [#id],
          [Testet: #requirement],

          [Beschreibung],
          table.cell(colspan: 2, description),
          [Testvoraussetzung],
          table.cell(colspan: 2, precondition),
          [Testschritte],
          table.cell(colspan: 2, steps),
          [Erwartetes Ergebnis],
          table.cell(colspan: 2, result),
        ),
        caption: [Testfall #id],
      )#label(id)

    ]
  }
}
#let cases() = {
  return _testCases
    .final()
    .enumerate(start: 1)
    .map(c => (
      id: "TC-" + str(c.at(0)),
      requirement: c.at(1).requirement,
      description: c.at(1).description,
      precondition: c.at(1).precondition,
      steps: c.at(1).steps,
      result: c.at(1).result,
    ))
}

#let protocoll(
  case: "",
  date: datetime.today(),
  tester: "",
  defectClass: none,
  defect: "",
  result,
) = {
  // style
  show table.cell.where(x: 0): strong
  show table.cell.where(y: 0): it => strong(delta: -300, it)


  if (defectClass == none) {
    defectClass = 0
  }

  let dcColor() = {
    if (defectClass >= 4) {
      return palette.red.at("300")
    }
    if (defectClass >= 2) {
      return palette.orange.at("300")
    }
    if (defectClass > 0) {
      return palette.yellow.at("300")
    }
    return palette.green.at("300")
  }

  _testResults.update(cases => {
    cases.push((
      case: case,
      date: date,
      defectClass: defectClass,
      defect: defect,
    ))
    return cases
  })


  context {
    figure(
      tabler.sideways(
        columns: (auto, 1fr),
        [Testfall:],
        link(label(case), case),
        [Tester:],
        [#tester],
        [Datum:],
        date.display("[day].[month].[year]"),
        [Mängelklasse:],
        table.cell(fill: dcColor())[#defectClass],
        ..if (defectClass > 0) {
          ([Mängel:], defect)
        },
        [Ergebnis:],
        result,
      ),
      caption: [Testergebnis für #link(label(case), case) vom #date.display("[day].[month].[year]")],
    )
  }
}

// table.header([Testfall], [Durchführungsdatum], [Mängelklasse], [Mängel]),
#let results() = {
  return _testResults
    .final()
    .map(r => (
      r.case,
      r.date.display("[day].[month].[year]"),
      table.cell(fill: if (r.defectClass >= 4) {
        palette.red.at("300")
      } else if (r.defectClass >= 2) {
        palette.orange.at("300")
      } else if (r.defectClass > 0) {
        palette.yellow.at("300")
      } else { palette.green.at("300") })[#r.defectClass],
      if r.defect == "" { "-" } else { r.defect },
    ))
}