"""Consultas y cálculos sobre la base.

El saldo inicial de cada (cuenta, periodo) es el cierre del periodo anterior de
la MISMA cuenta. Una `SaldoInicial` declarada actúa como ancla cuando no hay
cierre previo y como fuente de aviso cuando contradice el cierre previo. Las
cuentas sin movimientos ni ancla en un periodo se ignoran.
"""
from collections import defaultdict

from sqlalchemy import select

from .modelos import Categoria, Cuenta, Movimiento, SaldoInicial

MESES = ["enero", "febrero", "marzo", "abril", "mayo", "junio",
         "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"]


def semana_lunes(f):
    """Semana secuencial dentro del mes, de lunes a domingo (misma regla que el Excel)."""
    primero = f.replace(day=1)
    lunes0 = primero.toordinal() - primero.weekday()
    return (f.toordinal() - lunes0) // 7 + 1


def periodo_de(f):
    """Periodo de una fecha en formato YYYY-MM."""
    return f.strftime("%Y-%m")


def nombre_periodo(periodo):
    anio, mes = int(periodo[:4]), int(periodo[5:7])
    return f"{MESES[mes - 1].capitalize()} {anio}"


def listar_cuentas(sesion):
    return list(sesion.scalars(select(Cuenta).order_by(Cuenta.nombre)))


def listar_categorias(sesion):
    return list(sesion.scalars(select(Categoria).order_by(Categoria.tipo, Categoria.nombre)))


def _anclas(sesion):
    return {(s.cuenta_id, s.periodo): float(s.monto)
            for s in sesion.scalars(select(SaldoInicial))}


def _movimientos_por_par(sesion):
    por_par = defaultdict(list)
    for m in sesion.scalars(select(Movimiento).order_by(Movimiento.fecha, Movimiento.id)):
        por_par[(m.cuenta_id, periodo_de(m.fecha))].append(m)
    return por_par


def periodos(sesion):
    """Periodos con datos (movimientos o ancla), ordenados cronológicamente."""
    con_mov = {periodo_de(f) for f in sesion.scalars(select(Movimiento.fecha))}
    return sorted(con_mov | {p for (_, p) in _anclas(sesion)})


def periodos_de_cuenta(sesion, cuenta_id):
    """Periodos en los que una cuenta tiene movimientos o ancla, en orden."""
    anclas = {p for (cid, p) in _anclas(sesion) if cid == cuenta_id}
    con_mov = {periodo_de(f) for f in sesion.scalars(
        select(Movimiento.fecha).where(Movimiento.cuenta_id == cuenta_id))}
    return sorted(anclas | con_mov)


def _armar_bloque(periodo, cuenta, saldo_inicial, movs):
    """Totales, saldo corrido, cierre y tarjetas de semana de un (cuenta, periodo)."""
    saldo = saldo_inicial
    serie = []
    for m in movs:
        saldo += m["ing"] - m["egr"]
        serie.append({"fecha": m["fecha"], "saldo": round(saldo, 2)})

    total_ing = round(sum(m["ing"] for m in movs), 2)
    total_egr = round(sum(m["egr"] for m in movs), 2)
    cierre = serie[-1]["saldo"] if serie else round(saldo_inicial, 2)
    if serie:
        serie.insert(0, {"fecha": serie[0]["fecha"], "saldo": round(saldo_inicial, 2)})

    grupos = {}
    for m in movs:
        s = grupos.setdefault(m["semana"], {"n": m["semana"], "ini": m["fecha"],
                                            "fin": m["fecha"], "ing": 0.0, "egr": 0.0})
        s["ini"] = min(s["ini"], m["fecha"])
        s["fin"] = max(s["fin"], m["fecha"])
        s["ing"] += m["ing"]
        s["egr"] += m["egr"]

    acum = saldo_inicial
    semanas = []
    for n in sorted(grupos):
        s = grupos[n]
        s["ing"] = round(s["ing"], 2)
        s["egr"] = round(s["egr"], 2)
        s["neto"] = round(s["ing"] - s["egr"], 2)
        acum += s["neto"]
        s["saldo_fin"] = round(acum, 2)
        semanas.append(s)

    return {
        "key": periodo,
        "cuenta": cuenta.nombre,
        "nombre": nombre_periodo(periodo),
        "moneda": cuenta.moneda,
        "saldo_inicial": round(saldo_inicial, 2),
        "serie": serie,
        "movs": movs,
        "total_ing": total_ing,
        "total_egr": total_egr,
        "neto": round(total_ing - total_egr, 2),
        "cierre": cierre,
        "semanas": semanas,
    }


