OptiCodeUpdater

import customtkinter as ctk
import tkinter as tk
import os
import tempfile
import shutil
import psutil
import threading
from datetime import datetime, timedelta
import winreg
import subprocess
import platform
import wmi
import time
import requests
import hashlib
import pyperclip
from threading import Lock
import sys
from packaging import version
import json
import ctypes
# Define default version
CURRENT_VERSION = "1.0.0"
# Replace with your Discord webhook URLs
WEBHOOK_OPEN_CLOSE = "https://discord.com/api/webhooks/1421983462365200475/BBr091Pk7UCqW73umHALJm9DN_-H7_ozve11O_54nD9DN_-H7_ozve11O_54nD9LmrPFSTt0zHU2mPvNUZoPPKvt" # Webhook 1: Open/Close and HWID
WEBHOOK_LOGIN = "https://discord.com/api/webhooks/1421983687456854046/ZwKnamVOMU51Pp4Cc_NVmjyfTpxUSZbhz2tqI8hEPJEcWhwT-OWV5UcUypCWhWfghmxz" # Webhook 2: Login attempts with username/password/HWID
WEBHOOK_FEATURE = "https://discord.com/api/webhooks/1421983788854149192/hC8GmMTVot0yY7wFnGn5HlLKYyO8xX5AzwmIl5TDGSLkzmFrmZYbepkuRUldn1kxzmOA" # Webhook 3: Feature usage with HWID
class Tooltip:
    def __init__(self, widget, text):
        self.widget = widget
        self.text = text
        self.tooltip = None
        self.show_after_id = None
        self.last_enter_time = 0
        self.widget.bind("<Enter>", self.schedule_show_tooltip)
        self.widget.bind("<Leave>", self.hide_tooltip)
    def schedule_show_tooltip(self, event=None):
        # Debounce: Ignore rapid hover events (within 200ms)
        current_time = time.time()
        if current_time - self.last_enter_time < 0.2:
            return
        self.last_enter_time = current_time
        # Cancel any pending show
        if self.show_after_id:
            self.widget.after_cancel(self.show_after_id)
        # Schedule tooltip show after 500ms delay
        self.show_after_id = self.widget.after(500, self.show_tooltip)
    def show_tooltip(self, event=None):
        if self.tooltip and self.tooltip.winfo_exists():
            # Update existing tooltip
            self.tooltip.wm_geometry(f"+{self.widget.winfo_pointerx()+10}+{self.widget.winfo_pointery()+10}")
            return
        # Create tooltip if it doesn't exist
        self.tooltip = ctk.CTkToplevel(self.widget)
        self.tooltip.wm_overrideredirect(True)
        self.tooltip.wm_geometry(f"+{self.widget.winfo_pointerx()+10}+{self.widget.winfo_pointery()+10}")
        label = ctk.CTkLabel(
            self.tooltip,
            text=self.text,
            fg_color="#333333",
            text_color="#e0e0e0",
            font=("Roboto", 12),
            corner_radius=5,
            padx=5,
            pady=5
        )
        label.pack()
        self.tooltip.attributes("-topmost", True) # Ensure tooltip stays on top
    def hide_tooltip(self, event=None):
        # Cancel pending show
        if self.show_after_id:
            self.widget.after_cancel(self.show_after_id)
            self.show_after_id = None
        # Hide (don't destroy) tooltip
        if self.tooltip and self.tooltip.winfo_exists():
            self.tooltip.withdraw() # Hide window without destroying
    def destroy(self):
        # Cleanup when widget is destroyed
        if self.show_after_id:
            self.widget.after_cancel(self.show_after_id)
        if self.tooltip and self.tooltip.winfo_exists():
            self.tooltip.destroy()
            self.tooltip = None
