Vorrania/backend/app/services/conversion.py

"""Einheiten-Umrechnung auf Basis der verwaltbaren Unit-Tabelle.

Bestände werden immer in der kanonischen Basiseinheit der jeweiligen Art
gespeichert: Stück (count), Gramm (weight), Milliliter (volume). Verwaltete
Einheiten (z.B. Kilogramm, Liter, Pfund) rechnen über ihren Faktor dorthin um.
"""

from __future__ import annotations

from typing import NamedTuple

from sqlalchemy import func
from sqlalchemy.orm import Session

from ..models import BaseUnit, Group, Product, Unit, UnitKind
from . import gruppen

BASE_OF_KIND: dict[UnitKind, BaseUnit] = {
    UnitKind.count: BaseUnit.piece,
    UnitKind.weight: BaseUnit.gram,
    UnitKind.volume: BaseUnit.milliliter,
}
KIND_OF_BASE: dict[BaseUnit, UnitKind] = {v: k for k, v in BASE_OF_KIND.items()}

BASE_LABEL: dict[BaseUnit, str] = {
    BaseUnit.piece: "Stück",
    BaseUnit.gram: "Gramm",
    BaseUnit.milliliter: "Milliliter",
}

PACKAGE_TOKENS = {"package", "packung", "pkg", "pack"}

# Kürzel/Aliase, die direkt auf eingebaute Einheitennamen zeigen.
_ALIAS = {
    "g": "gramm", "gram": "gramm", "gramm": "gramm",
    "kg": "kilogramm", "kilogramm": "kilogramm",
    "ml": "milliliter", "milliliter": "milliliter",
    "l": "liter", "liter": "liter",
    "stück": "stück", "stueck": "stück", "st": "stück", "stk": "stück", "piece": "stück",
}


class ConversionError(ValueError):
    """Fachlicher Fehler bei der Einheiten-Umrechnung."""


def kind_of_product(product: Product) -> UnitKind:
    return KIND_OF_BASE[product.base_unit]


def find_unit(db: Session, token: str) -> Unit | None:
    t = token.strip().lower()
    t = _ALIAS.get(t, t)
    return db.query(Unit).filter(func.lower(Unit.name) == t).first()


def zweit_faktor(product: Product, ziel: BaseUnit) -> float | None:
    """Wie viele ``ziel``-Basiseinheiten EINE Basiseinheit des Artikels wert ist.

    Die Zweiteinheit am Artikel („3 Stück ≙ 250 g") ist die einzige Brücke
    zwischen den sonst strikt getrennten Arten. Sie gilt in BEIDE Richtungen:
    derselbe Eintrag macht aus einem Stück-Artikel 83,333 g je Stück und aus
    einem Gramm-Artikel 0,012 Stück je Gramm.

    Gleiche Art → 1.0. Ohne (oder mit unbrauchbarer) Brücke → ``None``; dann
    bleibt es bei der strikten Trennung, und der Aufrufer entscheidet, was das
    heisst – ablehnen beim Einlagern, aussortieren beim Gruppenbestand.
    """
    if product.base_unit == ziel:
        return 1.0
    if product.secondary_base != ziel.value:
        return None          # keine Brücke in DIESE Art
    anzahl = product.secondary_count      # in der Basiseinheit des Artikels
    menge = product.secondary_amount      # in secondary_base
    if not anzahl or not menge or anzahl <= 0 or menge <= 0:
        return None
    # „3 Stück ≙ 250 g" -> 1 Stück = 250/3 g. Bei einem Gramm-Artikel steht
    # dieselbe Zeile als „250 g ≙ 3 Stück" da und liefert 3/250 Stück je Gramm.
    return menge / anzahl


def in_artikel_basis(product: Product, menge: float, quell_base: BaseUnit) -> float | None:
    """Gegenrichtung: eine Menge in ``quell_base`` in die Artikel-Basiseinheit.

    Bewusst erst multiplizieren, dann teilen. ``250 * 3 / 250`` ist exakt 3;
    der Umweg ueber den Faktor (``250 / (250/3)``) ergibt 3,0000000000000004 –
    und daran scheitert sonst „den ganzen Bestand auslagern" an der Pruefung in
    ``check_out``.
    """
    if quell_base == product.base_unit:
        return menge
    if product.secondary_base != quell_base.value:
        return None
    anzahl = product.secondary_count
    zweit = product.secondary_amount
    if not anzahl or not zweit or anzahl <= 0 or zweit <= 0:
        return None
    return menge * anzahl / zweit


