#!/usr/bin/env python3
import sys, time, subprocess
import psutil
from collections import deque
from PyQt6.QtCore import Qt, QTimer, QThread, pyqtSignal, QPointF, QRectF, QPropertyAnimation, QEasingCurve, pyqtProperty
from PyQt6.QtGui import QFont, QPainter, QColor, QPen, QBrush, QPainterPath, QAction, QIcon
from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
                             QLabel, QProgressBar, QSystemTrayIcon, QMenu, QGridLayout, 
                             QStackedWidget, QPushButton, QFrame, QScrollArea, QSlider)

# ==========================================
# THREAD DE DONNÉES (CPU, RAM, GPU, RESEAU)
# ==========================================
class UltimateMonitorThread(QThread):
    stats_updated = pyqtSignal(dict)

    def __init__(self):
        super().__init__()
        self.interval = 1000
        self.net_io = psutil.net_io_counters()
        self.last_time = time.time()

    def run(self):
        while True:
            current_time = time.time()
            dt = current_time - self.last_time
            new_net_io = psutil.net_io_counters()
            
            stats = {
                'cpu_temp': self.get_cpu_temp(),
                'cpu_percent': psutil.cpu_percent(interval=None),
                'cores': self.get_cores_temp(),
                'ram': psutil.virtual_memory().percent,
                'swap': psutil.swap_memory().percent,
                'disk': psutil.disk_usage('/').percent,
                'net_dl': (new_net_io.bytes_recv - self.net_io.bytes_recv) / dt / 1024 / 1024, # MB/s
                'net_ul': (new_net_io.bytes_sent - self.net_io.bytes_sent) / dt / 1024 / 1024, # MB/s
                'gpu': self.get_gpu_info()
            }
            
            self.net_io = new_net_io
            self.last_time = current_time
            self.stats_updated.emit(stats)
            self.msleep(self.interval)

    def get_cpu_temp(self):
        temps = psutil.sensors_temperatures()
        for name in ['coretemp', 'acpitz', 'cpu_thermal', 'k10temp']:
            if name in temps: return int(temps[name][0].current)
        return 40

    def get_cores_temp(self):
        cores = []
        temps = psutil.sensors_temperatures()
        if 'coretemp' in temps:
            cores = [(e.label, int(e.current)) for e in temps['coretemp'] if 'Core' in e.label]
        return cores if cores else [(f"Core {i}", 40) for i in range(psutil.cpu_count(logical=False) or 4)]

    def get_gpu_info(self):
        # Tente de récupérer les infos NVIDIA en priorité
        try:
            res = subprocess.check_output(['nvidia-smi', '--query-gpu=temperature.gpu,utilization.gpu', '--format=csv,noheader,nounits'], encoding='utf-8')
            temp, util = map(int, res.strip().split(', '))
            return {"name": "NVIDIA GPU", "temp": temp, "util": util}
        except:
            # Fallback sur les capteurs standards (AMD/Intel)
            temps = psutil.sensors_temperatures()
            if 'amdgpu' in temps:
                return {"name": "AMD GPU", "temp": int(temps['amdgpu'][0].current), "util": 0}
            return None

# ==========================================
# WIDGETS ANIMÉS ZORIN OS PRO
# ==========================================
class SmoothProgressBar(QProgressBar):
    def __init__(self, color="#1E88E5"):
        super().__init__()
        self.setFixedHeight(6)
        self.setTextVisible(False)
        self._color = color
        self._value = 0
        self.anim = QPropertyAnimation(self, b"animated_value")
        self.anim.setEasingCurve(QEasingCurve.Type.OutCubic)
        self.anim.setDuration(400)
        self.update_style()

    def update_style(self):
        self.setStyleSheet(f"""
            QProgressBar {{ background-color: #222222; border-radius: 3px; }}
            QProgressBar::chunk {{ background-color: {self._color}; border-radius: 3px; }}
        """)

    def set_color(self, color):
        self._color = color
        self.update_style()

    @pyqtProperty(int)
    def animated_value(self): return self._value

    @animated_value.setter
    def animated_value(self, val):
        self._value = val
        super().setValue(val)

    def set_smooth_value(self, val):
        self.anim.setStartValue(self._value)
        self.anim.setEndValue(val)
        self.anim.start()

