// Loop-10-Rest (gemeinsame Table Engine, Schritt 1 — Renderer-Konsolidierung):
// der eine Tabellen-Baustein für die Lese-Tabellen der Detail-Module. Ersetzt
// die handgeschriebenen <table className="w-full text-sm">-Blöcke (vorher 8
// unabhängige Kopien desselben Klassen-Skeletts, siehe
// scratchpad-Analyse loop10-rest-engines-analyse + program-status Loop 10).
//
// Bewusst NUR Rendering: keine Filter-/Sortier-UI, keine Virtualisierung —
// beides wartet auf die offenen Scope-Entscheidungen (Filter-Dimensionen/
// Seiten bzw. Dependency-Freigabe). Die Filter-/Sortier-Engine selbst
// existiert getestet in lib/qaf-differences/internal/table-specs.ts und
// bleibt der Andockpunkt, sobald die Entscheidungen fallen — dieser
// Renderer erfindet keine zweite.
//
// Klassen-Skelett ist byte-gleich zum bisherigen Handmuster (py-2/pr-3/
// text-right/tabular-nums-Reihenfolge), damit die Migration visuell
// verlustfrei ist — Parität sichern die Sektions-Smoke-Tests.
// tdd-guard:skip — presentational; Verhalten pinnt qaf-data-table.test.tsx.

import type { ReactNode } from "react"

export interface DataTableColumn<T> {
  key: string
  headerDe: ReactNode
  /** Rechtsbündige Zahlen-Spalte (setzt text-right am th und td). */
  align?: "right"
  /** Zahlen-Zelle: setzt tabular-nums am td (wie das bisherige Handmuster). */
  numeric?: boolean
  cell: (row: T) => ReactNode
  /** Zusätzliche td-Klassen je Zeile (z. B. text-foreground, Delta-Farbe). */
  cellClassName?: (row: T) => string
  /** Natives title-Attribut je Zelle (z. B. Beleg-Tooltip) — undefined
   * lässt das Attribut weg, exakt wie das bisherige Handmuster. */
  cellTitle?: (row: T) => string | undefined
}

function headerClass(isLast: boolean, align?: "right"): string {
  return [
    "py-2",
    isLast ? null : "pr-3",
    align === "right" ? "text-right" : null,
    "font-medium",
  ]
    .filter(Boolean)
    .join(" ")
}

function cellClass<T>(
  col: DataTableColumn<T>,
  row: T,
  isLast: boolean,
): string {
  return [
    "py-2",
    isLast ? null : "pr-3",
    col.align === "right" ? "text-right" : null,
    col.numeric ? "tabular-nums" : null,
    // `|| null` lässt einen leeren cellClassName-String bewusst wegfallen —
    // das alte Handmuster (Template-Literal) hätte hier einen trailing
    // space erzeugt; das saubere Verhalten ist im Renderer-Test exakt
    // gepinnt (Review-#508-M1). `??` wäre falsch: es ließe "" in den join.
    col.cellClassName?.(row) || null,
  ]
    .filter(Boolean)
    .join(" ")
}

export function QafDataTable<T>({
  columns,
  rows,
  rowKey,
  rowClassName,
}: {
  columns: ReadonlyArray<DataTableColumn<T>>
  rows: readonly T[]
  rowKey: (row: T) => string
  /** Zusätzliche tr-Klassen je Zeile (z. B. Summen-Hervorhebung) —
   * Leerstring/undefined fällt sauber weg, KEIN trailing space (dieselbe
   * bewusste Verbesserung ggü. dem alten Template-Literal-Handmuster wie
   * bei cellClassName, Review-#508-M1). */
  rowClassName?: (row: T) => string | undefined
}) {
  const last = columns.length - 1
  return (
    <div className="overflow-x-auto">
      <table className="w-full text-sm">
        <thead>
          <tr className="border-b border-border text-left text-muted-foreground">
            {columns.map((c, i) => (
              <th key={c.key} className={headerClass(i === last, c.align)}>
                {c.headerDe}
              </th>
            ))}
          </tr>
        </thead>
        <tbody>
          {rows.map((r) => (
            <tr
              key={rowKey(r)}
              className={["border-b border-border/60", rowClassName?.(r) || null]
                .filter(Boolean)
                .join(" ")}
            >
              {columns.map((c, i) => (
                <td
                  key={c.key}
                  className={cellClass(c, r, i === last)}
                  title={c.cellTitle?.(r)}
                >
                  {c.cell(r)}
                </td>
              ))}
            </tr>
          ))}
        </tbody>
      </table>
    </div>
  )
}