def to_base(
    db: Session,
    product: Product,
    quantity: float,
    unit_token: str,
    *,
    hausmasse: bool = False,
) -> float:
    """Rechnet eine Menge (in unit_token) in die Basiseinheit des Produkts um.

    Reihenfolge: Packung → verwaltete Einheit → Hausmaß → Zweiteinheit-Brücke.
    Die Einheitentabelle steht VOR den Hausmaßen, weil sie die harte Physik ist:
    Ein versehentlich angelegtes Hausmaß namens „Liter" würde sonst die echte
    Einheit dauerhaft verdecken.

    ``hausmasse=True`` lässt Hausmaße überhaupt zu („2 EL"). Vorgabe ist False,
    weil ein Esslöffel ein Schätzwert ist: Beim **Verbrauchen und Auslagern** ist
    das richtig, beim **Einlagern** und bei **Mindestbeständen** ausdrücklich
    nicht. Der Schalter hält das in der Signatur fest, statt es der Disziplin an
    jeder Aufrufstelle zu überlassen.
    """
    if quantity <= 0:
        raise ConversionError("Menge muss größer als 0 sein")

    t = (unit_token or "").strip().lower()
    if t in PACKAGE_TOKENS:
        if not product.package_size or product.package_size <= 0:
            raise ConversionError(
                "Für dieses Produkt ist keine Packungsgröße hinterlegt."
            )
        return quantity * product.package_size

    unit = find_unit(db, t)
    if unit is None:
        if hausmasse:
            gerechnet = _hausmass_to_base(db, product, quantity, t)
            if gerechnet is not None:
                return gerechnet
        raise ConversionError(f"Unbekannte Einheit: {unit_token}")
    if unit.kind != kind_of_product(product):
        # Artfremde Einheit: geht nur über die Zweiteinheit des Artikels.
        # „250 g" bei einem in Stück geführten Artikel wird zu 3 Stück.
        # Bewusst OHNE Runden – krumme Mengen sind erlaubt, sonst driftete
        # der gebuchte Bestand von der tatsächlichen Entnahme weg.
        ergebnis = in_artikel_basis(product, quantity * unit.factor, BASE_OF_KIND[unit.kind])
        if ergebnis is None:
            raise ConversionError(
                f"Einheit '{unit.name}' passt nicht zur Art des Produkts "
                f"({BASE_LABEL[product.base_unit]}). Mit einer Zweiteinheit am "
                f"Artikel (z.B. „3 Stück ≙ 250 g\") ginge es."
            )
        return ergebnis
    return quantity * unit.factor


def _hausmass_to_base(
    db: Session, product: Product, quantity: float, token: str
) -> float | None:
    """Hausmaß-Token auflösen. ``None`` = kein Hausmaß dieses Namens.

    Unterschied, der wichtig ist: Ein **unbekannter Name** gibt ``None`` zurück,
    damit danach die normale Einheitensuche greift. Ein **bekanntes Maß ohne
    Menge** für diesen Artikel ist dagegen ein Fehler mit klarer Ansage – genau
    die Meldung, aus der der Rezeptabgleich sein „Maß jetzt anlegen" macht.
    """
    from .vererbung import mass_aufloesen, mass_in_basiseinheit

    angabe = mass_aufloesen(db, product, token)
    if angabe is None:
        bekannt = _bekanntes_mass(db, token)
        if bekannt is not None:
            # Den richtigen Namen nennen, nicht das klein geschriebene Token –
            # die Meldung steht so in der Oberflaeche.
            raise ConversionError(
                f"Für diese Kategorie ist kein Maß '{bekannt.name}' hinterlegt."
            )
        return None
    ergebnis = mass_in_basiseinheit(db, product, token, quantity)
    if ergebnis is None:
        raise ConversionError(
            f"Das Maß '{angabe.measure.name}' ist in "
            f"{BASE_LABEL[BaseUnit(angabe.base)]} hinterlegt und passt nicht zur "
            f"Art dieses Artikels ({BASE_LABEL[product.base_unit]}). Mit einer "
            f"Zweiteinheit am Artikel ginge es."
        )
    return ergebnis


def _bekanntes_mass(db: Session, token: str):
    """Das Hausmaß mit diesem Namen oder dieser Kurzform – sonst ``None``."""
    from ..models import Measure

    t = (token or "").strip().lower()
    for measure in db.query(Measure).all():
        if t == measure.name.lower() or (measure.short and t == measure.short.lower()):
            return measure
    return None


def resolve_product_unit(db: Session, unit_id: int) -> tuple[BaseUnit, int]:
    """Ermittelt zu einer gewählten Einheit die kanonische Basiseinheit + Anzeige-ID."""
    unit = db.get(Unit, unit_id)
    if unit is None:
        raise ConversionError("Einheit nicht gefunden")
    return BASE_OF_KIND[unit.kind], unit.id


