import Link from 'next/link'
import { Banknote, Plus, Upload } from 'lucide-react'
import type { Prisma } from '@prisma/client'
import { Badge } from '@/components/ui/badge'
import { Button } from '@/components/ui/button'
import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
import { SeitenKopf, Leerzustand } from '@/components/seiten-kopf'
import { Rechtshinweis } from '@/components/rechtshinweis'
import { Belegzeichen, Betrag, Kennzahl, Vermischungswarnung } from '@/components/finanzen/bausteine'
import { Buchungsfilter } from '@/components/finanzen/buchungs-filter'
import { centZuZahl, db, nichtGeloescht } from '@/lib/db'
import { formatCent, formatDatum } from '@/lib/utils'
import { finanzKontext } from '@/lib/finanzen/seite'
import { BUCHUNG_EINBEZUG, zuBuchungEingabe } from '@/lib/berichte/gemeinsam'
import { belegDurchVertrag, betragPruefen, belegFehlt, kennzahlen, vermischungsWarnung, type BuchungEingabe } from '@/lib/finanzen/kassenbuch'
import { KATEGORIE_BESCHRIFTUNG, RICHTUNG_BESCHRIFTUNG } from '@/lib/finanzen/kategorien'
import { buchungsfilterSchema } from '@/lib/validierung/finanzen'

export const metadata = { title: 'Kassenbuch' }

const HOECHSTZAHL = 300

/**
 * Das Kassenbuch.
 *
 * Zwei Dinge sind hier absichtlich auffällig: Buchungen ohne Beleg und
 * ohne Begründung werden rot markiert, und eine Buchung, die auf einem
 * Konto des Betreuers läuft und trotzdem als Vermögen der Betreuten
 * gilt, bekommt eine eigene Warnung. Beides sind die Punkte, an denen
 * eine Rechnungslegung beim Gericht auseinanderfällt.
 */
