"""
Seed F11: obra DESF11 con 3 rubros forzando desvios conocidos.

Criterio §3.6 del prompt Sesion F:
    "Cargar seed con 3 rubros forzando desvio: el motor devuelve 3 alertas
     (1 AMARILLO + 2 ROJO)."

Rubros:
    R1_AV (peso 40%): avance plan 40% / real 28%  -> desvio 12pp  -> R1 AMARILLO
    R2_AV (peso 30%): avance plan 50% / real 23%  -> desvio 27pp  -> R2 ROJO
    R3_CT (peso 30%): sobrecosto 30% vs plan      -> R4 ROJO

Esperado: 3 alertas exactas. Idempotente: al correr, borra DESF11 previa y
recrea.

Uso:
    python db/seed_desvios_f11.py
"""
from __future__ import annotations

import sqlite3
import sys
from pathlib import Path

HERE = Path(__file__).resolve().parent
DB_PATH = HERE / "ergon.db"

OBRA = {
    "codigo": "DESF11",
    "nombre": "Test Desvios F11 (DEMO)",
    "cliente": "Testing DG",
    "ubicacion": "Asuncion",
    "tipo": "Test motor alertas",
    "moneda": "PYG",
    "presupuesto_total": 10_000_000_000.0,
    "fecha_inicio": "2026-01-01",
    "fecha_fin_plan": "2027-12-31",
    "fecha_corte_actual": "2026-04-30",
    "umbral_desvio_pct": 10.0,
    "umbral_critico_pct": 20.0,
    "dg_nivel_servicio": 2,
    "dg_fiscalizador": "Ing. Victor Del Puerto",
    "dg_responsable": "Victor Del Puerto",
    "dg_version_template": "v1.0",
    "es_demo": 1,
}

RUBROS = [
    (1, "R1_AV", 40.0),
    (2, "R2_AV", 30.0),
    (3, "R3_CT", 30.0),
]

# (rubro_orden, mes, plan_acum_pct, real_acum_pct)
AVANCE = [
    # R1_AV: 40 plan / 28 real -> 12 pp desvio -> R1 AMARILLO (umbral 10, critico 20)
    (1, "2026-04", 40.0, 28.0),
    # R2_AV: 50 plan / 23 real -> 27 pp -> R2 ROJO
    (2, "2026-04", 50.0, 23.0),
    # R3_CT: sin atraso avance
    (3, "2026-04", 30.0, 30.0),
]

# (rubro_orden, mes, plan, real)
# R3_CT: PV acum 1000, AC acum 1300 -> sobrecosto 30% -> R4 ROJO (umbral 10 / critico 20)
# R1_AV y R2_AV: costo alineado al plan (no dispara R3/R4).
PRESUPUESTO = [
    (1, "2026-04", 4_000_000_000.0, 4_000_000_000.0),
    (2, "2026-04", 3_000_000_000.0, 3_000_000_000.0),
    (3, "2026-04", 1_000_000_000.0, 1_300_000_000.0),
]


def main() -> int:
    if not DB_PATH.exists():
        print(f"[ERROR] DB no existe: {DB_PATH}", file=sys.stderr)
        return 1
    conn = sqlite3.connect(str(DB_PATH))
    conn.row_factory = sqlite3.Row
    conn.execute("PRAGMA foreign_keys = ON")

    try:
        cur = conn.cursor()
        cur.execute("BEGIN")

        # Limpieza idempotente: cascade via FK ON DELETE CASCADE (rubros_obra, avance_mensual, etc).
        row = cur.execute(
            "SELECT id FROM obras WHERE codigo = ?", (OBRA["codigo"],),
        ).fetchone()
        if row:
            print(f"  [seed] eliminando {OBRA['codigo']} previa (id={row['id']})")
            cur.execute("DELETE FROM obras WHERE id = ?", (row["id"],))

        # Insert obra
        cur.execute(
            """
            INSERT INTO obras (
              codigo, nombre, cliente, ubicacion, tipo, moneda,
              presupuesto_total, fecha_inicio, fecha_fin_plan, fecha_corte_actual,
              umbral_desvio_pct, umbral_critico_pct,
              dg_nivel_servicio, dg_fiscalizador, dg_responsable,
              dg_version_template, es_demo
            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            """,
            tuple(OBRA[k] for k in (
                "codigo", "nombre", "cliente", "ubicacion", "tipo", "moneda",
                "presupuesto_total", "fecha_inicio", "fecha_fin_plan",
                "fecha_corte_actual", "umbral_desvio_pct", "umbral_critico_pct",
                "dg_nivel_servicio", "dg_fiscalizador", "dg_responsable",
                "dg_version_template", "es_demo",
            )),
        )
        obra_id = cur.lastrowid
        print(f"  [seed] insertada obra {OBRA['codigo']} id={obra_id}")

        # Rubros
        rubro_id_by_orden: dict[int, int] = {}
        for orden, nombre, peso in RUBROS:
            cur.execute(
                "INSERT INTO rubros_obra (obra_id, orden, nombre, peso_pct) VALUES (?, ?, ?, ?)",
                (obra_id, orden, nombre, peso),
            )
            rubro_id_by_orden[orden] = cur.lastrowid

        # Avance
        for orden, mes, plan, real in AVANCE:
            cur.execute(
                """INSERT INTO avance_mensual
                   (obra_id, rubro_id, mes, plan_acum_pct, real_acum_pct)
                   VALUES (?, ?, ?, ?, ?)""",
                (obra_id, rubro_id_by_orden[orden], mes, plan, real),
            )

        # Presupuesto
        for orden, mes, plan, real in PRESUPUESTO:
            cur.execute(
                """INSERT INTO presupuesto_mensual
                   (obra_id, rubro_id, mes, plan, real)
                   VALUES (?, ?, ?, ?, ?)""",
                (obra_id, rubro_id_by_orden[orden], mes, plan, real),
            )

        conn.commit()
        print(f"  [seed] rubros={len(RUBROS)}, avance={len(AVANCE)}, "
              f"presupuesto={len(PRESUPUESTO)}")
        print(f"  [seed] OK. Ejecute: python -c \"import sys; sys.path.insert(0,'db');"
              f" import api_obras, alertas_engine; "
              f"print(alertas_engine.evaluar(api_obras.get_conn(),'DESF11'))\"")
        return 0
    except Exception as e:
        conn.rollback()
        print(f"[ERROR] {e}", file=sys.stderr)
        return 1
    finally:
        conn.close()


if __name__ == "__main__":
    sys.exit(main())