"""Verificación independiente del histórico en la base.

Recalcula todo por (cuenta, periodo) contando los movimientos a mano (sin pasar
por el repositorio) y lo compara con:
  - los saldos que consumen el dashboard y los reportes (repositorio),
  - la columna SALDO del Excel para Banco Bs (los mismos valores que valida
    `verificar_saldos.py`),
  - los hitos acordados con el usuario: cierres por cuenta y totales en divisa.

Uso:
    python -m capilla_web.verificar_integridad [ruta_xlsx]

Termina con código de salida 1 si algo no cuadra.
"""
import sys
from collections import defaultdict

from sqlalchemy import select

from .db import repositorio as repo
from .db.modelos import Categoria, Cuenta, Movimiento, SaldoInicial
from .db.sesion import crear_sesion
from .importar_desde_xlsx import ARCHIVO_POR_DEFECTO, parsear

TOLERANCIA = 0.01

# Cierres acordados con el usuario (los mismos que valida verificar_saldos.py).
HITOS_CIERRES = {
    ("Banco Bs", "2026-06"): 78331.77,
    ("Banco Bs", "2026-07"): 131886.21,
    ("Banco Bs", "2026-08"): 85437.58,
    ("Banco Bs", "2026-09"): 86072.24,
    ("Caja Bs", "2026-06"): 39360.00,
    ("Caja Bs", "2026-07"): 22060.00,
    ("Caja Bs", "2026-08"): 4700.00,
    ("Caja Bs", "2026-09"): 4000.00,
    ("Caja USD", "2026-06"): 114.00,
    ("Caja USD", "2026-07"): 14.00,
    ("Caja USD", "2026-09"): 4.00,
}

# Totales por cuenta y tipo: en las cajas en dólares deben ser cantidades en
# USD (100 y 110), nunca los montos en Bs de los traspasos (79,600).
HITOS_TOTALES = {
    ("Caja USD", "ingreso"): 100.00,
    ("Caja USD", "egreso"): 110.00,
    ("Caja Bs", "egreso"): 40160.00,
}


def _recuento(sesion):
    """Cuenta movimientos a mano: (cuenta_id, periodo) -> {ing, egr, n}."""
    totales = defaultdict(lambda: {"ing": 0.0, "egr": 0.0, "n": 0})
    for m in sesion.scalars(select(Movimiento)):
        registro = totales[(m.cuenta_id, m.fecha.strftime("%Y-%m"))]
        registro["ing" if m.tipo == "ingreso" else "egr"] += float(m.monto)
        registro["n"] += 1
    return totales


def _cadenas(cuentas, totales, anclas):
    """Cierre por (cuenta, periodo) arrastrando el cierre anterior de la misma cuenta."""
    por_cuenta = defaultdict(list)
    for cid, periodo in set(totales) | set(anclas):
        por_cuenta[cid].append(periodo)

    resultado = {}
    for cid, periodos in por_cuenta.items():
        anterior = None
        for periodo in sorted(periodos):
            t = totales.get((cid, periodo), {"ing": 0.0, "egr": 0.0, "n": 0})
            ancla = anclas.get((cid, periodo))
            inicial = ancla if ancla is not None else (anterior or 0.0)
            resultado[(cid, periodo)] = {
                "inicial": round(inicial, 2),
                "ing": round(t["ing"], 2),
                "egr": round(t["egr"], 2),
                "n": t["n"],
                "cierre": round(inicial + t["ing"] - t["egr"], 2),
            }
            anterior = resultado[(cid, periodo)]["cierre"]
    return resultado


