Vorrania/backend/app/crud.py

"""Kleine gemeinsame Helfer für Router."""

from __future__ import annotations

from collections import defaultdict
from datetime import date

from fastapi import HTTPException, status
from sqlalchemy import func
from sqlalchemy.orm import Session

from .models import Barcode, Category, CategoryTracking, Item, Lot, Product, ProductImage
from .schemas import BarcodeOut, LocationMinStockOut, ProductOut
from .services.conversion import KIND_OF_BASE, display_unit_info
from .services.stock import current_stock, location_subtree_stock_base


def product_tracking(db: Session, product: Product) -> str:
    """Verwaltungsart eines Artikels: aus seiner Kategorie abgeleitet.

    Ohne Kategorie gilt "food" – so bleibt das Verhalten bestehender
    (reiner Lebensmittel-)Installationen unverändert. Ein Artikel in einer
    Gegenstands-Kategorie wird als "object" geführt.

    Einzelstücke und Verbrauchsgegenstände sind immer Gegenstände: Diese Arten
    gibt es nur bei Gegenständen, sie werden aber (anders als "Menge je Lagerort")
    über ein Flag am Artikel geführt. So bleibt ein als Verbrauchsgegenstand
    umgestellter Artikel auch ohne (Gegenstands-)Kategorie ein Gegenstand.
    """
    if product.individual or product.bulk:
        return CategoryTracking.object.value
    if product.category_id is None:
        return CategoryTracking.food.value
    cat = product.category or db.get(Category, product.category_id)
    return cat.tracking if cat and cat.tracking else CategoryTracking.food.value


def product_to_out(db: Session, product: Product) -> ProductOut:
    out = ProductOut.model_validate(product)
    out.stock = current_stock(db, product.id)
    out.expired_count = (
        db.query(Lot)
        .filter(
            Lot.product_id == product.id,
            Lot.best_before.isnot(None),
            Lot.best_before < date.today(),
            Lot.quantity > 0,
        )
        .count()
    )
    out.barcodes = [
        BarcodeOut.model_validate(b)
        for b in db.query(Barcode).filter(Barcode.product_id == product.id).order_by(Barcode.id).all()
    ]
    out.category_name = product.category.name if product.category else None
    # Bild-Version = Epoch der letzten Bildänderung (identisch zum ETag der
    # Bild-Route), damit der Client nur geänderte Bilder neu lädt. None = kein Bild.
    bild_ts = (
        db.query(ProductImage.updated_at)
        .filter(ProductImage.product_id == product.id)
        .scalar()
    )
    out.image_version = int(bild_ts.timestamp()) if bild_ts is not None else None
    out.tracking = CategoryTracking(product_tracking(db, product))
    out.shop_name = product.shop.name if product.shop else None
    out.kind = KIND_OF_BASE[product.base_unit].value
    name, factor = display_unit_info(product)
    out.unit_name = name
    out.unit_factor = factor

    # Mindestbestand in der Einheit anzeigen, in der er erfasst wurde.
    if product.min_stock is not None:
        if product.min_stock_in_packages and product.package_size:
            out.min_stock_display = product.min_stock / product.package_size
            out.min_stock_unit_label = "Pkg"
        elif product.min_stock_unit is not None:
            out.min_stock_display = product.min_stock / product.min_stock_unit.factor
            out.min_stock_unit_label = product.min_stock_unit.name
        else:
            out.min_stock_display = product.min_stock / factor
            out.min_stock_unit_label = name

    out.location_min_stocks = [
        LocationMinStockOut(
            location_id=e.location_id,
            location_name=e.location.name if e.location else None,
            min_stock=e.min_stock,
            stock=location_subtree_stock_base(db, product, e.location_id),
        )
        for e in sorted(product.location_min_stocks, key=lambda x: x.id)
    ]
    return out