def bloques(sesion):
    """Un bloque por (cuenta, periodo) en orden cronológico, más los avisos."""
    cuentas = {c.id: c for c in listar_cuentas(sesion)}
    anclas = _anclas(sesion)
    por_par = _movimientos_por_par(sesion)
    pares = set(por_par) | set(anclas)

    cierres = {}
    avisos = []
    resultado = []

    for periodo in sorted({p for (_, p) in pares}):
        ids = {cid for (cid, p) in pares if p == periodo}
        for cid in sorted(ids, key=lambda c: cuentas[c].nombre if c in cuentas else ""):
            if cid not in cuentas:
                continue
            cuenta = cuentas[cid]
            ancla = anclas.get((cid, periodo))
            cierre_prev = cierres.get(cid)
            saldo_inicial = ancla if ancla is not None else (cierre_prev or 0.0)
            if ancla is not None and cierre_prev is not None and abs(ancla - cierre_prev) > 0.01:
                avisos.append(
                    f"AVISO ({periodo} / {cuenta.nombre}): SALDO INICIAL ({ancla:,.2f}) "
                    f"no coincide con el cierre del periodo anterior ({cierre_prev:,.2f})"
                )

            movs = []
            for m in por_par.get((cid, periodo), []):
                ing = float(m.monto) if m.tipo == "ingreso" else 0.0
                egr = float(m.monto) if m.tipo == "egreso" else 0.0
                movs.append({
                    "id": m.id,
                    "fecha": m.fecha.isoformat(),
                    "semana": semana_lunes(m.fecha),
                    "desc": m.descripcion or "",
                    "ing": round(ing, 2),
                    "egr": round(egr, 2),
                    "cuenta": cuenta.nombre,
                    "moneda": cuenta.moneda,
                    "categoria": m.categoria.nombre if m.categoria else "",
                    "ref": m.referencia or "",
                    "traspaso_id": m.traspaso_id,
                })

            bloque = _armar_bloque(periodo, cuenta, saldo_inicial, movs)
            resultado.append(bloque)
            cierres[cid] = bloque["cierre"]

    return resultado, avisos


def datos_dashboard(sesion):
    """Datos con el mismo formato que consumía el dashboard (cuentas/categorías/meses/movimientos)."""
    bloques_, avisos = bloques(sesion)
    for aviso in avisos:
        print(aviso)
    return {
        "cuentas": [{"nombre": c.nombre, "moneda": c.moneda} for c in listar_cuentas(sesion)],
        "categorias": [{"tipo": c.tipo, "categoria": c.nombre}
                       for c in listar_categorias(sesion)],
        "meses": bloques_,
        "movimientos": [m for b in bloques_ for m in b["movs"]],
        "avisos": avisos,
    }


def resumen_saldos(sesion):
    """Ingresos, egresos y cierre por (cuenta, periodo), recalculados aparte."""
    bloques_, _ = bloques(sesion)
    return [
        {
            "cuenta": b["cuenta"],
            "periodo": b["key"],
            "moneda": b["moneda"],
            "saldo_inicial": b["saldo_inicial"],
            "ingresos": b["total_ing"],
            "egresos": b["total_egr"],
            "neto": b["neto"],
            "cierre": b["cierre"],
        }
        for b in bloques_
    ]


def cierres_por_cuenta(sesion):
    """Cierre final de cada cuenta (el del último periodo con datos)."""
    resultado = {}
    for b in bloques(sesion)[0]:
        resultado[b["cuenta"]] = b["cierre"]
    return resultado


def bloque(sesion, cuenta, periodo):
    """Bloque de un (cuenta, periodo), o None si esa cuenta no tiene datos ahí."""
    for b in bloques(sesion)[0]:
        if b["cuenta"] == cuenta and b["key"] == periodo:
            return b
    return None


def periodos_por_cuenta(sesion):
    """{nombre de cuenta: [periodos con datos]} para los selectores."""
    return {c.nombre: periodos_de_cuenta(sesion, c.id) for c in listar_cuentas(sesion)}
