#!/usr/bin/env python3
"""Backfill attività di miglioramento per i DVR già importati.

Logica: per ogni dvr_pericoli con col_d o col_e in ('X','N') e codice_attivita
valorizzato sul punto, crea una dvr_attivita_miglioramento se non esiste.

- 'X' (giallo) → MEDIO (R=4, scadenza 180gg)
- 'N' (rosso) → ALTO (R=8, scadenza 0 giorni)
- Se U e P entrambi presenti, si prende il livello più alto.

Famiglia: derivata dal codice_attivita ("D1" → "D", "P1-P2" → "P").
data_inizio: data di emissione del DVR (fallback: oggi).
"""
import re
import sqlite3
from datetime import datetime, timedelta
from pathlib import Path

import os as _os
DB = Path(_os.environ["IMPORT_DB"]) if _os.environ.get("IMPORT_DB") else Path(__file__).resolve().parents[1] / "db" / "dev.db"


def famiglia_di(codice: str) -> str:
    head = codice.split("-")[0]
    m = re.match(r"^([A-Z]+)", head)
    return m.group(1) if m else head


def livello_da_up(u: str | None, p: str | None) -> tuple[int, str, int | None]:
    def score(v):
        if v == "N":
            return 8
        if v == "X":
            return 4
        return 0

    r = max(score(u), score(p))
    if r == 0:
        return 0, "NON_APPLICABILE", None
    if r == 8:
        return 8, "ALTO", 0
    if r == 4:
        return 4, "MEDIO", 180
    return r, "BASSO", 365


def main():
    conn = sqlite3.connect(DB)
    cur = conn.cursor()

    # Mappa famiglia codice → id
    cur.execute("SELECT codice, id FROM lookup_attivita_famiglie")
    famiglie = dict(cur.fetchall())

    # Tutte le righe candidate
    cur.execute(
        """SELECT p.id, p.dvr_id, p.col_d, p.col_e, lp.codice_attivita, d.data_emissione
           FROM dvr_pericoli p
           JOIN lookup_pericoli_punti lp ON lp.id = p.punto_id
           JOIN dvr d ON d.id = p.dvr_id
           WHERE lp.codice_attivita IS NOT NULL
             AND (p.col_d IN ('X','N') OR p.col_e IN ('X','N'))"""
    )
    rows = cur.fetchall()
    print(f"Trovate {len(rows)} righe candidate")

    # Skippa quelle che hanno già un'attività
    cur.execute(
        "SELECT source_id FROM dvr_attivita_miglioramento WHERE source_type='pericolo'"
    )
    gia_fatti = {r[0] for r in cur.fetchall()}
    print(f"Skippo {len(gia_fatti)} già esistenti")

    n_creati = 0
    n_skip_codice = 0
    n_skip_famiglia = 0
    oggi = datetime.now().date()

    for pid, dvr_id, col_d, col_e, codice, data_emiss in rows:
        if pid in gia_fatti:
            continue

        r, livello, giorni = livello_da_up(col_d, col_e)
        if r == 0:
            n_skip_codice += 1
            continue

        fam_cod = famiglia_di(codice)
        fam_id = famiglie.get(fam_cod)
        if not fam_id:
            n_skip_famiglia += 1
            continue

        # Data inizio: data emissione DVR (fallback oggi)
        try:
            data_inizio = (
                datetime.strptime(data_emiss, "%Y-%m-%d").date() if data_emiss else oggi
            )
        except (ValueError, TypeError):
            data_inizio = oggi

        data_scadenza = None
        if giorni is not None:
            data_scadenza = (data_inizio + timedelta(days=giorni)).isoformat()

        cur.execute(
            """INSERT INTO dvr_attivita_miglioramento
               (dvr_id, famiglia_id, source_type, source_id, r_score, livello,
                data_inizio, data_scadenza, stato)
               VALUES (?, ?, 'pericolo', ?, ?, ?, ?, ?, 'aperta')""",
            (dvr_id, fam_id, pid, r, livello, data_inizio.isoformat(), data_scadenza),
        )
        n_creati += 1

    conn.commit()
    conn.close()

    print()
    print(f"Attività create: {n_creati}")
    print(f"Skip (livello 0): {n_skip_codice}")
    print(f"Skip (famiglia non trovata): {n_skip_famiglia}")


if __name__ == "__main__":
    main()