export default async function BuchungenSeite({
  searchParams,
}: {
  searchParams: Promise<Record<string, string | string[] | undefined>>
}) {
  const roh = await searchParams
  const { betreute, darfSchreiben } = await finanzKontext()
  const schreiben = darfSchreiben('FINANZEN')

  const flach: Record<string, string> = {}
  for (const [schluessel, wert] of Object.entries(roh)) {
    if (typeof wert === 'string') flach[schluessel] = wert
  }
  const gepruft = buchungsfilterSchema.safeParse(flach)
  const filter = gepruft.success
    ? gepruft.data
    : {
        kontoId: null,
        kategorie: null,
        richtung: null,
        von: null,
        bis: null,
        suche: null,
        nurOhneBeleg: false,
        nurEigeneAuslagen: false,
      }

  const bedingung: Prisma.BuchungWhereInput = {
    betreuteId: betreute.id,
    ...nichtGeloescht,
    ...(filter.kontoId ? { kontoId: filter.kontoId } : {}),
    ...(filter.kategorie ? { kategorie: filter.kategorie } : {}),
    ...(filter.richtung ? { richtung: filter.richtung } : {}),
    ...(filter.von || filter.bis
      ? {
          datum: {
            ...(filter.von ? { gte: filter.von } : {}),
            ...(filter.bis ? { lte: filter.bis } : {}),
          },
        }
      : {}),
    // Der Verwendungszweck ist verschluesselt und laesst sich nicht
    // durchsuchen - gesucht wird deshalb nur in der Gegenstelle.
    ...(filter.suche ? { gegenstelle: { contains: filter.suche, mode: 'insensitive' } } : {}),
    ...(filter.nurEigeneAuslagen ? { betrifftBetreute: false } : {}),
    ...(filter.nurOhneBeleg
      ? { belegId: null, OR: [{ belegFehltBegruendung: null }, { belegFehltBegruendung: '' }] }
      : {}),
  }

  const [zeilen, gesamt, konten] = await Promise.all([
    db.buchung.findMany({
      where: bedingung,
      include: BUCHUNG_EINBEZUG,
      orderBy: [{ datum: 'desc' }, { erstelltAm: 'desc' }],
      take: HOECHSTZAHL,
    }),
    db.buchung.count({ where: bedingung }),
    db.konto.findMany({
      where: { betreuteId: betreute.id, ...nichtGeloescht },
      select: { id: true, bezeichnung: true },
      orderBy: { bezeichnung: 'asc' },
    }),
  ])

  const buchungen: BuchungEingabe[] = zeilen.map(zuBuchungEingabe)

  const zahlen = kennzahlen(buchungen)

  return (
    <div className="space-y-6">
      <SeitenKopf
        titel="Kassenbuch"
        beschreibung="Jede Einnahme und jede Ausgabe. Aus diesen Zeilen entsteht die Rechnungslegung – deshalb gehört zu jeder Zeile ein Beleg oder eine Begründung, warum keiner da ist."
        pfad={[{ titel: 'Vermögen & Kasse', href: '/finanzen' }, { titel: 'Kassenbuch' }]}
        aktionen={
          schreiben ? (
            <>
              <Button asChild variant="secondary">
                <Link href="/finanzen/buchungen/import">
                  <Upload aria-hidden="true" />
                  Importieren
                </Link>
              </Button>
              <Button asChild>
                <Link href="/finanzen/buchungen/neu">
                  <Plus aria-hidden="true" />
                  Buchung erfassen
                </Link>
              </Button>
            </>
          ) : undefined
        }
      />

      <Buchungsfilter
        konten={konten}
        aktiv={{
          kontoId: filter.kontoId ?? '',
          kategorie: filter.kategorie ?? '',
          richtung: filter.richtung ?? '',
          von: filter.von ? filter.von.toISOString().slice(0, 10) : '',
          bis: filter.bis ? filter.bis.toISOString().slice(0, 10) : '',
          suche: filter.suche ?? '',
          nurOhneBeleg: filter.nurOhneBeleg,
          nurEigeneAuslagen: filter.nurEigeneAuslagen,
        }}
      />

      <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-4">
        <Kennzahl titel="Buchungen in der Auswahl" wert={gesamt} />
        <Kennzahl
          titel="Einnahmen"
          wert={formatCent(centZuZahl(zahlen.einnahmenCent))}
          hinweis="ohne Umbuchungen und eigene Auslagen"
        />
        <Kennzahl
          titel="Ausgaben"
          wert={formatCent(centZuZahl(zahlen.ausgabenCent))}
          hinweis="ohne Umbuchungen und eigene Auslagen"
        />
        <Kennzahl
          titel="Ohne Beleg und ohne Begründung"
          wert={zahlen.beleg.ohneNachweis}
          hinweis={
            zahlen.beleg.ohneNachweis > 0
              ? 'Genau danach fragt der Rechtspfleger.'
              : 'Da fehlt nichts.'
          }
          ton={zahlen.beleg.ohneNachweis > 0 ? 'achtung' : 'gut'}
        />
      </div>

      {zahlen.vermischungen > 0 && <Vermischungswarnung />}

      {buchungen.length === 0 ? (
        <Leerzustand
          icon={Banknote}
          titel={gesamt === 0 ? 'Noch keine Buchung erfasst' : 'Keine Buchung passt zu diesem Filter'}
          beschreibung={
            gesamt === 0
              ? 'Erfasse die erste Buchung von Hand oder lies einen Kontoauszug als CSV ein.'
              : 'Setz den Filter zurück oder wähl einen anderen Zeitraum.'
          }
          aktion={
            schreiben && gesamt === 0 ? (
              <Button asChild>
                <Link href="/finanzen/buchungen/neu">
                  <Plus aria-hidden="true" />
                  Buchung erfassen
                </Link>
              </Button>
            ) : undefined
          }
        />
      ) : (
        <>
          <Table>
            <TableHeader>
              <TableRow>
                <TableHead>Datum</TableHead>
                <TableHead>Vorgang</TableHead>
                <TableHead>Konto</TableHead>
                <TableHead>Beleg</TableHead>
                <TableHead className="text-right">Betrag</TableHead>
              </TableRow>
            </TableHeader>
            <TableBody>
              {buchungen.map((buchung) => (
                <TableRow
                  key={buchung.id}
                  className={belegFehlt(buchung) ? 'bg-ampel-rot/5' : undefined}
                >
                  <TableCell className="whitespace-nowrap align-top">
                    {formatDatum(buchung.datum)}
                  </TableCell>
                  <TableCell className="align-top">
                    <Link
                      href={`/finanzen/buchungen/${buchung.id}`}
                      className="font-medium hover:underline"
                    >
                      {buchung.gegenstelle ?? KATEGORIE_BESCHRIFTUNG[buchung.kategorie]}
                    </Link>
                    <span className="block text-sm text-muted-foreground">
                      {RICHTUNG_BESCHRIFTUNG[buchung.richtung]} ·{' '}
                      {KATEGORIE_BESCHRIFTUNG[buchung.kategorie]}
                    </span>
                    {buchung.verwendungszweck && (
                      <span className="block text-sm text-muted-foreground">
                        {buchung.verwendungszweck}
                      </span>
                    )}
                    <span className="mt-1 flex flex-wrap gap-1.5">
                      {!buchung.betrifftBetreute && (
                        <Badge variant="secondary">eigene Auslage</Badge>
                      )}
                      {buchung.vermoegenswirksam && (
                        <Badge variant="outline">vermögenswirksam</Badge>
                      )}
                      {vermischungsWarnung(buchung) && <Vermischungswarnung kurz />}
                    </span>
                  </TableCell>
                  <TableCell className="align-top text-sm text-muted-foreground">
                    {buchung.kontoBezeichnung ?? 'kein Konto'}
                  </TableCell>
                  <TableCell className="align-top">
                    <Belegzeichen
                      belegId={buchung.belegId}
                      belegTitel={buchung.belegTitel ?? null}
                      begruendung={buchung.belegFehltBegruendung}
                      vertragBezeichnung={
                      belegDurchVertrag(buchung) ? (buchung.vertragBezeichnung ?? null) : null
                      }
                      vertragAutomatisch={buchung.vertragAutomatisch ?? false}
                      betragZuPruefen={betragPruefen(buchung)}
                    />
                  </TableCell>
                  <TableCell className="text-right align-top">
                    <Betrag cent={centZuZahl(buchung.betragCent)} richtung={buchung.richtung} />
                  </TableCell>
                </TableRow>
              ))}
            </TableBody>
          </Table>

          {gesamt > buchungen.length && (
            <p className="text-sm text-muted-foreground">
              Es werden die {HOECHSTZAHL} jüngsten von {gesamt} Buchungen gezeigt. Grenze den
              Zeitraum ein, um die älteren zu sehen.
            </p>
          )}
        </>
      )}

      <Rechtshinweis rechtsgrundlage="§ 1865 BGB" />
    </div>
  )
}