def products_to_out_bulk(db: Session, products: list[Product]) -> list[ProductOut]:
    """Wie ``product_to_out``, aber für viele Artikel mit **gebündelten** Abfragen
    statt N+1 – für die Listen-Ansichten. Bestand, abgelaufene Chargen, Codes und
    Bild-Version werden je einmal für alle Artikel geholt; Relationen (Kategorie,
    Shop, Einheiten, Bedarfe, Feldwerte) sollten vom Aufrufer eager-geladen sein.
    """
    if not products:
        return []
    ids = [p.id for p in products]

    # Bestand: Lot-Summen (Nicht-Einzelstücke) bzw. Item-Anzahl (Einzelstücke).
    lot_sums = dict(
        db.query(Lot.product_id, func.coalesce(func.sum(Lot.quantity), 0.0))
        .filter(Lot.product_id.in_(ids)).group_by(Lot.product_id).all()
    )
    item_counts = dict(
        db.query(Item.product_id, func.count(Item.id))
        .filter(Item.product_id.in_(ids)).group_by(Item.product_id).all()
    )
    # Abgelaufene Chargen je Artikel.
    heute = date.today()
    expired = dict(
        db.query(Lot.product_id, func.count(Lot.id))
        .filter(
            Lot.product_id.in_(ids),
            Lot.best_before.isnot(None),
            Lot.best_before < heute,
            Lot.quantity > 0,
        )
        .group_by(Lot.product_id).all()
    )
    # Zusätzliche EAN-Codes je Artikel.
    codes: dict[int, list[Barcode]] = defaultdict(list)
    for b in db.query(Barcode).filter(Barcode.product_id.in_(ids)).order_by(Barcode.id).all():
        codes[b.product_id].append(b)
    # Bild-Version (Epoch der letzten Bildänderung) je Artikel.
    imgs = dict(
        db.query(ProductImage.product_id, ProductImage.updated_at)
        .filter(ProductImage.product_id.in_(ids)).all()
    )

    out: list[ProductOut] = []
    for product in products:
        o = ProductOut.model_validate(product)
        o.stock = (
            float(item_counts.get(product.id, 0)) if product.individual
            else float(lot_sums.get(product.id, 0.0))
        )
        o.expired_count = expired.get(product.id, 0)
        o.barcodes = [BarcodeOut.model_validate(b) for b in codes.get(product.id, [])]
        o.category_name = product.category.name if product.category else None
        ts = imgs.get(product.id)
        o.image_version = int(ts.timestamp()) if ts is not None else None
        o.tracking = CategoryTracking(product_tracking(db, product))
        o.shop_name = product.shop.name if product.shop else None
        o.kind = KIND_OF_BASE[product.base_unit].value
        name, factor = display_unit_info(product)
        o.unit_name = name
        o.unit_factor = factor
        if product.min_stock is not None:
            if product.min_stock_in_packages and product.package_size:
                o.min_stock_display = product.min_stock / product.package_size
                o.min_stock_unit_label = "Pkg"
            elif product.min_stock_unit is not None:
                o.min_stock_display = product.min_stock / product.min_stock_unit.factor
                o.min_stock_unit_label = product.min_stock_unit.name
            else:
                o.min_stock_display = product.min_stock / factor
                o.min_stock_unit_label = name
        o.location_min_stocks = [
            LocationMinStockOut(
                location_id=e.location_id,
                location_name=e.location.name if e.location else None,
                min_stock=e.min_stock,
                stock=location_subtree_stock_base(db, product, e.location_id),
            )
            for e in sorted(product.location_min_stocks, key=lambda x: x.id)
        ]
        out.append(o)
    return out


def resolve_product(
    db: Session, product_id: int | None, barcode: str | None
) -> Product:
    """Findet ein Produkt per ID oder Barcode; wirft 404, wenn keins passt."""
    product: Product | None = None
    if product_id is not None:
        product = db.get(Product, product_id)
    elif barcode:
        product = db.query(Product).filter(Product.barcode == barcode).first()
    else:
        raise HTTPException(
            status.HTTP_400_BAD_REQUEST, "product_id oder barcode erforderlich"
        )
    if product is None:
        raise HTTPException(status.HTTP_404_NOT_FOUND, "Produkt nicht gefunden")
    return product