"""Aus einem Eingangs-Vorschlag eine Buchung machen.

Als Dienst und nicht im Router, weil es zwei Aufrufer gibt: die Oberflaeche
(„Buchen") und die Bankanbindung, die ihre Umsaetze gleich selbst bucht. Zwei
Kopien derselben Umrechnung waeren genau die Stelle, an der Salden auseinander
laufen.
"""

from __future__ import annotations

import logging

from sqlalchemy.orm import Session

from ..models import (
    Account,
    BankAccountLink,
    InboxItem,
    InboxStatus,
    Transaction,
    TxnType,
    User,
)
from . import buchung, currency

log = logging.getLogger(__name__)


def buche(db: Session, user: User, eintrag: InboxItem) -> Transaction | None:
    """Aus einem Vorschlag eine Buchung machen. Ohne Konto geht es nicht."""
    if eintrag.status == InboxStatus.booked or eintrag.transaction_id is not None:
        return None
    if eintrag.account_id is None:
        return None
    konto = db.get(Account, eintrag.account_id)
    if konto is None or konto.owner_id != user.id:
        return None
    betrag = abs(eintrag.amount_cents)
    txn = Transaction(
        owner_id=user.id,
        type=TxnType.expense if eintrag.amount_cents < 0 else TxnType.income,
        date=eintrag.date,
        account_id=konto.id,
        amount_cents=betrag,
        amount_eur_cents=currency.compute_amount_eur_cents(
            db, betrag, konto.currency, eintrag.date),
        category_id=eintrag.category_id,
        payee=eintrag.payee,
        description=eintrag.note,
    )
    db.add(txn)
    db.flush()
    eintrag.transaction_id = txn.id
    eintrag.status = InboxStatus.booked
    return txn


def ist_angebunden(db: Session, user: User, konto: Account) -> bool:
    """Holt Certain die Umsaetze dieses Kontos selbst von der Bank?

    Entscheidend fuer einen Uebertrag: Bei einem angebundenen Gegenkonto
    liefert die Bank die Gegenbuchung selbst. Wer sie hier trotzdem anlegt,
    hat das Geld zweimal.
    """
    return db.query(BankAccountLink.id).filter(
        BankAccountLink.owner_id == user.id,
        BankAccountLink.account_id == konto.id,
    ).first() is not None


def buche_als_uebertrag(db: Session, user: User, eintrag: InboxItem,
                        ziel: Account) -> Transaction | None:
    """Einen Vorschlag als Kontouebertrag buchen.

    Statt Ausgabe oder Einnahme entsteht EINE Buchung, die das Geld vom einen
    Konto ins andere bewegt. Die Richtung kommt aus dem Vorzeichen: Ein
    negativer Betrag ist ein Abgang von diesem Konto, ein positiver ein Zugang.

    Bei verschiedenen Waehrungen wird die Seite exakt gesetzt, die wir wirklich
    kennen – die aus dem Vorschlag. Die andere wird umgerechnet.
    """
    if eintrag.status == InboxStatus.booked or eintrag.transaction_id is not None:
        return None
    if eintrag.account_id is None or eintrag.account_id == ziel.id:
        return None
    konto = db.get(Account, eintrag.account_id)
    if konto is None or konto.owner_id != user.id:
        return None

    betrag = abs(eintrag.amount_cents)
    if eintrag.amount_cents < 0:
        von, nach = konto, ziel
        ziel_betrag = None                 # wird umgerechnet
    else:
        von, nach = ziel, konto
        # Bekannt ist der Zugang, gesucht der Abgang – also rueckwaerts.
        ziel_betrag = betrag
        if ziel.currency != konto.currency:
            umgerechnet = currency.convert(
                db, betrag, konto.currency, ziel.currency, eintrag.date)
            betrag = umgerechnet if umgerechnet is not None else betrag

    txn = Transaction(
        owner_id=user.id,
        type=TxnType.transfer,
        date=eintrag.date,
        account_id=von.id,
        to_account_id=nach.id,
        amount_cents=betrag,
        to_amount_cents=ziel_betrag,
        payee=eintrag.payee,
        description=eintrag.note,
    )
    buchung.setze_betraege(db, txn, von, nach)
    db.add(txn)
    db.flush()
    eintrag.transaction_id = txn.id
    eintrag.status = InboxStatus.booked
    # Ein Uebertrag traegt keine Kategorie – er ist keine Ausgabe.
    eintrag.category_id = None
    return txn


def suche_uebertraege(db: Session, user: User) -> int:
    """Nach dem Buchen nach Uebertraegen sehen – so wie nach einem Import.

    Die Gegenseite eines Uebertrags entsteht erst beim Buchen. Ohne diesen
    Aufruf wuerde sie nie gefunden, und beide Seiten zaehlten dauerhaft als
    Ausgabe und Einnahme in der Auswertung mit.

    Ein Fehler hier darf das Buchen nicht kippen: Die Buchung ist schon
    festgeschrieben, die Verknuepfung ist nur eine Schicht darueber.
    """
    from . import uebertraege

    try:
        return uebertraege.finde(db, user).get("verknuepft", 0)
    except Exception:                      # pragma: no cover - Sicherheitsnetz
        log.exception("Uebertragssuche nach dem Buchen fehlgeschlagen")
        db.rollback()
        return 0