CoreManager.cs

using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.Json;
using System.Threading;

namespace WinTombstone
{
    public class CoreManager
    {
        public AppSettings Settings { get; private set; }
        private readonly string _jsonPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "settings.json");
        private readonly object _settingsLock = new object();

        private readonly Dictionary<string, List<OverlayForm>> _activeOverlays = new Dictionary<string, List<OverlayForm>>();
        private readonly Dictionary<int, IntPtr> _frozenJobs = new Dictionary<int, IntPtr>();
        private readonly object _overlayLock = new object();
        private CancellationTokenSource _saveCts;
        private SynchronizationContext _uiContext;

        public static readonly List<string> SystemBlacklist = new List<string>
        {
            "explorer.exe",
            "taskmgr.exe",
            "wintombstone.exe",
            "searchui.exe",
            "searchapp.exe",
            "shellexperiencehost.exe",
            "lockapp.exe"
        };

        public event Action<TargetApp> AppStateChanged;

        public CoreManager()
        {
            _uiContext = SynchronizationContext.Current;
            NativeHelper.EnableDebugPrivilege();
            LoadSettings();
        }

        // ... LoadSettings 和 SaveSettings 方法保持不变，无需修改 ...
        public void LoadSettings()
        {
            lock (_settingsLock)
            {
                if (File.Exists(_jsonPath))
                {
                    try
                    {
                        string json = File.ReadAllText(_jsonPath);
                        Settings = JsonSerializer.Deserialize<AppSettings>(json) ?? new AppSettings();
                    }
                    catch { Settings = new AppSettings(); }
                }
                else
                {
                    Settings = new AppSettings();
                }

                if (string.IsNullOrEmpty(Settings.Language)) Settings.Language = "CN";
                Localization.CurrentLanguage = Settings.Language;

                if (Settings.Blacklist == null) Settings.Blacklist = new List<string>();
                if (Settings.LinkedApps == null) Settings.LinkedApps = new Dictionary<string, List<string>>();

                if (Settings.Whitelist != null)
                {
                    foreach (var app in Settings.Whitelist)
                    {
                        app.IsFrozen = CheckIfAppIsActuallySuspended(app);
                    }
                }
            }
        }

        public void SaveSettings(bool forceImmediate = false)
        {
            if (!forceImmediate)
            {
                _saveCts?.Cancel();
                _saveCts = new CancellationTokenSource();
            }

            var token = _saveCts?.Token ?? CancellationToken.None;

            Task.Run(async () =>
            {
                try
                {
                    if (!forceImmediate)
                    {
                        await Task.Delay(500, token);
                        if (token.IsCancellationRequested) return;
                    }

                    string json;
                    lock (_settingsLock)
                    {
                        Settings.Language = Localization.CurrentLanguage;
                        json = JsonSerializer.Serialize(Settings, new JsonSerializerOptions { WriteIndented = true });
                    }

                    string tempPath = _jsonPath + ".tmp";
                    await File.WriteAllTextAsync(tempPath, json, CancellationToken.None);

                    if (File.Exists(_jsonPath)) File.Delete(_jsonPath);
                    File.Move(tempPath, _jsonPath);
                }
                catch { }
            });
        }
        // ... (End of unmodified section) ...

        private bool CheckIfAppIsActuallySuspended(TargetApp app)
        {
            try
            {
                var processes = GetProcessesByPath(app.ExePath);
                if (processes.Count == 0) return false;
                try
                {
                    foreach (var p in processes)
                    {
                        if (IsProcessSuspended(p)) return true;
                    }
                }
                finally
                {
                    foreach (var p in processes) { try { p.Dispose(); } catch { } }
                }
            }
            catch { }
            return false;
        }

        public bool IsBlacklisted(string exeName)
        {
            string name = Path.GetFileName(exeName).ToLower();
            if (SystemBlacklist.Contains(name)) return true;
            if (Settings.Blacklist.Any(b => b.Equals(name, StringComparison.OrdinalIgnoreCase))) return true;
            return false;
        }