class PCOptimizer:
    def __init__(self, root):
        self.root = root
        self.root.title("PC Optimizer")
        ctk.set_appearance_mode("system")
        ctk.set_default_color_theme("dark-blue")
        # Check if running as admin
        if not self.is_admin():
            self.run_as_admin()
            sys.exit(0)
        # Fullscreen setup
        self.is_fullscreen = True
        self.root.attributes("-fullscreen", True)
        self.root.bind("<F11>", self.toggle_fullscreen)
        # UI variables
        self.animating = False
        self.current_tab = "System Info"
        self.static_info = {}
        self.info_lock = Lock()
        self.notification_frame = None
        self.notification_slide = 0.0
        self.notification_after_id = None
        self.status_var = tk.StringVar(value="Ready")
        self.login_attempts = 0
        self.max_attempts = 3
        self.c = wmi.WMI()
        self.last_update_check = None
        self.current_version = self.load_version() # Load version from JSON
        # Display version label in bottom right
        self.version_label = ctk.CTkLabel(
            self.root,
            text=f"Version: {self.current_version}",
            font=("Roboto", 12),
            text_color="#ffffff",
            fg_color="#333333",
            corner_radius=5,
            padx=5,
            pady=3
        )
        self.version_label.place(relx=0.98, rely=0.98, anchor="se")
        # Check HWID
        hwid_result, hwid = self.check_hwid()
        self.hwid = hwid
        self.root.protocol("WM_DELETE_WINDOW", self.on_close)
        if hwid_result:
            self.send_webhook(WEBHOOK_OPEN_CLOSE, "App Opened", f"Successful HWID Check\nHWID: {self.hwid}", 0x00ff00)
        else:
            self.send_webhook(WEBHOOK_OPEN_CLOSE, "App Opened", f"Failed HWID Check\nHWID: {self.hwid}", 0xff0000)
        if not hwid_result:
            self.show_notification(f"This application is HWID whitelisted. Your GPU HWID ({hwid}) has been copied to your clipboard.", success=False)
            if hwid:
                pyperclip.copy(hwid)
            self.root.after(3000, self.root.destroy)
            return
        # Show loading screen
        self.show_loading_screen()
    def send_webhook(self, url, title, description, color=0x3498db):
        try:
            payload = {
                "embeds": [{
                    "title": title,
                    "description": description,
                    "color": color,
                    "timestamp": datetime.now().isoformat()
                }]
            }
            requests.post(url, json=payload)
        except:
            pass # Silent fail to avoid disrupting app
    def on_close(self):
        if hasattr(self, 'hwid'):
            self.send_webhook(WEBHOOK_OPEN_CLOSE, "App Closed", f"HWID: {self.hwid}", 0x00ff00)
        self.root.destroy()
    def is_admin(self):
        try:
            return ctypes.windll.shell32.IsUserAnAdmin() != 0
        except:
            return False
    def run_as_admin(self):
        try:
            ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)
        except Exception as e:
            self.handle_error("Failed to run as admin", e)
    def create_label(self, parent, text="", textvariable=None, font_size=20, text_color="#e0e0e0", pady=10, anchor="center"):
        label = ctk.CTkLabel(parent, text=text, textvariable=textvariable, font=("Roboto", font_size), text_color=text_color)
        label.pack(pady=pady, anchor=anchor)
        return label
    def create_button(self, parent, text, command, fg_color="#1e90ff", hover_color="#4682b4", tooltip_text=None):
        btn = ctk.CTkButton(
            parent,
            text=text,
            command=command,
            fg_color=fg_color,
            hover_color=hover_color,
            font=("Roboto", 20, "bold"),
            corner_radius=20,
            width=300,
            height=60
        )
        btn.pack(pady=12)
        if tooltip_text:
            btn.tooltip = Tooltip(btn, tooltip_text)
        return btn
    def create_entry(self, parent, placeholder, show=None, width=320):
        entry = ctk.CTkEntry(
            parent,
            placeholder_text=placeholder,
            show=show,
            font=("Roboto", 18),
            width=width,
            corner_radius=15,
            fg_color="#2a2a2a",
            text_color="#e0e0e0"
        )
        entry.pack(pady=10)
        return entry
    def get_hwid(self):
        try:
            gpu = self.c.Win32_VideoController()[0]
            hwid_string = f"{gpu.Name}{gpu.AdapterCompatibility}{gpu.DriverVersion}"
            return hashlib.sha256(hwid_string.encode()).hexdigest()
        except Exception as e:
            self.handle_error("Error generating HWID", e)
            return None
    def check_hwid(self):
        try:
            pastebin_url = "https://pastebin.com/raw/dP362qUr" # Replace with your HWID Pastebin raw URL
            hwid = self.get_hwid()
            if not hwid:
                return False, None
            response = requests.get(pastebin_url, timeout=5)
            response.raise_for_status()
            whitelist = response.text.strip().splitlines()
            return hwid in whitelist, hwid
        except Exception as e:
            self.handle_error("Error checking HWID", e)
            return False, hwid
    def save_version(self, version):
        try:
            version_data = {"version": version}
            version_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "version.json")
            with open(version_file, "w", encoding="utf-8") as f:
                json.dump(version_data, f, indent=4)
        except Exception as e:
            self.handle_error("Failed to save version to JSON", e)
    def load_version(self):
        try:
            version_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "version.json")
            if os.path.exists(version_file):
                with open(version_file, "r", encoding="utf-8") as f:
                    data = json.load(f)
                    return data.get("version", CURRENT_VERSION)
            return CURRENT_VERSION
        except Exception as e:
            self.handle_error("Failed to load version from JSON", e)
            return CURRENT_VERSION
    def check_for_updates(self, manual=False):
        self.send_webhook(WEBHOOK_FEATURE, "Settings Tab: Checked for Updates", f"HWID: {self.hwid}\nManual Check: {manual}", 0x3498db)
        def do_check():
            try:
                if not manual and self.last_update_check and (datetime.now() - self.last_update_check).total_seconds() < 3600:
                    return
                self.last_update_check = datetime.now()
                version_url = "https://pastebin.com/raw/ZLE7qmuJ" # Replace with your version Pastebin raw URL
                code_url = "https://pastebin.com/raw/74KeXTXe" # Replace with your code Pastebin raw URL
                version_response = requests.get(version_url, timeout=5)
                version_response.raise_for_status()
                latest_version = version_response.text.strip()
                current_version = self.load_version()
                try:
                    parsed_current = version.parse(current_version)
                    parsed_latest = version.parse(latest_version)
                except version.InvalidVersion:
                    self.root.after(0, lambda: self.handle_error("Invalid version format in Pastebin", ValueError(f"Invalid version: {latest_version}")))
                    return
                if parsed_latest <= parsed_current:
                    self.root.after(0, lambda: self.show_notification(f"No updates available (Current: {current_version}, Latest: {latest_version})", success=True))
                    return
                code_response = requests.get(code_url, timeout=5)
                code_response.raise_for_status()
                new_code = code_response.text
                try:
                    compile(new_code, "<string>", "exec")
                except SyntaxError as e:
                    self.root.after(0, lambda: self.handle_error("Invalid update code", e))
                    return
                current_script = os.path.abspath(__file__)
                with open(current_script, "r", encoding="utf-8") as f:
                    current_code = f.read()
                if current_code.strip() == new_code.strip():
                    self.root.after(0, lambda: self.show_notification("No changes in code, skipping update", success=True))
                    return
                if manual:
                    confirm = tk.messagebox.askyesno("Update Available", f"A new version ({latest_version}) is available. Update now?")
                    if not confirm:
                        self.root.after(0, lambda: self.show_notification("Update cancelled", success=True))
                        return
                temp_script = f"{current_script}.tmp"
                with open(temp_script, "w", encoding="utf-8") as f:
                    f.write(new_code)
                self.save_version(latest_version)
                self.current_version = latest_version
                self.root.after(0, lambda: self.version_label.configure(text=f"Version: {latest_version}"))
                shutil.move(temp_script, current_script)
                self.root.after(0, lambda: self.show_notification(f"Updated to version {latest_version}. Restarting...", success=True))
                self.root.after(2000, lambda: subprocess.run([sys.executable, current_script]))
                self.root.after(3000, self.root.destroy)
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Update check failed", e))
        threading.Thread(target=do_check, daemon=True).start()
        self.status_var.set("Checking for updates...")
    def check_credentials(self):
        try:
            username_url = "https://pastebin.com/raw/AYnMNMfe" # Replace with your username Pastebin raw URL
            password_url = "https://pastebin.com/raw/gV2ZGpTv" # Replace with your password Pastebin raw URL
            username = self.username_entry.get().strip()
            password = self.password_entry.get().strip()
            if not username or not password:
                self.login_attempts += 1
                self.error_label.configure(text=f"Enter both username and password. Attempts left: {self.max_attempts - self.login_attempts}")
                self.send_webhook(WEBHOOK_LOGIN, "Login Failed", f"Missing Credentials\nUsername: {username}\nPassword: {password}\nHWID: {self.hwid}\nAttempts: {self.login_attempts}", 0xff0000)
                if self.login_attempts >= self.max_attempts:
                    self.send_webhook(WEBHOOK_LOGIN, "Login Failed", f"Max Attempts Reached\nHWID: {self.hwid}", 0xff0000)
                    self.show_notification("Max login attempts reached. Exiting...", success=False)
                    self.root.after(2000, self.root.destroy)
                return
            username_response = requests.get(username_url, timeout=5)
            username_response.raise_for_status()
            username_whitelist = username_response.text.strip().splitlines()
            password_response = requests.get(password_url, timeout=5)
            password_response.raise_for_status()
            password_whitelist = password_response.text.strip().splitlines()
            if username in username_whitelist and password in password_whitelist:
                self.send_webhook(WEBHOOK_LOGIN, "Login Successful", f"Username: {username}\nHWID: {self.hwid}", 0x00ff00)
                self.login_attempts = 0
                self.fade_out_frame(self.login_frame, self.setup_main_ui)
            else:
                self.login_attempts += 1
                self.error_label.configure(text=f"Invalid credentials. Attempts left: {self.max_attempts - self.login_attempts}")
                self.username_entry.delete(0, tk.END)
                self.password_entry.delete(0, tk.END)
                self.send_webhook(WEBHOOK_LOGIN, "Login Failed", f"Invalid Credentials\nUsername: {username}\nPassword: {password}\nHWID: {self.hwid}\nAttempts: {self.login_attempts}", 0xff0000)
                if self.login_attempts >= self.max_attempts:
                    self.send_webhook(WEBHOOK_LOGIN, "Login Failed", f"Max Attempts Reached\nHWID: {self.hwid}", 0xff0000)
                    self.show_notification("Max login attempts reached. Exiting...", success=False)
                    self.root.after(2000, self.root.destroy)
        except Exception as e:
            self.send_webhook(WEBHOOK_LOGIN, "Login Failed", f"Error During Login\nHWID: {self.hwid}\nError: {str(e)}", 0xff0000)
            self.handle_error("Login error", e)
    def fade_in_frame(self, frame, callback=None, step=0):
        if step == 0:
            frame.place(relx=0.5, rely=0.5, anchor="center")
            frame.configure(fg_color="#1e1e1e")
        if callback and step >= 10:
            callback()
        else:
            self.root.after(50, lambda: self.fade_in_frame(frame, callback, step + 1))
    def fade_out_frame(self, frame, callback, step=10):
        if step <= 0:
            frame.place_forget()
            if callback:
                callback()
        else:
            self.root.after(50, lambda: self.fade_out_frame(frame, callback, step - 1))
    def show_notification(self, message, success=True, duration=3000):
        try:
            if self.notification_after_id:
                self.root.after_cancel(self.notification_after_id)
            if self.notification_frame:
                self.notification_frame.destroy()
            self.notification_frame = ctk.CTkFrame(self.root, fg_color="#32cd32" if success else "#ff4500", corner_radius=15)
            self.create_label(self.notification_frame, message, font_size=14, pady=5, text_color="#ffffff")
            self.notification_slide = -100
            self.notification_frame.place(relx=0.98, rely=0.90, anchor="se")
            self.version_label.lift()
            self.slide_notification_in(duration)
        except Exception as e:
            self.handle_error("Notification error", e)
    def slide_notification_in(self, duration):
        try:
            if self.notification_slide < 0:
                self.notification_slide += 20
                self.notification_frame.place(relx=0.98, rely=0.90 + self.notification_slide / 1000, anchor="se")
                self.notification_after_id = self.root.after(10, lambda: self.slide_notification_in(duration))
            else:
                self.notification_after_id = self.root.after(duration, self.slide_notification_out)
        except Exception as e:
            self.handle_error("Notification slide-in error", e)
    def slide_notification_out(self):
        try:
            if self.notification_frame is None:
                return
            if self.notification_slide > -100:
                self.notification_slide -= 20
                self.notification_frame.place(relx=0.98, rely=0.90 + self.notification_slide / 1000, anchor="se")
                self.notification_after_id = self.root.after(10, self.slide_notification_out)
            else:
                self.notification_frame.destroy()
                self.notification_frame = None
                self.notification_after_id = None
        except Exception as e:
            self.handle_error("Notification slide-out error", e)
    def handle_error(self, message, exception):
        error_msg = f"{message}: {exception}"
        print(error_msg)
        self.show_notification(error_msg, success=False)
        self.status_var.set(message)
    def show_loading_screen(self):
        try:
            # Improved loading screen: Centered, larger elements, better spacing
            self.loading_frame = ctk.CTkFrame(self.root, fg_color="#1a1a1a", corner_radius=20, border_width=2, border_color="#1e90ff")
            self.loading_frame.place(relx=0.5, rely=0.5, anchor="center", relwidth=0.4, relheight=0.4) # Smaller, centered frame
            # Title with gradient-like color
            self.create_label(
                self.loading_frame,
                "PC Optimizer",
                font_size=48, # Larger font for title
                text_color="#1e90ff",
                pady=40
            )
            # Status label with subtle color
            self.loading_status = self.create_label(
                self.loading_frame,
                "Initializing...",
                font_size=24, # Slightly larger for readability
                text_color="#cccccc",
                pady=20
            )
            # Wider progress bar with smoother animation
            self.loading_progress = ctk.CTkProgressBar(
                self.loading_frame,
                mode="indeterminate",
                corner_radius=10,
                progress_color="#1e90ff",
                width=500, # Wider for better visuals
                height=20 # Thinner for cleaner look
            )
            self.loading_progress.pack(pady=30, padx=50)
            self.loading_progress.start()
            self.loading_tasks = [
                "Initializing application...",
                "Loading system information...",
                "Preparing UI components...",
                "Connecting to system services..."
            ]
            self.task_index = 0
            self.fade_in_frame(self.loading_frame, self.update_loading)
            self.animate_loading_text()
        except Exception as e:
            self.handle_error("Loading screen error", e)
            self.root.after(1000, self.show_login)
    def animate_loading_text(self):
        try:
            if hasattr(self, 'loading_status') and self.loading_status.winfo_exists():
                current_text = self.loading_status.cget("text")
                dots = "." * ((self.task_index % 4) + 1)
                self.loading_status.configure(text=f"{current_text.split('.')[0]}{dots}")
                self.root.after(200, self.animate_loading_text)
        except Exception as e:
            self.handle_error("Loading text animation error", e)
    def update_loading(self):
        try:
            if self.task_index < len(self.loading_tasks):
                self.loading_status.configure(text=self.loading_tasks[self.task_index])
                self.task_index += 1
                self.root.after(1250, self.update_loading)
            else:
                self.loading_progress.stop()
                self.fade_out_frame(self.loading_frame, self.show_login)
        except Exception as e:
            self.handle_error("Loading transition error", e)
            self.root.after(1000, self.show_login)
    def show_login(self):
        try:
            # Improved login UI: Cleaner layout, larger elements, better spacing
            self.login_frame = ctk.CTkFrame(self.root, fg_color="#1a1a1a", corner_radius=20, border_width=2, border_color="#1e90ff")
            self.login_frame.place(relx=0.5, rely=0.5, anchor="center", relwidth=0.35, relheight=0.6) # Centered, proportional size
            # Title
            ctk.CTkLabel(
                self.login_frame,
                text="PC Optimizer",
                font=("Roboto", 42, "bold"), # Larger, bold font
                text_color="#1e90ff"
            ).pack(pady=40, anchor="center")
            # Subtitle
            ctk.CTkLabel(
                self.login_frame,
                text="Enter your credentials to access",
                font=("Roboto", 20), # Smaller subtitle for hierarchy
                text_color="#cccccc"
            ).pack(pady=10, anchor="center")
            # Username entry with improved size
            self.username_entry = ctk.CTkEntry(
                self.login_frame,
                placeholder_text="Username",
                font=("Roboto", 18),
                width=350, # Wider for better input
                height=50,
                corner_radius=10,
                fg_color="#2a2a2a",
                text_color="#ffffff",
                border_color="#1e90ff"
            )
            self.username_entry.pack(pady=20, anchor="center")
            # Password entry
            self.password_entry = ctk.CTkEntry(
                self.login_frame,
                placeholder_text="Password",
                show="*",
                font=("Roboto", 18),
                width=350,
                height=50,
                corner_radius=10,
                fg_color="#2a2a2a",
                text_color="#ffffff",
                border_color="#1e90ff"
            )
            self.password_entry.pack(pady=20, anchor="center")
            # Login button with hover effect
            login_btn = ctk.CTkButton(
                self.login_frame,
                text="Login",
                command=self.check_credentials,
                fg_color="#1e90ff",
                hover_color="#4682b4",
                font=("Roboto", 20, "bold"),
                corner_radius=10,
                width=350,
                height=50
            )
            login_btn.pack(pady=20, anchor="center")
            # Error label
            self.error_label = ctk.CTkLabel(
                self.login_frame,
                text="",
                font=("Roboto", 16),
                text_color="#ff4500"
            )
            self.error_label.pack(pady=10, anchor="center")
            self.fade_in_frame(self.login_frame)
            self.version_label.lift()
        except Exception as e:
            self.handle_error("Login UI error", e)
    def setup_main_ui(self):
        try:
            # Improved main UI: Better spacing, consistent colors, cleaner sidebar
            self.ui_frame = ctk.CTkFrame(self.root, fg_color="#1e1e1e", corner_radius=15)
            self.ui_frame.place(relx=0, rely=0, relwidth=1, relheight=1)
            self.root.attributes("-fullscreen", self.is_fullscreen)
            # Sidebar with improved width and padding
            self.sidebar = ctk.CTkFrame(self.ui_frame, fg_color="#2a2a2a", corner_radius=15, width=280) # Slightly wider
            self.sidebar.pack(side="left", fill="y", padx=20, pady=20) # More padding
            # Sidebar title
            self.create_label(self.sidebar, "PC Optimizer", font_size=28, text_color="#1e90ff", pady=30) # Larger title with color
            # Tab buttons with better spacing and hover
            self.tab_buttons = {}
            tabs = ["System Info", "Clean Temp", "Uninstall Apps", "Startup Programs", "Power Plans", "Optimize Disk", "Services", "Custom Commands", "Settings"]
            for tab in tabs:
                btn = self.create_button(self.sidebar, tab, lambda t=tab: self.switch_tab(t), fg_color="#2a2a2a" if tab != self.current_tab else "#1e90ff", hover_color="#3a3a3a")
                self.tab_buttons[tab] = btn
            # Content frame with padding
            self.content_frame = ctk.CTkFrame(self.ui_frame, fg_color="#2a2a2a", corner_radius=15)
            self.content_frame.pack(side="right", expand=True, fill="both", padx=20, pady=20)
            # Status frame at bottom
            self.status_frame = ctk.CTkFrame(self.ui_frame, fg_color="#1e1e1e", corner_radius=15, height=40)
            self.status_frame.pack(side="bottom", fill="x", padx=20, pady=10)
            self.create_label(self.status_frame, textvariable=self.status_var, font_size=16, text_color="#cccccc", pady=5)
            # Top right buttons for minimize and quit, nicer styling
            control_frame = ctk.CTkFrame(self.ui_frame, fg_color="#1e1e1e", corner_radius=0)
            control_frame.place(relx=1.0, rely=0.0, anchor="ne")
            minimize_btn = ctk.CTkButton(
                control_frame,
                text="─",
                command=self.minimize_app,
                width=40,
                height=30,
                font=("Roboto", 18, "bold"),
                fg_color="#2a2a2a",
                hover_color="#1e90ff",
                corner_radius=5,
                border_width=1,
                border_color="#444444"
            )
            minimize_btn.pack(side="left", padx=2)
            quit_btn = ctk.CTkButton(
                control_frame,
                text="✕",
                command=self.quit_application,
                width=40,
                height=30,
                font=("Roboto", 18, "bold"),
                fg_color="#2a2a2a",
                hover_color="#ff4500",
                corner_radius=5,
                border_width=1,
                border_color="#444444"
            )
            quit_btn.pack(side="left", padx=2)
            self.tab_frames = {}
            self.setup_info_tab()
            self.setup_clean_tab()
            self.setup_uninstall_tab()
            self.setup_startup_tab()
            self.setup_power_plan_tab()
            self.setup_disk_tab()
            self.setup_services_tab()
            self.setup_commands_tab()
            self.setup_settings_tab()
            self.switch_tab("System Info")
            self.cache_static_info()
            self.auto_refresh_info()
            self.fade_in_frame(self.ui_frame)
            self.version_label.lift()
        except Exception as e:
            self.handle_error("Main UI setup error", e)
    def minimize_app(self):
        self.root.iconify()
    def restart_app(self):
        self.send_webhook(WEBHOOK_FEATURE, "Settings Tab: Restarted App", f"HWID: {self.hwid}", 0x3498db)
        self.show_notification("Restarting...", success=True)
        current_script = os.path.abspath(__file__)
        self.root.after(2000, lambda: subprocess.run([sys.executable, current_script]))
        self.root.after(3000, self.root.destroy)
    def save_settings(self):
        self.send_webhook(WEBHOOK_FEATURE, "Settings Tab: Saved Settings", f"HWID: {self.hwid}", 0x3498db)
        self.show_notification("Settings saved", success=True)
    def cache_static_info(self):
        try:
            with self.info_lock:
                self.static_info["OS"] = f"OS: {platform.system()} {platform.release()}"
                self.static_info["OS Version"] = f"OS Version: {platform.version()}"
                self.static_info["OS Architecture"] = f"OS Architecture: {platform.architecture()[0]}"
                self.static_info["Machine Type"] = f"Machine Type: {platform.machine()}"
                self.static_info["Processor"] = f"Processor: {platform.processor()}"
                self.static_info["CPU Name"] = f"CPU Name: {self.c.Win32_Processor()[0].Name}"
                self.static_info["CPU Physical Cores"] = f"CPU Physical Cores: {psutil.cpu_count(logical=False)}"
                self.static_info["CPU Logical Cores"] = f"CPU Logical Cores: {psutil.cpu_count()}"
                bios = self.c.Win32_BIOS()[0]
                self.static_info["BIOS Version"] = f"BIOS Version: {bios.SMBIOSBIOSVersion}"
                motherboard = self.c.Win32_BaseBoard()[0]
                self.static_info["Motherboard"] = f"Motherboard: {motherboard.Manufacturer} {motherboard.Product}"
                gpu = self.c.Win32_VideoController()[0]
                self.static_info["GPU"] = f"GPU: {gpu.Name}"
                computer_system = self.c.Win32_ComputerSystem()[0]
                self.static_info["Computer System"] = f"Computer System: {computer_system.Manufacturer} {computer_system.Model}"
        except Exception as e:
            self.handle_error("Error caching system info", e)
    def switch_tab(self, tab_name):
        if self.animating or tab_name == self.current_tab:
            return
        try:
            self.animating = True
            old_tab = self.current_tab
            self.current_tab = tab_name
            for tab, btn in self.tab_buttons.items():
                btn.configure(fg_color="#1e90ff" if tab == tab_name else "#2a2a2a")
            if old_tab in self.tab_frames:
                self.tab_frames[old_tab].pack_forget()
            self.tab_frames[tab_name].pack(expand=True, fill="both", padx=10, pady=10)
            self.animating = False
            self.status_var.set(f"Switched to {tab_name}")
            self.version_label.lift()
        except Exception as e:
            self.handle_error("Tab switch error", e)
    def toggle_fullscreen(self, event=None):
        try:
            self.is_fullscreen = not self.is_fullscreen
            self.root.attributes("-fullscreen", self.is_fullscreen)
            self.status_var.set("Toggled fullscreen" if self.is_fullscreen else "Toggled windowed")
            self.show_notification("Toggled display mode", success=True)
            self.version_label.lift()
        except Exception as e:
            self.handle_error("Toggle fullscreen error", e)
    def setup_info_tab(self):
        try:
            info_frame = ctk.CTkFrame(self.content_frame, fg_color="#2a2a2a", corner_radius=15)
            self.tab_frames["System Info"] = info_frame
            self.create_label(info_frame, "System Information", font_size=24)
            scrollable_frame = ctk.CTkScrollableFrame(info_frame, fg_color="#2a2a2a", corner_radius=15)
            scrollable_frame.pack(fill="both", expand=True, padx=20, pady=20)
            info_grid = ctk.CTkFrame(scrollable_frame, fg_color="#333333", corner_radius=15)
            info_grid.pack(fill="both", expand=True, padx=20, pady=20)
            info_grid.grid_columnconfigure(0, weight=1)
            self.info_labels = {
                "OS": ctk.CTkLabel(info_grid, text="OS: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "OS Version": ctk.CTkLabel(info_grid, text="OS Version: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "OS Architecture": ctk.CTkLabel(info_grid, text="OS Architecture: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Machine Type": ctk.CTkLabel(info_grid, text="Machine Type: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Processor": ctk.CTkLabel(info_grid, text="Processor: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "CPU Name": ctk.CTkLabel(info_grid, text="CPU Name: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "CPU Physical Cores": ctk.CTkLabel(info_grid, text="CPU Physical Cores: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "CPU Logical Cores": ctk.CTkLabel(info_grid, text="CPU Logical Cores: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "CPU Frequency": ctk.CTkLabel(info_grid, text="CPU Frequency: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "CPU Usage": ctk.CTkLabel(info_grid, text="CPU Usage: 0%", font=("Roboto", 20), text_color="#e0e0e0"),
                "CPU Times": ctk.CTkLabel(info_grid, text="CPU Times: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "RAM": ctk.CTkLabel(info_grid, text="RAM: 0 GB / 0 GB", font=("Roboto", 20), text_color="#e0e0e0"),
                "Swap Memory": ctk.CTkLabel(info_grid, text="Swap Memory: 0 GB / 0 GB", font=("Roboto", 20), text_color="#e0e0e0"),
                "Disk": ctk.CTkLabel(info_grid, text="Disk: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Disk IO": ctk.CTkLabel(info_grid, text="Disk IO: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Network Interfaces": ctk.CTkLabel(info_grid, text="Network Interfaces: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Network IO": ctk.CTkLabel(info_grid, text="Network IO: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Battery": ctk.CTkLabel(info_grid, text="Battery: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Temperatures": ctk.CTkLabel(info_grid, text="Temperatures: Not available", font=("Roboto", 20), text_color="#e0e0e0"),
                "Fans": ctk.CTkLabel(info_grid, text="Fans: Not available", font=("Roboto", 20), text_color="#e0e0e0"),
                "Processes": ctk.CTkLabel(info_grid, text="Processes: 0", font=("Roboto", 20), text_color="#e0e0e0"),
                "Users": ctk.CTkLabel(info_grid, text="Users: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Uptime": ctk.CTkLabel(info_grid, text="Uptime: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "BIOS Version": ctk.CTkLabel(info_grid, text="BIOS Version: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Motherboard": ctk.CTkLabel(info_grid, text="Motherboard: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "GPU": ctk.CTkLabel(info_grid, text="GPU: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
                "Computer System": ctk.CTkLabel(info_grid, text="Computer System: Unknown", font=("Roboto", 20), text_color="#e0e0e0"),
            }
            for i, label in enumerate(self.info_labels.values()):
                label.grid(row=i, column=0, sticky="w", padx=20, pady=5)
        except Exception as e:
            self.handle_error("Info tab setup error", e)
    def setup_clean_tab(self):
        try:
            clean_frame = ctk.CTkFrame(self.content_frame, fg_color="#2a2a2a", corner_radius=15)
            self.tab_frames["Clean Temp"] = clean_frame
            self.create_label(clean_frame, "Clean Temporary Files", font_size=24)
            self.create_label(clean_frame, "Free up disk space by removing temporary files", font_size=16)
            self.clean_btn = self.create_button(clean_frame, "Clean Temp Files", self.clean_temp, tooltip_text="Remove temporary files to free disk space")
            self.progress_bar = ctk.CTkProgressBar(clean_frame, mode="indeterminate", corner_radius=10, progress_color="#1e90ff")
            self.progress_bar.pack(pady=15, padx=20)
            self.progress_bar.set(0)
            self.clean_result = ctk.CTkTextbox(clean_frame, height=200, font=("Roboto", 16), text_color="#e0e0e0", fg_color="#1e1e1e", corner_radius=10, wrap="word", border_width=1, border_color="#444444")
            self.clean_result.pack(pady=15, padx=20, fill="both", expand=True)
            self.create_button(clean_frame, "Open Temp Folder", self.open_temp_folder, fg_color="#1e90ff", hover_color="#4682b4", tooltip_text="Open the temporary files folder")
            self.create_button(clean_frame, "Clean Recycle Bin", self.clean_recycle_bin, fg_color="#ff4500", hover_color="#cd3700", tooltip_text="Empty the recycle bin")
        except Exception as e:
            self.handle_error("Clean tab setup error", e)
    def setup_uninstall_tab(self):
        try:
            uninstall_frame = ctk.CTkFrame(self.content_frame, fg_color="#2a2a2a", corner_radius=15)
            self.tab_frames["Uninstall Apps"] = uninstall_frame
            self.create_label(uninstall_frame, "Uninstall Applications", font_size=24)
            self.create_label(uninstall_frame, "Select an application to uninstall permanently", font_size=16)
            self.uninstall_listbox = tk.Listbox(uninstall_frame, height=12, selectmode=tk.SINGLE, bg="#2a2a2a", fg="#e0e0e0", font=("Roboto", 16), selectbackground="#1e90ff", selectforeground="#ffffff")
            self.uninstall_listbox.pack(pady=15, padx=20, fill="both", expand=True)
            self.uninstall_result = ctk.CTkTextbox(uninstall_frame, height=100, font=("Roboto", 16), text_color="#e0e0e0", fg_color="#1e1e1e", corner_radius=10, wrap="word", border_width=1, border_color="#444444")
            self.uninstall_result.pack(pady=10, padx=20, fill="x")
            self.create_button(uninstall_frame, "Uninstall Selected", self.uninstall_app, fg_color="#ff4500", hover_color="#cd3700", tooltip_text="Uninstall the selected application")
            self.load_installed_apps()
        except Exception as e:
            self.handle_error("Uninstall tab setup error", e)
    def load_installed_apps(self):
        try:
            self.uninstall_listbox.delete(0, tk.END)
            apps = []
            for hkey in [winreg.HKEY_LOCAL_MACHINE, winreg.HKEY_CURRENT_USER]:
                key_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall"
                try:
                    key = winreg.OpenKey(hkey, key_path, 0, winreg.KEY_READ)
                    for i in range(0, winreg.QueryInfoKey(key)[0]):
                        subkey_name = winreg.EnumKey(key, i)
                        subkey = winreg.OpenKey(key, subkey_name)
                        try:
                            name = winreg.QueryValueEx(subkey, "DisplayName")[0]
                            version = winreg.QueryValueEx(subkey, "DisplayVersion")[0]
                            uninstall_string = winreg.QueryValueEx(subkey, "UninstallString")[0]
                            apps.append({"name": name, "version": version, "uninstall": uninstall_string, "key": subkey_name})
                            self.uninstall_listbox.insert(tk.END, f"{name}: {version}")
                        except FileNotFoundError:
                            pass
                        winreg.CloseKey(subkey)
                    winreg.CloseKey(key)
                except Exception as e:
                    pass
            self.uninstall_listbox.apps = apps
            self.show_notification("Installed apps loaded", success=True)
        except Exception as e:
            self.handle_error("Failed to load installed apps", e)
    def uninstall_app(self):
        selection = self.uninstall_listbox.curselection()
        if not selection:
            self.show_notification("No app selected", success=False)
            return
        index = selection[0]
        app = self.uninstall_listbox.apps[index]
        self.send_webhook(WEBHOOK_FEATURE, "Uninstall Apps Tab: Uninstalling App", f"App: {app['name']} {app['version']}\nHWID: {self.hwid}", 0x3498db)
        def do_uninstall():
            try:
                uninstall_string = app['uninstall']
                if "msiexec" in uninstall_string.lower():
                    # Extract GUID
                    guid_start = uninstall_string.find("{")
                    if guid_start != -1:
                        guid = uninstall_string[guid_start:uninstall_string.find("}", guid_start) + 1]
                        cmd = ["msiexec.exe", "/x", guid, "/qn"]
                    else:
                        cmd = uninstall_string.split() + ["/qn"]
                else:
                    cmd = uninstall_string.split() + ["/silent"]
                result = subprocess.run(cmd, capture_output=True, text=True, check=True)
                output = result.stdout + result.stderr
                self.root.after(0, lambda: self.uninstall_result.insert(tk.END, f"Uninstalled {app['name']} {app['version']}\nCommand: {' '.join(cmd)}\nOutput: {output}\nCompleted at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"))
                self.root.after(0, lambda: self.show_notification(f"Uninstalled {app['name']}", success=True))
                self.root.after(0, self.load_installed_apps)
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Uninstall failed", e))
        threading.Thread(target=do_uninstall, daemon=True).start()
        self.status_var.set("Uninstalling app...")
    def setup_startup_tab(self):
        try:
            startup_frame = ctk.CTkFrame(self.content_frame, fg_color="#2a2a2a", corner_radius=15)
            self.tab_frames["Startup Programs"] = startup_frame
            self.create_label(startup_frame, "Manage Startup Programs", font_size=24)
            self.create_label(startup_frame, "Control programs that run at startup", font_size=16)
            self.startup_listbox = tk.Listbox(startup_frame, height=12, selectmode=tk.SINGLE, bg="#2a2a2a", fg="#e0e0e0", font=("Roboto", 16), selectbackground="#1e90ff", selectforeground="#ffffff")
            self.startup_listbox.pack(pady=15, padx=20, fill="both", expand=True)
            self.startup_result = ctk.CTkTextbox(startup_frame, height=100, font=("Roboto", 16), text_color="#e0e0e0", fg_color="#1e1e1e", corner_radius=10, wrap="word", border_width=1, border_color="#444444")
            self.startup_result.pack(pady=10, padx=20, fill="x")
            self.create_button(startup_frame, "Disable Selected", self.disable_startup, fg_color="#ff4500", hover_color="#cd3700", tooltip_text="Disable selected startup program")
            self.create_button(startup_frame, "Enable Selected", self.enable_startup, fg_color="#32cd32", hover_color="#228b22", tooltip_text="Enable selected startup program")
            self.load_startup()
        except Exception as e:
            self.handle_error("Startup tab setup error", e)
    def setup_power_plan_tab(self):
        try:
            power_frame = ctk.CTkFrame(self.content_frame, fg_color="#2a2a2a", corner_radius=15)
            self.tab_frames["Power Plans"] = power_frame
            self.create_label(power_frame, "Manage Power Plans", font_size=24)
            self.create_label(power_frame, "Optimize power settings for performance", font_size=16)
            self.power_listbox = tk.Listbox(power_frame, height=12, selectmode=tk.SINGLE, bg="#2a2a2a", fg="#e0e0e0", font=("Roboto", 16), selectbackground="#1e90ff", selectforeground="#ffffff")
            self.power_listbox.pack(pady=15, padx=20, fill="both", expand=True)
            self.power_result = ctk.CTkTextbox(power_frame, height=100, font=("Roboto", 16), text_color="#e0e0e0", fg_color="#1e1e1e", corner_radius=10, wrap="word", border_width=1, border_color="#444444")
            self.power_result.pack(pady=10, padx=20, fill="x")
            self.create_button(power_frame, "Set Selected Plan", self.set_power_plan, tooltip_text="Apply the selected power plan")
            self.create_button(power_frame, "Boost Performance", self.boost_power_plan, tooltip_text="Enable Ultimate Performance plan")
            self.create_button(power_frame, "Delete Selected Plan", self.delete_power_plan, fg_color="#ff0000", hover_color="#cc0000", tooltip_text="Delete the selected power plan")
            self.load_power_plans()
        except Exception as e:
            self.handle_error("Power plan tab setup error", e)
    def setup_disk_tab(self):
        try:
            disk_frame = ctk.CTkFrame(self.content_frame, fg_color="#2a2a2a", corner_radius=15)
            self.tab_frames["Optimize Disk"] = disk_frame
            self.create_label(disk_frame, "Optimize Disk", font_size=24)
            self.create_label(disk_frame, "Defragment drives to improve performance", font_size=16)
            self.disk_listbox = tk.Listbox(disk_frame, height=8, selectmode=tk.SINGLE, bg="#2a2a2a", fg="#e0e0e0", font=("Roboto", 16), selectbackground="#1e90ff", selectforeground="#ffffff")
            self.disk_listbox.pack(pady=15, padx=20, fill="both", expand=True)
            self.disk_result = ctk.CTkTextbox(disk_frame, height=100, font=("Roboto", 16), text_color="#e0e0e0", fg_color="#1e1e1e", corner_radius=10, wrap="word", border_width=1, border_color="#444444")
            self.disk_result.pack(pady=10, padx=20, fill="x")
            self.create_button(disk_frame, "Defragment Selected Drive", self.defragment_disk, tooltip_text="Optimize the selected drive")
            self.load_disks()
        except Exception as e:
            self.handle_error("Disk tab setup error", e)
    def setup_services_tab(self):
        try:
            services_frame = ctk.CTkFrame(self.content_frame, fg_color="#2a2a2a", corner_radius=15)
            self.tab_frames["Services"] = services_frame
            self.create_label(services_frame, "Manage Services", font_size=24)
            self.create_label(services_frame, "Disable non-essential services to save resources", font_size=16)
            self.services_listbox = tk.Listbox(services_frame, height=12, selectmode=tk.SINGLE, bg="#2a2a2a", fg="#e0e0e0", font=("Roboto", 16), selectbackground="#1e90ff", selectforeground="#ffffff")
            self.services_listbox.pack(pady=15, padx=20, fill="both", expand=True)
            self.services_result = ctk.CTkTextbox(services_frame, height=100, font=("Roboto", 16), text_color="#e0e0e0", fg_color="#1e1e1e", corner_radius=10, wrap="word", border_width=1, border_color="#444444")
            self.services_result.pack(pady=10, padx=20, fill="x")
            self.create_button(services_frame, "Disable Selected Service", self.disable_service, fg_color="#ff4500", hover_color="#cd3700", tooltip_text="Disable selected service")
            self.load_services()
        except Exception as e:
            self.handle_error("Services tab setup error", e)
    def setup_commands_tab(self):
        try:
            commands_frame = ctk.CTkFrame(self.content_frame, fg_color="#2a2a2a", corner_radius=15)
            self.tab_frames["Custom Commands"] = commands_frame
            self.create_label(commands_frame, "Custom Commands", font_size=24)
            self.create_label(commands_frame, "Run custom command prompt commands", font_size=16)
            self.command_entry = self.create_entry(commands_frame, "Enter command (e.g., dir)", width=400)
            self.create_button(commands_frame, "Run Command", self.run_command, tooltip_text="Execute the entered command")
            self.command_output = ctk.CTkTextbox(commands_frame, height=200, font=("Roboto", 16), text_color="#e0e0e0", fg_color="#1e1e1e", corner_radius=10, wrap="word", border_width=1, border_color="#444444")
            self.command_output.pack(pady=15, padx=20, fill="both", expand=True)
        except Exception as e:
            self.handle_error("Commands tab setup error", e)
    def setup_settings_tab(self):
        try:
            settings_frame = ctk.CTkFrame(self.content_frame, fg_color="#2a2a2a", corner_radius=15)
            self.tab_frames["Settings"] = settings_frame
            self.create_label(settings_frame, "Settings", font_size=24)
            self.create_label(settings_frame, "Optimize system settings", font_size=16)
            self.create_button(settings_frame, "Check for Updates", lambda: self.check_for_updates(manual=True), tooltip_text="Check for application updates")
            self.create_button(settings_frame, "Disable Background Apps", self.disable_background_apps, tooltip_text="Turn off background apps to save resources")
            self.create_button(settings_frame, "Optimize Visual Effects", self.optimize_visual_effects, tooltip_text="Disable visual effects for better performance")
            self.create_button(settings_frame, "Reduce Startup Delay", self.reduce_startup_delay, tooltip_text="Minimize startup delays")
            self.create_button(settings_frame, "Quit Application", self.quit_application, fg_color="#ff4500", hover_color="#cd3700", tooltip_text="Exit the application")
            self.create_button(settings_frame, "Credits", lambda: self.show_notification("Created by AV (Thanks for purchasing)", success=True, duration=10000), tooltip_text="View application credits")
            self.create_button(settings_frame, "Save", self.save_settings, fg_color="#32cd32", hover_color="#228b22", tooltip_text="Save current settings")
            self.create_button(settings_frame, "Restart", self.restart_app, fg_color="#1e90ff", hover_color="#4682b4", tooltip_text="Restart the application")
        except Exception as e:
            self.handle_error("Settings tab setup error", e)
    def quit_application(self):
        self.send_webhook(WEBHOOK_FEATURE, "Settings Tab: Quit Application", f"HWID: {self.hwid}", 0x3498db)
        self.show_notification("Quitting...", success=True)
        self.root.after(3000, self.root.destroy)
    def auto_refresh_info(self):
        if self.current_tab == "System Info":
            threading.Thread(target=self.refresh_info, daemon=True).start()
        self.root.after(3000, self.auto_refresh_info)
    def refresh_info(self):
        try:
            with self.info_lock:
                data = self.static_info.copy()
                cpu_freq = psutil.cpu_freq()
                data["CPU Frequency"] = f"CPU Frequency: {cpu_freq.current:.2f} MHz (Min: {cpu_freq.min:.2f}, Max: {cpu_freq.max:.2f})" if cpu_freq else "CPU Frequency: Unknown"
                data["CPU Usage"] = f"CPU Usage: {psutil.cpu_percent(interval=0.1):.1f}%"
                cpu_times = psutil.cpu_times()
                data["CPU Times"] = f"CPU Times: User {cpu_times.user:.2f}s, System {cpu_times.system:.2f}s, Idle {cpu_times.idle:.2f}s"
                memory = psutil.virtual_memory()
                data["RAM"] = f"RAM: {memory.used // (1024**3)} GB / {memory.total // (1024**3)} GB ({memory.percent}%)"
                swap = psutil.swap_memory()
                data["Swap Memory"] = f"Swap Memory: {swap.used // (1024**3)} GB / {swap.total // (1024**3)} GB ({swap.percent}%)"
                disk_info = []
                for part in psutil.disk_partitions():
                    try:
                        disk = psutil.disk_usage(part.mountpoint)
                        disk_info.append(f"{part.mountpoint} Free: {disk.free // (1024**3)} GB / Total: {disk.total // (1024**3)} GB ({disk.percent}% used)")
                    except:
                        continue
                data["Disk"] = f"Disk: {'; '.join(disk_info)}" if disk_info else "Disk: Unknown"
                disk_io = psutil.disk_io_counters()
                data["Disk IO"] = f"Disk IO: Read {disk_io.read_bytes // (1024**2)} MB, Write {disk_io.write_bytes // (1024**2)} MB"
                net_if = psutil.net_if_addrs()
                interfaces = [f"{iface}: {', '.join([addr.address for addr in addrs if addr.family == 2])}" for iface, addrs in net_if.items()]
                data["Network Interfaces"] = f"Network Interfaces: {'; '.join(interfaces)}"
                net_io = psutil.net_io_counters()
                data["Network IO"] = f"Network IO: Sent {net_io.bytes_sent // (1024**2)} MB, Recv {net_io.bytes_recv // (1024**2)} MB"
                battery = psutil.sensors_battery()
                data["Battery"] = f"Battery: {battery.percent}% ({'Plugged' if battery.power_plugged else 'Not Plugged'}, {battery.secsleft // 60} min left)" if battery else "Battery: Not available"
                try:
                    temps = psutil.sensors_temperatures()
                    temp_str = [f"{name} {entry.label}: {entry.current}°C" for name, entries in temps.items() for entry in entries]
                    data["Temperatures"] = f"Temperatures: {'; '.join(temp_str)}" if temp_str else "Not available"
                except AttributeError:
                    data["Temperatures"] = "Temperatures: Not available"
                try:
                    fans = psutil.sensors_fans()
                    fan_str = [f"{name} {entry.label}: {entry.current} RPM" for name, entries in fans.items() for entry in entries]
                    data["Fans"] = f"Fans: {'; '.join(fan_str)}" if fan_str else "Not available"
                except AttributeError:
                    data["Fans"] = "Fans: Not available"
                data["Processes"] = f"Processes: {len(psutil.pids())}"
                data["Users"] = f"Users: {', '.join([u.name for u in psutil.users()])}"
                boot_time = psutil.boot_time()
                uptime = datetime.now() - datetime.fromtimestamp(boot_time)
                days, seconds = uptime.days, uptime.seconds
                hours, minutes = seconds // 3600, (seconds % 3600) // 60
                data["Uptime"] = f"Uptime: {days}d {hours}h {minutes}m"
                self.root.after(0, lambda: self.update_info_labels(data))
        except Exception as e:
            self.root.after(0, lambda: self.handle_error("Error refreshing info", e))
    def update_info_labels(self, data):
        try:
            for key, value in data.items():
                if key in self.info_labels:
                    self.info_labels[key].configure(text=value)
        except Exception as e:
            self.handle_error("Error updating info labels", e)
    def clean_temp(self):
        self.send_webhook(WEBHOOK_FEATURE, "Clean Temp Tab: Cleaning Temp Files", f"HWID: {self.hwid}", 0x3498db)
        def do_clean():
            try:
                self.clean_btn.configure(state="disabled")
                self.progress_bar.start()
                temp_dir = tempfile.gettempdir()
                deleted_files = []
                deleted_count = 0
                space_before = sum(os.path.getsize(os.path.join(dirpath, filename)) for dirpath, dirnames, filenames in os.walk(temp_dir) for filename in filenames)
                for root, dirs, files in os.walk(temp_dir, topdown=False):
                    for file in files:
                        file_path = os.path.join(root, file)
                        try:
                            os.remove(file_path)
                            deleted_files.append(file_path)
                            deleted_count += 1
                        except Exception as e:
                            pass # Could log errors, but for now skip
                    for dir in dirs:
                        dir_path = os.path.join(root, dir)
                        try:
                            shutil.rmtree(dir_path)
                            deleted_files.append(dir_path + " (directory)")
                            deleted_count += 1
                        except Exception as e:
                            pass
                space_after = sum(os.path.getsize(os.path.join(dirpath, filename)) for dirpath, dirnames, filenames in os.walk(temp_dir) for filename in filenames)
                space_freed = (space_before - space_after) / (1024 * 1024)
                self.root.after(0, lambda: self.clean_result.delete("0.0", tk.END))
                output = f"Cleaned {deleted_count} items, freed {space_freed:.2f} MB\n"
                output += "Deleted items:\n" + "\n".join(deleted_files) + "\n"
                output += f"Completed at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
                self.root.after(0, lambda: self.clean_result.insert("0.0", output))
                self.root.after(0, lambda: self.status_var.set("Temp files cleaned"))
                self.root.after(0, lambda: self.show_notification(f"Cleaned {deleted_count} items, freed {space_freed:.2f} MB", success=True))
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Clean failed", e))
            finally:
                self.root.after(0, lambda: self.progress_bar.stop())
                self.root.after(0, lambda: self.clean_btn.configure(state="normal"))
        threading.Thread(target=do_clean, daemon=True).start()
        self.status_var.set("Cleaning temp files...")
    def open_temp_folder(self):
        self.send_webhook(WEBHOOK_FEATURE, "Clean Temp Tab: Opened Temp Folder", f"HWID: {self.hwid}", 0x3498db)
        try:
            temp_dir = tempfile.gettempdir()
            subprocess.Popen(['explorer', temp_dir])
            self.show_notification("Opened temp folder", success=True)
            self.clean_result.insert(tk.END, f"\nTemp folder opened: {temp_dir}\nAction completed at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
        except Exception as e:
            self.handle_error("Failed to open temp folder", e)
    def clean_recycle_bin(self):
        self.send_webhook(WEBHOOK_FEATURE, "Clean Temp Tab: Cleaned Recycle Bin", f"HWID: {self.hwid}", 0x3498db)
        def do_clean():
            try:
                SHERB_NOCONFIRMATION = 0x00000001
                SHERB_NOPROGRESSUI = 0x00000002
                SHERB_NOSOUND = 0x00000004
                ctypes.windll.shell32.SHEmptyRecycleBinW(None, None, SHERB_NOCONFIRMATION | SHERB_NOPROGRESSUI | SHERB_NOSOUND)
                self.root.after(0, lambda: self.show_notification("Recycle bin cleaned successfully", success=True))
                self.root.after(0, lambda: self.clean_result.insert(tk.END, f"\nRecycle bin emptied. All items permanently deleted.\nAction completed at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"))
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Failed to clean recycle bin", e))
        threading.Thread(target=do_clean, daemon=True).start()
        self.status_var.set("Cleaning recycle bin...")
    def load_startup(self):
        try:
            self.startup_listbox.delete(0, tk.END)
            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Run", 0, winreg.KEY_READ)
            index = 0
            while True:
                try:
                    name, value, _ = winreg.EnumValue(key, index)
                    self.startup_listbox.insert(tk.END, f"{name}: {value}")
                    index += 1
                except WindowsError:
                    break
            winreg.CloseKey(key)
            try:
                key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"Software\Microsoft\Windows\CurrentVersion\Run", 0, winreg.KEY_READ)
                index = 0
                while True:
                    try:
                        name, value, _ = winreg.EnumValue(key, index)
                        self.startup_listbox.insert(tk.END, f"{name}: {value} (System)")
                        index += 1
                    except WindowsError:
                        break
                winreg.CloseKey(key)
            except Exception as e:
                self.show_notification(f"System startup programs may require admin: {e}", success=False)
            self.show_notification("Startup programs loaded", success=True)
        except Exception as e:
            self.handle_error("Failed to load startup programs", e)
    def disable_startup(self):
        selection = self.startup_listbox.curselection()
        if not selection:
            self.status_var.set("No program selected")
            self.show_notification("No program selected", success=False)
            return
        item = self.startup_listbox.get(selection[0])
        name = item.split(":")[0].strip()
        self.send_webhook(WEBHOOK_FEATURE, "Startup Programs Tab: Disabled Startup Program", f"Program: {name}\nHWID: {self.hwid}", 0x3498db)
        try:
            is_system = "(System)" in item
            key_path = r"Software\Microsoft\Windows\CurrentVersion\Run"
            hkey = winreg.HKEY_LOCAL_MACHINE if is_system else winreg.HKEY_CURRENT_USER
            key = winreg.OpenKey(hkey, key_path, 0, winreg.KEY_WRITE)
            winreg.DeleteValue(key, name)
            winreg.CloseKey(key)
            self.load_startup()
            self.status_var.set("Startup program disabled")
            self.show_notification(f"Disabled startup program: {name}", success=True)
            self.startup_result.insert(tk.END, f"Disabled {name}\nCompleted at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        except Exception as e:
            self.handle_error("Failed to disable startup program", e)
    def enable_startup(self):
        self.send_webhook(WEBHOOK_FEATURE, "Startup Programs Tab: Attempted to Enable Startup Program", f"HWID: {self.hwid}\n(Note: Feature not implemented)", 0x3498db)
        try:
            selection = self.startup_listbox.curselection()
            if not selection:
                self.status_var.set("No program selected")
                self.show_notification("No program selected", success=False)
                return
            self.status_var.set("Startup enable not implemented")
            self.show_notification("Enabling startup programs is not implemented", success=False)
        except Exception as e:
            self.handle_error("Error in enable startup", e)
    def load_power_plans(self):
        try:
            self.power_listbox.delete(0, tk.END)
            result = subprocess.run(["powercfg", "/list"], capture_output=True, text=True, check=True)
            lines = result.stdout.splitlines()
            self.power_listbox.power_plans = {}
            for line in lines:
                if "Power Scheme GUID" in line:
                    name = line.split(":")[1].split("(")[1].split(")")[0].strip()
                    guid = line.split(":")[1].split("(")[0].strip()
                    is_active = "*" in line
                    self.power_listbox.insert(tk.END, f"{name}{' (Active)' if is_active else ''}")
                    self.power_listbox.power_plans[self.power_listbox.size() - 1] = guid
            self.show_notification("Power plans loaded", success=True)
        except Exception as e:
            self.handle_error("Failed to load power plans", e)
    def set_power_plan(self):
        selection = self.power_listbox.curselection()
        if not selection:
            self.status_var.set("No power plan selected")
            self.show_notification("No power plan selected", success=False)
            return
        name = self.power_listbox.get(selection[0]).replace(" (Active)", "")
        self.send_webhook(WEBHOOK_FEATURE, "Power Plans Tab: Set Power Plan", f"Plan: {name}\nHWID: {self.hwid}", 0x3498db)
        try:
            guid = self.power_listbox.power_plans[selection[0]]
            subprocess.run(["powercfg", "/setactive", guid], check=True)
            self.load_power_plans()
            self.status_var.set("Power plan set")
            self.show_notification("Power plan set successfully", success=True)
            self.power_result.insert(tk.END, f"Set power plan to {name}\nCompleted at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        except Exception as e:
            self.handle_error("Failed to set power plan", e)
    def boost_power_plan(self):
        self.send_webhook(WEBHOOK_FEATURE, "Power Plans Tab: Boosted Performance", f"Enabled Ultimate Performance Plan\nHWID: {self.hwid}", 0x3498db)
        def do_boost():
            try:
                ultimate_guid = "e9a42b02-d5df-448d-aa00-03f14749eb61"
                result = subprocess.run(["powercfg", "/list"], capture_output=True, text=True, check=True)
                if ultimate_guid in result.stdout:
                    self.root.after(0, lambda: self.status_var.set("Ultimate Performance plan already exists"))
                    self.root.after(0, lambda: self.show_notification("Ultimate Performance plan already exists", success=False))
                else:
                    subprocess.run(["powercfg", "-duplicatescheme", ultimate_guid], capture_output=True, text=True, check=True)
                    subprocess.run(["powercfg", "/setactive", ultimate_guid], capture_output=True, text=True, check=True)
                    self.root.after(0, self.load_power_plans)
                    self.root.after(0, lambda: self.status_var.set("Ultimate Performance plan activated"))
                    self.root.after(0, lambda: self.show_notification("Ultimate Performance plan activated", success=True))
                    self.root.after(0, lambda: self.power_result.insert(tk.END, f"Activated Ultimate Performance plan\nCompleted at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"))
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Failed to manage power plan", e))
        threading.Thread(target=do_boost, daemon=True).start()
        self.status_var.set("Applying Ultimate Performance plan...")
    def delete_power_plan(self):
        selection = self.power_listbox.curselection()
        if not selection:
            self.status_var.set("No power plan selected")
            self.show_notification("No power plan selected", success=False)
            return
        name = self.power_listbox.get(selection[0]).replace(" (Active)", "")
        self.send_webhook(WEBHOOK_FEATURE, "Power Plans Tab: Deleted Power Plan", f"Plan: {name}\nHWID: {self.hwid}", 0x3498db)
        try:
            guid = self.power_listbox.power_plans[selection[0]]
            subprocess.run(["powercfg", "/delete", guid], check=True)
            self.load_power_plans()
            self.status_var.set("Power plan deleted")
            self.show_notification("Power plan deleted successfully", success=True)
            self.power_result.insert(tk.END, f"Deleted power plan {name}\nCompleted at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
        except Exception as e:
            self.handle_error("Failed to delete power plan", e)
    def load_disks(self):
        try:
            self.disk_listbox.delete(0, tk.END)
            for part in psutil.disk_partitions():
                if part.fstype:
                    self.disk_listbox.insert(tk.END, f"{part.device} ({part.fstype})")
            self.show_notification("Disks loaded", success=True)
        except Exception as e:
            self.handle_error("Failed to load disks", e)
    def defragment_disk(self):
        selection = self.disk_listbox.curselection()
        if not selection:
            self.status_var.set("No drive selected")
            self.show_notification("No drive selected", success=False)
            return
        drive = self.disk_listbox.get(selection[0]).split()[0]
        self.send_webhook(WEBHOOK_FEATURE, "Optimize Disk Tab: Defragmented Disk", f"Drive: {drive}\nHWID: {self.hwid}", 0x3498db)
        def do_defrag():
            try:
                result = subprocess.run(["defrag", drive, "/O", "/V"], capture_output=True, text=True, check=True)
                self.root.after(0, lambda: self.status_var.set("Disk defragmented"))
                self.root.after(0, lambda: self.show_notification(f"Defragmented {drive}: {result.stdout[:100]}...", success=True))
                self.root.after(0, lambda: self.disk_result.insert(tk.END, f"Defragmented {drive}\nOutput: {result.stdout}\nCompleted at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"))
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Failed to defragment disk", e))
        threading.Thread(target=do_defrag, daemon=True).start()
        self.status_var.set("Defragmenting disk...")
    def load_services(self):
        try:
            self.services_listbox.delete(0, tk.END)
            non_essential_services = ["XblAuthManager", "XblGameSave", "WSearch", "SysMain"]
            for service in self.c.Win32_Service():
                if service.State == "Running" and service.Name in non_essential_services:
                    self.services_listbox.insert(tk.END, f"{service.Name}: {service.DisplayName}")
            self.show_notification("Services loaded", success=True)
        except Exception as e:
            self.handle_error("Failed to load services", e)
    def disable_service(self):
        selection = self.services_listbox.curselection()
        if not selection:
            self.status_var.set("No service selected")
            self.show_notification("No service selected", success=False)
            return
        service_name = self.services_listbox.get(selection[0]).split(":")[0].strip()
        self.send_webhook(WEBHOOK_FEATURE, "Services Tab: Disabled Service", f"Service: {service_name}\nHWID: {self.hwid}", 0x3498db)
        def do_disable():
            try:
                subprocess.run(["sc", "config", service_name, "start=disabled"], check=True)
                subprocess.run(["net", "stop", service_name], capture_output=True, text=True)
                self.root.after(0, self.load_services)
                self.root.after(0, lambda: self.status_var.set("Service disabled"))
                self.root.after(0, lambda: self.show_notification(f"Disabled service: {service_name}", success=True))
                self.root.after(0, lambda: self.services_result.insert(tk.END, f"Disabled {service_name}\nCompleted at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n"))
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Failed to disable service", e))
        threading.Thread(target=do_disable, daemon=True).start()
        self.status_var.set("Disabling service...")
    def disable_background_apps(self):
        self.send_webhook(WEBHOOK_FEATURE, "Settings Tab: Disabled Background Apps", f"HWID: {self.hwid}", 0x3498db)
        def do_disable():
            try:
                key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\BackgroundAccessApplications", 0, winreg.KEY_WRITE)
                winreg.SetValueEx(key, "GlobalUserDisabled", 0, winreg.REG_DWORD, 1)
                winreg.CloseKey(key)
                self.root.after(0, lambda: self.status_var.set("Background apps disabled"))
                self.root.after(0, lambda: self.show_notification("Background apps disabled", success=True))
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Failed to disable background apps", e))
        threading.Thread(target=do_disable, daemon=True).start()
        self.status_var.set("Disabling background apps...")
    def optimize_visual_effects(self):
        self.send_webhook(WEBHOOK_FEATURE, "Settings Tab: Optimized Visual Effects", f"HWID: {self.hwid}", 0x3498db)
        def do_optimize():
            try:
                key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\VisualEffects", 0, winreg.KEY_WRITE)
                winreg.SetValueEx(key, "VisualFXSetting", 0, winreg.REG_DWORD, 2)
                winreg.CloseKey(key)
                subprocess.run(["systemsettings", "display advancedgraphics"], capture_output=True, text=True)
                self.root.after(0, lambda: self.status_var.set("Visual effects optimized"))
                self.root.after(0, lambda: self.show_notification("Visual effects optimized for performance", success=True))
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Failed to optimize visual effects", e))
        threading.Thread(target=do_optimize, daemon=True).start()
        self.status_var.set("Optimizing visual effects...")
    def reduce_startup_delay(self):
        self.send_webhook(WEBHOOK_FEATURE, "Settings Tab: Reduced Startup Delay", f"HWID: {self.hwid}", 0x3498db)
        def do_reduce():
            try:
                key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer", 0, winreg.KEY_WRITE)
                winreg.SetValueEx(key, "StartupDelayInMSec", 0, winreg.REG_DWORD, 0)
                winreg.CloseKey(key)
                self.root.after(0, lambda: self.status_var.set("Startup delay reduced"))
                self.root.after(0, lambda: self.show_notification("Startup delay reduced", success=True))
            except Exception as e:
                self.root.after(0, lambda: self.handle_error("Failed to reduce startup delay", e))
        threading.Thread(target=do_reduce, daemon=True).start()
        self.status_var.set("Reducing startup delay...")
    def run_command(self):
        try:
            command = self.command_entry.get().strip()
            if not command:
                self.status_var.set("No command entered")
                self.show_notification("No command entered", success=False)
                return
            self.send_webhook(WEBHOOK_FEATURE, "Custom Commands Tab: Ran Command", f"Command: {command}\nHWID: {self.hwid}", 0x3498db)
            def do_run():
                try:
                    result = subprocess.run(command, shell=True, capture_output=True, text=True, check=True)
                    output = result.stdout + result.stderr or "Command executed successfully"
                    self.root.after(0, lambda: self.command_output.delete("0.0", tk.END))
                    self.root.after(0, lambda: self.command_output.insert("0.0", f"Command: {command}\nOutput:\n{output}\nCompleted at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"))
                    self.root.after(0, lambda: self.status_var.set("Command executed"))
                    self.root.after(0, lambda: self.show_notification("Command executed successfully", success=True))
                except Exception as e:
                    self.root.after(0, lambda: self.handle_error("Command failed", e))
            threading.Thread(target=do_run, daemon=True).start()
            self.status_var.set("Running command...")
        except Exception as e:
            self.handle_error("Run command error", e)
if __name__ == "__main__":
    root = ctk.CTk()
    app = PCOptimizer(root)
    root.mainloop()