TrayApplication.cs

using DefaultBrowserWindows.Models;
using DefaultBrowserWindows.Services;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Windows.Forms;

namespace DefaultBrowserWindows
{
    public class TrayApplication : Control, IDisposable
    {
        private NotifyIcon _notifyIcon = null!;
        private ContextMenuStrip _contextMenu = null!;
        private BrowserService _browserService;
        private ConfigurationService _configService;
        private RegistryService _registryService;
        private List<BrowserInfo> _installedBrowsers = null!;
        private System.Windows.Forms.Timer _refreshTimer = null!;
        
        public TrayApplication()
        {
            _browserService = new BrowserService();
            _configService = new ConfigurationService();
            _registryService = new RegistryService();
            
            // Create the control handle to enable Invoke calls
            this.CreateControl();
            
            InitializeTrayIcon();
            RefreshBrowserList();
            
            // Handle command line arguments
            var args = Environment.GetCommandLineArgs();
            if (args.Length > 1)
            {
                HandleCommandLineArguments(args);
            }
            
            // Set up refresh timer
            _refreshTimer = new System.Windows.Forms.Timer();
            _refreshTimer.Interval = 30000; // Refresh every 30 seconds
            _refreshTimer.Tick += (s, e) => RefreshBrowserList();
            _refreshTimer.Start();
        }
        
        private void InitializeTrayIcon()
        {
            _contextMenu = new ContextMenuStrip();
            
            _notifyIcon = new NotifyIcon()
            {
                Icon = CreateDefaultIcon(),
                ContextMenuStrip = _contextMenu,
                Text = "Default Browser Windows",
                Visible = true
            };
            
            _notifyIcon.DoubleClick += (s, e) => ShowBrowserSelection();
        }
        
        private Icon CreateDefaultIcon()
        {
            // Create a simple icon programmatically
            var bitmap = new Bitmap(16, 16);
            using (var g = Graphics.FromImage(bitmap))
            {
                g.Clear(Color.Transparent);
                g.FillEllipse(Brushes.Blue, 2, 2, 12, 12);
                g.DrawString("B", new Font("Arial", 8, FontStyle.Bold), Brushes.White, 4, 2);
            }
            
            return Icon.FromHandle(bitmap.GetHicon());
        }
        
        private void RefreshBrowserList()
        {
            _installedBrowsers = _browserService.GetInstalledBrowsers();
            BuildContextMenu();
            UpdateTrayIcon();
        }
        
        private void BuildContextMenu()
        {
            _contextMenu.Items.Clear();
            
            // Browser selection section
            _contextMenu.Items.Add(new ToolStripLabel("Select Browser:") { Font = new Font(_contextMenu.Font, FontStyle.Bold) });
            _contextMenu.Items.Add(new ToolStripSeparator());
            
            var selectedBrowser = _installedBrowsers.FirstOrDefault(b => 
                b.Name.Equals(_configService.Configuration.SelectedBrowserName, StringComparison.OrdinalIgnoreCase));
            
            foreach (var browser in _installedBrowsers)
            {
                var item = new ToolStripMenuItem(browser.DisplayName)
                {
                    Tag = browser,
                    Checked = browser.Equals(selectedBrowser)
                };
                
                item.Click += BrowserMenuItem_Click;
                _contextMenu.Items.Add(item);
            }
            
            _contextMenu.Items.Add(new ToolStripSeparator());
            
            // Settings section
            var settingsItem = new ToolStripMenuItem("Settings...");
            settingsItem.Click += (s, e) => ShowSettings();
            _contextMenu.Items.Add(settingsItem);
            
            // Registration section
            var isRegistered = _registryService.IsRegisteredAsDefaultBrowser();
            var isActualDefault = _registryService.IsActuallyDefaultBrowser();
            
            var registerItem = new ToolStripMenuItem(isRegistered ? "Unregister as Default Browser" : "Register as Default Browser");
            registerItem.Click += RegisterMenuItem_Click;
            _contextMenu.Items.Add(registerItem);
            
            // Status indicator
            var statusText = isRegistered ? (isActualDefault ? "✓ Active Default Browser" : "⚠ Registered but not default") : "✗ Not registered";
            var statusItem = new ToolStripMenuItem(statusText)
            {
                Enabled = false,
                ForeColor = isActualDefault ? Color.Green : (isRegistered ? Color.Orange : Color.Red)
            };
            _contextMenu.Items.Add(statusItem);
            
            // If registered but not set as default on Windows 10+, add helper menu
            if (isRegistered && !isActualDefault && _registryService.IsWindows10OrLater())
            {
                var helpItem = new ToolStripMenuItem("Open Windows Settings");
                helpItem.Click += (s, e) => _registryService.OpenDefaultAppsSettings();
                _contextMenu.Items.Add(helpItem);
            }
            
            _contextMenu.Items.Add(new ToolStripSeparator());
            
            // Diagnostics section
            var diagnosticsItem = new ToolStripMenuItem("Diagnostics");
            
            var statusDetailsItem = new ToolStripMenuItem("Show Association Details");
            statusDetailsItem.Click += (s, e) => ShowAssociationDetails();
            diagnosticsItem.DropDownItems.Add(statusDetailsItem);
            
            if (_registryService.IsEdgeInterferenceDetected())
            {
                var edgeItem = new ToolStripMenuItem("⚠ Edge Interference Detected");
                edgeItem.Click += (s, e) => ShowEdgeInterferenceHelp();
                diagnosticsItem.DropDownItems.Add(edgeItem);
            }
            
            _contextMenu.Items.Add(diagnosticsItem);
            
            _contextMenu.Items.Add(new ToolStripSeparator());
            
            // About and Exit
            var aboutItem = new ToolStripMenuItem("About");
            aboutItem.Click += (s, e) => ShowAbout();
            _contextMenu.Items.Add(aboutItem);
            
            var exitItem = new ToolStripMenuItem("Exit");
            exitItem.Click += (s, e) => Application.Exit();
            _contextMenu.Items.Add(exitItem);
        }
        
