#!/usr/bin/env python3
"""Aggiorna dashboard_data.json — solo dati reali, niente stime/fuffa."""

import json, os, subprocess, platform
from datetime import datetime

HOME = os.environ.get('HERMES_HOME', os.path.expanduser('~/.hermes'))
TOKEN_COST_FILE = os.path.join(HOME, 'token_costs.json')
LAST_LPT_FILE = os.path.join(HOME, 'last_lpt.txt')
SESSIONS_FILE = os.path.join(HOME, 'sessions', 'sessions.json')
OUTPUT_FILE = os.path.join(HOME, 'dashboard_data.json')

# Prezzi reali per 1M token (USD) — solo per provider a pagamento
PRICING = {
    "claude-sonnet-4": {"input": 15.00, "output": 75.00},
}

FAK_DIR = os.path.join(HOME, 'fak-comparison')


def load_fak_data():
    """Carica dati confronto FAK"""
    data_file = os.path.join(FAK_DIR, 'comparison_data.json')
    if not os.path.exists(data_file):
        return {"status": "no_data", "note": "Nessuna tariffa caricata"}
    try:
        with open(data_file) as f:
            data = json.load(f)
        carriers = list(data.get("rates", {}).keys())
        totals = {}
        for c in carriers:
            r = data["rates"].get(c, {})
            if isinstance(r, dict):
                totals[c] = len(r)
            else:
                totals[c] = "forfettarie"
        return {
            "status": "ok",
            "carriers": carriers,
            "totals": totals,
            "last_updated": data.get("metadata", {}).get("last_updated", "N/A")
        }
    except Exception as e:
        return {"status": "error", "note": str(e)}


def get_system_health():
    try:
        load = os.getloadavg()
        cpu_pct = round((load[0] / os.cpu_count()) * 100, 1) if os.cpu_count() else 0.0
    except:
        cpu_pct = 0.0
    try:
        mem = subprocess.check_output(
            "free -m | awk '/Mem:/{print $3,$2}'", shell=True, text=True
        ).strip().split()
        ram_pct = round(int(mem[0]) / int(mem[1]) * 100, 1) if len(mem) >= 2 else 0.0
    except:
        ram_pct = 0.0
    try:
        disk = subprocess.check_output("df -h / | tail -1", shell=True, text=True).split()
        disk_pct = int(disk[4].replace('%', ''))
    except:
        disk_pct = 0
    return {"cpu": f"{cpu_pct}%", "ram": f"{ram_pct}%", "disk": f"{disk_pct}%"}


def load_token_costs():
    if os.path.exists(TOKEN_COST_FILE):
        with open(TOKEN_COST_FILE) as f:
            return json.load(f)
    return {"daily": {}}


def save_token_costs(tc):
    with open(TOKEN_COST_FILE, 'w') as f:
        json.dump(tc, f, indent=2)


def load_last_lpt():
    if os.path.exists(LAST_LPT_FILE):
        with open(LAST_LPT_FILE) as f:
            return int(f.read().strip())
    return 0


def save_last_lpt(val):
    with open(LAST_LPT_FILE, 'w') as f:
        f.write(str(val))


def get_current_session_data():
    """Legge last_prompt_tokens e estimated_cost_usd dalla sessione attuale (Emma)."""
    try:
        if os.path.exists(SESSIONS_FILE):
            with open(SESSIONS_FILE) as f:
                sd = json.load(f)
            for sk, sv in sd.items():
                if '1174780110' in sk:
                    return {
                        "lpt": sv.get('last_prompt_tokens', 0),
                        "cost": sv.get('estimated_cost_usd', 0) or 0,
                        "provider": sv.get('provider', ''),
                        "model": sv.get('model', ''),
                    }
    except:
        pass
    return {"lpt": 0, "cost": 0, "provider": "", "model": ""}