        public void FreezeApp(TargetApp app)
        {
            Console.WriteLine($"[Core] 尝试冻结: {app.AppName}");

            if (IsBlacklisted(app.ExePath) || IsBlacklisted(app.AppName + ".exe"))
            {
                UnfreezeApp(app);
                return;
            }
            lock (_overlayLock)
            {
                if (_activeOverlays.ContainsKey(app.ExePath)) return;
            }

            List<Process> processes = null;
            try
            {
                processes = GetProcessesByPath(app.ExePath);
                if (processes.Count == 0)
                {
                    app.LastActiveTime = DateTime.Now;
                    UpdateAppState(app, false);
                    return;
                }

                if (processes.Any(p => IsProcessSuspended(p)))
                {
                    Console.WriteLine($"[Core] 检测到 {app.AppName} 已处于被挂起状态，同步状态。");
                    UpdateAppState(app, true);
                    return;
                }

                List<OverlayForm> overlays = null;
                _uiContext.Send(_ =>
                {
                    overlays = GenerateOverlaysForProcesses(app, processes);
                }, null);

                if (overlays != null && overlays.Count > 0)
                {
                    lock (_overlayLock)
                    {
                        _activeOverlays[app.ExePath] = overlays;
                    }
                }

                foreach (var p in processes)
                {
                    SuspendSingleProcess(p);
                }

                _uiContext.Send(_ => NativeHelper.ForceReleaseMouse(), null);

                ProcessLinkedApps(app.ExePath, isSuspending: true);

                UpdateAppState(app, true);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[Core] 冻结流程失败: {ex.Message}");
                UnfreezeApp(app);
            }
            finally
            {
                if (processes != null)
                    foreach (var p in processes) { try { p.Dispose(); } catch { } }
            }
        }


        public void UnfreezeApp(TargetApp app)
        {
            Console.WriteLine($"[Core] 尝试解冻: {app.AppName}");

            List<Process> processes = null;
            try
            {
                processes = GetProcessesByPath(app.ExePath);
                foreach (var p in processes)
                {
                    ResumeSingleProcess(p);
                }

                ProcessLinkedApps(app.ExePath, isSuspending: false);

                List<OverlayForm> overlays = null;
                lock (_overlayLock)
                {
                    _activeOverlays.TryGetValue(app.ExePath, out overlays);
                    if (overlays != null) _activeOverlays.Remove(app.ExePath);
                }

                if (overlays != null)
                {
                    _uiContext.Send(_ =>
                    {
                        foreach (var overlay in overlays)
                        {
                            RestoreOriginalWindow(overlay);
                        }
                    }, null);
                }

                app.LastActiveTime = DateTime.Now;
                UpdateAppState(app, false);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[Core] 解冻流程异常: {ex.Message}");
            }
            finally
            {
                if (processes != null)
                    foreach (var p in processes) { try { p.Dispose(); } catch { } }
            }
        }

        // ================= JOB OBJECT 冻结机制 =================

        private void FreezeProcessWithJobObject(int pid)
        {
            if (_frozenJobs.ContainsKey(pid))
            {
                Console.WriteLine($"[Core] PID {pid} already frozen, skipping");
                return;
            }

            IntPtr hProcess = NativeHelper.OpenProcess(NativeHelper.PROCESS_ALL_ACCESS, false, pid);
            if (hProcess == IntPtr.Zero)
            {
                Console.WriteLine($"[Core] OpenProcess failed PID {pid}, Error: {Marshal.GetLastWin32Error()}");
                return;
            }

            IntPtr hJob = NativeHelper.CreateJobObjectW(IntPtr.Zero, null);
            if (hJob == IntPtr.Zero)
            {
                int err = Marshal.GetLastWin32Error();
                NativeHelper.CloseHandle(hProcess);
                Console.WriteLine($"[Core] CreateJobObject failed, Error: {err}");
                return;
            }

            if (!NativeHelper.AssignProcessToJobObject(hJob, hProcess))
            {
                int err = Marshal.GetLastWin32Error();
                NativeHelper.CloseHandle(hJob);
                NativeHelper.CloseHandle(hProcess);
                Console.WriteLine($"[Core] AssignProcessToJobObject failed PID {pid}, Error: {err}");
                return;
            }
            NativeHelper.CloseHandle(hProcess);

            if (!NativeHelper.JobFreeze(hJob, true))
            {
                int err = Marshal.GetLastWin32Error();
                NativeHelper.CloseHandle(hJob);
                Console.WriteLine($"[Core] JobFreeze failed PID {pid}, Error: {err}");
                return;
            }

            _frozenJobs[pid] = hJob;
            Console.WriteLine($"[Core] PID {pid} frozen via Job Object");
        }

        private void UnfreezeProcessWithJobObject(int pid)
        {
            if (!_frozenJobs.TryGetValue(pid, out IntPtr hJob))
            {
                return;
            }

            NativeHelper.JobFreeze(hJob, false);
            NativeHelper.CloseHandle(hJob);
            _frozenJobs.Remove(pid);
            Console.WriteLine($"[Core] PID {pid} unfrozen");
        }

        private void SuspendSingleProcess(Process p)
        {
            try
            {
                if (p.HasExited) return;
                FreezeProcessWithJobObject(p.Id);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[Core] freeze PID {p.Id} exception: {ex.Message}");
            }
        }

