#!/usr/bin/env python3
"""check_job_health.py — controllo di salute indipendente dei job gate-ufficio.

Diverso da `logbook/collect_logs.py` (Nave di sistema: cron/log locali di
Nave, backup HDD, mirror pCloud) — questo appartiene al dominio delle
"schedulazioni ufficio" (`schedule.json` -> servizio-schedulazioni ->
gate-ufficio -> job_runner.py), stesso repository di quel circuito.
Spostato qui il 03/09/2026 dopo essere stato scritto per errore dentro
collect_logs.py, mescolando due sistemi di schedulazione concettualmente
distinti (vedi memory/MEMORY.md).

Legge solo i log dei job già sincronizzati da Ufficio via Dropbox in
`../ufficio/logs/` — nessun accesso diretto a Ufficio, nessuna credenziale
lato Nave. Indipendente da qualunque sessione Adrian viva.
"""

from __future__ import annotations

import datetime as dt
import json
import re
import subprocess
from collections import deque
from pathlib import Path

from croniter import croniter

HERE = Path(__file__).resolve().parent
ROOT = HERE.parents[2]
LOGS_DIR = HERE.parent / "ufficio" / "logs"
SCHEDULE_PATH = HERE / "schedule.json"
REPORT_PATH = HERE / "logs" / "job_health_latest.txt"
NOTIFIED_ISSUES_PATH = HERE / "logs" / "job_health_notified_issues.json"
MAILBOX_WRITE = ROOT / "scripts" / "slave_mailbox_write.sh"

JOB_FILENAME_RE = re.compile(r"^(?P<job>.+)_(?P<date>\d{8})_(?P<time>\d{6})\.log$")
JOB_ESITO_RE = re.compile(r"=== ESITO: (\w+) exit_code=(-?\d+) duration=([\d.]+)s ===")

# "backup" è un caso a parte: gira ogni 2h ma solo quando il PC ufficio è acceso — un controllo
# basato sul cron (prossima occorrenza attesa + un margine) darebbe falsi allarmi ogni sera/
# weekend. Tolleranza fissa (03/09/2026, decisa con Mauro): 3 giorni dall'ultimo run, non legata
# al cron.
BACKUP_JOB_NAME = "backup"
BACKUP_STALE_THRESHOLD = dt.timedelta(days=3)

# exit_code=3 e' la convenzione di restic per "backup salvato, ma almeno un file sorgente non
# era leggibile" (es. un .xlsx con lock Excel aperto da un collega) — non un fallimento reale.
# Specifico di restic/backup, per questo vive qui e non in job_runner.py (che resta agnostico
# al contenuto del job, vedi la sua stessa docstring). Deciso con Mauro 03/09/2026, dato che
# capita di continuo con 5 quote di rete condivise durante l'orario di lavoro.
BACKUP_OK_EXIT_CODES = {"0", "3"}

# Per tutti gli altri job ("schedulazioni standard", cadenza giornaliera/settimanale): margine di
# tolleranza dopo l'orario atteso — deciso con Mauro (03/09) "un tempo di 6 ore dovrebbe essere
# sufficiente per partire". Calcolato sulla prossima occorrenza cron passata (croniter), non su
# un'età fissa dall'ultimo run — così un job lun-ven non segnala falso durante il weekend.
STANDARD_JOB_BUFFER = dt.timedelta(hours=6)

# (09/09/2026) Il margine sopra era fisso per QUALUNQUE job, anche quelli ogni 15 minuti — che
# quindi potevano restare fermi 6 ore prima di essere segnalati. Causa reale: lo scheduler
# Ufficio è morto alle 09:45, scoperto da Mauro solo alle 11:46 perché nessun controllo
# indipendente e frequente esisteva (vedi memory/MEMORY.md, incidente 09/09). Fix: il margine
# ora scala con la cadenza reale del job (3x l'intervallo tra due occorrenze attese, con un
# minimo di 45 minuti per non generare falsi allarmi su micro-ritardi), sempre limitato in alto
# da STANDARD_JOB_BUFFER — i job giornalieri/settimanali restano quindi invariati.
MIN_JOB_BUFFER = dt.timedelta(minutes=45)