def display_unit_info(product: Product) -> tuple[str, float]:
    """Name und Faktor der Anzeigeeinheit des Produkts (Fallback: Basiseinheit)."""
    if product.display_unit is not None:
        return product.display_unit.name, product.display_unit.factor
    return BASE_LABEL[product.base_unit], 1.0


def article_unit(product: Product) -> tuple[float, str]:
    """Faktor und Bezeichnung der *Artikeleinheit* – das zählbare Gebinde.

    Gibt es eine Packungsgröße, ist eine Einheit ein Gebinde (Glas, Packung …),
    sonst die Anzeigeeinheit des Produkts. Nur diese Größe lässt sich über
    verschiedene Artikel hinweg sinnvoll addieren: 3 Gläser + 2 Packungen sind
    5 Einheiten, während 1000 g + 2 Stück keine sinnvolle Summe ergeben.
    """
    if product.package_size and product.package_size > 0:
        return product.package_size, (product.package_label or "Packung")
    name, factor = display_unit_info(product)
    return (factor or 1.0), name


def article_units(product: Product, quantity_base: float) -> float:
    """Rechnet eine Menge in Basiseinheiten in Artikeleinheiten um."""
    factor, _ = article_unit(product)
    return quantity_base / factor if factor else quantity_base


class GroupMinContext(NamedTuple):
    divisor: float             # Basiseinheiten je Mindestbestand-Einheit
    label: str                 # Einzahl-Label ("Glas", "Gramm", …)
    is_package: bool           # zaehlbares Gebinde (aufrunden) vs. Anzeige-/Basiseinheit
    base_unit: BaseUnit | None
    matching: list[Product]    # Produkte, die zur Gruppen-Einheit zaehlen
    # Artikel-ID -> Gruppen-Basiseinheiten je EINER Basiseinheit des Artikels.
    # Fuer gleichartige Artikel 1,0; fuer artfremde der Zweiteinheit-Faktor.
    # Bestandssummen muessen damit GEWICHTET werden (services/stock.py).
    faktoren: dict[int, float]


def group_min_context(group: Group) -> GroupMinContext:
    """In welcher Einheit der Mindestbestand einer Gruppe zu lesen ist.

    Eine Gruppe zaehlt in ihrer verwalteten Einheit (``min_stock_unit``) oder – wenn
    ein Gruppen-Gebinde definiert und aktiv ist – in ganzen Packungen. Die
    Packungsgroesse ist ein **Richtwert der Gruppe** (nicht die der einzelnen
    Produkte), weil deren Packungen unterschiedlich gross sein koennen.

    ``matching`` umfasst die Artikel der Gruppe UND ihrer Untergruppen
    (transitiv): „Wurst" zaehlt Wurst, Grillwurst, Salami und alles darunter.
    Die Einheiten-Filterung der OBERgruppe gilt dabei fuer den ganzen
    Teilgraphen.

    Artfremde Artikel zaehlen mit, WENN sie eine Zweiteinheit in die Art der
    Gruppe tragen: ein in Stueck gefuehrter Artikel mit „3 Stueck ≙ 250 g"
    zaehlt in einer Kilogramm-Gruppe mit 83,333 g je Stueck. Ohne Bruecke bleibt
    er wie bisher aussen vor. Die Umrechnung steht in ``faktoren``.
    """
    alle = gruppen.produkte(group)  # inkl. Untergruppen, ohne Dubletten
    unit = group.min_stock_unit
    if unit is not None:
        base = BASE_OF_KIND[unit.kind]
        matching = []
        faktoren: dict[int, float] = {}
        for p in alle:
            f = zweit_faktor(p, base)
            if f is not None:
                matching.append(p)
                faktoren[p.id] = f
        base_unit: BaseUnit | None = base
    else:
        # Ohne verwaltete Einheit zaehlt die Gruppe roh weiter – dann werden
        # Gramm und Stueck weiterhin ungefiltert addiert (unveraendert).
        matching = alle
        faktoren = {p.id: 1.0 for p in alle}
        base_unit = None
    if group.min_stock_in_packages and group.package_size and group.package_size > 0:
        return GroupMinContext(
            divisor=float(group.package_size),
            label=group.package_label or "Packung",
            is_package=True, base_unit=base_unit, matching=matching, faktoren=faktoren,
        )
    if unit is not None:
        return GroupMinContext(
            divisor=unit.factor or 1.0, label=unit.name, is_package=False,
            base_unit=base_unit, matching=matching, faktoren=faktoren,
        )
    return GroupMinContext(
        divisor=1.0, label="", is_package=False,
        base_unit=None, matching=matching, faktoren=faktoren,
    )