        private void ResumeSingleProcess(Process p)
        {
            try
            {
                if (p.HasExited) return;
                UnfreezeProcessWithJobObject(p.Id);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"[Core] unfreeze PID {p.Id} exception: {ex.Message}");
            }
        }

        public void RestoreAll()
        {
            if (Settings?.Whitelist == null) return;
            foreach (var app in Settings.Whitelist.Where(a => a.IsFrozen).ToList())
            {
                UnfreezeApp(app);
            }

            foreach (var kvp in _frozenJobs.ToList())
            {
                NativeHelper.JobFreeze(kvp.Value, false);
                NativeHelper.CloseHandle(kvp.Value);
            }
            _frozenJobs.Clear();

            lock (_overlayLock)
            {
                _activeOverlays.Clear();
            }
        }

        // ... 后续代码 (GenerateOverlaysForProcesses, CreateOverlayForWindow, RestoreOriginalWindow, 
        // IsProcessAliveSafe, GetProcessesByPath 等) 保持原样，直接复制粘贴原来的即可 ...
        // 为了确保完整性，以下是需要保留的关键辅助函数（请确保您没有删除它们）

        private List<OverlayForm> GenerateOverlaysForProcesses(TargetApp app, List<Process> processes)
        {
            var overlays = new List<OverlayForm>();
            foreach (var p in processes)
            {
                try
                {
                    if (p.HasExited) continue;
                    var windows = NativeHelper.GetVisibleWindowsForProcess(p.Id);
                    foreach (var hWnd in windows)
                    {
                        if (!NativeHelper.IsTaskbarWindow(hWnd)) continue;

                        NativeHelper.RECT rect;
                        bool isMinimized = NativeHelper.IsIconic(hWnd);

                        if (isMinimized)
                        {
                            NativeHelper.WINDOWPLACEMENT placement = new NativeHelper.WINDOWPLACEMENT();
                            placement.length = Marshal.SizeOf(placement);
                            NativeHelper.GetWindowPlacement(hWnd, ref placement);
                            rect = placement.rcNormalPosition;
                        }
                        else
                        {
                            NativeHelper.GetWindowRect(hWnd, out rect);
                        }

                        if (rect.Width <= 0 || rect.Height <= 0) continue;

                        var overlay = CreateOverlayForWindow(app, hWnd, rect, isMinimized);
                        if (overlay != null) overlays.Add(overlay);
                    }
                }
                catch { }
            }
            return overlays;
        }

        private OverlayForm CreateOverlayForWindow(TargetApp app, IntPtr hWnd, NativeHelper.RECT rect, bool isMinimized)
        {
            IntPtr hPrev = NativeHelper.GetWindow(hWnd, NativeHelper.GW_HWNDPREV);
            Bitmap bmp = new Bitmap(rect.Width, rect.Height);

            if (!isMinimized)
            {
                using (Graphics g = Graphics.FromImage(bmp))
                {
                    IntPtr hdc = g.GetHdc();
                    try
                    {
                        if (!NativeHelper.PrintWindow(hWnd, hdc, NativeHelper.PW_RENDERFULLCONTENT))
                            NativeHelper.PrintWindow(hWnd, hdc, 0);
                    }
                    finally { g.ReleaseHdc(hdc); }
                }
            }

            NativeHelper.ShowWindow(hWnd, NativeHelper.SW_HIDE);

            var overlay = new OverlayForm(app, bmp, hWnd, UnfreezeApp, () => SaveSettings())
            {
                Location = new Point(rect.Left, rect.Top),
                Size = new Size(rect.Width, rect.Height),
                StartPosition = FormStartPosition.Manual
            };

            if (isMinimized)
            {
                overlay.WindowState = FormWindowState.Minimized;
            }

            overlay.Show();

            if (hPrev != IntPtr.Zero && !isMinimized)
            {
                NativeHelper.SetWindowPos(overlay.Handle, hPrev, 0, 0, 0, 0,
                    NativeHelper.SWP_NOMOVE | NativeHelper.SWP_NOSIZE | NativeHelper.SWP_NOACTIVATE);
            }
            return overlay;
        }

        private void RestoreOriginalWindow(OverlayForm overlay)
        {
            try
            {
                IntPtr originalHwnd = overlay.OriginalWindowHandle;
                bool isOverlayMinimized = overlay.WindowState == FormWindowState.Minimized;

                NativeHelper.ShowWindow(originalHwnd, NativeHelper.SW_SHOW);

                if (NativeHelper.IsIconic(originalHwnd) || isOverlayMinimized)
                {
                    NativeHelper.ShowWindow(originalHwnd, NativeHelper.SW_RESTORE);
                    NativeHelper.SetForegroundWindow(originalHwnd);
                }
                else
                {
                    NativeHelper.SetWindowPos(originalHwnd, IntPtr.Zero,
                        overlay.Location.X, overlay.Location.Y, 0, 0,
                        NativeHelper.SWP_NOSIZE | NativeHelper.SWP_NOZORDER | NativeHelper.SWP_SHOWWINDOW | NativeHelper.SWP_NOACTIVATE);
                }

                overlay.Close();
            }
            catch { }
        }

        private void UpdateAppState(TargetApp app, bool isFrozen)
        {
            app.IsFrozen = isFrozen;
            AppStateChanged?.Invoke(app);
        }

        private List<Process> GetProcessesByPath(string exePath)
        {
            var result = new List<Process>();
            if (string.IsNullOrWhiteSpace(exePath)) return result;

            string targetName = Path.GetFileNameWithoutExtension(exePath);

            var candidates = Process.GetProcessesByName(targetName).ToList();

            if (candidates.Count == 0)
            {
                try { candidates.AddRange(Process.GetProcesses()); } catch { }
            }

            var distinctCandidates = candidates.GroupBy(p => p.Id).Select(g => g.First()).ToList();

            var matchedPids = new HashSet<int>();
            foreach (var p in distinctCandidates)
            {
                try
                {
                    if (!IsProcessAliveSafe(p)) continue;
                    string currentPath = NativeHelper.GetRealProcessPath(p.Id);

                    if (!string.IsNullOrEmpty(currentPath) &&
                        string.Equals(currentPath, exePath, StringComparison.OrdinalIgnoreCase))
                    {
                        matchedPids.Add(p.Id);
                    }
                }
                catch { }
            }

            foreach (var p in distinctCandidates)
            {
                try { p.Dispose(); } catch { }
            }

            if (matchedPids.Count == 0) return result;

            var parentChildMap = NativeHelper.GetProcessParentChildrenMap();
            var pidsToProcess = new Queue<int>(matchedPids);
            var allPids = new HashSet<int>(matchedPids);

            while (pidsToProcess.Count > 0)
            {
                int currentPid = pidsToProcess.Dequeue();
                if (parentChildMap.TryGetValue(currentPid, out var children))
                {
                    foreach (var childId in children)
                    {
                        if (allPids.Add(childId)) pidsToProcess.Enqueue(childId);
                    }
                }
            }

            var finalResult = new List<Process>();
            foreach (var pid in allPids)
            {
                try
                {
                    var p = Process.GetProcessById(pid);
                    if (IsProcessAliveSafe(p))
                    {
                        finalResult.Add(p);
                    }
                    else
                    {
                        try { p.Dispose(); } catch { }
                    }
                }
                catch { }
            }
            return finalResult;
        }

        private bool IsProcessAliveSafe(Process p)
        {
            try
            {
                return !p.HasExited;
            }
            catch (System.ComponentModel.Win32Exception)
            {
                return IsProcessRunningViaNative(p.Id);
            }
            catch
            {
                return false;
            }
        }

        private bool IsProcessRunningViaNative(int pid)
        {
            IntPtr hProcess = IntPtr.Zero;
            try
            {
                hProcess = NativeHelper.OpenProcess(NativeHelper.PROCESS_QUERY_LIMITED_INFORMATION, false, pid);
                if (hProcess != IntPtr.Zero) return true;
            }
            catch { }
            finally
            {
                if (hProcess != IntPtr.Zero) NativeHelper.CloseHandle(hProcess);
            }
            return false;
        }

        private string GetSafeProcessPath(int pid)
        {
            return NativeHelper.GetRealProcessPath(pid);
        }

        private bool IsProcessSuspended(Process process)
        {
            try
            {
                process.Refresh();
                foreach (ProcessThread thread in process.Threads)
                {
                    if (thread.ThreadState == System.Diagnostics.ThreadState.Wait &&
                        thread.WaitReason == ThreadWaitReason.Suspended)
                    {
                        return true;
                    }
                }
            }
            catch
            {
                return false;
            }
            return false;
        }

        private void ProcessLinkedApps(string mainExePath, bool isSuspending)
        {
            if (Settings.LinkedApps == null) return;
            string mainExeName = Path.GetFileName(mainExePath).ToLower();
            if (!Settings.LinkedApps.ContainsKey(mainExeName)) return;

            var linkedList = Settings.LinkedApps[mainExeName];
            foreach (var linkedExe in linkedList)
            {
                if (string.IsNullOrWhiteSpace(linkedExe) || IsBlacklisted(linkedExe)) continue;
                string nameNoExt = Path.GetFileNameWithoutExtension(linkedExe);
                try
                {
                    var processes = Process.GetProcessesByName(nameNoExt);
                    foreach (var p in processes)
                    {
                        if (isSuspending) SuspendSingleProcess(p);
                        else ResumeSingleProcess(p);
                    }
                }
                catch { }
            }
        }
    }
}