def _dynamic_buffer(cron: str, now: dt.datetime) -> dt.timedelta:
    it = croniter(cron, now)
    prev_occurrence = it.get_prev(dt.datetime)
    it2 = croniter(cron, prev_occurrence)
    prev_prev_occurrence = it2.get_prev(dt.datetime)
    interval = prev_occurrence - prev_prev_occurrence
    return min(STANDARD_JOB_BUFFER, max(MIN_JOB_BUFFER, interval * 3))


def _tail(path: Path, max_lines: int = 10) -> list[str]:
    try:
        with path.open("r", encoding="utf-8", errors="ignore") as handle:
            return list(deque(handle, max_lines))
    except OSError:
        return []


def _parse_job_log_timestamp(path: Path) -> dt.datetime | None:
    """Estrae il timestamp di run dal nome del file (<job>_YYYYMMDD_HHMMSS.log)."""
    match = JOB_FILENAME_RE.match(path.name)
    if not match:
        return None
    try:
        return dt.datetime.strptime(match.group("date") + match.group("time"), "%Y%m%d%H%M%S")
    except ValueError:
        return None


def _latest_job_esito(latest: Path) -> tuple[str, str, str] | None:
    """Riga di esito più recente in coda al log (scritta da job_runner.py a fine job)."""
    for line in reversed(_tail(latest, max_lines=10)):
        match = JOB_ESITO_RE.search(line)
        if match:
            return match.groups()
    return None


def _check_one_job(
    job_name: str, cron: str, now: dt.datetime, timeout_seconds: int | None
) -> tuple[list[str], str | None]:
    """Verifica un singolo job: ultimo log abbastanza recente e concluso bene."""
    lines = [f"### {job_name}", f"Schedule: `{cron}`"]

    candidates = sorted(
        LOGS_DIR.glob(f"{job_name}_*.log"),
        key=lambda p: _parse_job_log_timestamp(p) or dt.datetime.min,
    )
    if not candidates:
        lines.append("⚠️  Nessun log trovato per questo job.")
        return lines, f"{job_name}: nessun log trovato"

    latest = candidates[-1]
    timestamp = _parse_job_log_timestamp(latest) or dt.datetime.fromtimestamp(latest.stat().st_mtime)
    age = now - timestamp
    age_str = f"{age.days}g {age.seconds // 3600}h"

    if job_name == BACKUP_JOB_NAME:
        stale = age > BACKUP_STALE_THRESHOLD
        stale_detail = f"oltre la tolleranza di {BACKUP_STALE_THRESHOLD.days} giorni"
    else:
        last_scheduled = croniter(cron, now).get_prev(dt.datetime)
        buffer = _dynamic_buffer(cron, now)
        stale = timestamp < last_scheduled and (now - last_scheduled) > buffer
        buffer_str = (
            f"{int(buffer.total_seconds() // 3600)}h"
            if buffer >= dt.timedelta(hours=1)
            else f"{int(buffer.total_seconds() // 60)}min"
        )
        stale_detail = (
            f"atteso per le {last_scheduled.isoformat(timespec='minutes')}, "
            f"oltre il margine di {buffer_str}"
        )

    if stale:
        lines.append(f"⚠️  Ultimo log ({latest.name}) risale a {age_str} fa — {stale_detail}.")
        return lines, f"{job_name}: nessun run da {age_str}"

    esito = _latest_job_esito(latest)
    if esito is None:
        # (09/09/2026) Un job lungo (es. omdb_batch_enrich, rate-limited, puo' girare ore) non ha
        # ancora scritto la riga di esito finche' non finisce — non e' un'interruzione, e' normale
        # amministrazione. Prima di segnalarlo, verifica che sia gia' oltre il proprio
        # timeout_seconds (da schedule.json) piu' un margine di sicurezza: solo allora e' plausibile
        # che sia davvero bloccato. Bug reale: prima di questo fix era invisibile (report letto una
        # sola volta al giorno), diventato rumoroso appena il check e' diventato proattivo (mailbox
        # ogni 30 min) — scoperto lo stesso giorno su un run reale di omdb_batch_enrich.
        if timeout_seconds is not None and age.total_seconds() < timeout_seconds:
            lines.append(f"⏳ In corso: {latest.name}, avviato {age_str} fa (timeout {timeout_seconds // 60}min).")
            return lines, None
        lines.append(
            f"⚠️  Ultimo log ({latest.name}) senza riga di esito leggibile "
            f"da {age_str} — oltre il timeout configurato, job_runner potrebbe essere stato interrotto."
        )
        return lines, f"{job_name}: log {latest.name} senza esito leggibile da {age_str}"

    status, exit_code, duration = esito
    ok_codes = BACKUP_OK_EXIT_CODES if job_name == BACKUP_JOB_NAME else {"0"}
    if exit_code not in ok_codes:
        lines.append(f"⚠️  Ultimo run ({latest.name}): status={status} exit_code={exit_code}.")
        return lines, f"{job_name}: ultimo run fallito (status={status} exit_code={exit_code})"

    note = " (file sorgente bloccato, innocuo)" if exit_code == "3" else ""
    lines.append(
        f"✅ Ultimo run OK: {latest.name}, {age_str} fa, "
        f"exit_code={exit_code}{note}, durata {float(duration) / 60:.1f}min."
    )
    return lines, None


