"""Importación del histórico de `movimientos.xlsx` a la base.

Es el único puente Excel -> base. Se ejecuta una sola vez y es determinista:
antes de escribir borra los datos históricos y los vuelve a crear, de modo que
reejecutarlo deja exactamente el mismo estado.

Qué hace:
  1. Lee todas las hojas de mes e ignora la fila `Total`.
  2. Convierte las filas `SALDO INICIAL` en anclas: solo importa la primera de
     cada cuenta, porque las siguientes son el arrastre del cierre anterior y
     el repositorio ya las calcula.
  3. Normaliza las categorías contra el catálogo (mayúsculas/espacios).
  4. Reclasifica como traspasos los movimientos que en el Excel son patas
     sueltas y crea la pata que falta:
       - "Compra de USD" del banco  -> traspaso Banco Bs -> Caja USD (con tasa).
       - ingresos por efectivo       -> traspaso Caja Bs -> Banco Bs.
  5. Agrega lo que no está en el Excel y se declaró con el usuario: ancla de
     Caja Bs, ancla e histórico de Caja USD.
  6. Aborta sin escribir si el cierre de Banco Bs calculado no coincide con la
     columna SALDO del Excel.

Uso:
    python -m capilla_web.importar_desde_xlsx [ruta_xlsx]
"""
import re
import sys
from datetime import date, datetime

import openpyxl

from .db import repositorio as repo
from .db.modelos import Categoria, Cuenta, Movimiento, SaldoInicial, Traspaso
from .db.semilla import sembrar_catalogos
from .db.sesion import crear_sesion, crear_tablas

ARCHIVO_POR_DEFECTO = "movimientos.xlsx"
HOJAS_CATALOGO = ("CUENTAS", "CATEGORIAS")
TOLERANCIA = 0.01

MESES_HOJA = {
    "ENERO": 1, "FEBRERO": 2, "MARZO": 3, "ABRIL": 4, "MAYO": 5, "JUNIO": 6,
    "JULIO": 7, "AGOSTO": 8, "SEPTIEMBRE": 9, "SETIEMBRE": 9, "OCTUBRE": 10,
    "NOVIEMBRE": 11, "DICIEMBRE": 12,
}

# --- Valores declarados que no están en el Excel (ver design.md D7 y AGENTS.md) ---
# Ancla de Caja Bs: 4,000 Bs en la caja hoy + 40,160 Bs entregados al banco.
ANCLA_CAJA_BS = 44160.0
# Ancla de Caja USD: saldo con que arranca la caja en dólares.
ANCLA_CAJA_USD = 14.0
# Histórico de Caja USD que no está en el Excel: (fecha, tipo, monto USD, descripción, categoría).
HISTORICO_CAJA_USD = (
    (date(2026, 7, 18), "egreso", 100.0, "Entrega premio rifa", "Otros Gastos"),
    (date(2026, 9, 5), "egreso", 10.0, "Compra de cemento", "Compra de Materiales de Construcción"),
)

# Categorías mal tipadas en el Excel (un ingreso con categoría de egreso): se
# corrigen al importar. La clave es (tipo, nombre normalizado del Excel).
CORRECCIONES_CATEGORIA = {
    ("ingreso", "compra de efectivo"): "Venta Efectivo",
    ("ingreso", "otras compras"): "Otras Ventas",
}

# El ingreso por efectivo del banco es la pata bancaria de un traspaso Caja Bs -> Banco Bs.
# Cada pata lleva la categoría que le corresponde por su tipo y su cuenta: el par
# "Compra de Efectivo" (egreso) / "Venta Efectivo" (ingreso) son las dos caras de la
# misma operación, igual que "Compra de USD" (egreso) / "Venta de USD" (ingreso).
CATS_EFECTIVO = ("Venta Efectivo", "Compra de Efectivo")
CAT_EFECTIVO_ENTRADA = "Venta Efectivo"      # pata del banco (ingreso)
CAT_EFECTIVO_SALIDA = "Compra de Efectivo"   # pata de la caja (egreso)
CAT_USD_SALIDA = "Compra de USD"             # pata del banco (egreso)
CAT_USD_ENTRADA = "Venta de USD"             # pata de Caja USD (ingreso)
DESC_EFECTIVO = "VENTA DE EFECTIVO"
CAT_EFECTIVO = CAT_EFECTIVO_ENTRADA
CAT_USD = CAT_USD_SALIDA
RE_USD = re.compile(r"(\d+(?:[.,]\d+)?)\s*\$")