def get_cron_jobs():
    """Legge i cron job reali da hermes CLI (output testuale)."""
    import re
    env = os.environ.copy()
    env['PATH'] = f"{os.path.expanduser('~/.local/bin')}:{env.get('PATH', '')}"
    try:
        result = subprocess.check_output(
            'hermes cron list 2>/dev/null',
            shell=True, text=True, timeout=15, env=env
        )
    except:
        return []

    jobs = []
    current = None
    for line in result.splitlines():
        line_s = line.rstrip()
        # Riga tipo: "  a066d6c0271e [active]" oppure "  a066d6c0271e [paused]"
        m = re.match(r'\s{2}([a-f0-9]+)\s+\[(\w+)\]', line_s)
        if m:
            current = {"job_id": m.group(1), "enabled": m.group(2) == 'active'}
            jobs.append(current)
            continue
        if current is None:
            continue
        # Campi: Name:, Schedule:, Repeat:, Script:, Mode:, Last run: (indentati 4 spazi)
        m2 = re.match(r'\s{4}(\w[\w\s-]*?):\s+(.*)', line_s)
        if m2:
            key = m2.group(1).strip().lower().replace(' ', '_')
            val = m2.group(2).strip()
            if key == 'name':
                current['name'] = val
            elif key == 'schedule':
                current['schedule'] = val
            elif key == 'last_run':
                # "2026-06-14T13:56:30.673079+02:00  ok" oppure "never"
                parts = val.rsplit(None, 1)
                current['last_run_at'] = parts[0] if len(parts) > 1 else val
                current['last_status'] = parts[-1] if len(parts) > 1 else None
    return jobs


def load_tickets():
    """Legge tutti i ticket dalla cartella tickets/."""
    try:
        tickets_dir = os.path.join(HOME, 'tickets')
        if not os.path.isdir(tickets_dir):
            return {"lista": [], "totali": 0, "ultimo_aggiornamento": "mai"}

        files = sorted(
            [f for f in os.listdir(tickets_dir) if f.endswith('.json')], reverse=True
        )
        if not files:
            return {"lista": [], "totali": 0, "ultimo_aggiornamento": "mai"}
        
        lista = []
        last_update = "mai"
        for fname in files:
            try:
                with open(os.path.join(tickets_dir, fname)) as f:
                    t = json.load(f)
                ticket_data = t.get("ticket", t)  # supporta sia {"ticket": {...}} che flat
                entry = {
                    "id": ticket_data.get("ticket_id", ticket_data.get("id", fname.replace('.json', ''))),
                    "titolo": ticket_data.get("title", ticket_data.get("titolo", "?")),
                    "stato": ticket_data.get("status", ticket_data.get("stato", "?")),
                    "priorità": ticket_data.get("priority", ticket_data.get("priorità", "media")),
                    "assegnato_a": ticket_data.get("assigned_to", ticket_data.get("assegnato_a", "?")),
                    "completati": len(ticket_data.get("work_completed", [])),
                    "deliverables": len(ticket_data.get("deliverables", [])),
                    "json_file": fname,
                }
                # Se assegnato_a è una lista, appiattiscila a stringa
                if isinstance(entry["assegnato_a"], list):
                    entry["assegnato_a"] = ", ".join(entry["assegnato_a"])
                if not last_update or last_update == "mai":
                    lu = ticket_data.get("updated_at", ticket_data.get("data_creazione", ""))
                    if lu:
                        last_update = str(lu)[:16].replace('T', ' ')
                lista.append(entry)
            except Exception as e:
                lista.append({"id": fname, "titolo": f"Errore lettura: {e}", "stato": "?", "priorità": "media"})
        
        return {
            "lista": lista,
            "totali": len(files),
            "ultimo_aggiornamento": last_update,
        }
    except Exception:
        pass
    return {"lista": [], "totali": 0, "ultimo_aggiornamento": "mai"}


def get_skills_info():
    """Conta le skill reali installate leggendo le cartelle."""
    skills_dir = os.path.join(HOME, 'skills')
    if not os.path.isdir(skills_dir):
        return {"emma": 0, "total": 0, "shared": 0}
    try:
        entries = [d for d in os.listdir(skills_dir)
                   if os.path.isdir(os.path.join(skills_dir, d)) and not d.startswith('.')]
        emma_count = sum(1 for d in entries if 'emma' in d.lower() or 'dashboard' in d.lower())
        return {"emma": emma_count, "total": len(entries), "shared": len(entries) - emma_count}
    except:
        return {"emma": 0, "total": 0, "shared": 0}


# ============================================================
# MAIN
# ============================================================

now = datetime.now()
today_key = now.strftime('%Y-%m-%d')

# Dati sessione Emma
sd = get_current_session_data()
current_lpt = sd["lpt"]
session_cost = sd["cost"]
session_provider = sd["provider"]
session_model = sd["model"]

# Leggi contatori persistenti
last_lpt = load_last_lpt()
delta_tokens = max(0, current_lpt - last_lpt)

token_costs = load_token_costs()
if today_key not in token_costs['daily']:
    token_costs['daily'][today_key] = {
        "input_tokens": 0, "output_tokens": 0,
        "cost": 0.0, "calls": 0,
        "provider": "nessuno", "model": "nessuno",
        "note": ""
    }