def build_report(now: dt.datetime) -> tuple[str, bool]:
    """Verifica, per ogni job in schedule.json, che sia girato di recente e con successo."""
    lines = [
        f"# Salute job gate-ufficio – {now.isoformat(timespec='seconds')}",
        "",
        f"Percorso log: {LOGS_DIR}",
        f"Schedule: {SCHEDULE_PATH}",
        "",
    ]

    if not LOGS_DIR.exists() or not SCHEDULE_PATH.exists():
        lines.append("⚠️  Cartella log o schedule.json assente.")
        text = "\n".join(lines).strip() + "\n"
        return text, True

    schedule = json.loads(SCHEDULE_PATH.read_text(encoding="utf-8"))
    issues: list[str] = []
    for job_name, job_def in sorted(schedule.items()):
        # Schema esteso dal 03/09/2026 (scheduler locale su Ufficio, sostituisce il tunnel):
        # {job_name: {cron, command, timeout_seconds}} invece di {job_name: cron}.
        cron = job_def["cron"] if isinstance(job_def, dict) else job_def
        timeout_seconds = job_def.get("timeout_seconds") if isinstance(job_def, dict) else None
        job_lines, issue = _check_one_job(job_name, cron, now, timeout_seconds)
        lines.extend(job_lines)
        if issue:
            issues.append(issue)

    header = (
        "⚠️  Problemi individuati: " + ", ".join(issues)
        if issues
        else "✅ Tutti i job risultano OK."
    )
    lines.insert(2, header)
    text = "\n".join(lines).strip() + "\n"
    return text, bool(issues)


def _load_notified_issues() -> set[str]:
    try:
        return set(json.loads(NOTIFIED_ISSUES_PATH.read_text(encoding="utf-8")))
    except (OSError, json.JSONDecodeError):
        return set()


def _save_notified_issues(issues: set[str]) -> None:
    NOTIFIED_ISSUES_PATH.write_text(json.dumps(sorted(issues)), encoding="utf-8")


def _notify_new_issues(all_issues: list[str]) -> None:
    """Scrive in mailbox solo i problemi non già segnalati nel giro precedente — evita di
    ripetere lo stesso avviso ad ogni tick (09/09/2026: prima di questo fix, nessuno avvisava
    proattivamente, si scopriva solo leggendo il report a inizio sessione)."""
    current = set(all_issues)
    already_notified = _load_notified_issues()
    new_issues = current - already_notified
    if new_issues:
        text = "nuovi problemi rilevati: " + "; ".join(sorted(new_issues))
        subprocess.run(
            ["bash", str(MAILBOX_WRITE), "check_job_health", text],
            cwd=str(ROOT),
            check=False,
        )
    # Problemi risolti vengono dimenticati (si potrebbero ri-notificare se ricompaiono più tardi
    # con lo stesso testo — accettabile, meglio un doppio avviso che uno mancato).
    _save_notified_issues(current)


def main() -> None:
    now = dt.datetime.now()
    report_text, has_issues = build_report(now)

    REPORT_PATH.parent.mkdir(parents=True, exist_ok=True)
    REPORT_PATH.write_text(report_text, encoding="utf-8")

    issues_line = next((l for l in report_text.splitlines() if l.startswith("⚠️  Problemi")), "")
    all_issues = [i.strip() for i in issues_line.replace("⚠️  Problemi individuati: ", "").split(",") if i.strip()]
    _notify_new_issues(all_issues)

    print(report_text)
    if has_issues:
        print(f"⚠️  Anomalie rilevate. Vedi {REPORT_PATH}")
    else:
        print(f"Report salvato in {REPORT_PATH}")


if __name__ == "__main__":
    main()