class ImportacionError(Exception):
    """Error de datos que impide importar (no se escribe nada)."""


def _norm(texto):
    return " ".join(str(texto or "").strip().split()).lower()


def _periodo_hoja(nombre, fechas):
    """Periodo YYYY-MM de una hoja: mes por el nombre, año por sus fechas."""
    mes = MESES_HOJA.get(nombre.strip().upper())
    if mes is None:
        raise ImportacionError(f"Hoja de mes no reconocida: {nombre!r}")
    anios = {f.year for f in fechas}
    if len(anios) != 1:
        raise ImportacionError(f"Hoja {nombre!r}: año indeterminado {sorted(anios)}")
    return f"{anios.pop():04d}-{mes:02d}"


def parsear(ruta_xlsx):
    """Lee el libro: devuelve (filas, anclas, cierres de Banco Bs observados)."""
    wb = openpyxl.load_workbook(ruta_xlsx, data_only=True)
    filas, anclas, cierres = [], [], {}

    for ws in wb.worksheets:
        if ws.title.upper() in HOJAS_CATALOGO:
            continue
        movs, anclas_hoja = [], []
        for r in ws.iter_rows(min_row=2, values_only=True):
            fecha, _sem, desc, egr, ing = r[0], r[1], r[2], r[3], r[4]
            saldo, cuenta, moneda = r[5], r[6], r[7]
            categoria, ref = r[8], r[9]
            if not isinstance(fecha, datetime):
                continue  # fila Total o vacía
            if str(desc).strip().upper().startswith("SALDO INICIAL"):
                anclas_hoja.append({
                    "fecha": fecha.date(),
                    "cuenta": str(cuenta or "").strip(),
                    "saldo": float(saldo or 0),
                })
                continue
            movs.append({
                "fecha": fecha.date(),
                "desc": str(desc).strip(),
                "egr": round(float(egr or 0), 2),
                "ing": round(float(ing or 0), 2),
                "saldo_excel": float(saldo or 0),
                "cuenta": str(cuenta or "").strip(),
                "moneda": str(moneda or "").strip(),
                "categoria": str(categoria).strip() if categoria else "",
                "ref": str(ref or "").strip(),
            })
        if not movs and not anclas_hoja:
            continue
        periodo = _periodo_hoja(ws.title, [m["fecha"] for m in movs] or [a["fecha"] for a in anclas_hoja])
        for m in movs:
            m["periodo"] = periodo
            m["hoja"] = ws.title
        for a in anclas_hoja:
            a["periodo"] = periodo
        filas.extend(movs)
        anclas.extend(anclas_hoja)
        if movs:
            # El SALDO de la última fila con fecha es el cierre de Banco Bs de la hoja.
            cierres[periodo] = movs[-1]["saldo_excel"]
    return filas, anclas, cierres


