using System.Runtime.Versioning;
using DodoSSH.Client.Session;
using Microsoft.Win32;

namespace DodoSSH.Client.App.Platform;

/// <summary>
/// Registers this executable as the handler for <c>dodossh://</c> links, for this user, on Windows.
/// </summary>
/// <remarks>
/// <para>
/// <b>Under HKCU\Software\Classes, because the install is per user.</b> Velopack installs into the user's
/// own profile with no elevation, and a handler registered machine-wide would need the elevation the
/// installer deliberately never asks for. Windows merges this key into <c>HKEY_CLASSES_ROOT</c> for the
/// user, which is all a browser consults.
/// </para>
/// <para>
/// <b>Written by Velopack's install and update hooks, removed by its uninstall hook</b> — see
/// <c>Program.Main</c>. An update rewrites it because the first update to a build that has this is how an
/// existing installation gets it at all, and because it costs nothing to say again.
/// </para>
/// <para>
/// <b>Removed only when it is still ours.</b> The release and the nightly are separate installations that
/// both answer <c>dodossh://</c>, and the last one installed holds the key. Uninstalling the other must not
/// take the handler away from the one that is still there.
/// </para>
/// </remarks>
[SupportedOSPlatform("windows")]
internal static class WindowsUrlScheme
{
    private const string KeyPath = @"Software\Classes\" + SpelunkLink.Scheme;
    private const string CommandPath = @"shell\open\command";

    /// <summary>Points <c>dodossh://</c> at <paramref name="executable"/>.</summary>
    internal static void Register(string executable)
    {
        using var scheme = Registry.CurrentUser.CreateSubKey(KeyPath);

        scheme.SetValue(string.Empty, "URL:DodoSSH");

        // Empty, and its presence is the whole of it: this value is what makes the key a URL scheme rather
        // than a file type.
        scheme.SetValue("URL Protocol", string.Empty);

        using (var icon = scheme.CreateSubKey("DefaultIcon"))
        {
            icon.SetValue(string.Empty, $"\"{executable}\",0");
        }

        using var command = scheme.CreateSubKey(CommandPath);

        command.SetValue(string.Empty, CommandFor(executable));
    }

    /// <summary>Takes the handler away, if it is still <paramref name="executable"/>'s.</summary>
    internal static void Unregister(string executable)
    {
        string? registered;

        using (var command = Registry.CurrentUser.OpenSubKey($@"{KeyPath}\{CommandPath}"))
        {
            registered = command?.GetValue(string.Empty) as string;
        }

        if (IsOurs(registered, executable))
        {
            Registry.CurrentUser.DeleteSubKeyTree(KeyPath, throwOnMissingSubKey: false);
        }
    }

    /// <summary>The command Windows runs for a link: this executable, with the link as its one argument.</summary>
    /// <remarks>
    /// Both halves quoted. The path has spaces in it on any profile whose user name does, and the link is
    /// handed over whole as <c>%1</c> — which Windows quotes into one argument only because it is quoted
    /// here. Program.Main then reads it back and checks it before anything acts on it.
    /// </remarks>
    internal static string CommandFor(string executable) => $"\"{executable}\" \"%1\"";

    /// <summary>Whether a registered command is the one <see cref="Register"/> writes for this executable.</summary>
    internal static bool IsOurs(string? registered, string executable) =>
        string.Equals(registered, CommandFor(executable), StringComparison.OrdinalIgnoreCase);
}