Program.cs

using System;
using System.Drawing;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using MuSync.Utils;
namespace MuSync;
/// <summary>程序入口：单实例启动、托盘与主窗口，及会话 / 状态 / 轮询各管理器的组装。</summary>
internal static class Program
{
    private static RpcManager? _rpcManager;
    private static SteamStatusManager? _steamManager;
    private static SteamSessionManager? _sessionManager;
    private static MainForm? _mainForm;
    private static NotifyIcon? TrayIcon { get; set; }
    /// <summary>托盘图标守护（资源管理器重启后自动重新注册，见 TrayIconGuard）。</summary>
    private static TrayIconGuard? _trayIconGuard;
    private static ToolStripMenuItem? TrayStatusItem { get; set; }
    private static ToolStripMenuItem? _trayUpdateItem;
    private static UpdateChecker.UpdateInfo? _pendingUpdate;
    public static RpcManager? GetRpcManager() => _rpcManager;
    public static SteamStatusManager? GetSteamManager() => _steamManager;
    public static SteamSessionManager? GetSessionManager() => _sessionManager;
    /// <summary>后台检查发现的可用更新（供主窗口红点与托盘菜单项使用）；无更新时为 null。</summary>
    public static UpdateChecker.UpdateInfo? PendingUpdate => _pendingUpdate;

    /// <summary>本次启动时间（诊断信息用）。</summary>
    public static DateTime StartedAt { get; } = DateTime.Now;

    /// <summary>全局异常兜底：写日志（同步、最小依赖）+ 用 MessageBox 提示（不用普通窗体，防二次崩溃）。</summary>
    private static void HandleFatalException(string source, Exception? exception)
    {
        try
        {
            Logger.Error($"[FATAL] {source}未处理异常: {exception}");
        }
        catch
        {
            // 日志失败也要继续尝试提示
        }
        try
        {
            MessageBox.Show(
                Loc.L($"MuSync 遇到了一个未处理的错误，详情已记录到日志：\n\n{exception?.Message}", $"MuSync ran into an unhandled error. Details were saved to the log:\n\n{exception?.Message}"),
                "MuSync",
                MessageBoxButtons.OK,
                MessageBoxIcon.Error);
        }
        catch
        {
            // 提示失败时静默
        }
    }