def verificar_cierres_banco(filas, anclas, cierres):
    """Aborta si el cierre de Banco Bs calculado no coincide con la columna SALDO del Excel.

    Caja Bs no se verifica aquí: su ancla es declarada, no viene del Excel.
    """
    anclas_banco = {}
    for a in anclas:
        if a["cuenta"] == "Banco Bs" and a["periodo"] not in anclas_banco:
            anclas_banco[a["periodo"]] = a["saldo"]

    acumulado = {}
    for f in filas:
        if f["cuenta"] != "Banco Bs":
            continue
        estado = acumulado.setdefault(f["periodo"], {"saldo": anclas_banco.get(f["periodo"], 0.0)})
        estado["saldo"] += f["ing"] - f["egr"]

    problemas = []
    for periodo in sorted(acumulado):
        esperado = cierres.get(periodo)
        if esperado is None:
            continue
        calculado = round(acumulado[periodo]["saldo"], 2)
        if abs(calculado - round(esperado, 2)) > TOLERANCIA:
            problemas.append(
                f"  {periodo}: calculado {calculado:,.2f} vs Excel {esperado:,.2f} "
                f"(diferencia {calculado - esperado:,.2f})"
            )
    if problemas:
        raise ImportacionError(
            "El cierre de Banco Bs no coincide con la columna SALDO del Excel. "
            "No se escribió nada:\n" + "\n".join(problemas)
        )
    return acumulado


def _indices_catalogo(sesion):
    por_tipo, por_nombre = {}, {}
    for c in sesion.query(Categoria).all():
        por_tipo[(_norm(c.tipo), _norm(c.nombre))] = c
        por_nombre[_norm(c.nombre)] = c
    return {"por_tipo": por_tipo, "por_nombre": por_nombre}


def _resolver_categoria(texto, tipo, indice):
    """Categoría del catálogo que corresponde al texto del Excel.

    Devuelve (categoria, nota). `nota` describe una normalización aplicada o, si
    la categoría no existe en el catálogo, deja constancia para el informe.
    """
    clave = _norm(texto)
    if not clave:
        return None, "sin categoría en el Excel"
    exacta = indice["por_tipo"].get((tipo, clave))
    if exacta:
        return exacta, None
    otra = indice["por_nombre"].get(clave)
    if otra:
        return None, f"categoría {texto!r} es del tipo {otra.tipo}, no {tipo}"
    return None, f"categoría {texto!r} no está en el catálogo"


def _categoria(indice, tipo, nombre):
    """Categoría del catálogo por tipo y nombre; aborta si no existe."""
    categoria = indice["por_tipo"].get((_norm(tipo), _norm(nombre)))
    if categoria is None:
        raise ImportacionError(f"No existe la categoría de {tipo} {nombre!r}")
    return categoria


def _limpiar_datos(sesion):
    """Borra el histórico para reejecutar la importación de forma determinista."""
    sesion.query(Movimiento).delete()
    sesion.query(Traspaso).delete()
    sesion.query(SaldoInicial).delete()
    sesion.flush()