        private void BrowserMenuItem_Click(object? sender, EventArgs e)
        {
            if (sender is ToolStripMenuItem item && item.Tag is BrowserInfo browser)
            {
                _configService.SetSelectedBrowser(browser);
                RefreshBrowserList();
                
                if (_configService.Configuration.ShowNotifications)
                {
                    _notifyIcon.ShowBalloonTip(2000, "Browser Changed", 
                        $"Default browser set to {browser.DisplayName}", ToolTipIcon.Info);
                }
            }
        }
        
        private void RegisterMenuItem_Click(object? sender, EventArgs e)
        {
            var isRegistered = _registryService.IsRegisteredAsDefaultBrowser();
            
            if (isRegistered)
            {
                if (MessageBox.Show("Are you sure you want to unregister Default Browser Windows as the default browser?",
                    "Unregister Default Browser", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                {
                    _registryService.UnregisterAsDefaultBrowser();
                    RefreshBrowserList();
                }
            }
            else
            {
                if (!_registryService.IsRunningAsAdministrator())
                {
                    var result = MessageBox.Show("Administrator privileges are required to register as default browser. Restart as administrator?",
                        "Administrator Required", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                    
                    if (result == DialogResult.Yes)
                    {
                        _registryService.RestartAsAdministrator();
                        Application.Exit();
                    }
                }
                else
                {
                    if (_registryService.RegisterAsDefaultBrowser())
                    {
                        var message = "Successfully registered as default browser.";
                        
                        if (_registryService.IsWindows10OrLater())
                        {
                            message += "\n\nFor Windows 10+, you need to manually set the default browser:";
                            message += "\n1. Click 'Open Settings' to go to Default Apps";
                            message += "\n2. Select 'Default Browser Windows' as your web browser";
                            
                            var result = MessageBox.Show(message + "\n\nOpen Settings now?",
                                "Registration Complete - Manual Setup Required", 
                                MessageBoxButtons.YesNo, MessageBoxIcon.Information);
                                
                            if (result == DialogResult.Yes)
                            {
                                _registryService.OpenDefaultAppsSettings();
                            }
                        }
                        else
                        {
                            MessageBox.Show(message, "Registration Complete", 
                                MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                        
                        RefreshBrowserList();
                    }
                    else
                    {
                        MessageBox.Show("Failed to register as default browser. Please try running as administrator.",
                            "Registration Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
            }
        }
        
        private void ShowBrowserSelection()
        {
            using (var form = new BrowserSelectionForm(_installedBrowsers, _configService))
            {
                if (form.ShowDialog() == DialogResult.OK)
                {
                    RefreshBrowserList();
                }
            }
        }
        
        private void ShowSettings()
        {
            using (var form = new SettingsForm(_configService))
            {
                form.ShowDialog();
            }
        }
        
        private void ShowAbout()
        {
            MessageBox.Show(
                "Default Browser Windows v1.0\n\n" +
                "A Windows system tray app to intelligently control your default web browser.\n\n" +
                "Similar to DefaultBrowser for macOS, this tool allows you to quickly switch between browsers " +
                "and opens links with your most recently selected browser.\n\n" +
                "© 2024",
                "About Default Browser Windows",
                MessageBoxButtons.OK,
                MessageBoxIcon.Information);
        }
        
        private void UpdateTrayIcon()
        {
            var selectedBrowser = _installedBrowsers.FirstOrDefault(b => 
                b.Name.Equals(_configService.Configuration.SelectedBrowserName, StringComparison.OrdinalIgnoreCase));
            
            var tooltip = selectedBrowser != null 
                ? $"Default Browser: {selectedBrowser.DisplayName}"
                : "Default Browser Windows - No browser selected";
            
            _notifyIcon.Text = tooltip.Length > 63 ? tooltip.Substring(0, 60) + "..." : tooltip;
        }
        
        private void ShowAssociationDetails()
        {
            var details = _registryService.GetBrowserAssociationDetails();
            MessageBox.Show(details, "Browser Association Details", 
                MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

        private void ShowEdgeInterferenceHelp()
        {
            var message = "Microsoft Edge interference detected!\n\n" +
                "Windows may be redirecting some links to Edge regardless of your default browser setting. " +
                "This is a Windows feature that cannot be disabled through this application.\n\n" +
                "To work around this:\n" +
                "1. Open Windows Settings > Apps > Default apps\n" +
                "2. Ensure 'Default Browser Windows' is selected as your web browser\n" +
                "3. Check protocol associations for HTTP and HTTPS\n\n" +
                "Some Windows updates may reset these settings.";
                
            var result = MessageBox.Show(message + "\n\nOpen Windows Settings now?",
                "Edge Interference Help", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                
            if (result == DialogResult.Yes)
            {
                _registryService.OpenProtocolAssociationSettings();
            }
        }

        private void HandleCommandLineArguments(string[] args)
        {
            for (int i = 1; i < args.Length; i++)
            {
                var arg = args[i];
                
                if (arg.Equals("--register", StringComparison.OrdinalIgnoreCase))
                {
                    if (_registryService.RegisterAsDefaultBrowser())
                    {
                        MessageBox.Show("Successfully registered as default browser.",
                            "Registration Complete", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                    else
                    {
                        MessageBox.Show("Failed to register as default browser.",
                            "Registration Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                    Application.Exit();
                    return;
                }
                else if (arg.StartsWith("-") && (arg.Contains("showicons") || arg.Contains("hideicons") || arg.Contains("reinstall")))
                {
                    // Handle Windows registration commands
                    _registryService.HandleRegistrationCommand(arg);
                    Application.Exit();
                    return;
                }
                else if (arg.StartsWith("http://") || arg.StartsWith("https://") || arg.StartsWith("ftp://") || arg.EndsWith(".html") || arg.EndsWith(".htm"))
                {
                    // Handle URL or file
                    var selectedBrowser = _installedBrowsers.FirstOrDefault(b => 
                        b.Name.Equals(_configService.Configuration.SelectedBrowserName, StringComparison.OrdinalIgnoreCase));
                    
                    if (selectedBrowser != null)
                    {
                        _browserService.LaunchUrl(arg, selectedBrowser);
                    }
                    else
                    {
                        _browserService.LaunchUrl(arg);
                    }
                    
                    return; // Don't show tray icon for URL handling
                }
            }
        }
        
        public void HandleExternalCommand(string[] args)
        {
            // Handle command line arguments from another instance
            for (int i = 0; i < args.Length; i++)
            {
                var arg = args[i];
                
                if (arg.Equals("--register", StringComparison.OrdinalIgnoreCase))
                {
                    if (_registryService.RegisterAsDefaultBrowser())
                    {
                        _notifyIcon.ShowBalloonTip(3000, "Registration Complete", 
                            "Successfully registered as default browser.", ToolTipIcon.Info);
                    }
                    else
                    {
                        _notifyIcon.ShowBalloonTip(3000, "Registration Failed", 
                            "Failed to register as default browser.", ToolTipIcon.Error);
                    }
                    return;
                }
                else if (arg.StartsWith("-") && (arg.Contains("showicons") || arg.Contains("hideicons") || arg.Contains("reinstall")))
                {
                    // Handle Windows registration commands
                    _registryService.HandleRegistrationCommand(arg);
                    return;
                }
                else if (arg.StartsWith("http://") || arg.StartsWith("https://") || arg.StartsWith("ftp://") || arg.EndsWith(".html") || arg.EndsWith(".htm"))
                {
                    // Handle URL or file
                    var selectedBrowser = _installedBrowsers.FirstOrDefault(b => 
                        b.Name.Equals(_configService.Configuration.SelectedBrowserName, StringComparison.OrdinalIgnoreCase));
                    
                    if (selectedBrowser != null)
                    {
                        _browserService.LaunchUrl(arg, selectedBrowser);
                    }
                    else
                    {
                        _browserService.LaunchUrl(arg);
                    }
                    
                    return;
                }
            }
        }
        
        public new void Dispose()
        {
            _refreshTimer?.Dispose();
            _notifyIcon?.Dispose();
            _contextMenu?.Dispose();
        }
    }
}