#!/usr/bin/env python3
"""
Sincronizzatore automatico di contatori tasks_ok/tasks_fail da ACTION_LOG
Legge i file ACTION_LOG e aggiorna agent_state in dati.json
"""

import os
import re
import json
from datetime import datetime
from pathlib import Path

LOG_DIR = "/home/hermes/POWER-IT-kb/00_MASTER/ACTION_LOG/"
DATA_FILE = "/home/hermes/skynet-data/dati.json"

# Lista di tutti gli agenti POWER-IT conosciuti
KNOWN_AGENTS = {
    'ARIA', 'OTTO', 'SOFIA', 'THEMIS', 'SCOUT', 'NEXUS', 'DEUS', 'MARCO', 
    'DELTA', 'PITCH', 'CHRONO', 'VOX', 'HUNTER', 'GRANT', 'CASSAZIONE', 
    'PRETORE', 'GUARDIANO', 'NOSTRADAMUS', 'CERBERUS', 'MAGELLANO', 
    'BANDERUOLA', 'ORACLE', 'DEAL', 'TITAN', 'KPI_ANALYST', 'VISIO', 
    'SYNAPSE', 'PEOPLE', 'SPIELBERG', 'CURATOR', 'LIQUIDITY', 'SCOMMETTITORE',
    'SKYNET'  # Aggiungo SKYNET
}

def extract_date_from_filename(fname):
    """Estrai data dal nome file (formato: 2026-07-08_...)"""
    match = re.match(r'(\d{4}-\d{2}-\d{2})', fname)
    return match.group(1) if match else None

def find_agents_in_content(content):
    """Trova tutti gli agenti menzionati nel contenuto"""
    agents = set()
    # Cerca pattern come "Agente: NOME", "owner: NOME", "dichiarato_da: NOME", etc
    for agent in KNOWN_AGENTS:
        if re.search(rf'\b{agent}\b', content):
            agents.add(agent)
    return agents

def determine_task_outcome(content):
    """Determina se il task è completato o fallito"""
    # Patterns di successo
    success_patterns = [
        r'COMPLETED', r'completed', r'✅', 
        r'dichiarato_completato:\s*sì',
        r'verificato:\s*sì',
        r'success', r'eseguita', r'completat',
        r'STATUS.*COMPLETED', r'status.*completed'
    ]
    
    # Patterns di fallimento
    fail_patterns = [
        r'FAILED', r'failed', r'❌',
        r'dichiarato_completato:\s*no',
        r'ERROR', r'error', r'fail', r'fallito',
        r'STATUS.*FAILED'
    ]
    
    has_success = any(re.search(p, content, re.IGNORECASE) for p in success_patterns)
    has_fail = any(re.search(p, content, re.IGNORECASE) for p in fail_patterns)
    
    return has_success, has_fail

def sync_counters():
    """Sincronizza i contatori da ACTION_LOG a dati.json"""
    
    # Carica dati.json
    if not os.path.exists(DATA_FILE):
        print(f"⚠️  {DATA_FILE} non trovato!")
        return
    
    with open(DATA_FILE, 'r') as f:
        data = json.load(f)
    
    # Inizializza o recupera agent_state
    if 'skynet' not in data:
        data['skynet'] = {}
    if 'agent_state' not in data['skynet']:
        data['skynet']['agent_state'] = {}
    
    agent_state = data['skynet']['agent_state']
    
    # Assicura che ogni agente noto abbia una struttura base
    for agent_name in KNOWN_AGENTS:
        if agent_name not in agent_state:
            agent_state[agent_name] = {
                'status': 'idle',
                'last_action': '',
                'last_seen': '',
                'tasks_ok': 0,
                'tasks_fail': 0,
                'xp': 0
            }
    
    # Analizza ogni ACTION_LOG
    if not os.path.isdir(LOG_DIR):
        print(f"⚠️  {LOG_DIR} non trovata!")
        return
    
    log_files = [f for f in os.listdir(LOG_DIR) if f.endswith('.md')]
    log_files.sort()  # Ordina per nome (cronologico dato il formato data)
    
    updated_agents = set()
    
    for fname in log_files:
        path = os.path.join(LOG_DIR, fname)
        try:
            with open(path, 'r', encoding='utf-8') as f:
                content = f.read()
        except Exception as e:
            print(f"⚠️  Errore lettura {fname}: {e}")
            continue
        
        # Estrai data
        date_str = extract_date_from_filename(fname)
        if not date_str:
            continue
        
        # Trova agenti menzionati
        agents_found = find_agents_in_content(content)
        if not agents_found:
            continue
        
        # Determina esito
        has_success, has_fail = determine_task_outcome(content)
        
        # Aggiorna contatori per ogni agente
        for agent in agents_found:
            if agent not in agent_state:
                agent_state[agent] = {
                    'status': 'idle',
                    'last_action': '',
                    'last_seen': '',
                    'tasks_ok': 0,
                    'tasks_fail': 0,
                    'xp': 0
                }
            
            # Aggiorna last_seen se più recente
            current_last = agent_state[agent].get('last_seen', '')
            if not current_last or date_str > current_last[:10]:
                agent_state[agent]['last_seen'] = date_str
            
            # Incrementa contatori (ogni file = 1 task)
            # Se è fallito ma non ha successo → task_fail
            # Se ha successo → task_ok
            # Se ha entrambi → conta come successo
            if has_success:
                agent_state[agent]['tasks_ok'] = agent_state[agent].get('tasks_ok', 0) + 1
                updated_agents.add(agent)
            elif has_fail:
                agent_state[agent]['tasks_fail'] = agent_state[agent].get('tasks_fail', 0) + 1
                updated_agents.add(agent)
    
    # Salva dati.json aggiornato
    data['skynet']['agent_state'] = agent_state
    data['aggiornato_contatori'] = datetime.now().isoformat()
    
    try:
        with open(DATA_FILE, 'w', encoding='utf-8') as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
        print(f"✅ Sincronizzazione completata: {len(updated_agents)} agenti aggiornati")
    except Exception as e:
        print(f"❌ Errore salvataggio {DATA_FILE}: {e}")
        return
    
    # Stampa report
    print(f"\n📊 REPORT AGENTI (aggiornati con tasks > 0):")
    print("-" * 70)
    
    # Top 10 per tasks_ok
    sorted_by_ok = sorted(
        agent_state.items(),
        key=lambda x: x[1].get('tasks_ok', 0),
        reverse=True
    )[:10]
    
    print("\n🏆 Top 10 agenti per TASKS_OK:")
    for i, (name, state) in enumerate(sorted_by_ok, 1):
        tasks_ok = state.get('tasks_ok', 0)
        tasks_fail = state.get('tasks_fail', 0)
        last_seen = state.get('last_seen', '?')
        if tasks_ok > 0 or tasks_fail > 0:
            print(f"  {i:2}. {name:15} | OK: {tasks_ok:3} | FAIL: {tasks_fail:3} | Last: {last_seen}")
    
    print("\n" + "=" * 70)
    
    # Totale task
    total_ok = sum(s.get('tasks_ok', 0) for s in agent_state.values())
    total_fail = sum(s.get('tasks_fail', 0) for s in agent_state.values())
    print(f"\n📈 TOTALE SISTEMA:")
    print(f"  Tasks OK:   {total_ok}")
    print(f"  Tasks FAIL: {total_fail}")
    print(f"  TOTAL:      {total_ok + total_fail}")
    print(f"\n💾 Salvataggio in: {DATA_FILE}")
    print(f"⏱️  Timestamp: {data['aggiornato_contatori']}")

if __name__ == '__main__':
    sync_counters()