def _insertar(sesion, filas, anclas, indice, cuentas):
    """Crea anclas, movimientos y traspasos. Devuelve un resumen e incidencias."""
    resumen = {"anclas": 0, "movimientos": 0, "traspasos": 0, "legs_caja": 0,
               "caja_usd": 0, "notas": [], "fuera_catalogo": []}

    # 1) Anclas: la primera de cada cuenta según el Excel + las declaradas.
    primera = {}
    for a in anclas:
        if a["cuenta"] and (a["cuenta"] not in primera or a["periodo"] < primera[a["cuenta"]]["periodo"]):
            primera[a["cuenta"]] = a
    periodo_inicial = min(
        [f["periodo"] for f in filas] + [a["periodo"] for a in anclas] or ["2026-06"]
    )

    declaradas = []
    for nombre, info in primera.items():
        if nombre in cuentas:
            declaradas.append((nombre, info["periodo"], info["saldo"]))
    declaradas.append(("Caja Bs", periodo_inicial, ANCLA_CAJA_BS))
    declaradas.append(("Caja USD", periodo_inicial, ANCLA_CAJA_USD))

    for nombre, periodo, monto in declaradas:
        cuenta = cuentas.get(nombre)
        if cuenta is None:
            raise ImportacionError(f"Cuenta del Excel no está en el catálogo: {nombre!r}")
        sesion.add(SaldoInicial(cuenta_id=cuenta.id, periodo=periodo, monto=round(monto, 2)))
        resumen["anclas"] += 1

    def nuevo_movimiento(cuenta, fecha, desc, monto, tipo, categoria, ref, traspaso_id=None):
        mov = Movimiento(
            fecha=fecha, descripcion=desc, monto=round(monto, 2), tipo=tipo,
            cuenta_id=cuenta.id, categoria_id=categoria.id if categoria else None,
            referencia=ref or "", traspaso_id=traspaso_id,
        )
        sesion.add(mov)
        resumen["movimientos"] += 1
        return mov

    banco = cuentas["Banco Bs"]
    caja_bs = cuentas["Caja Bs"]
    caja_usd = cuentas["Caja USD"]

    # 2) Filas del Excel: cada una es un movimiento del banco; las de efectivo y
    #    de compra de USD son la pata bancaria de un traspaso y generan la otra.
    for f in sorted(filas, key=lambda x: (x["fecha"], x["hoja"])):
        cuenta = cuentas.get(f["cuenta"])
        if cuenta is None:
            raise ImportacionError(f"Movimiento con cuenta desconocida: {f['cuenta']!r} ({f['hoja']})")
        if f["moneda"] and cuenta.moneda != f["moneda"]:
            resumen["notas"].append(
                f"{f['hoja']} {f['fecha']}: moneda del Excel {f['moneda']!r} != moneda de la cuenta "
                f"{cuenta.moneda!r} (se usa la de la cuenta)"
            )
        tipo = "ingreso" if f["ing"] else "egreso"
        monto = f["ing"] or f["egr"]

        categoria_excel = f["categoria"]
        correcta = CORRECCIONES_CATEGORIA.get((tipo, _norm(categoria_excel)))
        if correcta:
            resumen["notas"].append(
                f"{f['hoja']} {f['fecha']} {f['desc']!r}: categoría de {tipo} corregida de "
                f"{categoria_excel!r} a {correcta!r}"
            )
            categoria_excel = correcta

        es_efectivo = _norm(categoria_excel) in {_norm(c) for c in CATS_EFECTIVO}
        es_compra_usd = _norm(categoria_excel) == _norm(CAT_USD)
        if es_efectivo and tipo == "ingreso":
            categoria_entrada = _categoria(indice, "ingreso", CAT_EFECTIVO_ENTRADA)
            categoria_salida = _categoria(indice, "egreso", CAT_EFECTIVO_SALIDA)
            traspaso = Traspaso(
                fecha=f["fecha"], cuenta_origen_id=caja_bs.id, cuenta_destino_id=banco.id,
                monto_origen=round(monto, 2), monto_destino=round(monto, 2), tasa=None,
                descripcion=f["desc"], referencia=f["ref"],
            )
            sesion.add(traspaso)
            resumen["traspasos"] += 1
            sesion.flush()
            nuevo_movimiento(banco, f["fecha"], f["desc"], monto, "ingreso",
                             categoria_entrada, f["ref"], traspaso.id)
            nuevo_movimiento(caja_bs, f["fecha"], DESC_EFECTIVO, monto, "egreso",
                             categoria_salida, f["ref"], traspaso.id)
            resumen["legs_caja"] += 1
            continue

        if es_compra_usd and tipo == "egreso":
            categoria_salida = _categoria(indice, "egreso", CAT_USD_SALIDA)
            categoria_entrada = _categoria(indice, "ingreso", CAT_USD_ENTRADA)
            usd = RE_USD.search(f["desc"])
            if not usd:
                raise ImportacionError(
                    f"No se pudo leer el monto en dólares de {f['hoja']} {f['fecha']} {f['desc']!r}"
                )
            monto_usd = float(usd.group(1).replace(",", "."))
            traspaso = Traspaso(
                fecha=f["fecha"], cuenta_origen_id=banco.id, cuenta_destino_id=caja_usd.id,
                monto_origen=round(monto, 2), monto_destino=round(monto_usd, 2),
                tasa=round(monto / monto_usd, 4) if monto_usd else None,
                descripcion=f["desc"], referencia=f["ref"],
            )
            sesion.add(traspaso)
            resumen["traspasos"] += 1
            sesion.flush()
            nuevo_movimiento(banco, f["fecha"], f["desc"], monto, "egreso", categoria_salida,
                             f["ref"], traspaso.id)
            nuevo_movimiento(caja_usd, f["fecha"], f["desc"], monto_usd, "ingreso",
                             categoria_entrada, f["ref"], traspaso.id)
            resumen["notas"].append(
                f"{f['hoja']} {f['fecha']}: traspaso Banco Bs -> Caja USD por "
                f"{monto_usd:,.2f} USD con tasa {traspaso.tasa:,.4f} "
                f"({CAT_USD_SALIDA!r} / {CAT_USD_ENTRADA!r})"
            )
            continue

        categoria, nota = _resolver_categoria(categoria_excel, tipo, indice)
        if nota:
            resumen["fuera_catalogo"].append(f"{f['hoja']} {f['fecha']} {f['desc']!r}: {nota}")
        nuevo_movimiento(cuenta, f["fecha"], f["desc"], monto, tipo, categoria, f["ref"])

    # 3) Histórico de Caja USD que no está en el Excel.
    for fecha, tipo, monto, desc, nombre_cat in HISTORICO_CAJA_USD:
        categoria = _categoria(indice, tipo, nombre_cat)
        nuevo_movimiento(caja_usd, fecha, desc, monto, tipo, categoria, "S/R")
        resumen["caja_usd"] += 1
        resumen["notas"].append(
            f"Caja USD {fecha}: {tipo} de {monto:,.2f} USD ({desc}) con categoría {nombre_cat!r}"
        )

    return resumen