def verificar(ruta_xlsx=ARCHIVO_POR_DEFECTO):
    """Devuelve (ok, informe) comparando el recuento a mano con el repositorio, el Excel e hitos."""
    sesion = crear_sesion()
    try:
        cuentas = {c.id: c for c in sesion.scalars(select(Cuenta))}
        nombre = {cid: c.nombre for cid, c in cuentas.items()}
        totales = _recuento(sesion)
        anclas = {(s.cuenta_id, s.periodo): float(s.monto)
                  for s in sesion.scalars(select(SaldoInicial))}
        cadenas = _cadenas(cuentas, totales, anclas)
        _, _, cierres_excel = parsear(ruta_xlsx)

        problemas = []
        ids_por_nombre = {c.nombre: cid for cid, c in cuentas.items()}

        # 1) El repositorio (dashboard y reportes) coincide con el recuento a mano.
        repo_saldos = repo.resumen_saldos(sesion)
        if len(repo_saldos) != len(cadenas):
            problemas.append(f"El repositorio devuelve {len(repo_saldos)} bloques y el recuento "
                             f"a mano {len(cadenas)}")
        for s in repo_saldos:
            cid = ids_por_nombre.get(s["cuenta"])
            mano = cadenas.get((cid, s["periodo"]))
            if mano is None:
                problemas.append(f"{s['cuenta']} {s['periodo']}: el recuento a mano no lo tiene")
                continue
            for campo, valor_mano in (("saldo_inicial", mano["inicial"]), ("ingresos", mano["ing"]),
                                      ("egresos", mano["egr"]), ("cierre", mano["cierre"])):
                if abs(valor_mano - s[campo]) > TOLERANCIA:
                    problemas.append(f"{s['cuenta']} {s['periodo']} {campo}: repositorio "
                                     f"{s[campo]:,.2f} vs recuento {valor_mano:,.2f}")

        # 2) Banco Bs contra la columna SALDO del Excel (lo que valida verificar_saldos.py).
        for (cid, periodo), datos in cadenas.items():
            if nombre[cid] != "Banco Bs":
                continue
            esperado = cierres_excel.get(periodo)
            if esperado is not None and abs(datos["cierre"] - round(esperado, 2)) > TOLERANCIA:
                problemas.append(f"Banco Bs {periodo}: cierre {datos['cierre']:,.2f} vs Excel "
                                 f"{esperado:,.2f}")

        # 3) Hitos acordados.
        for (cuenta, periodo), esperado in HITOS_CIERRES.items():
            cid = ids_por_nombre.get(cuenta)
            datos = cadenas.get((cid, periodo))
            if datos is None:
                problemas.append(f"Hito sin datos: {cuenta} {periodo}")
            elif abs(datos["cierre"] - esperado) > TOLERANCIA:
                problemas.append(f"Hito {cuenta} {periodo}: {datos['cierre']:,.2f} != {esperado:,.2f}")

        for (cuenta, tipo), esperado in HITOS_TOTALES.items():
            cid = ids_por_nombre.get(cuenta)
            clave = "ing" if tipo == "ingreso" else "egr"
            suma = round(sum(t[clave] for (c, _p), t in totales.items() if c == cid), 2)
            if abs(suma - esperado) > TOLERANCIA:
                problemas.append(f"Hito total {cuenta} {tipo}: {suma:,.2f} != {esperado:,.2f}")

        # 4) Cada movimiento pertenece a una cuenta del catálogo y a una sola cuenta.
        movs = sesion.scalars(select(Movimiento)).all()
        if sum(t["n"] for t in totales.values()) != len(movs):
            problemas.append("Hay movimientos contados en más de una cuenta")
        for m in movs:
            if m.cuenta_id not in cuentas:
                problemas.append(f"Movimiento {m.id} con cuenta inexistente")
            if m.tipo not in ("ingreso", "egreso"):
                problemas.append(f"Movimiento {m.id} con tipo inválido: {m.tipo!r}")

        # 5) Ninguna categoría con el tipo contrario al del movimiento.
        for m in movs:
            if m.categoria_id is None:
                continue
            categoria = sesion.get(Categoria, m.categoria_id)
            if categoria is None:
                problemas.append(f"Movimiento {m.id} con categoría inexistente")
            elif categoria.tipo.lower() != m.tipo:
                problemas.append(f"Movimiento {m.id} ({m.tipo}) con la categoría "
                                 f"{categoria.nombre!r}, que es de {categoria.tipo}")

        # 6) Las cuentas en divisa no reciben montos en Bs.
        for cid, c in cuentas.items():
            if c.moneda == "Bs":
                continue
            for (c2, periodo), t in totales.items():
                if c2 == cid and t["ing"] + t["egr"] > 5000:
                    problemas.append(f"{c.nombre} {periodo}: montos sospechosamente grandes para "
                                     f"{c.moneda} ({t['ing'] + t['egr']:,.2f})")

        informe = {
            "ok": not problemas,
            "problemas": problemas,
            "bloques": len(cadenas),
            "movimientos": len(movs),
            "cierres": {f"{nombre[cid]} {p}": d["cierre"] for (cid, p), d in sorted(
                cadenas.items(), key=lambda kv: (nombre[kv[0][0]], kv[0][1]))},
        }
        return informe["ok"], informe
    finally:
        sesion.close()


def main():
    ruta = sys.argv[1] if len(sys.argv) > 1 else ARCHIVO_POR_DEFECTO
    ok, informe = verificar(ruta)
    print(f"VERIFICACION DE INTEGRIDAD (Excel: {ruta})")
    print("=" * 62)
    print(f"Bloques (cuenta, periodo): {informe['bloques']} | Movimientos: {informe['movimientos']}")
    print("\nCierres:")
    for clave, cierre in informe["cierres"].items():
        print(f"  {clave:22} {cierre:>14,.2f}")
    if informe["problemas"]:
        print(f"\nPROBLEMAS ({len(informe['problemas'])}):")
        for p in informe["problemas"]:
            print(f"  - {p}")
        print("\nRESULTADO: FALLO")
        sys.exit(1)
    print("\nRESULTADO: OK en todas las comprobaciones")


if __name__ == "__main__":
    main()
