using System.Diagnostics;
using System.Windows;
using Microsoft.Windows.AppNotifications;

namespace WindowsGotify;

public partial class App : Application
{
    private static Mutex? _mutex;
    private Services.ConfigService? _configService;
    private Services.Logger? _logger;
    private Services.StateService? _stateService;
    private Services.GotifyApiService? _apiService;
    private Services.GotifyWebSocketService? _webSocketService;
    private Services.NotificationService? _notificationService;
    private Tray.TrayIconService? _trayService;
    private MainWindow? _mainWindow;

    protected override async void OnStartup(StartupEventArgs e)
    {
        base.OnStartup(e);

        _mutex = new Mutex(true, "WindowsGotifyAgent-SingleInstance", out bool createdNew);
        if (!createdNew)
        {
            Shutdown();
            return;
        }

        _logger = new Services.Logger();
        _configService = new Services.ConfigService(_logger);
        var config = await _configService.LoadAsync();

        _stateService = new Services.StateService(_logger);
        _apiService = new Services.GotifyApiService(config, _logger);
        _notificationService = new Services.NotificationService(config, _logger);

        try
        {
            // NotificationInvoked 必须在 Register 之前注册。
            AppNotificationManager.Default.NotificationInvoked += OnNotificationInvoked;
            AppNotificationManager.Default.Register();
            _logger.Info("Windows App SDK notification manager registered.");
        }
        catch (Exception ex)
        {
            _logger.Error("Notification registration failed.", ex);
        }

        _mainWindow = new MainWindow();
        _mainWindow.Hide();

        _trayService = new Tray.TrayIconService(
            onShowSettings: () => _mainWindow.ShowFromTray(),
            onTest: async () => await SendTestNotificationAsync(),
            onReconnect: () => _webSocketService?.RequestReconnect(),
            onExit: () => Shutdown()
        );

        _webSocketService = new Services.GotifyWebSocketService(
            config,
            _logger,
            _stateService,
            _apiService,
            _notificationService,
            status => _trayService.SetStatus(status));

        _mainWindow.Initialize(
            config,
            _configService,
            _logger,
            _trayService,
            _webSocketService,
            _apiService);

        if (config.Startup.Enabled)
        {
            Utils.StartupManager.EnableCurrentUserStartup(_logger);
        }

        await _webSocketService.StartAsync();
    }

    private async Task SendTestNotificationAsync()
    {
        if (_notificationService is null)
            return;

        await _notificationService.ShowAsync(
            new Models.GotifyMessage
            {
                Id = 0,
                AppId = 0,
                Message = "Windows Gotify Agent 测试通知。",
                Title = "Gotify 测试",
                Priority = 5,
                Date = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
            });
    }

    private void OnNotificationInvoked(
        AppNotificationManager sender,
        AppNotificationActivatedEventArgs args)
    {
        Dispatcher.Invoke(() =>
        {
            try
            {
                var arguments = args.Arguments;
                if (arguments.StartsWith("url=", StringComparison.OrdinalIgnoreCase))
                {
                    var url = Uri.UnescapeDataString(arguments[4..]);
                    Process.Start(new ProcessStartInfo
                    {
                        FileName = url,
                        UseShellExecute = true
                    });
                }
                else
                {
                    _mainWindow?.ShowFromTray();
                }
            }
            catch (Exception ex)
            {
                _logger?.Error("Notification invocation failed.", ex);
            }
        });
    }

    protected override void OnExit(ExitEventArgs e)
    {
        try
        {
            _webSocketService?.Stop();
            _trayService?.Dispose();
            AppNotificationManager.Default.Unregister();
            AppNotificationManager.Default.NotificationInvoked -= OnNotificationInvoked;
        }
        catch (Exception ex)
        {
            _logger?.Error("Application cleanup failed.", ex);
        }

        base.OnExit(e);
    }
}