"""Modelo de datos de la plataforma.

Regla de oro del proyecto: cada cuenta tiene su propia moneda y su propio saldo.
Nunca se convierte ni se mezcla dinero entre cuentas de distinta moneda; por eso
la moneda no se guarda en el movimiento, se deriva de la cuenta.
"""
from datetime import date
from typing import Optional

from sqlalchemy import Boolean, Date, Double, ForeignKey, String, UniqueConstraint
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship

TIPOS_MOVIMIENTO = ("ingreso", "egreso")
TIPOS_CATEGORIA = ("Ingreso", "Egreso")
MONEDAS = ("Bs", "USD", "USDT")


class Base(DeclarativeBase):
    pass


class Cuenta(Base):
    __tablename__ = "cuentas"

    id: Mapped[int] = mapped_column(primary_key=True)
    nombre: Mapped[str] = mapped_column(String(60), unique=True)
    moneda: Mapped[str] = mapped_column(String(10))
    activa: Mapped[bool] = mapped_column(Boolean, default=True)

    def __repr__(self):
        return f"<Cuenta {self.nombre} ({self.moneda})>"


class Categoria(Base):
    __tablename__ = "categorias"

    id: Mapped[int] = mapped_column(primary_key=True)
    tipo: Mapped[str] = mapped_column(String(10))
    nombre: Mapped[str] = mapped_column(String(80))

    __table_args__ = (
        UniqueConstraint("tipo", "nombre", name="uq_categoria_tipo_nombre"),
    )

    def __repr__(self):
        return f"<Categoria {self.tipo}: {self.nombre}>"


class Traspaso(Base):
    """Movimiento de fondos entre dos cuentas propias.

    Genera dos patas: un egreso en la cuenta origen y un ingreso en la destino.
    La `tasa` (bolívares por 1 unidad de divisa) solo aplica cuando hay
    conversión de moneda y no se usa para calcular saldos: cada cuenta queda
    expresada en su propia moneda.
    """
    __tablename__ = "traspasos"

    id: Mapped[int] = mapped_column(primary_key=True)
    fecha: Mapped[date] = mapped_column(Date)
    cuenta_origen_id: Mapped[int] = mapped_column(ForeignKey("cuentas.id"))
    cuenta_destino_id: Mapped[int] = mapped_column(ForeignKey("cuentas.id"))
    monto_origen: Mapped[float] = mapped_column(Double)
    monto_destino: Mapped[float] = mapped_column(Double)
    tasa: Mapped[Optional[float]] = mapped_column(Double, nullable=True)
    descripcion: Mapped[str] = mapped_column(String(200), default="")
    referencia: Mapped[str] = mapped_column(String(60), default="")

    cuenta_origen = relationship("Cuenta", foreign_keys=[cuenta_origen_id])
    cuenta_destino = relationship("Cuenta", foreign_keys=[cuenta_destino_id])

    def __repr__(self):
        return (f"<Traspaso {self.fecha} {self.monto_origen:,.2f} -> "
                f"{self.monto_destino:,.2f} tasa={self.tasa}>")


class Movimiento(Base):
    __tablename__ = "movimientos"

    id: Mapped[int] = mapped_column(primary_key=True)
    fecha: Mapped[date] = mapped_column(Date)
    descripcion: Mapped[str] = mapped_column(String(200))
    monto: Mapped[float] = mapped_column(Double)
    tipo: Mapped[str] = mapped_column(String(10))
    cuenta_id: Mapped[int] = mapped_column(ForeignKey("cuentas.id"))
    categoria_id: Mapped[Optional[int]] = mapped_column(
        ForeignKey("categorias.id"), nullable=True
    )
    referencia: Mapped[str] = mapped_column(String(60), default="")
    traspaso_id: Mapped[Optional[int]] = mapped_column(
        ForeignKey("traspasos.id"), nullable=True
    )

    cuenta = relationship("Cuenta")
    categoria = relationship("Categoria")

    def __repr__(self):
        return f"<Movimiento {self.fecha} {self.tipo} {self.monto:,.2f}>"


class SaldoInicial(Base):
    """Ancla declarada: saldo con el que arranca una cuenta en un periodo.

    Es un valor afirmado (no calculado) y existe porque el detalle histórico de
    las cajas es incompleto. Al cargar movimientos que el ancla ya representaba,
    hay que bajarla en el mismo total.
    """
    __tablename__ = "saldos_iniciales"

    id: Mapped[int] = mapped_column(primary_key=True)
    cuenta_id: Mapped[int] = mapped_column(ForeignKey("cuentas.id"))
    periodo: Mapped[str] = mapped_column(String(7))  # YYYY-MM
    monto: Mapped[float] = mapped_column(Double)

    __table_args__ = (
        UniqueConstraint("cuenta_id", "periodo", name="uq_saldo_cuenta_periodo"),
    )

    cuenta = relationship("Cuenta")

    def __repr__(self):
        return f"<SaldoInicial {self.cuenta_id} {self.periodo} {self.monto:,.2f}>"