    [STAThread]
    private static void Main()
    {
        // 全局异常兜底（UI 线程 / 后台线程 / 未观察任务）
        Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
        Application.ThreadException += (_, e) => HandleFatalException("UI 线程", e.Exception);
        AppDomain.CurrentDomain.UnhandledException +=
            (_, e) => HandleFatalException("后台线程", e.ExceptionObject as Exception);
        TaskScheduler.UnobservedTaskException += (_, e) =>
        {
            Logger.Warn($"[FATAL] 未观察任务异常: {e.Exception.Message}");
            e.SetObserved();
        };

        // 启动时清理旧日志（保留最近 7 天 / 20 MB 内，见 Logger.CleanupOldLogs）
        Logger.CleanupOldLogs();
        Logger.Info($"[Program] MuSync 启动（版本 {Application.ProductVersion}，PID {Environment.ProcessId}，{Environment.OSVersion.VersionString}）");
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        using var mutex = new Mutex(true, "MuSyncMutex", out var isNewInstance);
        if (!isNewInstance)
        {
            // 已有实例在运行：请求它把主窗口唤起到前台，然后安静退出
            Logger.Info("[Program] 已有实例在运行，本次启动直接退出");
            if (!TryActivateExistingInstance())
            {
                MessageBox.Show(Loc.L("MuSync 已在运行。可从任务栏右下角的托盘图标打开主窗口。", "MuSync is already running. Open the main window from the tray icon in the notification area."),
                    "MuSync", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            return;
        }
        // 首个实例：创建「唤起窗口」通知事件（托盘驻留时也能被第二次启动唤起）
        using var activationEvent = new EventWaitHandle(false, EventResetMode.AutoReset, ActivateEventName);
        Win32Api.AutoStart.MigrateLegacyRegistration();
        using var cts = new CancellationTokenSource();
        var token = cts.Token;
        _sessionManager = new SteamSessionManager();
        // 登录 / 重连成功后立即重推当前状态（重连后 Steam 侧状态已清空，且本地去重缓存会拦截重推）
        _sessionManager.OnLoginSucceeded += RefreshStatusAfterRecovery;
        _sessionManager.Start();
        // 系统唤醒 / 解锁后同样主动重推一次（睡眠期间连接可能中断）
        try
        {
            Microsoft.Win32.SystemEvents.PowerModeChanged += (_, e) =>
            {
                if (e.Mode == Microsoft.Win32.PowerModes.Resume)
                {
                    // 睡眠期间主循环心跳不会跳：先复位心跳，免得唤醒后被看门狗误判成停摆
                    GetRpcManager()?.NotifySystemResumed();
                    RefreshStatusAfterRecovery();
                }
            };
            Microsoft.Win32.SystemEvents.SessionSwitch += (_, e) =>
            {
                if (e.Reason == Microsoft.Win32.SessionSwitchReason.SessionUnlock) RefreshStatusAfterRecovery();
            };
        }
        catch (Exception ex)
        {
            Logger.Warn($"[Program] 订阅系统电源事件失败: {ex.Message}");
        }
        // 无论登录与否，先让界面与轮询跑起来（未登录时状态同步自动跳过）
        _steamManager = new SteamStatusManager(_sessionManager);
        _rpcManager = new RpcManager(_steamManager);
        _rpcManager.Start(token);
        _mainForm = new MainForm();
        // 提前创建窗口句柄：托盘驻留（窗口从未显示过）时也能从后台线程安全唤醒
        _ = _mainForm.Handle;
        StartActivationListener(activationEvent);
        TrayIcon = CreateTrayIcon();
        _trayIconGuard = TrayIconGuard.Attach(TrayIcon);
        TrayIcon.Visible = true;
        if (!Configurations.Instance.Settings.StartInTray)
            _mainForm.Show();
        else
            ShowMinimizeToTrayNotification();
        // 消息循环空闲后再启动登录流程，避免启动阶段阻塞 UI（最长 15 秒白屏的问题）
        Application.Idle += OnApplicationIdle;
        Application.Run();
        cts.Cancel();
        _steamManager.ClearStatus();
        _sessionManager.Dispose();
        var uptime = DateTime.Now - StartedAt;
        Logger.Info($"[Program] MuSync 正常退出（本次运行 {(int)uptime.TotalHours} 小时 {uptime.Minutes} 分）");
        // 清理托盘图标（防偶发残留）
        try
        {
            TrayIcon.Visible = false;
            TrayIcon.Dispose();
            _trayIconGuard?.Dispose();
        }
        catch
        {
            // 忽略
        }
    }

    private static void OnApplicationIdle(object? sender, EventArgs e)
    {
        Application.Idle -= OnApplicationIdle;
        _ = StartupSteamLoginAsync();
        _ = CheckUpdatesInBackgroundAsync();
    }

    /// <summary>
    /// 启动阶段令牌登录两次尝试之间的间隔：连接刚启动时可能还没稳住（首连抖动），
    /// 间隔一下再试，多数情况第二次就能登上，不必弹登录窗口。
    /// </summary>
    private const int ReconnectRetryDelaySeconds = 3;

    /// <summary>后台尝试令牌自动登录；只有「确定需要人工登录」时才弹登录窗口。</summary>
    private static async Task StartupSteamLoginAsync()
    {
        try
        {
            var config = Configurations.Instance.Settings;
            if (!config.EnableSteamSync || _sessionManager == null) return;
            var hasSavedToken = !string.IsNullOrEmpty(config.SteamUsername) &&
                                !string.IsNullOrEmpty(config.SteamRefreshToken);
            if (hasSavedToken)
            {
                var username = config.SteamUsername;
                // 启动阶段允许「多次尝试」而不是一次定生死：刚启动时连接可能还没稳住
                //（首连抖动 → 令牌调用立刻以 NetworkLost 失败），多试两轮就能自己登上，不必惊动用户。
                // 可用环境变量 MUSYNC_TOKEN_ATTEMPT_LIMIT 把次数上限压到 1（取值 1~5），
                // 用于在真实环境里复现「启动时令牌先失败、随后自愈重连成功」这条路径。
                var maxAttempts = 3;
                if (int.TryParse(Environment.GetEnvironmentVariable("MUSYNC_TOKEN_ATTEMPT_LIMIT"), out var limit) &&
                    limit is >= 1 and <= 5)
                {
                    maxAttempts = limit;
                }
                var ok = false;
                for (var attempt = 1; attempt <= maxAttempts && !ok; attempt++)
                {
                    // 每轮重新取令牌：被服务器拒绝时会被清空，那就没有可试的了
                    var token = Configurations.Instance.Settings.SteamRefreshToken;
                    if (string.IsNullOrEmpty(token)) break;
                    ok = await Task.Run(() => _sessionManager.LoginWithTokenAsync(username, token));
                    if (ok) break;
                    if (_sessionManager.IsLoggedOn) break;
                    if (_sessionManager.TokenLoginRejected)
                    {
                        // 服务器明确拒绝（令牌失效）：再试也没用，直接走人工登录
                        Logger.Warn("[Program] 令牌已被服务器拒绝，不再重试");
                        break;
                    }
                    if (attempt < maxAttempts)
                    {
                        Logger.Info($"[Program] 令牌自动登录未完成，{ReconnectRetryDelaySeconds} 秒后重试（第 {attempt + 1}/{maxAttempts} 次）");
                        await Task.Delay(TimeSpan.FromSeconds(ReconnectRetryDelaySeconds));
                    }
                }
                if (ok || _sessionManager.IsLoggedOn)
                {
                    Logger.Info("[Program] Token 自动登录成功");
                    return;
                }
                // 失败 != 需要人工登录：断网 / 超时属于可自愈失败，自带的重连循环几秒后就会自己登录成功。
                // 先等一会儿（重连成功会立刻唤醒），登录上了就不弹窗 —— 否则会出现
                // 「已经登录上、甚至都开始同步了，却还弹着一个登录窗」，用户再点一次登录还会把会话顶掉
                // （LogonSessionReplaced → 反复掉线重连）。
                if (await WaitForSessionLoginAsync(TimeSpan.FromSeconds(30)))
                {
                    Logger.Info("[Program] 令牌自动重连登录成功，无需手动登录");
                    return;
                }
                if (!_sessionManager.TokenLoginRejected)
                {
                    // 不是「令牌被服务器拒绝」，而是网络一直没恢复：留给后台重连继续自愈，不打扰用户
                    Logger.Warn("[Program] 令牌登录未完成且网络未恢复，交给后台自动重连，暂不弹登录窗口");
                    return;
                }
                Logger.Warn("[Program] 令牌已被服务器拒绝，需要在登录窗口重新登录");
            }
            // 走到这里说明确实需要手动登录；Idle 回调运行在 UI 线程，await 后仍回 UI 线程，弹模态窗安全
            using var loginForm = new SteamLoginForm(_sessionManager);
            loginForm.ShowDialog();
            if (loginForm.LoginSucceeded)
            {
                Logger.Info("[Program] Steam 登录成功，开始同步音乐状态");
            }
            else
            {
                MessageBox.Show(
                    Loc.L("未登录 Steam，音乐状态将不会同步到好友列表。\n\n", "You're not signed in to Steam, so your music status won't sync to friends.\n\n") +
                    Loc.L("你可以在设置中重新登录。", "You can sign in again from Settings."),
                    Loc.L("提示", "Notice"), MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }
        catch (Exception ex)
        {
            Logger.Error($"[Program] 启动登录流程异常: {ex}");
        }
    }

    /// <summary>
    /// 等会话真正进入「已登录」状态（50ms 粒度轮询 + 登录成功事件即时唤醒）。
    /// 判定只认 <see cref="SteamSessionManager.IsLoggedOn"/>：连接恢复不等于登录成功。
    /// </summary>
    private static async Task<bool> WaitForSessionLoginAsync(TimeSpan timeout)
    {
        if (_sessionManager == null) return false;
        if (_sessionManager.IsLoggedOn) return true;

        var manager = _sessionManager;
        var signal = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
        void OnLoggedOn() => signal.TrySetResult(true);
        manager.OnLoginSucceeded += OnLoggedOn;
        try
        {
            var deadline = DateTime.UtcNow + timeout;
            while (DateTime.UtcNow < deadline)
            {
                if (manager.IsLoggedOn) return true;
                await Task.WhenAny(signal.Task, Task.Delay(50));
            }
            return manager.IsLoggedOn;
        }
        finally
        {
            manager.OnLoginSucceeded -= OnLoggedOn;
        }
    }

    /// <summary>
    /// 启动后台更新检查：发现新版本时点亮设置按钮红点与托盘菜单项（不再弹气泡打扰）。
    /// </summary>
    private static async Task CheckUpdatesInBackgroundAsync()
    {
        try
        {
            await Task.Delay(TimeSpan.FromSeconds(8)).ConfigureAwait(false);
            while (true)
            {
                var info = await UpdateChecker.CheckAsync().ConfigureAwait(false);
                if (info != null)
                {
                    Logger.Info($"[Update] 发现新版本 {info.Tag}");
                    SetPendingUpdate(info);
                }
                // 常驻托盘时定期复查（6 小时一次），避免长期运行错过新版本
                await Task.Delay(TimeSpan.FromHours(6)).ConfigureAwait(false);
            }
        }
        catch (Exception ex)
        {
            Logger.Error($"[Update] 检查更新异常: {ex.Message}");
        }
    }

    /// <summary>记录发现的更新并刷新托盘菜单项（可从任意线程调用）。</summary>
    public static void SetPendingUpdate(UpdateChecker.UpdateInfo info)
    {
        _pendingUpdate = info;
        void Apply()
        {
            if (_trayUpdateItem == null) return;
            _trayUpdateItem.Text = Loc.L($"⬆ 有新版本 {info.Tag}", $"⬆ New version {info.Tag} available");
            _trayUpdateItem.Visible = true;
        }
        try
        {
            if (_mainForm is { IsHandleCreated: true } form && form.InvokeRequired)
            {
                form.BeginInvoke(Apply);
            }
            else
            {
                Apply();
            }
        }
        catch (Exception ex)
        {
            Logger.Warn($"[Update] 刷新更新提示失败: {ex.Message}");
        }
    }

    private const string ActivateEventName = "MuSyncActivateEvent";

    /// <summary>显示并激活主窗口（托盘菜单与二次启动唤起共用）。</summary>
    private static void ShowMainWindow()
    {
        if (_mainForm == null) return;
        _mainForm.Show();
        _mainForm.WindowState = FormWindowState.Normal;
        _mainForm.Activate();
    }

    /// <summary>把主窗口显示并移动到鼠标所在屏幕的工作区中央。</summary>
    private static void CenterMainWindow()
    {
        ShowMainWindow();
        if (_mainForm == null) return;
        var workArea = Screen.FromPoint(Cursor.Position).WorkingArea;
        _mainForm.Location = new Point(
            workArea.Left + (workArea.Width - _mainForm.Width) / 2,
            workArea.Top + (workArea.Height - _mainForm.Height) / 2);
    }

    /// <summary>通知已运行的实例唤起主窗口（第二次启动时调用）。</summary>
    private static bool TryActivateExistingInstance()
    {
        for (var attempt = 0; attempt < 20; attempt++)
        {
            try
            {
                if (EventWaitHandle.TryOpenExisting(ActivateEventName, out var handle))
                {
                    using (handle)
                    {
                        handle.Set();
                    }
                    return true;
                }
            }
            catch
            {
                // 忽略，稍后重试（兼容首个实例尚未创建事件的启动竞态）
            }
            Thread.Sleep(100);
        }
        return false;
    }

    /// <summary>监听「唤起窗口」通知（后台线程，收到后切回 UI 线程显示主窗口）。</summary>
    private static void StartActivationListener(EventWaitHandle activationEvent)
    {
        _ = Task.Run(() =>
        {
            while (true)
            {
                try
                {
                    activationEvent.WaitOne();
                    ShowMainWindowFromBackground();
                }
                catch (ObjectDisposedException)
                {
                    return; // 程序退出中
                }
                catch
                {
                    // 单次失败不退出监听
                }
            }
        });
    }

    /// <summary>后台线程安全地显示主窗口（必要时切回 UI 线程）。</summary>
    private static void ShowMainWindowFromBackground()
    {
        var form = _mainForm;
        if (form == null) return;
        try
        {
            if (form.IsHandleCreated && form.InvokeRequired)
            {
                form.BeginInvoke((Action)ShowMainWindow);
                return;
            }
            ShowMainWindow();
        }
        catch (Exception ex)
        {
            Logger.Warn($"[Program] 唤起主窗口失败: {ex.Message}");
        }
    }

    /// <summary>登录 / 系统唤醒 / 解锁后：清理去重缓存并请求立即重推状态。</summary>
    private static void RefreshStatusAfterRecovery()
    {
        try
        {
            GetSteamManager()?.InvalidatePushedCache();
            GetRpcManager()?.RequestStateRefresh();
        }
        catch (Exception ex)
        {
            Logger.Warn($"[Program] 恢复后重推状态失败: {ex.Message}");
        }
    }

    private static NotifyIcon CreateTrayIcon()
    {
        // 菜单顶部状态行（禁用态，由 UpdateTrayStatus 节流刷新）
        TrayStatusItem = new ToolStripMenuItem("MuSync") { Enabled = false };
        var pauseSyncItem = new ToolStripMenuItem(Loc.L("暂停同步", "Pause sync")) { CheckOnClick = true };
        pauseSyncItem.Click += (_, _) =>
        {
            var steamManager = GetSteamManager();
            if (steamManager == null) return;
            steamManager.ManualPause = pauseSyncItem.Checked;
            Logger.Info($"[Program] 手动暂停同步: {pauseSyncItem.Checked}");
            if (!pauseSyncItem.Checked)
            {
                // 恢复后立即重新推送当前状态
                GetRpcManager()?.RequestStateRefresh();
            }
        };
        // 更新提示项：默认隐藏，后台发现新版本后点亮
        _trayUpdateItem = new ToolStripMenuItem(Loc.L("有新版本", "New version available")) { Visible = false };
        _trayUpdateItem.Click += (_, _) =>
        {
            if (_pendingUpdate is not { } info) return;
            using var updateForm = new UpdateForm(UpdateChecker.GetCurrentVersionText(), info);
            updateForm.ShowDialog();
        };
        var showMainWindowItem = new ToolStripMenuItem(Loc.L("主窗口", "Main window"));
        var centerWindowItem = new ToolStripMenuItem(Loc.L("窗口回中", "Center window"));
        var showSettingsItem = new ToolStripMenuItem(Loc.L("设置", "Settings"));
        var exitMenuItem = new ToolStripMenuItem(Loc.L("退出", "Exit"));
        var contextMenu = new ContextMenuStrip();
        contextMenu.Items.AddRange(
            TrayStatusItem, _trayUpdateItem, new ToolStripSeparator(),
            showMainWindowItem, centerWindowItem, pauseSyncItem, showSettingsItem,
            new ToolStripSeparator(), exitMenuItem);
        showSettingsItem.Click += (_, _) =>
        {
            using var settingsForm = new SettingsForm();
            settingsForm.StartPosition = FormStartPosition.CenterScreen;
            settingsForm.ShowDialog();
            _mainForm?.ApplyAppearance();
        };
        showMainWindowItem.Click += (_, _) => ShowMainWindow();
        centerWindowItem.Click += (_, _) => CenterMainWindow();
        exitMenuItem.Click += (_, _) => Application.Exit();
        var notifyIcon = new NotifyIcon
        {
            Icon = AppResource.Icon,
            Text = "MuSync",
            ContextMenuStrip = contextMenu
        };
        notifyIcon.DoubleClick += (_, _) => ShowMainWindow();
        return notifyIcon;
    }

    /// <summary>刷新托盘悬停提示与右键菜单状态行（由主轮询循环节流调用，约每 5 秒）。</summary>
    public static void UpdateTrayStatus()
    {
        var icon = TrayIcon;
        if (icon == null) return;
        try
        {
            string text;
            var config = Configurations.Instance.Settings;
            if (config.EnableSteamSync && config.PauseWhenPlayingGame &&
                GetSteamManager()?.IsRealGameActive == true)
            {
                text = Loc.L("游戏中，音乐同步已暂停", "In a game — music sync paused");
            }
            else if (GetSteamManager()?.ManualPause == true)
            {
                text = Loc.L("同步已手动暂停", "Sync paused manually");
            }
            else
            {
                var appDisplay = GetRpcManager()?.GetActiveAppDisplay();
                var current = GetRpcManager()?.GetCurrentPlayerInfo();
                if (appDisplay != null && current?.PlayerInfo is { } song)
                {
                    text = $"{appDisplay} + {song.Title}";
                }
                else if (appDisplay != null)
                {
                    text = appDisplay;
                }
                else if (current?.PlayerInfo is { } onlySong)
                {
                    text = Loc.L($"正在播放 {Loc.PlayerName(current.Value.PlayerName)}: {onlySong.Title}", $"Playing on {Loc.PlayerName(current.Value.PlayerName)}: {onlySong.Title}");
                }
                else
                {
                    text = Loc.L("未在播放音乐", "Not playing");
                }
            }
            text = StringUtils.GetTruncatedStringByMaxByteLength(text, 60);
            // 托盘控件归 UI 线程：本方法由后台主循环每 5 秒调一次，直接写控件属于跨线程操作
            // （WinForms 不支持），这里统一切回 UI 线程再写（写法与 SetPendingUpdate 一致）。
            var statusItem = TrayStatusItem;
            void Apply()
            {
                icon.Text = text;
                if (statusItem != null && statusItem.Text != text)
                {
                    statusItem.Text = text;
                }
            }
            var form = _mainForm;
            if (form is { IsHandleCreated: true } && form.InvokeRequired)
            {
                form.BeginInvoke(Apply);
            }
            else
            {
                Apply();
            }
        }
        catch (Exception ex)
        {
            // 托盘刷新失败不影响主流程
            Logger.Error($"[Program] 刷新托盘状态失败: {ex.Message}");
        }
    }

    public static void ShowMinimizeToTrayNotification()
    {
        // 静音版托盘气泡：保留文字提示，但不播放系统提示音
        if (TrayIcon is { } icon)
        {
            Win32Api.TrayBalloon.ShowSilent(icon, Loc.L("应用仍在运行", "MuSync is still running"), Loc.L("MuSync 已最小化到托盘区域。", "MuSync is now in the tray."));
        }
    }
}