"""Operaciones de escritura sobre la base (núcleo, sin Flask).

Toda escritura valida contra los catálogos: cuentas y categorías son listas
cerradas. Un movimiento que pertenece a un traspaso no se edita ni se borra
suelto: editar una pata descuadraría el traspaso, así que se rechaza, y borrarla
elimina el traspaso completo (sus dos patas) en una sola operación.
"""
from datetime import date

from sqlalchemy import select

from .modelos import Categoria, Cuenta, Movimiento, Traspaso


class ValidacionError(Exception):
    """Datos inválidos. El mensaje está pensado para mostrarse al usuario."""


def _fecha(valor):
    if isinstance(valor, date):
        return valor
    try:
        return date.fromisoformat(str(valor).strip())
    except ValueError:
        raise ValidacionError("La fecha es obligatoria y debe tener formato AAAA-MM-DD")


def _monto(valor):
    texto = str(valor or "").strip().replace(" ", "")
    if "," in texto and "." in texto:
        texto = texto.replace(".", "").replace(",", ".")
    elif "," in texto:
        texto = texto.replace(",", ".")
    try:
        monto = round(float(texto), 2)
    except ValueError:
        raise ValidacionError(f"El monto no es un número válido: {valor!r}")
    if monto <= 0:
        raise ValidacionError("El monto debe ser mayor que cero")
    return monto


def _entero(valor, que):
    try:
        return int(valor)
    except (TypeError, ValueError):
        raise ValidacionError(f"{que} inválida: {valor!r}")


def obtener_cuenta(sesion, cuenta_id):
    cuenta = sesion.get(Cuenta, _entero(cuenta_id, "Cuenta"))
    if cuenta is None:
        raise ValidacionError("La cuenta indicada no está en el catálogo de cuentas")
    return cuenta


def obtener_categoria(sesion, categoria_id, tipo):
    """Categoría del catálogo que corresponde al tipo; None si no se indicó ninguna."""
    if categoria_id in (None, "", "0"):
        return None
    categoria = sesion.get(Categoria, _entero(categoria_id, "Categoría"))
    if categoria is None:
        raise ValidacionError("La categoría indicada no está en el catálogo de categorías")
    if categoria.tipo.lower() != tipo:
        raise ValidacionError(
            f"La categoría {categoria.nombre!r} es de {categoria.tipo} y el movimiento es {tipo}"
        )
    return categoria


def _validar_tipo(tipo):
    if tipo not in ("ingreso", "egreso"):
        raise ValidacionError("El tipo de movimiento debe ser ingreso o egreso")
    return tipo


def _validar_descripcion(descripcion):
    texto = str(descripcion or "").strip()
    if not texto:
        raise ValidacionError("La descripción es obligatoria")
    return texto


def crear_movimiento(sesion, *, fecha, cuenta_id, descripcion, monto, tipo,
                     categoria_id=None, referencia=""):
    """Alta de un movimiento simple (no forma parte de un traspaso)."""
    tipo = _validar_tipo(tipo)
    cuenta = obtener_cuenta(sesion, cuenta_id)
    categoria = obtener_categoria(sesion, categoria_id, tipo)
    movimiento = Movimiento(
        fecha=_fecha(fecha),
        descripcion=_validar_descripcion(descripcion),
        monto=_monto(monto),
        tipo=tipo,
        cuenta_id=cuenta.id,
        categoria_id=categoria.id if categoria else None,
        referencia=str(referencia or "").strip(),
    )
    sesion.add(movimiento)
    sesion.commit()
    return movimiento


def editar_movimiento(sesion, movimiento_id, *, fecha, cuenta_id, descripcion, monto,
                      tipo, categoria_id=None, referencia=""):
    """Edita un movimiento suelto. Las patas de un traspaso no se editan aquí."""
    movimiento = sesion.get(Movimiento, _entero(movimiento_id, "Movimiento"))
    if movimiento is None:
        raise ValidacionError("El movimiento no existe")
    if movimiento.traspaso_id:
        raise ValidacionError(
            "Este movimiento es parte de un traspaso: bórralo y vuelve a registrarlo "
            "para no descuadrar las dos cuentas"
        )
    tipo = _validar_tipo(tipo)
    cuenta = obtener_cuenta(sesion, cuenta_id)
    categoria = obtener_categoria(sesion, categoria_id, tipo)
    movimiento.fecha = _fecha(fecha)
    movimiento.descripcion = _validar_descripcion(descripcion)
    movimiento.monto = _monto(monto)
    movimiento.tipo = tipo
    movimiento.cuenta_id = cuenta.id
    movimiento.categoria_id = categoria.id if categoria else None
    movimiento.referencia = str(referencia or "").strip()
    sesion.commit()
    return movimiento


