MainWindow.xaml.cs

using System.Management;
using System.IO;
using System.Text;
using System.Windows;
using System.Windows.Input;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Collections.ObjectModel;
using System.Linq;
using ModernOptimizer.Helpers;
using ModernOptimizer.Models;
using System.Threading.Tasks;

namespace ModernOptimizer;

public partial class MainWindow : Window
{
    private int _logEventCount = 0;
    private Settings _settings;
    private ObservableCollection<StartupItem> _startupItems = new();
    private SystemCleaner.CleanupResult? _scanResult;
    private Border? _notificationBorder;

    public MainWindow()
    {
        InitializeComponent();
        
        // Enable hardware acceleration for better performance
        RenderOptions.ProcessRenderMode = System.Windows.Interop.RenderMode.Default;
        
        _settings = Settings.Load();
        LoadSettings();
        
        // Initialize audio system
        AudioHelper.Initialize();
        
        // Generate click sound if it doesn't exist
        var soundPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Assets", "click.wav");
        if (!File.Exists(soundPath))
        {
            SoundGenerator.GenerateClickSound(soundPath);
        }
        
        LoadSystemInformation();
        LogActivity("SYSTEM", "Vera Optimizer initialized", LogLevel.Success);
        LogActivity("INFO", "Administrator privileges verified", LogLevel.Info);
        LogActivity("SETTINGS", $"Settings loaded from: {Settings.GetSettingsPath()}", LogLevel.Success);
        CreateNotificationOverlay();
        MainTabControl.SelectionChanged += TabControl_SelectionChanged;
        
        // Smooth window fade-in animation on startup (optimized)
        Opacity = 0;
        Loaded += (s, e) =>
        {
            var fadeIn = new DoubleAnimation
            {
                From = 0,
                To = 1,
                Duration = TimeSpan.FromMilliseconds(300), // Faster for better responsiveness
                EasingFunction = new CubicEase { EasingMode = EasingMode.EaseOut }
            };
            BeginAnimation(OpacityProperty, fadeIn);
            
            // Load scripts dynamically
            LoadAdvancedScripts();
        };
        
        Closed += (s, e) => AudioHelper.Cleanup();
    }