class ModernGauge(QWidget):
    def __init__(self, title, color="#1E88E5"):
        super().__init__()
        self.setFixedSize(180, 180)
        self.value = 0
        self.title = title
        self.color = QColor(color)

    def set_value(self, val):
        self.value = val
        self.update()

    def set_color(self, hex_color):
        self.color = QColor(hex_color)
        self.update()

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
        rect = QRectF(20, 20, 140, 140)

        painter.setPen(QPen(QColor("#2A2A2A"), 12, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap))
        painter.drawArc(rect, 135 * 16, -270 * 16)

        span = int(-270 * (self.value / 100.0) * 16)
        painter.setPen(QPen(self.color, 12, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap))
        painter.drawArc(rect, 135 * 16, span)

        painter.setPen(QColor("#FFFFFF"))
        painter.setFont(QFont("Inter", 32, QFont.Weight.Thin))
        painter.drawText(rect, Qt.AlignmentFlag.AlignCenter, f"{self.value}°")
        
        painter.setFont(QFont("Inter", 9, QFont.Weight.Bold))
        painter.setPen(QColor("#888888"))
        painter.drawText(QRectF(20, 140, 140, 30), Qt.AlignmentFlag.AlignCenter, self.title)

# ==========================================
# INTERFACE PRINCIPALE
# ==========================================
class UltimateApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.accent_color = "#1E88E5" # Bleu Zorin par défaut
        self.init_ui()
        self.init_tray()
        
        self.thread = UltimateMonitorThread()
        self.thread.stats_updated.connect(self.update_data)
        self.thread.start()

    def init_ui(self):
        self.setWindowTitle("7Cooler Ultimate")
        self.resize(850, 550)
        self.setStyleSheet("QMainWindow { background-color: #0E0E0E; color: #FFFFFF; }")

        main_widget = QWidget()
        self.setCentralWidget(main_widget)
        main_layout = QHBoxLayout(main_widget)
        main_layout.setContentsMargins(0, 0, 0, 0)
        main_layout.setSpacing(0)

        # --- MENU LATÉRAL ---
        sidebar = QFrame()
        sidebar.setFixedWidth(200)
        sidebar.setStyleSheet("background-color: #151515; border-right: 1px solid #222;")
        side_layout = QVBoxLayout(sidebar)
        side_layout.setContentsMargins(10, 30, 10, 30)

        brand = QLabel("7COOLER")
        brand.setFont(QFont("Inter", 16, QFont.Weight.Black))
        brand.setAlignment(Qt.AlignmentFlag.AlignCenter)
        brand.setStyleSheet("letter-spacing: 2px; margin-bottom: 30px;")
        side_layout.addWidget(brand)

        self.btn_dash = self.create_nav_btn("📊 Tableau de bord", 0)
        self.btn_hard = self.create_nav_btn("🌡️ Matériel & Capteurs", 1)
        self.btn_set = self.create_nav_btn("⚙️ Paramètres", 2)
        
        side_layout.addWidget(self.btn_dash)
        side_layout.addWidget(self.btn_hard)
        side_layout.addWidget(self.btn_set)
        side_layout.addStretch()

        # --- CONTENU CENTRAL (PAGES) ---
        self.stack = QStackedWidget()
        self.stack.setStyleSheet("background-color: #0E0E0E;")
        
        self.page_dash = self.build_dashboard()
        self.page_hard = self.build_hardware()
        self.page_set = self.build_settings()
        
        self.stack.addWidget(self.page_dash)
        self.stack.addWidget(self.page_hard)
        self.stack.addWidget(self.page_set)

        main_layout.addWidget(sidebar)
        main_layout.addWidget(self.stack)

        self.switch_page(0)

    def create_nav_btn(self, text, index):
        btn = QPushButton(text)
        btn.setFont(QFont("Inter", 10, QFont.Weight.Bold))
        btn.setCursor(Qt.CursorShape.PointingHandCursor)
        btn.setStyleSheet("""
            QPushButton { text-align: left; padding: 12px; border-radius: 8px; background: transparent; color: #888; border: none; }
            QPushButton:hover { background: #222; color: #FFF; }
        """)
        btn.clicked.connect(lambda: self.switch_page(index))
        return btn

    def switch_page(self, index):
        self.stack.setCurrentIndex(index)
        for i, btn in enumerate([self.btn_dash, self.btn_hard, self.btn_set]):
            if i == index:
                btn.setStyleSheet(f"text-align: left; padding: 12px; border-radius: 8px; background: {self.accent_color}; color: #FFF; font-weight: bold; border: none;")
            else:
                btn.setStyleSheet("text-align: left; padding: 12px; border-radius: 8px; background: transparent; color: #888; border: none;")

    # --- PAGE 1: DASHBOARD ---
    def build_dashboard(self):
        page = QWidget()
        layout = QVBoxLayout(page)
        layout.setContentsMargins(40, 40, 40, 40)
        
        title = QLabel("Vue d'ensemble")
        title.setFont(QFont("Inter", 22, QFont.Weight.Bold))
        layout.addWidget(title)

        # Jauges Hautes
        gauge_layout = QHBoxLayout()
        self.cpu_gauge = ModernGauge("CPU TEMP")
        self.gpu_gauge = ModernGauge("GPU TEMP")
        gauge_layout.addWidget(self.cpu_gauge)
        gauge_layout.addWidget(self.gpu_gauge)
        gauge_layout.addStretch()
        layout.addLayout(gauge_layout)

        layout.addSpacing(30)

        # Barres d'utilisation
        self.bars = {}
        for name, label in [('cpu', 'Charge CPU'), ('ram', 'Mémoire Vive'), ('swap', 'Fichier d\'échange'), ('disk', 'Stockage Principal')]:
            lbl = QLabel(f"{label}: 0%")
            lbl.setFont(QFont("Inter", 10))
            bar = SmoothProgressBar()
            self.bars[name] = {'lbl': lbl, 'bar': bar}
            layout.addWidget(lbl)
            layout.addWidget(bar)
            layout.addSpacing(10)
            
        layout.addStretch()
        return page

    # --- PAGE 2: HARDWARE ---
    def build_hardware(self):
        page = QWidget()
        layout = QVBoxLayout(page)
        layout.setContentsMargins(40, 40, 40, 40)
        
        title = QLabel("Capteurs Détaillés")
        title.setFont(QFont("Inter", 22, QFont.Weight.Bold))
        layout.addWidget(title)

        scroll = QScrollArea()
        scroll.setWidgetResizable(True)
        scroll.setStyleSheet("QScrollArea { border: none; background: transparent; }")
        
        content = QWidget()
        self.grid = QGridLayout(content)
        scroll.setWidget(content)
        layout.addWidget(scroll)
        
        # Réseau UI
        self.net_lbl = QLabel("Réseau: DL 0 MB/s | UL 0 MB/s")
        self.net_lbl.setFont(QFont("Inter", 12, QFont.Weight.Bold))
        self.net_lbl.setStyleSheet("color: #888;")
        layout.addWidget(self.net_lbl)
        
        return page

    # --- PAGE 3: SETTINGS ---
    def build_settings(self):
        page = QWidget()
        layout = QVBoxLayout(page)
        layout.setContentsMargins(40, 40, 40, 40)
        
        title = QLabel("Paramètres de l'Application")
        title.setFont(QFont("Inter", 22, QFont.Weight.Bold))
        layout.addWidget(title)

        # Thèmes
        theme_lbl = QLabel("Couleur d'accentuation")
        theme_lbl.setFont(QFont("Inter", 12, QFont.Weight.Bold))
        layout.addWidget(theme_lbl)

        colors_layout = QHBoxLayout()
        for c in ["#1E88E5", "#E53935", "#43A047", "#8E24AA", "#FDD835", "#FFFFFF"]:
            btn = QPushButton()
            btn.setFixedSize(40, 40)
            btn.setStyleSheet(f"background-color: {c}; border-radius: 20px; border: 2px solid #333;")
            btn.setCursor(Qt.CursorShape.PointingHandCursor)
            btn.clicked.connect(lambda checked, col=c: self.change_accent(col))
            colors_layout.addWidget(btn)
        colors_layout.addStretch()
        layout.addLayout(colors_layout)
        
        layout.addSpacing(30)

        # Intervalle
        speed_lbl = QLabel("Vitesse de rafraîchissement (ms)")
        speed_lbl.setFont(QFont("Inter", 12, QFont.Weight.Bold))
        layout.addWidget(speed_lbl)
        
        self.slider = QSlider(Qt.Orientation.Horizontal)
        self.slider.setRange(500, 3000)
        self.slider.setValue(1000)
        self.slider.setTickPosition(QSlider.TickPosition.TicksBelow)
        self.slider.setTickInterval(500)
        self.slider.valueChanged.connect(self.change_speed)
        layout.addWidget(self.slider)

        layout.addStretch()
        return page

    def change_accent(self, color):
        self.accent_color = color
        self.cpu_gauge.set_color(color)
        self.gpu_gauge.set_color(color)
        for b in self.bars.values(): b['bar'].set_color(color)
        self.switch_page(self.stack.currentIndex()) # Refresh menu color

    def change_speed(self, val):
        self.thread.interval = val

    def update_data(self, stats):
        # Update Dashboard
        self.cpu_gauge.set_value(stats['cpu_temp'])
        
        if stats['gpu']:
            self.gpu_gauge.set_value(stats['gpu']['temp'])
            self.gpu_gauge.title = stats['gpu']['name'].upper()
        else:
            self.gpu_gauge.set_value(0)
            self.gpu_gauge.title = "NO GPU"

        self.bars['cpu']['lbl'].setText(f"Charge CPU: {stats['cpu_percent']}%")
        self.bars['cpu']['bar'].set_smooth_value(int(stats['cpu_percent']))
        
        self.bars['ram']['lbl'].setText(f"Mémoire Vive: {stats['ram']}%")
        self.bars['ram']['bar'].set_smooth_value(int(stats['ram']))
        
        self.bars['swap']['lbl'].setText(f"Fichier d'échange: {stats['swap']}%")
        self.bars['swap']['bar'].set_smooth_value(int(stats['swap']))
        
        self.bars['disk']['lbl'].setText(f"Stockage Principal: {stats['disk']}%")
        self.bars['disk']['bar'].set_smooth_value(int(stats['disk']))

        # Update Network
        self.net_lbl.setText(f"Réseau: ↓ {stats['net_dl']:.2f} MB/s  |  ↑ {stats['net_ul']:.2f} MB/s")

        # Update Hardware Grid
        for i in reversed(range(self.grid.count())): 
            w = self.grid.itemAt(i).widget()
            if w: w.setParent(None)

        row, col = 0, 0
        for name, temp in stats['cores']:
            card = QFrame()
            card.setStyleSheet("background-color: #1A1A1A; border-radius: 10px; padding: 10px;")
            cl = QVBoxLayout(card)
            
            n = QLabel(name)
            n.setStyleSheet("color: #888; font-size: 11px;")
            t = QLabel(f"{temp}°C")
            t.setFont(QFont("Inter", 16, QFont.Weight.Bold))
            if temp > 85: t.setStyleSheet("color: #E53935;")
            
            cl.addWidget(n)
            cl.addWidget(t)
            self.grid.addWidget(card, row, col)
            
            col += 1
            if col > 3:
                col, row = 0, row + 1

        self.tray_icon.setToolTip(f"CPU: {stats['cpu_temp']}°C | RAM: {stats['ram']}%")

    def init_tray(self):
        self.tray_icon = QSystemTrayIcon(self)
        self.tray_icon.setIcon(QIcon.fromTheme("utilities-system-monitor"))
        menu = QMenu()
        show_action = QAction("Ouvrir 7Cooler Ultimate", self)
        show_action.triggered.connect(self.show)
        quit_action = QAction("Quitter", self)
        quit_action.triggered.connect(QApplication.instance().quit)
        menu.addAction(show_action)
        menu.addAction(quit_action)
        self.tray_icon.setContextMenu(menu)
        self.tray_icon.show()

    def closeEvent(self, event):
        event.ignore()
        self.hide()
        self.tray_icon.showMessage("7Cooler Ultimate", "Fonctionne en arrière-plan", QSystemTrayIcon.MessageIcon.Information, 2000)

if __name__ == "__main__":
    app = QApplication(sys.argv)
    QApplication.setQuitOnLastWindowClosed(False)
    app.setFont(QFont("Inter", 10))
    window = UltimateApp()
    window.show()
    sys.exit(app.exec())