tc_today = token_costs['daily'][today_key]

# Tracking costi — solo dati reali
if delta_tokens > 0:
    if session_cost > 0 and 'sonnet' in session_model.lower():
        # Sonnet via OpenRouter — costo reale
        tc_today['cost'] += session_cost
        tc_today['provider'] = 'OpenRouter'
        tc_today['model'] = 'claude-sonnet-4'
        tc_today['note'] = 'costo reale da sessione'
        print(f"[COST] Sonnet: +${session_cost:.4f}")
    elif session_cost > 0:
        # Altro provider a pagamento
        tc_today['cost'] += session_cost
        tc_today['provider'] = session_provider or 'OpenRouter'
        tc_today['model'] = session_model or '?'
        tc_today['note'] = 'costo reale da sessione'
        print(f"[COST] {session_provider}: +${session_cost:.4f}")
    else:
        # DeepSeek diretto = gratuito, solo conteggio chiamate
        tc_today['provider'] = 'DeepSeek'
        tc_today['model'] = 'deepseek-chat (V4 Flash)'
        tc_today['note'] = 'gratuito (api.deepseek.com)'
        print(f"[COST] DeepSeek: {delta_tokens} token, gratuito")

    tc_today['input_tokens'] += int(delta_tokens * 0.7)
    tc_today['output_tokens'] += delta_tokens - int(delta_tokens * 0.7)
    tc_today['calls'] += 1
    save_last_lpt(current_lpt)
else:
    print(f"[COST] Nessun nuovo token (lpt={current_lpt}, last={last_lpt})")
    # Mantieni provider esistente se già presente
    if 'provider' not in tc_today:
        tc_today['provider'] = 'DeepSeek'
        tc_today['model'] = 'deepseek-chat (V4 Flash)'
        tc_today['note'] = 'nessuna attività recente'

save_token_costs(token_costs)

# Calcola settimana e mese
week_cost = 0.0
week_days = 0
month_cost = 0.0
for date_key, day_data in token_costs['daily'].items():
    dc = day_data.get('cost', 0)
    if date_key.startswith(now.strftime('%Y-%m')):
        month_cost += dc
        try:
            d = datetime.strptime(date_key, '%Y-%m-%d')
            if (now - d).days <= 7:
                week_cost += dc
                week_days += 1
        except:
            pass

# Skills
skills_info = get_skills_info()

# Cron jobs
cron_jobs = get_cron_jobs()

# Tools — numero reale di strumenti a disposizione di Emma
# (non ho una fonte affidabile quindi lo ometto, mostro solo in HTML come "disponibili")
tools_count = len(cron_jobs)  # placeholder, l'HTML non lo mostrerà piu

# Build output
data = {
    "timestamp": now.strftime('%d/%m/%Y %H:%M'),
    "salute": get_system_health(),
    "server": {
        "hostname": platform.node(),
        "uptime": subprocess.check_output(
            "uptime -p 2>/dev/null || echo '?'", shell=True, text=True
        ).strip(),
        "ip": "192.168.1.102",
        "port": 8080,
    },
    "provider": {
        "attuale": "DeepSeek Platform (api.deepseek.com)",
        "modello": "deepseek-chat (V4 Flash)",
        "fallback": "OpenRouter",
    },
    "costi": {
        "today": {
            "cost": round(tc_today['cost'], 4),
            "calls": tc_today['calls'],
            "provider": tc_today['provider'],
            "model": tc_today['model'],
            "note": tc_today['note'],
            "input_tokens": tc_today['input_tokens'],
            "output_tokens": tc_today['output_tokens'],
        },
        "week": {"cost": round(week_cost, 4), "days": week_days},
        "month": round(month_cost, 4),
    },
    "tickets": load_tickets(),
    "fak_comparison": load_fak_data(),
    "cron_jobs": cron_jobs,
    "skills": skills_info,
}

with open(OUTPUT_FILE, 'w') as f:
    json.dump(data, f, indent=2)

print(f"[OK] Dashboard aggiornata: {OUTPUT_FILE}")
print(f"[OK] Oggi: ${tc_today['cost']:.4f} ({tc_today['note']}) - {tc_today['calls']} chiamate")
print(f"[OK] Skills: {skills_info['total']} totali ({skills_info['emma']} Emma)")
print(f"[OK] Cron: {len(cron_jobs)} jobs")