App.xaml.cs

using System;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using Microsoft.Win32;

namespace KillerScan
{
    public partial class App : Application
    {
        // ============================================================
        // Paths
        // ============================================================

        private static readonly string AppName    = "KillerScan";
        private static readonly string ExeName    = "KillerScan.exe";
        private static readonly string InstallDir = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
            "Programs", AppName);
        private static readonly string InstallExe = Path.Combine(InstallDir, ExeName);

        // Machine-wide ("all users") install target. Used by the /silent path that winget, choco
        // and RMM call, and by the "Install for all users" checkbox in the confirm dialog.
        private static readonly string MachineInstallDir = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), AppName);
        private static readonly string MachineInstallExe = Path.Combine(MachineInstallDir, ExeName);

        private static readonly string StartMenuDir = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.Programs), AppName);
        private static readonly string StartMenuLnk = Path.Combine(StartMenuDir, $"{AppName}.lnk");
        private static readonly string DesktopLnk   = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), $"{AppName}.lnk");

        // ============================================================
        // Shell interop
        // ============================================================

        [DllImport("shell32.dll")]
        private static extern void SHChangeNotify(uint wEventId, uint uFlags, IntPtr dwItem1, IntPtr dwItem2);
        private const uint SHCNE_ASSOCCHANGED = 0x08000000;
        private const uint SHCNF_IDLIST       = 0x0000;

        // ============================================================
        // Startup
        // ============================================================

        protected override void OnStartup(StartupEventArgs e)
        {
            KillerFamily.Accessibility.AccessibleControls.Initialize();
            KillerFamily.Theming.AccentShadow.Initialize();
            Controls.AltDrag.Register();   // Alt+drag moves any window (Controls/AltDrag.cs)
            Services.AppTheme.Configure();
            base.OnStartup(e);
            if (e.Args.Length > 0 && string.Equals(e.Args[0], "/apply-verified-update", StringComparison.OrdinalIgnoreCase))
            {
                Shutdown(Services.TrustedUpdate.Apply(e.Args));
                return;
            }
            if (e.Args.Length > 0 && string.Equals(e.Args[0], "/complete-uninstall", StringComparison.OrdinalIgnoreCase))
            {
                Shutdown(e.Args.Length == 2 ? Services.UninstallCompletion.Complete(e.Args[1])
                    : KillerFamily.Deployment.InstallerExitCodes.Failure);
                return;
            }
            // Every window (dialogs, tools, pickers) takes the family UI face from the active theme
            // unless it sets its own, so no dialog falls back to the system Segoe UI.
            EventManager.RegisterClassHandler(typeof(Window), FrameworkElement.LoadedEvent, new RoutedEventHandler((s, _) =>
            {
                if (s is Window w && DependencyPropertyHelper.GetValueSource(w, Control.FontFamilyProperty).BaseValueSource == BaseValueSource.Default)
                    w.SetResourceReference(Control.FontFamilyProperty, "UiFont");
            }));
            Services.EngineHost.Configure();
            Shell.MainWindow.PublishGrainTile();   // install and uninstall dialogs open before any main window
            // Startup prompts can close before the main window exists.
            ShutdownMode = ShutdownMode.OnExplicitShutdown;

            // Force CPU (software) rendering. WPF composites through the GPU by default, and
            // console-session screen scrapers (ScreenConnect, LiveConnect, VNC, TeamViewer) can't
            // capture GPU-composited surfaces, so the window renders black in the remote view while
            // looking fine on the physical machine. Those tools aren't Terminal Services sessions,
            // so SM_REMOTESESSION is false and WPF never auto-falls-back on its own. Software
            // rendering lands every surface in the normal desktop framebuffer they can capture.
            // Cost is negligible for an app this light (static shadows/grain, short opacity fades).
            System.Windows.Media.RenderOptions.ProcessRenderMode =
                System.Windows.Interop.RenderMode.SoftwareOnly;

            // Silent install: KillerScan.exe /silent
            // No UI. With admin rights (winget/choco/RMM) it installs machine-wide to Program
            // Files; without them (the Microsoft Store) it installs for the current user.
            if (e.Args.Length > 0 &&
                string.Equals(e.Args[0], "/silent", StringComparison.OrdinalIgnoreCase))
            {
                Shutdown(DoSilentInstall());
                return;
            }

            // Handle uninstall flag (called by Add/Remove Programs)
            if (e.Args.Length > 0 &&
                (string.Equals(e.Args[0], "/uninstall", StringComparison.OrdinalIgnoreCase) ||
                 string.Equals(e.Args[0], "/uninstall-silent", StringComparison.OrdinalIgnoreCase) ||
                 string.Equals(e.Args[0], "/confirm-uninstall", StringComparison.OrdinalIgnoreCase)))
            {
                bool silent = string.Equals(e.Args[0], "/uninstall-silent", StringComparison.OrdinalIgnoreCase);
                if (!silent)
                {
                    Services.ThemeManager.InitializeInstaller();
                    Services.LocaleManager.Initialize();
                }
                Controls.TaskbarIdentity.UseUninstall();
                Shutdown(string.Equals(e.Args[0], "/confirm-uninstall", StringComparison.OrdinalIgnoreCase)
                    ? ConfirmUninstall() : Uninstall(silent));
                return;
            }

            // Elevated half of the dual-install repair below: removes the machine-wide copy.
            if (e.Args.Length > 0 &&
                string.Equals(e.Args[0], "/remove-machine-conflict", StringComparison.OrdinalIgnoreCase))
            {
                try { RemoveMachineInstallConflict(); Shutdown(0); }
                catch (Exception error) { Console.Error.WriteLine(error.Message); Shutdown(KillerFamily.Deployment.InstallerExitCodes.FromException(error)); }
                return;
            }

            int uiScanIndex = Features.Cli.CliRunner.UiScanIndex(e.Args);
            bool startUiScan = uiScanIndex >= 0;
            string? uiScanTarget = startUiScan
                ? string.Join(",", e.Args.Skip(uiScanIndex + 1))
                : null;

            // Headless command line: /scan, /help, /version (Features/Cli/CliRunner.cs). Handled
            // before anything builds a window, so a CLI run never shows one and works while a GUI
            // instance is already open. Arguments carrying no recognized command fall through to
            // the normal launch below. /uiscan deliberately bypasses this path and opens the UI.
            if (!startUiScan && Features.Cli.CliRunner.TryRunCli(e.Args, out int cliExit))
            {
                Shutdown(cliExit);
                return;
            }

            // Demo / screenshot mode: KillerScan.exe --demo fills the grid with fabricated
            // devices so screenshots carry no real network data.
            Services.DemoData.Enabled = Array.Exists(e.Args, a =>
                string.Equals(a, "--demo", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(a, "/demo",  StringComparison.OrdinalIgnoreCase));

            // Standalone startup prompts use the installer palette.
            Services.ThemeManager.InitializeInstaller();
            Services.LocaleManager.Initialize();

            if (!Services.IsolatedSettings.Enabled) OfferInstallConflictRepair();

            // Restore the saved theme before building the main window.
            KillerFamily.Layout.ShortcutHints.Initialize(GetSetting, SetSetting);
            Services.ThemeManager.Initialize();
            Services.FilmGrain.Initialize();   // after the theme, before the window is built
            ShutdownMode = ShutdownMode.OnLastWindowClose;
            MainWindow = new Shell.MainWindow(uiScanTarget, startUiScan);
            MainWindow.Show();
        }

        // ============================================================
        // Public surface used by MainWindow (portable badge / install)
        // ============================================================

        /// <summary>
        /// True when running from outside EITHER installed location (i.e. portable mode).
        /// Must check the machine-wide path as well as the per-user one: a /silent install from
        /// winget, choco or an RMM lands in Program Files, and comparing only against the
        /// per-user path made those properly-installed copies show the PORTABLE badge and the
        /// Install button.
        /// </summary>
        internal static bool IsPortable()
        {
            string currentExe = Process.GetCurrentProcess().MainModule!.FileName;
            return !string.Equals(currentExe, InstallExe, StringComparison.OrdinalIgnoreCase)
                && !string.Equals(currentExe, MachineInstallExe, StringComparison.OrdinalIgnoreCase);
        }

        /// <summary>True when a machine-wide copy is already present on disk.</summary>
        internal static bool MachineInstallExists() => File.Exists(MachineInstallExe);

        /// <summary>Localized install messages, with a fallback for headless error output.</summary>
        private static string L(string key, string fallback) =>
            Current?.TryFindResource(key) as string ?? fallback;

        /// <summary>Repairs a machine that carries BOTH a per-user and a machine-wide install -
        /// the state where each Add/Remove Programs entry describes the other copy's version and
        /// launching gets whichever exe the shell resolves first. Detected at startup; offers to
        /// remove whichever copy is NOT running. Removing the machine copy needs elevation, so
        /// that path re-runs this exe with /remove-machine-conflict under UAC.</summary>
        private static void OfferInstallConflictRepair()
        {
            if (!File.Exists(InstallExe) || !File.Exists(MachineInstallExe)) return;
            string current = Process.GetCurrentProcess().MainModule?.FileName ?? "";
            bool runningMachine = string.Equals(current, MachineInstallExe, StringComparison.OrdinalIgnoreCase);
            bool runningUser = string.Equals(current, InstallExe, StringComparison.OrdinalIgnoreCase);
            if (!runningMachine && !runningUser) return;

            // Two whole sentences rather than one with the scope substituted in: languages that
            // inflect the noun cannot take "per-user" or "all-users" as a drop-in word.
            string body = runningMachine
                ? L("Str_Conflict_RemoveUser", "KillerScan is installed twice. Remove the other per-user copy now?\n\nYour settings will not be removed.")
                : L("Str_Conflict_RemoveMachine", "KillerScan is installed twice. Remove the other all-users copy now?\n\nYour settings will not be removed.");
            var confirm = new Controls.ConfirmDialog(
                L("Str_Conflict_Title", "installation conflict"), body,
                L("Str_Uninstall_Title", "Uninstall"), L("Str_Btn_Cancel", "Cancel"));
            confirm.ShowDialog();
            if (!confirm.Confirmed) return;

            if (runningMachine)
            {
                try { RemovePerUserInstall(); }
                catch (Exception error) { Controls.ConfirmDialog.ShowNotice(error.Message); }
            }
            else
            {
                try
                {
                    using var p = Process.Start(new ProcessStartInfo(current, "/remove-machine-conflict")
                    { UseShellExecute = true, Verb = "runas" });
                    p?.WaitForExit();
                }
                catch { /* declining UAC leaves both copies in place */ }
            }
        }

        private static void RemoveMachineInstallConflict()
        {
            using var lease = KillerFamily.Deployment.InstallerExitCodes.Acquire(AppName);
            Services.UninstallCompletion.RemoveOwned(machine: true);
            Services.InstallationFiles.RemoveEmpty(MachineInstallDir);
        }

        /// <summary>
        /// Installs KillerScan, then relaunches from the installed location.
        /// For an all-users install the app re-runs itself elevated with /silent - the same
        /// machine-wide path winget and choco already use - so UAC only appears when the user
        /// actually ticked the box. Returns false if elevation was declined; other failures
        /// propagate to the installation error dialog without shutting down the app.
        /// </summary>
        internal static bool InstallAndRelaunch(bool wantDesktop, bool allUsers)
        {
            if (allUsers)
            {
                if (!RunElevatedSilentInstall()) return false;

                // One install only: drop the per-user copy now that a machine-wide one exists.
                // Done from THIS (unelevated) process so it removes the invoking user's profile
                // copy, which an elevated process might not resolve to. The machine install already
                // succeeded, so a copy that cannot be removed (no registration, files in use) must not
                // turn that into a reported failure; the conflict prompt offers it again at next start.
                try { RemovePerUserInstall(); }
                catch (Exception error) { Debug.WriteLine("Per-user cleanup after machine install: " + error.Message); }

                Process.Start(new ProcessStartInfo(MachineInstallExe));
                Application.Current.Shutdown();
                return true;
            }

            DoInstall(wantDesktop);
            Process.Start(new ProcessStartInfo(InstallExe));
            Application.Current.Shutdown();
            return true;
        }

        /// <summary>Re-run this exe elevated with /silent and wait for it to finish.</summary>
        private static bool RunElevatedSilentInstall()
        {
            try
            {
                var psi = new ProcessStartInfo(Process.GetCurrentProcess().MainModule!.FileName, "/silent")
                {
                    UseShellExecute = true,
                    Verb = "runas",          // triggers the UAC prompt
                };
                using var p = Process.Start(psi);
                p?.WaitForExit();
                if (p is null) throw new System.ComponentModel.Win32Exception(1067);
                if (p.ExitCode != 0) throw new System.ComponentModel.Win32Exception(p.ExitCode);
                if (!File.Exists(MachineInstallExe)) throw new FileNotFoundException(null, MachineInstallExe);
                return true;
            }
            catch (System.ComponentModel.Win32Exception ex) when (ex.NativeErrorCode == 1223)
            {
                // Declining the UAC prompt throws Win32Exception 1223 (ERROR_CANCELLED).
                return false;
            }
        }

        /// <summary>Remove a per-user install: files, shortcuts, and its HKCU marker.
        /// Settings under Software\KillerScan\Settings are deliberately left alone so theme,
        /// accent, locale and window placement survive the move to a machine-wide install.</summary>
        private static void RemovePerUserInstall()
        {
            if (!Directory.Exists(InstallDir)) return;
            using var lease = KillerFamily.Deployment.InstallerExitCodes.Acquire(AppName);
            Services.UninstallCompletion.RemoveOwned(machine: false);
            Services.InstallationFiles.RemoveEmpty(InstallDir);
        }

        // ============================================================
        // Registry helpers
        // ============================================================

        private static bool IsInstalled()
        {
            using var key = Registry.CurrentUser.OpenSubKey(@"Software\KillerScan");
            if (key is null) return false;
            return key.GetValue("Installed") is int i && i == 1;
        }

        // ============================================================
        // Preference store  (Software\KillerScan\Settings)
        // Mirrors KillerPDF: simple per-user string settings, used by
        // ThemeManager / LocaleManager to persist theme, accent, and locale.
        // ============================================================

        internal static string? GetSetting(string name)
        {
            if (Services.IsolatedSettings.Enabled) return Services.IsolatedSettings.Get(name);
            try
            {
                using var key = Registry.CurrentUser.OpenSubKey(@"Software\KillerScan\Settings");
                return key?.GetValue(name) as string;
            }
            catch { return null; }
        }

        internal static void SetSetting(string name, string value)
        {
            if (Services.IsolatedSettings.Enabled) { Services.IsolatedSettings.Set(name, value); return; }
            try
            {
                using var key = Registry.CurrentUser.CreateSubKey(@"Software\KillerScan\Settings");
                key?.SetValue(name, value);
            }
            catch { /* best-effort */ }
        }

        internal static void RemoveSetting(string name)
        {
            if (Services.IsolatedSettings.Enabled) { Services.IsolatedSettings.Set(name, null); return; }
            try
            {
                using var key = Registry.CurrentUser.OpenSubKey(@"Software\KillerScan\Settings", writable: true);
                key?.DeleteValue(name, throwOnMissingValue: false);
            }
            catch { /* best-effort */ }
        }

        // ============================================================
        // Installation
        // ============================================================

        // ============================================================
        // Silent install, used by winget / choco / RMM and the Microsoft Store
        // ============================================================

        private static int DoSilentInstall()
        {
            try
            {
                using var installLease = KillerFamily.Deployment.InstallerExitCodes.Acquire(AppName);

                // An unsigned or tampered exe must not be able to write itself into
                // Program Files, least of all while elevated.
                var (valid, _, _) = Services.CodeSignature.GetSignerInfo();
                if (!valid)
                {
                    Console.Error.WriteLine("Silent install refused: EXE has no valid Authenticode signature.");
                    return KillerFamily.Deployment.InstallerExitCodes.SecurityRejected;
                }

                // Without admin rights, as the Microsoft Store runs installers, this is the normal
                // per-user install with no prompt. The app never needs admin rights.
                if (!KillerFamily.Deployment.InstallerExitCodes.IsElevated())
                {
                    DoInstall(wantDesktop: false);
                    return KillerFamily.Deployment.InstallerExitCodes.Success;
                }

                string installDir = Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), AppName);
                string installExe = Path.Combine(installDir, ExeName);
                string startMenuDir = Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.CommonPrograms), AppName);
                string startMenuLnk = Path.Combine(startMenuDir, $"{AppName}.lnk");

                Directory.CreateDirectory(installDir);
                string src = Process.GetCurrentProcess().MainModule!.FileName;
                Services.ExecutableDeployment.Install(src, installExe);
                AddToPath(installDir, EnvironmentVariableTarget.Machine);

                Directory.CreateDirectory(startMenuDir);
                CreateShortcut(startMenuLnk, installExe);

                string version = Assembly.GetExecutingAssembly().GetName().Version?.ToString(3) ?? "";

                using (var key = Registry.LocalMachine.CreateSubKey(@"Software\KillerScan"))
                {
                    key.SetValue("Installed",   1);
                    key.SetValue("InstallPath", installExe);
                    key.SetValue("Version",     version);
                }

                using (var key = Registry.LocalMachine.CreateSubKey(
                    @"Software\Microsoft\Windows\CurrentVersion\Uninstall\KillerScan"))
                {
                    key.SetValue("DisplayName",          AppName);
                    key.SetValue("DisplayVersion",       version);
                    key.SetValue("Publisher",            "Steve the Killer");
                    key.SetValue("InstallLocation",      installDir);
                    key.SetValue("DisplayIcon",          $"{installExe},0");
                    key.SetValue("UninstallString",      Services.UninstallCompletion.Command(machine: true, silent: false));
                    key.SetValue("QuietUninstallString", Services.UninstallCompletion.Command(machine: true, silent: true));
                    key.SetValue("NoModify",             1);
                    key.SetValue("NoRepair",             1);
                }
                return KillerFamily.Deployment.InstallerExitCodes.Success;
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"Silent install failed: {ex.Message}");
                return KillerFamily.Deployment.InstallerExitCodes.FromException(ex);
            }
        }

        private static void DoInstall(bool wantDesktop)
        {
            try
            {
                using var lease = KillerFamily.Deployment.InstallerExitCodes.Acquire(AppName);
                Directory.CreateDirectory(InstallDir);
                string src = Process.GetCurrentProcess().MainModule!.FileName;
                Services.ExecutableDeployment.Install(src, InstallExe);
                AddToPath(InstallDir, EnvironmentVariableTarget.User);

                Directory.CreateDirectory(StartMenuDir);
                CreateShortcut(StartMenuLnk, InstallExe);
                if (wantDesktop)
                    CreateShortcut(DesktopLnk, InstallExe);

                using (var key = Registry.CurrentUser.CreateSubKey(@"Software\KillerScan"))
                {
                    key.SetValue("Installed",   1);
                    key.SetValue("InstallPath", InstallExe);
                    key.SetValue("Version",
                        Assembly.GetExecutingAssembly().GetName().Version?.ToString(3) ?? "");
                }

                using (var key = Registry.CurrentUser.CreateSubKey(
                    @"Software\Microsoft\Windows\CurrentVersion\Uninstall\KillerScan"))
                {
                    key.SetValue("DisplayName",          AppName);
                    key.SetValue("DisplayVersion",
                        Assembly.GetExecutingAssembly().GetName().Version?.ToString(3) ?? "");
                    key.SetValue("Publisher",            "Steve the Killer");
                    key.SetValue("InstallLocation",      InstallDir);
                    key.SetValue("DisplayIcon",          $"{InstallExe},0");
                    key.SetValue("UninstallString",      Services.UninstallCompletion.Command(machine: false, silent: false));
                    key.SetValue("QuietUninstallString", Services.UninstallCompletion.Command(machine: false, silent: true));
                    key.SetValue("NoModify",             1);
                    key.SetValue("NoRepair",             1);
                }
            }
            catch (Exception ex)
            {
                throw new IOException(ex.Message, ex);
            }
        }

        private static void CreateShortcut(string lnkPath, string targetPath)
        {
            try
            {
                var shellType = Type.GetTypeFromProgID("WScript.Shell");
                if (shellType is null) return;
                dynamic shell    = Activator.CreateInstance(shellType)!;
                dynamic shortcut = shell.CreateShortcut(lnkPath);
                shortcut.TargetPath       = targetPath;
                shortcut.WorkingDirectory = Path.GetDirectoryName(targetPath);
                shortcut.Save();
            }
            catch { /* best-effort */ }
        }

        /// <summary>Add an install directory to PATH exactly once. The self-installer updates the
        /// current user; the elevated silent installer updates the machine, so a new terminal can
        /// invoke the app as simply "KillerScan" from any directory.</summary>
        private static void AddToPath(string directory, EnvironmentVariableTarget target) =>
            Services.CommandLinePath.Register(directory, target == EnvironmentVariableTarget.Machine);

        /// <summary>Remove every spelling of an install directory from PATH without disturbing
        /// entries belonging to other programs.</summary>
        private static void RemoveFromPath(string directory, EnvironmentVariableTarget target) =>
            Services.CommandLinePath.Unregister(directory, target == EnvironmentVariableTarget.Machine);

        // ============================================================
        // Uninstall
        // ============================================================

        private static int ConfirmUninstall()
        {
            var confirm = new Controls.ConfirmDialog(
                L("Str_Uninstall_Confirm", "Uninstall KillerScan from this computer?"), string.Empty,
                L("Str_Uninstall_Title", "Uninstall"), L("Str_Btn_Cancel", "Cancel"));
            confirm.ShowDialog();
            return confirm.Confirmed ? 0 : KillerFamily.Deployment.InstallerExitCodes.Cancelled;
        }

        private static int Uninstall(bool silent)
        {
            string currentExe = Process.GetCurrentProcess().MainModule!.FileName;
            bool machineInstall = string.Equals(currentExe, MachineInstallExe, StringComparison.OrdinalIgnoreCase);
            if (silent)
            {
                Console.Error.WriteLine("The loaded installation cannot complete its own removal. Run the registered QuietUninstallString and wait for its exit code. No files were removed.");
                return KillerFamily.Deployment.InstallerExitCodes.Busy;
            }
            int confirmation = ConfirmUninstall();
            if (confirmation != 0) return confirmation;
            try
            {
                using var parent = Process.GetCurrentProcess();
                using var helper = Process.Start(Services.UninstallCompletion.StartInfo(machineInstall, silent: true,
                    parent.Id, parent.StartTime.ToUniversalTime().Ticks));
                if (helper == null) throw new IOException("The uninstall completion helper did not start.");
                return 0;
            }
            catch (Exception error)
            {
                Controls.ConfirmDialog.ShowNotice(error.Message);
                return KillerFamily.Deployment.InstallerExitCodes.FromException(error);
            }
        }
    }
}