    private void LoadAdvancedScripts()
    {
        try
        {
            ScriptsContainer.Children.Clear();
            
            var scriptsBase = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Scripts");
            if (!Directory.Exists(scriptsBase))
            {
                var errorText = new TextBlock
                {
                    Text = "Scripts folder not found",
                    FontSize = 14,
                    Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF5555")),
                    HorizontalAlignment = HorizontalAlignment.Center,
                    Margin = new Thickness(0, 50, 0, 50)
                };
                ScriptsContainer.Children.Add(errorText);
                return;
            }

            var categories = new[]
            {
                new { Name = "1 Check", Icon = "🔍", Title = "System Diagnostics", Color = "#4FACFE" },
                new { Name = "2 Refresh", Icon = "🔄", Title = "System Refresh", Color = "#00F260" },
                new { Name = "3 Setup", Icon = "⚙️", Title = "Initial Setup", Color = "#FF6B9D" },
                new { Name = "4 Installers", Icon = "📦", Title = "Setup & Apps", Color = "#FFA07A" },
                new { Name = "5 Graphics", Icon = "🎮", Title = "Graphics & Gaming", Color = "#C471F5" },
                new { Name = "6 Windows", Icon = "🪟", Title = "Windows Tweaks", Color = "#00D9FF" },
                new { Name = "7 Hardware", Icon = "🖱️", Title = "Hardware Tweaks", Color = "#FFD700" },
                new { Name = "8 Advanced", Icon = "⚡", Title = "Advanced Tweaks", Color = "#FF4757" }
            };

            foreach (var category in categories)
            {
                var categoryPath = Path.Combine(scriptsBase, category.Name);
                if (!Directory.Exists(categoryPath)) continue;

                var scripts = Directory.GetFiles(categoryPath, "*.ps1").OrderBy(f => f).ToList();
                if (scripts.Count == 0) continue;

                // Category Header
                var headerText = new TextBlock
                {
                    Text = $"{category.Icon} {category.Title}",
                    FontSize = 18,
                    FontWeight = FontWeights.Bold,
                    Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString(category.Color)),
                    Margin = new Thickness(0, 20, 0, 15)
                };
                ScriptsContainer.Children.Add(headerText);

                // Scripts in this category
                foreach (var scriptPath in scripts)
                {
                    var scriptName = Path.GetFileNameWithoutExtension(scriptPath);
                    
                    var scriptCard = new Border
                    {
                        Background = new SolidColorBrush(Color.FromArgb(20, 255, 255, 255)),
                        BorderBrush = new SolidColorBrush(Color.FromArgb(40, 255, 255, 255)),
                        BorderThickness = new Thickness(1),
                        CornerRadius = new CornerRadius(8),
                        Padding = new Thickness(15, 12, 15, 12),
                        Margin = new Thickness(0, 0, 0, 8)
                    };

                    var grid = new Grid();
                    grid.ColumnDefinitions.Add(new ColumnDefinition { Width = new GridLength(1, GridUnitType.Star) });
                    grid.ColumnDefinitions.Add(new ColumnDefinition { Width = GridLength.Auto });

                    var nameText = new TextBlock
                    {
                        Text = scriptName,
                        FontSize = 13,
                        Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#EAEAEA")),
                        VerticalAlignment = VerticalAlignment.Center
                    };
                    Grid.SetColumn(nameText, 0);
                    grid.Children.Add(nameText);

                    var runButton = new Button
                    {
                        Content = "▶️ Run Script",
                        Padding = new Thickness(15, 6, 15, 6),
                        Tag = scriptPath,
                        Background = new SolidColorBrush(Color.FromArgb(30, 0, 255, 240)),
                        BorderBrush = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#00FFF0")),
                        BorderThickness = new Thickness(1),
                        Foreground = new SolidColorBrush(Colors.White),
                        FontSize = 12,
                        FontWeight = FontWeights.Medium,
                        Cursor = Cursors.Hand
                    };
                    runButton.Click += RunScript_Click;
                    Grid.SetColumn(runButton, 1);
                    grid.Children.Add(runButton);

                    scriptCard.Child = grid;
                    ScriptsContainer.Children.Add(scriptCard);
                }
            }

            LogActivity("SCRIPTS", "Loaded advanced scripts interface", LogLevel.Success);
        }
        catch (Exception ex)
        {
            LogActivity("ERROR", $"Failed to load scripts: {ex.Message}", LogLevel.Error);
        }
    }

    #region Settings Management

    private void LoadSettings()
    {
        PerformanceToggle.IsChecked = _settings.PerformanceTweaksEnabled;
        NetworkThrottlingToggle.IsChecked = _settings.NetworkThrottlingDisabled;
        HibernationToggle.IsChecked = _settings.HibernationDisabled;
        WindowsTelemetryToggle.IsChecked = _settings.WindowsTelemetryDisabled;
        CoPilotToggle.IsChecked = _settings.CoPilotDisabled;
    }

    private void SaveSettings()
    {
        _settings.PerformanceTweaksEnabled = PerformanceToggle.IsChecked ?? false;
        _settings.NetworkThrottlingDisabled = NetworkThrottlingToggle.IsChecked ?? false;
        _settings.HibernationDisabled = HibernationToggle.IsChecked ?? false;
        _settings.WindowsTelemetryDisabled = WindowsTelemetryToggle.IsChecked ?? false;
        _settings.CoPilotDisabled = CoPilotToggle.IsChecked ?? false;
        _settings.Save();
        LogActivity("SETTINGS", "User preferences saved to AppData", LogLevel.Success);
    }

    #endregion

    #region Activity Log System

    private enum LogLevel
    {
        Info,
        Success,
        Warning,
        Error
    }

    private void LogActivity(string category, string message, LogLevel level = LogLevel.Info)
    {
        _logEventCount++;
        
        var timestamp = DateTime.Now.ToString("HH:mm:ss");
        var levelColor = level switch
        {
            LogLevel.Success => "#27C93F",
            LogLevel.Warning => "#FFBD2E",
            LogLevel.Error => "#FF5F56",
            _ => "#4FACFE"
        };

        var levelText = level switch
        {
            LogLevel.Success => "[OK]",
            LogLevel.Warning => "[WARN]",
            LogLevel.Error => "[ERR]",
            _ => "[>>]"
        };

        Dispatcher.Invoke(() =>
        {
            var currentLog = ActivityLog.Text;
            var newEntry = $"\n[{timestamp}] {levelText} [{category}] {message}";
            ActivityLog.Text = currentLog + newEntry;
            LogCount.Text = $"{_logEventCount} events";

            // Update status indicator
            StatusIndicator.Fill = new System.Windows.Media.SolidColorBrush(
                (System.Windows.Media.Color)System.Windows.Media.ColorConverter.ConvertFromString(levelColor)
            );
            StatusText.Text = level switch
            {
                LogLevel.Success => "Success",
                LogLevel.Warning => "Warning",
                LogLevel.Error => "Error",
                _ => "Active"
            };

            // Auto-scroll to bottom
            LogScrollViewer.ScrollToEnd();
        });
    }

    private void ClearLog_Click(object sender, RoutedEventArgs e)
    {
        ActivityLog.Text = "[SYSTEM] Activity log cleared";
        _logEventCount = 0;
        LogCount.Text = "0 events";
        StatusIndicator.Fill = new System.Windows.Media.SolidColorBrush(
            (System.Windows.Media.Color)System.Windows.Media.ColorConverter.ConvertFromString("#27C93F")
        );
        StatusText.Text = "Ready";
    }

    #endregion

    #region Window Controls

    private void TitleBar_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
    {
        if (e.ClickCount == 2)
        {
            MaximizeButton_Click(sender, e);
        }
        else
        {
            DragMove();
        }
    }

    private void MinimizeButton_Click(object sender, RoutedEventArgs e)
    {
        WindowState = WindowState.Minimized;
        LogActivity("WINDOW", "Window minimized", LogLevel.Info);
    }

    private void MaximizeButton_Click(object sender, RoutedEventArgs e)
    {
        // Professional smooth animation for maximize/restore
        if (WindowState == WindowState.Normal)
        {
            WindowState = WindowState.Maximized;
            LogActivity("WINDOW", "Window maximized", LogLevel.Info);
        }
        else
        {
            WindowState = WindowState.Normal;
            LogActivity("WINDOW", "Window restored", LogLevel.Info);
        }
    }

    private void CloseButton_Click(object sender, RoutedEventArgs e)
    {
        Close();
    }

    #endregion

    #region Navigation

    private void TabControl_SelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        // No animations - instant tab switching for maximum responsiveness
    }

    private void AnimateTabTransition(TabItem tab)
    {
        // Removed for instant performance
    }

    private void NavigateToDashboard(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 0;
        LogActivity("NAV", "Navigated to Dashboard", LogLevel.Info);
    }

    private void NavigateToOptimizations(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 1;
        LogActivity("NAV", "Navigated to Optimizations", LogLevel.Info);
    }

    private void NavigateToPrivacy(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 2;
        LogActivity("NAV", "Navigated to Privacy & Security", LogLevel.Info);
    }

    private void NavigateToStats(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 3;
        LogActivity("NAV", "Navigated to Optimization Stats", LogLevel.Info);
        UpdateOptimizationScore();
    }

    private void NavigateToStartup(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 5; // Updated: Stats is now index 3, System Info is 4
        LogActivity("NAV", "Navigated to Startup Manager", LogLevel.Info);
        LoadStartupItems();
    }

    private void NavigateToCleaner(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 6; // Updated
        LogActivity("NAV", "Navigated to System Cleaner", LogLevel.Info);
    }

    private void NavigateToSystemInfo(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 4; // Updated: System Info is now index 4
        LogActivity("NAV", "Navigated to System Information", LogLevel.Info);
    }

    private void NavigateToActivityLog(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 7; // Updated
        LogActivity("NAV", "Viewing Activity Log", LogLevel.Info);
    }

    private void NavigateToAdvancedScripts(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 8; // Advanced Scripts tab
        LogActivity("NAV", "Navigated to Advanced Scripts", LogLevel.Info);
    }

    private void NavigateToAbout(object sender, RoutedEventArgs e)
    {
        AudioHelper.PlayClickSound();
        MainTabControl.SelectedIndex = 9; // About tab
        LogActivity("NAV", "Viewing About", LogLevel.Info);
    }

    private void OpenScriptFolder_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            AudioHelper.PlayClickSound();
            if (sender is Button button && button.Tag is string folderName)
            {
                var scriptsPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Scripts", folderName);
                if (Directory.Exists(scriptsPath))
                {
                    System.Diagnostics.Process.Start("explorer.exe", scriptsPath);
                    LogActivity("SCRIPTS", $"Opened folder: {folderName}", LogLevel.Success);
                    ShowToast($"Opened {folderName} scripts folder");
                }
                else
                {
                    LogActivity("ERROR", $"Scripts folder not found: {folderName}", LogLevel.Error);
                    ShowToast($"Scripts folder not found: {folderName}", true);
                }
            }
        }
        catch (Exception ex)
        {
            LogActivity("ERROR", $"Failed to open scripts folder: {ex.Message}", LogLevel.Error);
            ShowToast($"Error: {ex.Message}", true);
        }
    }

    private async void RunScript_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            AudioHelper.PlayClickSound();
            if (sender is Button button && button.Tag is string scriptPath)
            {
                if (!File.Exists(scriptPath))
                {
                    LogActivity("ERROR", $"Script not found: {Path.GetFileName(scriptPath)}", LogLevel.Error);
                    ShowToast("Script file not found", true);
                    return;
                }

                var scriptName = Path.GetFileName(scriptPath);
                LogActivity("SCRIPT", $"Running: {scriptName}", LogLevel.Info);
                ShowToast($"Running {scriptName}...");

                // Disable button during execution
                button.IsEnabled = false;
                button.Content = "⏳ Running...";

                // Run script silently in background
                await Task.Run(() =>
                {
                    try
                    {
                        var process = new System.Diagnostics.Process
                        {
                            StartInfo = new System.Diagnostics.ProcessStartInfo
                            {
                                FileName = "powershell.exe",
                                Arguments = $"-NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File \"{scriptPath}\"",
                                UseShellExecute = false,
                                RedirectStandardOutput = true,
                                RedirectStandardError = true,
                                CreateNoWindow = true,
                                Verb = "runas" // Run as admin
                            }
                        };

                        var output = new System.Text.StringBuilder();
                        var error = new System.Text.StringBuilder();

                        process.OutputDataReceived += (s, args) =>
                        {
                            if (!string.IsNullOrEmpty(args.Data))
                            {
                                output.AppendLine(args.Data);
                                Dispatcher.Invoke(() => LogActivity("OUTPUT", args.Data, LogLevel.Info));
                            }
                        };

                        process.ErrorDataReceived += (s, args) =>
                        {
                            if (!string.IsNullOrEmpty(args.Data))
                            {
                                error.AppendLine(args.Data);
                                Dispatcher.Invoke(() => LogActivity("ERROR", args.Data, LogLevel.Warning));
                            }
                        };

                        process.Start();
                        process.BeginOutputReadLine();
                        process.BeginErrorReadLine();
                        process.WaitForExit();

                        var exitCode = process.ExitCode;
                        Dispatcher.Invoke(() =>
                        {
                            if (exitCode == 0)
                            {
                                LogActivity("SCRIPT", $"✅ Completed: {scriptName}", LogLevel.Success);
                                ShowToast($"✅ {scriptName} completed successfully");
                            }
                            else
                            {
                                LogActivity("SCRIPT", $"⚠️ Completed with code {exitCode}: {scriptName}", LogLevel.Warning);
                                ShowToast($"Script finished with code {exitCode}", true);
                            }
                        });
                    }
                    catch (System.ComponentModel.Win32Exception)
                    {
                        // User cancelled UAC or no admin rights
                        Dispatcher.Invoke(() =>
                        {
                            LogActivity("SCRIPT", $"❌ Admin rights required for: {scriptName}", LogLevel.Error);
                            ShowToast("Administrator rights required", true);
                        });
                    }
                    catch (Exception ex)
                    {
                        Dispatcher.Invoke(() =>
                        {
                            LogActivity("ERROR", $"Script failed: {ex.Message}", LogLevel.Error);
                            ShowToast($"Error: {ex.Message}", true);
                        });
                    }
                });

                // Re-enable button
                button.IsEnabled = true;
                button.Content = "▶️ Run Script";
            }
        }
        catch (Exception ex)
        {
            LogActivity("ERROR", $"Failed to execute script: {ex.Message}", LogLevel.Error);
            ShowToast($"Error: {ex.Message}", true);
        }
    }

    private void OpenGitHubRepo_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            AudioHelper.PlayClickSound();
            System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
            {
                FileName = "https://github.com/FR33THYFR33THY/Ultimate-Windows-Optimization-Guide",
                UseShellExecute = true
            });
            LogActivity("INFO", "Opened Ultimate Windows Optimization Guide repository", LogLevel.Info);
        }
        catch (Exception ex)
        {
            LogActivity("ERROR", $"Failed to open GitHub repository: {ex.Message}", LogLevel.Error);
        }
    }

    #endregion

    #region Startup Manager

    private void LoadStartupItems()
    {
        Task.Run(() =>
        {
            var items = StartupManager.GetStartupItems();
            
            Dispatcher.Invoke(() =>
            {
                _startupItems.Clear();
                foreach (var item in items)
                {
                    _startupItems.Add(item);
                }
                
                StartupItemsControl.ItemsSource = _startupItems;
                
                if (_startupItems.Count == 0)
                {
                    NoStartupItemsText.Visibility = Visibility.Visible;
                }
                else
                {
                    NoStartupItemsText.Visibility = Visibility.Collapsed;
                }
                
                LogActivity("STARTUP", $"Loaded {_startupItems.Count} startup programs", LogLevel.Success);
                ShowToast($"Found {_startupItems.Count} startup programs");
            });
        });
    }

    private void RefreshStartup_Click(object sender, RoutedEventArgs e)
    {
        LogActivity("STARTUP", "Refreshing startup items list...", LogLevel.Info);
        LoadStartupItems();
    }

    private void StartupItem_Changed(object sender, RoutedEventArgs e)
    {
        if (sender is CheckBox checkBox && checkBox.Tag is StartupItem item)
        {
            try
            {
                if (checkBox.IsChecked == false)
                {
                    LogActivity("STARTUP", $"Disabling startup item: {item.Name}", LogLevel.Info);
                    if (StartupManager.DisableStartupItem(item))
                    {
                        LogActivity("STARTUP", $"Successfully disabled: {item.Name}", LogLevel.Success);
                        ShowToast($"Disabled: {item.Name}");
                    }
                    else
                    {
                        LogActivity("STARTUP", $"Failed to disable: {item.Name}", LogLevel.Error);
                        ShowToast($"Failed to disable: {item.Name}", true);
                        checkBox.IsChecked = true;
                    }
                }
                else
                {
                    LogActivity("STARTUP", $"Enabling startup item: {item.Name}", LogLevel.Info);
                    if (StartupManager.EnableStartupItem(item))
                    {
                        LogActivity("STARTUP", $"Successfully enabled: {item.Name}", LogLevel.Success);
                        ShowToast($"Enabled: {item.Name}");
                    }
                    else
                    {
                        LogActivity("STARTUP", $"Failed to enable: {item.Name}", LogLevel.Error);
                        ShowToast($"Failed to enable: {item.Name}", true);
                        checkBox.IsChecked = false;
                    }
                }
            }
            catch (Exception ex)
            {
                LogActivity("ERROR", $"Startup modification error: {ex.Message}", LogLevel.Error);
                ShowToast($"Error: {ex.Message}", true);
            }
        }
    }

    #endregion

    #region System Cleaner

    private void ScanSystem_Click(object sender, RoutedEventArgs e)
    {
        ScanButton.IsEnabled = false;
        CleanButton.IsEnabled = false;
        CleanerStatusText.Text = "Scanning system...";
        
        Task.Run(() =>
        {
            LogActivity("CLEANER", "Starting system scan...", LogLevel.Info);
            _scanResult = SystemCleaner.ScanSystem();
            
            Dispatcher.Invoke(() =>
            {
                var totalSize = SystemCleaner.FormatBytes(_scanResult.TotalSize);
                CleanerStatusText.Text = $"Scan complete - Found cleanable files";
                CleanerSizeText.Text = totalSize;
                CleanerSizeText.Visibility = Visibility.Visible;
                CleanButton.IsEnabled = true;
                ScanButton.IsEnabled = true;
                
                LogActivity("CLEANER", $"Scan complete - {totalSize} of cleanable files found", LogLevel.Success);
                ShowToast($"Found {totalSize} of cleanable files");
            });
        });
    }

    private void CleanSystem_Click(object sender, RoutedEventArgs e)
    {
        var result = MessageBox.Show(
            "This will permanently delete temporary files and cached data. Continue?",
            "Confirm Cleanup",
            MessageBoxButton.YesNo,
            MessageBoxImage.Question
        );

        if (result != MessageBoxResult.Yes)
            return;

        CleanButton.IsEnabled = false;
        ScanButton.IsEnabled = false;
        CleanerStatusText.Text = "Cleaning system...";
        
        // Capture checkbox states on UI thread
        var cleanTemp = TempFilesCheck.IsChecked == true;
        var cleanBrowser = BrowserCacheCheck.IsChecked == true;
        var cleanUpdate = UpdateCacheCheck.IsChecked == true;
        var cleanRecycle = RecycleBinCheck.IsChecked == true;
        var cleanPrefetch = PrefetchCheck.IsChecked == true;
        var cleanThumbnail = ThumbnailCheck.IsChecked == true;
        
        Task.Run(() =>
        {
            try
            {
                LogActivity("CLEANER", "Starting system cleanup...", LogLevel.Info);
                
                // All cleanup happens on background thread to prevent freezing
                if (cleanTemp)
                {
                    LogActivity("CLEANER", "Cleaning temporary files...", LogLevel.Info);
                    SystemCleaner.CleanTempFiles();
                    LogActivity("CLEANER", "Temporary files cleaned successfully", LogLevel.Success);
                }
                
                if (cleanBrowser)
                {
                    LogActivity("CLEANER", "Cleaning browser cache...", LogLevel.Info);
                    SystemCleaner.CleanBrowserCache();
                    LogActivity("CLEANER", "Browser cache cleaned successfully", LogLevel.Success);
                }
                
                if (cleanUpdate)
                {
                    LogActivity("CLEANER", "Cleaning Windows Update cache...", LogLevel.Info);
                    SystemCleaner.CleanUpdateCache();
                    LogActivity("CLEANER", "Update cache cleaned successfully", LogLevel.Success);
                }
                
                if (cleanRecycle)
                {
                    LogActivity("CLEANER", "Emptying Recycle Bin...", LogLevel.Info);
                    SystemCleaner.CleanRecycleBin();
                    LogActivity("CLEANER", "Recycle Bin emptied successfully", LogLevel.Success);
                }
                
                if (cleanPrefetch)
                {
                    LogActivity("CLEANER", "Cleaning prefetch data...", LogLevel.Info);
                    SystemCleaner.CleanPrefetch();
                    LogActivity("CLEANER", "Prefetch data cleaned successfully", LogLevel.Success);
                }
                
                if (cleanThumbnail)
                {
                    LogActivity("CLEANER", "Cleaning thumbnail cache...", LogLevel.Info);
                    SystemCleaner.CleanThumbnailCache();
                    LogActivity("CLEANER", "Thumbnail cache cleaned successfully", LogLevel.Success);
                }
                
                // Update UI on completion
                Dispatcher.Invoke(() =>
                {
                    var freedSize = _scanResult != null ? SystemCleaner.FormatBytes(_scanResult.TotalSize) : "Unknown";
                    CleanerStatusText.Text = "Cleanup complete!";
                    CleanerSizeText.Visibility = Visibility.Collapsed;
                    CleanButton.IsEnabled = false;
                    ScanButton.IsEnabled = true;
                    
                    LogActivity("CLEANER", $"System cleanup complete - approximately {freedSize} freed", LogLevel.Success);
                    ShowToast($"Cleanup complete! ~{freedSize} freed");
                });
            }
            catch (Exception ex)
            {
                Dispatcher.Invoke(() =>
                {
                    LogActivity("ERROR", $"Cleanup error: {ex.Message}", LogLevel.Error);
                    ShowToast($"Cleanup error: {ex.Message}", true);
                    CleanButton.IsEnabled = true;
                    ScanButton.IsEnabled = true;
                    CleanerStatusText.Text = "Error during cleanup";
                });
            }
        });
    }

    #endregion

    #region Professional Toast Notifications

    private void CreateNotificationOverlay()
    {
        // Create notification container that sits at top-center of window
        // Content is now a Grid containing everything
        var rootGrid = (Grid)Content;
        
        _notificationBorder = new Border
        {
            Background = new SolidColorBrush(Color.FromArgb(240, 20, 25, 40)),
            CornerRadius = new CornerRadius(12),
            Padding = new Thickness(20, 12, 20, 12),
            HorizontalAlignment = HorizontalAlignment.Center,
            VerticalAlignment = VerticalAlignment.Top,
            Margin = new Thickness(0, 80, 0, 0),
            Visibility = Visibility.Collapsed,
            Effect = new System.Windows.Media.Effects.DropShadowEffect
            {
                Color = Colors.Black,
                BlurRadius = 20,
                Opacity = 0.5,
                ShadowDepth = 3
            }
        };

        var stackPanel = new StackPanel
        {
            Orientation = Orientation.Horizontal
        };

        var iconText = new TextBlock
        {
            Text = "✓",
            FontSize = 16,
            FontWeight = FontWeights.Bold,
            Foreground = new SolidColorBrush(Color.FromRgb(39, 201, 63)),
            Margin = new Thickness(0, 0, 10, 0),
            VerticalAlignment = VerticalAlignment.Center
        };
        iconText.SetValue(System.Windows.Controls.Panel.ZIndexProperty, 1000);

        var messageText = new TextBlock
        {
            FontSize = 13,
            FontWeight = FontWeights.Medium,
            Foreground = Brushes.White,
            VerticalAlignment = VerticalAlignment.Center
        };
        messageText.SetValue(System.Windows.Controls.Panel.ZIndexProperty, 1000);

        stackPanel.Children.Add(iconText);
        stackPanel.Children.Add(messageText);
        _notificationBorder.Child = stackPanel;
        _notificationBorder.SetValue(System.Windows.Controls.Panel.ZIndexProperty, 10000);
        
        rootGrid.Children.Add(_notificationBorder);
    }

    private void ShowToast(string message, bool isError = false)
    {
        if (_notificationBorder == null) return;

        Dispatcher.Invoke(() =>
        {
            var stackPanel = (StackPanel)_notificationBorder.Child;
            var iconText = (TextBlock)stackPanel.Children[0];
            var messageText = (TextBlock)stackPanel.Children[1];

            if (isError)
            {
                iconText.Text = "✕";
                iconText.Foreground = new SolidColorBrush(Color.FromRgb(255, 95, 86));
                _notificationBorder.BorderBrush = new SolidColorBrush(Color.FromRgb(255, 95, 86));
                _notificationBorder.BorderThickness = new Thickness(2);
            }
            else
            {
                iconText.Text = "✓";
                iconText.Foreground = new SolidColorBrush(Color.FromRgb(39, 201, 63));
                _notificationBorder.BorderBrush = new SolidColorBrush(Color.FromRgb(39, 201, 63));
                _notificationBorder.BorderThickness = new Thickness(2);
            }

            messageText.Text = message;
            _notificationBorder.Visibility = Visibility.Visible;

            // Professional slide-in animation
            var slideIn = new ThicknessAnimation
            {
                From = new Thickness(0, -50, 0, 0),
                To = new Thickness(0, 80, 0, 0),
                Duration = TimeSpan.FromMilliseconds(300),
                EasingFunction = new CubicEase { EasingMode = EasingMode.EaseOut }
            };

            var fadeIn = new DoubleAnimation
            {
                From = 0,
                To = 1,
                Duration = TimeSpan.FromMilliseconds(300)
            };

            _notificationBorder.BeginAnimation(Border.MarginProperty, slideIn);
            _notificationBorder.BeginAnimation(UIElement.OpacityProperty, fadeIn);

            // Auto-hide after 3 seconds
            Task.Delay(3000).ContinueWith(_ =>
            {
                Dispatcher.Invoke(() =>
                {
                    var slideOut = new ThicknessAnimation
                    {
                        From = new Thickness(0, 80, 0, 0),
                        To = new Thickness(0, -50, 0, 0),
                        Duration = TimeSpan.FromMilliseconds(300),
                        EasingFunction = new CubicEase { EasingMode = EasingMode.EaseIn }
                    };

                    var fadeOut = new DoubleAnimation
                    {
                        From = 1,
                        To = 0,
                        Duration = TimeSpan.FromMilliseconds(300)
                    };

                    slideOut.Completed += (s, e) =>
                    {
                        _notificationBorder.Visibility = Visibility.Collapsed;
                    };

                    _notificationBorder.BeginAnimation(Border.MarginProperty, slideOut);
                    _notificationBorder.BeginAnimation(UIElement.OpacityProperty, fadeOut);
                });
            });
        });
    }

    #endregion

    #region Optimization Event Handlers

    private void PerformanceToggle_Changed(object sender, RoutedEventArgs e)
    {
        try
        {
            if (PerformanceToggle.IsChecked == true)
            {
                LogActivity("OPTIMIZE", "Applying performance tweaks...", LogLevel.Info);
                OptimizationHelper.EnablePerformanceTweaks();
                LogActivity("OPTIMIZE", "Performance tweaks enabled successfully", LogLevel.Success);
                ShowToast("Performance tweaks enabled successfully!");
            }
            else
            {
                LogActivity("OPTIMIZE", "Performance tweaks disabled", LogLevel.Info);
                ShowToast("Performance tweaks disabled");
            }
            SaveSettings();
        }
        catch (Exception ex)
        {
            LogActivity("ERROR", $"Failed to apply performance tweaks: {ex.Message}", LogLevel.Error);
            ShowToast($"Failed to apply performance tweaks: {ex.Message}", true);
            PerformanceToggle.IsChecked = !PerformanceToggle.IsChecked;
        }
    }

    private void NetworkThrottlingToggle_Changed(object sender, RoutedEventArgs e)
    {
        try
        {
            if (NetworkThrottlingToggle.IsChecked == true)
            {
                LogActivity("NETWORK", "Disabling network throttling...", LogLevel.Info);
                OptimizationHelper.DisableNetworkThrottling();
                LogActivity("NETWORK", "Network throttling disabled - restart may be required", LogLevel.Success);
                ShowToast("Network throttling disabled - restart required");
            }
            else
            {
                LogActivity("NETWORK", "Network throttling settings reverted", LogLevel.Info);
                ShowToast("Network throttling re-enabled");
            }
            SaveSettings();
        }
        catch (Exception ex)
        {
            LogActivity("ERROR", $"Network throttling modification failed: {ex.Message}", LogLevel.Error);
            ShowToast($"Failed to modify network throttling: {ex.Message}", true);
            NetworkThrottlingToggle.IsChecked = !NetworkThrottlingToggle.IsChecked;
        }
    }

    private void HibernationToggle_Changed(object sender, RoutedEventArgs e)
    {
        try
        {
            if (HibernationToggle.IsChecked == true)
            {
                LogActivity("POWER", "Disabling hibernation...", LogLevel.Info);
                OptimizationHelper.DisableHibernation();
                LogActivity("POWER", "Hibernation disabled - disk space freed", LogLevel.Success);
                ShowToast("Hibernation disabled successfully!");
            }
            else
            {
                LogActivity("POWER", "Enabling hibernation...", LogLevel.Info);
                OptimizationHelper.EnableHibernation();
                LogActivity("POWER", "Hibernation enabled", LogLevel.Success);
                ShowToast("Hibernation enabled successfully!");
            }
            SaveSettings();
        }
        catch (Exception ex)
        {
            LogActivity("ERROR", $"Hibernation modification failed: {ex.Message}", LogLevel.Error);
            ShowToast($"Failed to modify hibernation: {ex.Message}", true);
            HibernationToggle.IsChecked = !HibernationToggle.IsChecked;
        }
    }

    private void WindowsTelemetryToggle_Changed(object sender, RoutedEventArgs e)
    {
        try
        {
            if (WindowsTelemetryToggle.IsChecked == true)
            {
                LogActivity("PRIVACY", "Disabling Windows telemetry...", LogLevel.Info);
                OptimizationHelper.DisableWindowsTelemetry();
                LogActivity("PRIVACY", "Windows telemetry disabled - restart recommended", LogLevel.Success);
                ShowToast("Windows telemetry disabled - restart recommended");
            }
            else
            {
                LogActivity("PRIVACY", "Windows telemetry settings reverted", LogLevel.Info);
                ShowToast("Windows telemetry settings reverted");
            }
            SaveSettings();
        }
        catch (Exception ex)
        {
            LogActivity("ERROR", $"Telemetry modification failed: {ex.Message}", LogLevel.Error);
            ShowToast($"Failed to modify telemetry: {ex.Message}", true);
            WindowsTelemetryToggle.IsChecked = !WindowsTelemetryToggle.IsChecked;
        }
    }

    private void CoPilotToggle_Changed(object sender, RoutedEventArgs e)
    {
        try
        {
            if (CoPilotToggle.IsChecked == true)
            {
                LogActivity("PRIVACY", "Disabling Windows CoPilot AI...", LogLevel.Info);
                OptimizationHelper.DisableCoPilot();
                LogActivity("PRIVACY", "CoPilot AI disabled successfully", LogLevel.Success);
                ShowToast("CoPilot AI disabled successfully!");
            }
            else
            {
                LogActivity("PRIVACY", "CoPilot AI re-enabled", LogLevel.Info);
                ShowToast("CoPilot AI re-enabled");
            }
            SaveSettings();
        }
        catch (Exception ex)
        {
            LogActivity("ERROR", $"CoPilot modification failed: {ex.Message}", LogLevel.Error);
            ShowToast($"Failed to modify CoPilot: {ex.Message}", true);
            CoPilotToggle.IsChecked = !CoPilotToggle.IsChecked;
        }
    }

    #endregion

    #region System Information

    private void LoadSystemInformation()
    {
        // Load system info asynchronously to avoid blocking UI thread
        Task.Run(() =>
        {
            try
            {
                var systemInfo = GetSystemInfo();
                Dispatcher.Invoke(() =>
                {
                    SystemInfoText.Text = systemInfo;
                });
            }
            catch (Exception ex)
            {
                Dispatcher.Invoke(() =>
                {
                    SystemInfoText.Text = $"Error loading system information: {ex.Message}";
                });
            }
        });
    }

    private string GetSystemInfo()
    {
        var info = new System.Text.StringBuilder();

        try
        {
            // Operating System
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            info.AppendLine("OPERATING SYSTEM");
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            var os = Environment.OSVersion;
            info.AppendLine($"OS: {os.VersionString}");
            info.AppendLine($"Platform: {os.Platform}");
            info.AppendLine($"64-bit OS: {Environment.Is64BitOperatingSystem}");
            info.AppendLine($"64-bit Process: {Environment.Is64BitProcess}");
            info.AppendLine();

            // Computer Information
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            info.AppendLine("COMPUTER INFORMATION");
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            info.AppendLine($"Computer Name: {Environment.MachineName}");
            info.AppendLine($"User Name: {Environment.UserName}");
            info.AppendLine($"User Domain: {Environment.UserDomainName}");
            info.AppendLine();

            // Processor Information
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            info.AppendLine("PROCESSOR");
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            info.AppendLine($"Processor Count: {Environment.ProcessorCount}");
            
            try
            {
                using var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_Processor");
                foreach (ManagementObject obj in searcher.Get())
                {
                    info.AppendLine($"Name: {obj["Name"]}");
                    info.AppendLine($"Manufacturer: {obj["Manufacturer"]}");
                    info.AppendLine($"Max Clock Speed: {obj["MaxClockSpeed"]} MHz");
                    info.AppendLine($"Cores: {obj["NumberOfCores"]}");
                    info.AppendLine($"Logical Processors: {obj["NumberOfLogicalProcessors"]}");
                }
            }
            catch { info.AppendLine("Unable to retrieve processor details"); }
            info.AppendLine();

            // Memory Information
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            info.AppendLine("MEMORY");
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            try
            {
                using var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_ComputerSystem");
                foreach (ManagementObject obj in searcher.Get())
                {
                    var totalMemory = Convert.ToDouble(obj["TotalPhysicalMemory"]);
                    var totalMemoryGB = Math.Round(totalMemory / (1024 * 1024 * 1024), 2);
                    info.AppendLine($"Total Physical Memory: {totalMemoryGB} GB");
                }
            }
            catch { info.AppendLine("Unable to retrieve memory information"); }
            info.AppendLine();

            // Graphics Information
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            info.AppendLine("GRAPHICS");
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            try
            {
                using var searcher = new ManagementObjectSearcher("SELECT * FROM Win32_VideoController");
                foreach (ManagementObject obj in searcher.Get())
                {
                    info.AppendLine($"Name: {obj["Name"]}");
                    info.AppendLine($"Driver Version: {obj["DriverVersion"]}");
                    var ram = obj["AdapterRAM"];
                    if (ram != null)
                    {
                        var ramGB = Math.Round(Convert.ToDouble(ram) / (1024 * 1024 * 1024), 2);
                        info.AppendLine($"Video Memory: {ramGB} GB");
                    }
                    info.AppendLine();
                }
            }
            catch { info.AppendLine("Unable to retrieve graphics information"); }

            // Storage Information
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            info.AppendLine("STORAGE");
            info.AppendLine("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
            var drives = DriveInfo.GetDrives();
            foreach (var drive in drives)
            {
                if (drive.IsReady)
                {
                    var totalSizeGB = Math.Round((double)drive.TotalSize / (1024 * 1024 * 1024), 2);
                    var freeSpaceGB = Math.Round((double)drive.AvailableFreeSpace / (1024 * 1024 * 1024), 2);
                    var usedSpaceGB = Math.Round(totalSizeGB - freeSpaceGB, 2);
                    var usedPercentage = Math.Round((usedSpaceGB / totalSizeGB) * 100, 1);
                    
                    info.AppendLine($"{drive.Name} ({drive.DriveType})");
                    info.AppendLine($"  Total: {totalSizeGB} GB");
                    info.AppendLine($"  Used: {usedSpaceGB} GB ({usedPercentage}%)");
                    info.AppendLine($"  Free: {freeSpaceGB} GB");
                    info.AppendLine($"  File System: {drive.DriveFormat}");
                    info.AppendLine();
                }
            }
        }
        catch (Exception ex)
        {
            info.AppendLine($"Error: {ex.Message}");
        }

        return info.ToString();
    }

    #endregion

    #region Optimization Score Calculator

    private void UpdateOptimizationScore()
    {
        Task.Run(() =>
        {
            try
            {
                // Calculate individual scores
                int perfScore = CalculatePerformanceScore();
                int privacyScore = CalculatePrivacyScore();
                int startupScore = CalculateStartupScore();
                int storageScore = CalculateStorageScore();
                int networkScore = CalculateNetworkScore();
                int servicesScore = CalculateServicesScore();

                // Calculate overall score (weighted average)
                int overallScore = (perfScore + privacyScore + startupScore + storageScore + networkScore + servicesScore) / 6;

                Dispatcher.Invoke(() =>
                {
                    // Update overall score
                    ScoreValue.Text = overallScore.ToString();
                    
                    // Update score circle (circumference = 2πr, r = 90, so ~565)
                    double percentage = overallScore / 100.0;
                    double dashLength = 565 * percentage;
                    ScoreCircle.StrokeDashArray = new System.Windows.Media.DoubleCollection { dashLength, 565 };
                    
                    // Update score status and color
                    if (overallScore >= 85)
                    {
                        ScoreStatus.Text = "EXCELLENT";
                        ScoreDescription.Text = "Your system is highly optimized and running smoothly!";
                        ((Border)ScoreStatus.Parent).Background = new SolidColorBrush(Color.FromRgb(39, 201, 63));
                        ScoreCircle.Stroke = new SolidColorBrush(Color.FromRgb(39, 201, 63));
                    }
                    else if (overallScore >= 70)
                    {
                        ScoreStatus.Text = "GOOD";
                        ScoreDescription.Text = "Your system is performing well with room for improvement";
                        ((Border)ScoreStatus.Parent).Background = new SolidColorBrush(Color.FromRgb(79, 172, 254));
                        ScoreCircle.Stroke = new SolidColorBrush(Color.FromRgb(79, 172, 254));
                    }
                    else if (overallScore >= 50)
                    {
                        ScoreStatus.Text = "FAIR";
                        ScoreDescription.Text = "Consider applying more optimizations to improve performance";
                        ((Border)ScoreStatus.Parent).Background = new SolidColorBrush(Color.FromRgb(255, 189, 0));
                        ScoreCircle.Stroke = new SolidColorBrush(Color.FromRgb(255, 189, 0));
                    }
                    else
                    {
                        ScoreStatus.Text = "NEEDS WORK";
                        ScoreDescription.Text = "Your system requires optimization for better performance";
                        ((Border)ScoreStatus.Parent).Background = new SolidColorBrush(Color.FromRgb(255, 61, 61));
                        ScoreCircle.Stroke = new SolidColorBrush(Color.FromRgb(255, 61, 61));
                    }
                    
                    // Update individual scores
                    PerformanceScore.Text = perfScore.ToString();
                    PrivacyScore.Text = privacyScore.ToString();
                    StartupScore.Text = startupScore.ToString();
                    StorageScore.Text = storageScore.ToString();
                    NetworkScore.Text = networkScore.ToString();
                    ServicesScore.Text = servicesScore.ToString();
                    
                    // Update bar widths
                    PerformanceBar.Width = perfScore;
                    PrivacyBar.Width = privacyScore;
                    StartupBar.Width = startupScore;
                    StorageBar.Width = storageScore;
                    NetworkBar.Width = networkScore;
                    ServicesBar.Width = servicesScore;
                });
                
                LogActivity("STATS", $"Optimization score calculated: {overallScore}/100", LogLevel.Success);
            }
            catch (Exception ex)
            {
                LogActivity("ERROR", $"Failed to calculate optimization score: {ex.Message}", LogLevel.Error);
            }
        });
    }

    private int CalculatePerformanceScore()
    {
        int score = 70; // Base score
        
        if (_settings.PerformanceTweaksEnabled) score += 15;
        if (_settings.NetworkThrottlingDisabled) score += 10;
        if (_settings.HibernationDisabled) score += 5;
        
        return Math.Min(score, 100);
    }

    private int CalculatePrivacyScore()
    {
        int score = 50; // Base score (Windows default has telemetry)
        
        if (_settings.WindowsTelemetryDisabled) score += 25;
        if (_settings.CoPilotDisabled) score += 15;
        // Add more privacy checks as features are implemented
        score += 10; // Placeholder for other privacy settings
        
        return Math.Min(score, 100);
    }

    private int CalculateStartupScore()
    {
        // Calculate based on number of startup items
        int startupItemCount = _startupItems?.Count ?? 0;
        
        if (startupItemCount == 0) return 100;
        if (startupItemCount <= 5) return 90;
        if (startupItemCount <= 10) return 80;
        if (startupItemCount <= 15) return 70;
        if (startupItemCount <= 20) return 60;
        
        return Math.Max(40, 100 - (startupItemCount * 3));
    }

    private int CalculateStorageScore()
    {
        try
        {
            var systemDrive = DriveInfo.GetDrives().FirstOrDefault(d => d.Name == "C:\\");
            if (systemDrive != null && systemDrive.IsReady)
            {
                double freePercentage = (double)systemDrive.AvailableFreeSpace / systemDrive.TotalSize * 100;
                
                if (freePercentage >= 50) return 100;
                if (freePercentage >= 30) return 85;
                if (freePercentage >= 20) return 70;
                if (freePercentage >= 10) return 50;
                
                return 30;
            }
        }
        catch { }
        
        return 75; // Default if unable to check
    }

    private int CalculateNetworkScore()
    {
        int score = 90; // Base score
        
        if (_settings.NetworkThrottlingDisabled) score += 10;
        
        return Math.Min(score, 100);
    }

    private int CalculateServicesScore()
    {
        // Base score - will be enhanced when service management is fully implemented
        int score = 80;
        
        if (_settings.PerformanceTweaksEnabled) score += 10;
        
        return Math.Min(score, 100);
    }

    #endregion
}