def importar(ruta_xlsx=ARCHIVO_POR_DEFECTO, sesion=None, limpiar=True):
    """Importa el histórico completo. Devuelve (resumen, cierres)."""
    propia = sesion is None
    try:
        if propia:
            crear_tablas()
            sesion = crear_sesion()

        sembrar_catalogos(sesion, ruta_xlsx)
        filas, anclas, cierres_excel = parsear(ruta_xlsx)
        verificar_cierres_banco(filas, anclas, cierres_excel)

        indice = _indices_catalogo(sesion)
        cuentas = {c.nombre: c for c in repo.listar_cuentas(sesion)}

        if limpiar:
            _limpiar_datos(sesion)

        resumen = _insertar(sesion, filas, anclas, indice, cuentas)
        sesion.flush()
        resumen["saldos"] = repo.resumen_saldos(sesion)
        sesion.commit()
        return resumen, cierres_excel
    except Exception:
        sesion.rollback()
        raise
    finally:
        if propia:
            sesion.close()


def main():
    ruta = sys.argv[1] if len(sys.argv) > 1 else ARCHIVO_POR_DEFECTO
    resumen, _ = importar(ruta)

    print(f"Importado desde {ruta}")
    print(f"  anclas={resumen['anclas']}  movimientos={resumen['movimientos']}  "
          f"traspasos={resumen['traspasos']}  patas de caja={resumen['legs_caja']}  "
          f"caja USD={resumen['caja_usd']}")

    if resumen["notas"]:
        print("\nNormalizaciones y traspasos:")
        for n in resumen["notas"]:
            print(f"  - {n}")
    if resumen["fuera_catalogo"]:
        print("\nCategorías fuera del catálogo:")
        for n in resumen["fuera_catalogo"]:
            print(f"  - {n}")
    else:
        print("\nNinguna categoría quedó fuera del catálogo.")

    print("\nSaldos por cuenta y periodo:")
    for s in resumen["saldos"]:
        print(f"  {s['cuenta']:9} {s['periodo']}  ini={s['saldo_inicial']:>12,.2f}  "
              f"ing={s['ingresos']:>12,.2f}  egr={s['egresos']:>12,.2f}  "
              f"cierre={s['cierre']:>12,.2f}  {s['moneda']}")


if __name__ == "__main__":
    main()
