import psutil
from typing import List, Dict
from pydantic import BaseModel


class CPUUsage(BaseModel):
    percent: float
    average: float
    cores: int
    per_cpu: List[float]


class MemoryUsage(BaseModel):
    percent: float
    used: int  # en bytes
    total: int  # en bytes
    available: int  # en bytes


class ProcessInfo(BaseModel):
    pid: int
    name: str
    status: str
    cpu_percent: float
    memory_percent: float
    username: str


class SystemStats(BaseModel):
    cpu: CPUUsage
    memory: MemoryUsage
    processes: List[ProcessInfo]


class SystemService:
    """Service pour récupérer les informations système"""
    
    @staticmethod
    def get_cpu_usage() -> CPUUsage:
        """Récupère l'utilisation CPU (non-bloquant, utilise le cache)"""
        per_cpu = psutil.cpu_percent(interval=0, percpu=True)
        avg_cpu = sum(per_cpu) / len(per_cpu) if per_cpu else 0
        return CPUUsage(
            percent=avg_cpu,
            average=avg_cpu,
            cores=psutil.cpu_count(),
            per_cpu=per_cpu
        )
    
    @staticmethod
    def get_memory_usage() -> MemoryUsage:
        """Récupère l'utilisation mémoire"""
        mem = psutil.virtual_memory()
        return MemoryUsage(
            percent=mem.percent,
            used=mem.used,
            total=mem.total,
            available=mem.available
        )
    
    @staticmethod
    def get_top_processes(limit: int = 5) -> List[ProcessInfo]:
        """Récupère les processus les plus actifs (optimisé)"""
        processes = []
        try:
            for proc in psutil.process_iter(['pid', 'name', 'status', 'username']):
                try:
                    info = proc.info
                    cpu_percent = proc.cpu_percent(interval=0)
                    
                    # Ne garder que les processus avec une activité CPU > 0
                    if cpu_percent > 0.1:
                        mem_percent = proc.memory_percent()
                        processes.append(ProcessInfo(
                            pid=info['pid'],
                            name=info['name'],
                            status=info['status'],
                            cpu_percent=cpu_percent,
                            memory_percent=mem_percent,
                            username=info['username'] or 'N/A'
                        ))
                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
                    continue
            
            # Trier par utilisation CPU
            processes.sort(key=lambda x: x.cpu_percent, reverse=True)
            return processes[:limit]
        except Exception as e:
            return []
            return []
            print(f"Erreur lors de la récupération des processus: {e}")
            return []
    
    @staticmethod
    def get_system_stats() -> SystemStats:
        """Récupère les statistiques système complètes"""
        return SystemStats(
            cpu=SystemService.get_cpu_usage(),
            memory=SystemService.get_memory_usage(),
            processes=SystemService.get_top_processes(15)
        )