def _tasa(valor):
    """Tasa opcional: debe ser un número positivo si viene."""
    texto = str(valor or "").strip().replace(" ", "").replace(",", ".")
    if not texto:
        return None
    try:
        tasa = round(float(texto), 4)
    except ValueError:
        raise ValidacionError(f"La tasa no es un número válido: {valor!r}")
    if tasa <= 0:
        raise ValidacionError("La tasa debe ser mayor que cero")
    return tasa


def crear_traspaso(sesion, *, fecha, cuenta_origen_id, cuenta_destino_id, monto_origen,
                   monto_destino, tasa=None, descripcion="", referencia="",
                   categoria_origen_id=None, categoria_destino_id=None):
    """Traspaso entre cuentas propias: egreso en el origen e ingreso en el destino.

    Cada pata puede llevar su propia categoría, siempre del tipo que le
    corresponde: la salida del catálogo de egresos y la entrada del de ingresos.
    La tasa, cuando hay conversión, se guarda como bolívares por una unidad de la
    divisa (en compra y en venta). Entre cuentas de la misma moneda no se admite
    tasa. No se permite convertir directamente entre dos divisas (USD <-> USDT):
    para eso hace falta pasar por una cuenta en bolívares.
    """
    origen = obtener_cuenta(sesion, cuenta_origen_id)
    destino = obtener_cuenta(sesion, cuenta_destino_id)
    if origen.id == destino.id:
        raise ValidacionError("La cuenta de origen y la de destino deben ser distintas")

    categoria_salida = obtener_categoria(sesion, categoria_origen_id, "egreso")
    categoria_entrada = obtener_categoria(sesion, categoria_destino_id, "ingreso")

    origen_monto = _monto(monto_origen)
    destino_monto = _monto(monto_destino)
    tasa_dada = _tasa(tasa)

    if origen.moneda == destino.moneda:
        if tasa_dada is not None:
            raise ValidacionError(
                f"No corresponde una tasa: {origen.nombre} y {destino.nombre} están en "
                f"la misma moneda ({origen.moneda})"
            )
        tasa_final = None
    else:
        if origen.moneda == "Bs":
            calculada = round(origen_monto / destino_monto, 4)
        elif destino.moneda == "Bs":
            calculada = round(destino_monto / origen_monto, 4)
        else:
            raise ValidacionError(
                f"No se puede convertir directamente de {origen.moneda} a {destino.moneda}: "
                "usa una cuenta en bolívares como puente"
            )
        if tasa_dada is not None and abs(tasa_dada - calculada) > 0.01:
            raise ValidacionError(
                f"La tasa no coincide con los montos: {origen_monto:,.2f} {origen.moneda} / "
                f"{destino_monto:,.2f} {destino.moneda} da {calculada:,.4f}, no {tasa_dada:,.4f}"
            )
        tasa_final = calculada

    traspaso = Traspaso(
        fecha=_fecha(fecha),
        cuenta_origen_id=origen.id,
        cuenta_destino_id=destino.id,
        monto_origen=origen_monto,
        monto_destino=destino_monto,
        tasa=tasa_final,
        descripcion=_validar_descripcion(descripcion),
        referencia=str(referencia or "").strip(),
    )
    sesion.add(traspaso)
    sesion.flush()

    sesion.add(Movimiento(
        fecha=traspaso.fecha, descripcion=traspaso.descripcion, monto=origen_monto,
        tipo="egreso", cuenta_id=origen.id, referencia=traspaso.referencia,
        traspaso_id=traspaso.id,
        categoria_id=categoria_salida.id if categoria_salida else None,
    ))
    sesion.add(Movimiento(
        fecha=traspaso.fecha, descripcion=traspaso.descripcion, monto=destino_monto,
        tipo="ingreso", cuenta_id=destino.id, referencia=traspaso.referencia,
        traspaso_id=traspaso.id,
        categoria_id=categoria_entrada.id if categoria_entrada else None,
    ))
    sesion.commit()
    return traspaso


def borrar_traspaso(sesion, traspaso_id):
    """Borra el traspaso y sus dos patas en una sola operación. Devuelve las patas borradas."""
    patas = sesion.scalars(
        select(Movimiento).where(Movimiento.traspaso_id == traspaso_id)
    ).all()
    for pata in patas:
        sesion.delete(pata)
    traspaso = sesion.get(Traspaso, traspaso_id)
    if traspaso is not None:
        sesion.delete(traspaso)
    sesion.commit()
    return len(patas)


def borrar_movimiento(sesion, movimiento_id):
    """Borra un movimiento; si es pata de un traspaso, borra el traspaso completo."""
    movimiento = sesion.get(Movimiento, _entero(movimiento_id, "Movimiento"))
    if movimiento is None:
        raise ValidacionError("El movimiento no existe")
    if movimiento.traspaso_id:
        return borrar_traspaso(sesion, movimiento.traspaso_id)
    sesion.delete(movimiento)
    sesion.commit()
    return 1
