import time
import psutil
from datetime import datetime
from typing import Optional, List
from .schemas import TelemetrySnapshot

try:
    import pynvml
    HAS_PYNVML = True
    try:
        pynvml.nvmlInit()
    except Exception:
        HAS_PYNVML = False
except ImportError:
    HAS_PYNVML = False

import threading

class TelemetryService:
    def __init__(self):
        self.history: List[TelemetrySnapshot] = []
        self.peak_vram: float = 0
        self.max_history: int = 600  # 10 minutes at 1Hz
        self._lock = threading.Lock()
        self._has_gpu = HAS_PYNVML and self._detect_gpu()

    def _detect_gpu(self):
        if not HAS_PYNVML:
            return False
        try:
            count = pynvml.nvmlDeviceGetCount()
            return count > 0
        except:
            return False

    def get_snapshot(self, tokens_per_sec: Optional[float] = None) -> TelemetrySnapshot:
        now = datetime.utcnow()
        # CPU / RAM
        cpu = psutil.cpu_percent(interval=None)
        vm = psutil.virtual_memory()
        ram_used = (vm.total - vm.available) / (1024*1024)
        ram_total = vm.total / (1024*1024)

        snap = TelemetrySnapshot(
            timestamp=now,
            cpu_percent=cpu,
            ram_used_mb=round(ram_used, 1),
            ram_total_mb=round(ram_total, 1),
            ram_percent=vm.percent,
            has_gpu=self._has_gpu,
            tokens_per_sec=tokens_per_sec
        )

        if self._has_gpu:
            try:
                handle = pynvml.nvmlDeviceGetHandleByIndex(0)
                mem = pynvml.nvmlDeviceGetMemoryInfo(handle)
                util = pynvml.nvmlDeviceGetUtilizationRates(handle)
                snap.vram_used_mb = round(mem.used / (1024*1024), 1)
                snap.vram_total_mb = round(mem.total / (1024*1024), 1)
                snap.vram_percent = round((mem.used / mem.total) * 100, 1) if mem.total else 0
                snap.gpu_util_percent = util.gpu
                # name
                try:
                    name = pynvml.nvmlDeviceGetName(handle)
                    snap.gpu_name = name.decode() if isinstance(name, bytes) else str(name)
                except:
                    pass
                # temp
                try:
                    snap.gpu_temp_c = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
                except:
                    pass
                # power
                try:
                    snap.gpu_power_w = round(pynvml.nvmlDeviceGetPowerUsage(handle) / 1000, 1)
                    snap.gpu_power_limit_w = round(pynvml.nvmlDeviceGetEnforcedPowerLimit(handle) / 1000, 1)
                except:
                    pass
                # peak tracking
                if snap.vram_used_mb > self.peak_vram:
                    self.peak_vram = snap.vram_used_mb
                snap.vram_peak_mb = self.peak_vram
            except Exception as e:
                snap.gpu_util_percent = 0
        else:
            # Fake VRAM for demo / CPU-only environments
            # Simulate based on history
            snap.vram_total_mb = 24576
            snap.vram_used_mb = 0
            snap.vram_peak_mb = self.peak_vram
            snap.gpu_name = "No GPU detected (CPU mode)"

        with self._lock:
            self.history.append(snap)
            if len(self.history) > self.max_history:
                self.history = self.history[-self.max_history:]
        return snap

    def get_history(self, limit: int = 300):
        with self._lock:
            return self.history[-limit:]

    def reset_peak(self):
        self.peak_vram = 0

    def simulate_load(self, active: bool):
        # For demo when no GPU, simulate VRAM bump during generation
        if not self._has_gpu and active:
            import random
            base = 3500 + random.uniform(-200, 200)
            # keep peak
            if base > self.peak_vram:
                self.peak_vram = base
            return base
        return None

telemetry_service = TelemetryService()