using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Threading.Channels;

namespace NpgsqlRestClient;

/// <summary>
/// Server watch mode (`--watch` without `--test`): this process becomes a tiny SUPERVISOR that never
/// builds the server itself — it spawns this same executable as a CHILD (marked via an environment
/// variable), watches the SqlFileSource tree and the configuration files, and restarts the child on
/// every debounced change. The child runs the completely normal server pipeline (production parity),
/// with one relaxation: SqlFileSource ErrorMode is forced from Exit to Skip so a broken SQL file logs
/// its error and drops that endpoint instead of killing the server (see App.CreateEndpointSources).
///
/// Design notes:
/// - A child process (vs. in-process rebuild) guarantees clean state: Kestrel's port binding and
///   ASP.NET's route table cannot be torn down in-process (routes can be added, never removed), and
///   static caches would accumulate. This is the same conclusion `dotnet watch` and nodemon reached.
///   The in-process hot-swap upgrade is designed in scrap/WATCH_HOT_SWAP_PLAN.md (target 3.20).
/// - Graceful stop: SIGTERM via libc on Unix (Process.Kill would be SIGKILL), hard kill fallback after
///   a timeout; on Windows there is no SIGTERM for console children — hard process-tree kill, which is
///   acceptable here because a dev server holds nothing that needs teardown.
/// - The child runs a parent WATCHDOG: if the supervisor dies without stopping it (SIGKILL, a wrapper
///   runner like `bun run` murdering the process group), the child exits by itself — no orphan holding
///   the port.
/// </summary>
public static class WatchSupervisor
{
    /// <summary>Set on the child process; the value is the supervisor's PID (for the parent watchdog).</summary>
    public const string ChildEnv = "NPGSQLREST_WATCH_CHILD";

    public static bool IsChild { get; } = string.IsNullOrEmpty(Environment.GetEnvironmentVariable(ChildEnv)) is false;

    /// <summary>Child exit code meaning "the database poller detected a change — respawn me immediately".</summary>
    public const int DbChangeExitCode = 64;

    // Blittable signature — plain DllImport is AOT-safe here and avoids AllowUnsafeBlocks.
    [DllImport("libc", SetLastError = true, EntryPoint = "kill")]
    private static extern int kill(int pid, int sig);
    private const int SIGTERM = 15;

    /// <summary>
    /// Called in the CHILD: exit when the supervisor process disappears without stopping us first,
    /// so a SIGKILLed supervisor never leaves an orphaned server holding the port.
    /// </summary>
    public static void StartParentWatchdog()
    {
        if (int.TryParse(Environment.GetEnvironmentVariable(ChildEnv), out var parentPid) is false)
        {
            return;
        }
        var thread = new Thread(() =>
        {
            try
            {
                Process.GetProcessById(parentPid).WaitForExit();
            }
            catch
            {
                // already gone
            }
            Environment.Exit(143);
        })
        {
            IsBackground = true,
            Name = "watch-parent-watchdog",
        };
        thread.Start();
    }

    /// <summary>Supervisor main loop. Returns the process exit code.</summary>
    public static async Task<int> RunAsync(Config config, string[] args)
    {
        var output = new Out();

        // Something to watch? A SqlFileSource tree, database catalog polling, or both.
        var sqlFileCfg = config.NpgsqlRestCfg.GetSection("SqlFileSource");
        string? filePattern = null;
        if (sqlFileCfg.Exists() && config.GetConfigBool("Enabled", sqlFileCfg, true))
        {
            filePattern = config.GetConfigStr("FilePattern", sqlFileCfg);
        }
        // Database polling (the child does the actual polling by hashing the routine discovery query;
        // the supervisor needs the value for validation and the banner). With polling active, --watch is
        // valid even without a SQL file source — a routines-only project restarts on create/replace/drop/
        // comment. Polling is only meaningful when the routine source itself is enabled.
        var dbPollInterval = Builder.ParseTestTimeout(
            config.GetConfigStr("DatabasePollingInterval", config.Cfg.GetSection("Watch")), TimeSpan.FromSeconds(2));
        var routineOptionsCfg = config.NpgsqlRestCfg.GetSection("RoutineOptions");
        if (routineOptionsCfg.Exists() && config.GetConfigBool("Enabled", routineOptionsCfg, true) is false)
        {
            dbPollInterval = TimeSpan.Zero;
        }

        string? baseDirFull = null;
        var skipPattern = "*.test.sql";
        if (string.IsNullOrWhiteSpace(filePattern) is false)
        {
            var baseDir = WatchUtils.GetWatchBaseDir(filePattern);
            if (baseDir is null)
            {
                output.LineAnsi(
                    $"watch: cannot watch — SqlFileSource FilePattern \"{filePattern}\" has no existing base directory.",
                    Testing.TestRunner.AnsiFail);
                return 1;
            }
            baseDirFull = Path.GetFullPath(baseDir);
            skipPattern = (config.GetConfigStr("SkipPattern", sqlFileCfg) ?? "*.test.sql").Replace('\\', '/');
        }
        else if (dbPollInterval <= TimeSpan.Zero)
        {
            output.LineAnsi(
                "watch: nothing to watch — --watch without --test requires an enabled SqlFileSource with a FilePattern and/or database polling (Watch:DatabasePollingInterval). For test watch mode use --test --watch.",
                Testing.TestRunner.AnsiFail);
            return 1;
        }

        // Config files restart the server too: the .json/.jsonc files passed on the command line, plus
        // the implicit default when present.
        var configFiles = args
            .Where(a => a.StartsWith('-') is false
                && (a.EndsWith(".json", StringComparison.OrdinalIgnoreCase) || a.EndsWith(".jsonc", StringComparison.OrdinalIgnoreCase))
                && File.Exists(a))
            .Select(Path.GetFullPath)
            .ToList();
        if (File.Exists("appsettings.json"))
        {
            configFiles.Add(Path.GetFullPath("appsettings.json"));
        }
        configFiles = [.. configFiles.Distinct(StringComparer.Ordinal)];
        var configFileSet = new HashSet<string>(configFiles, StringComparer.Ordinal);

        using var stop = new CancellationTokenSource();
        bool stopping = false;
        void OnSignal(PosixSignalContext ctx)
        {
            // The child receives Ctrl+C from the terminal group by itself; for SIGTERM (docker stop,
            // where only PID 1 is signalled) the shutdown path below forwards the stop to the child.
            ctx.Cancel = true;
            stopping = true;
            stop.Cancel();
        }
        using var sigInt = PosixSignalRegistration.Create(PosixSignal.SIGINT, OnSignal);
        using var sigTerm = PosixSignalRegistration.Create(PosixSignal.SIGTERM, OnSignal);

        // Watchers (or the polling fallback for bind-mount environments) feed one debounced channel.
        var changes = Channel.CreateUnbounded<string>();
        var watchers = new List<FileSystemWatcher>();
        bool polling = WatchUtils.UsePollingWatcher;
        if (polling)
        {
            WatchUtils.StartPollingWatcher(baseDirFull ?? "", configFiles, changes.Writer, stop.Token);
        }
        else
        {
            if (baseDirFull is not null)
            {
                watchers.Add(WatchUtils.NewSqlWatcher(baseDirFull, changes.Writer));
            }
            foreach (var dir in configFiles.Select(Path.GetDirectoryName).Where(d => d is not null).Distinct(StringComparer.Ordinal))
            {
                var w = new FileSystemWatcher(dir!)
                {
                    NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.Size,
                };
                void OnFsEvent(object s, FileSystemEventArgs e)
                {
                    if (configFileSet.Contains(e.FullPath))
                    {
                        changes.Writer.TryWrite(e.FullPath);
                    }
                }
                w.Changed += OnFsEvent;
                w.Created += OnFsEvent;
                w.Renamed += (s, e) => { if (configFileSet.Contains(e.FullPath)) changes.Writer.TryWrite(e.FullPath); };
                w.EnableRaisingEvents = true;
                watchers.Add(w);
            }
        }

        var watchingParts = new List<string>(3);
        if (baseDirFull is not null)
        {
            watchingParts.Add($"{Path.GetRelativePath(Environment.CurrentDirectory, baseDirFull)} (*.sql)");
        }
        if (configFiles.Count > 0)
        {
            watchingParts.Add("config files");
        }
        if (dbPollInterval > TimeSpan.Zero)
        {
            watchingParts.Add($"database (poll {dbPollInterval.TotalSeconds:0.#}s)");
        }
        var watchingWhat = string.Join(" + ", watchingParts) + (polling ? " [polling]" : "");
        output.Line($"watch mode: supervising the server process, watching {watchingWhat} — Ctrl+C to stop", ConsoleColor.Cyan);

        Process child = Spawn(args);
        Task exitTask = child.WaitForExitAsync(CancellationToken.None);
        // The pending batch survives iterations that don't consume it (e.g. a database-change respawn),
        // so the channel never has two competing readers.
        Task<List<string>?>? pendingBatch = null;

        try
        {
            while (stopping is false)
            {
                pendingBatch ??= WatchUtils.NextChangeBatchAsync(changes.Reader, stop.Token);
                var completed = await Task.WhenAny(exitTask, pendingBatch);

                if (stopping)
                {
                    break;
                }

                if (completed == exitTask && pendingBatch.IsCompleted is false)
                {
                    if (child.ExitCode == DbChangeExitCode)
                    {
                        // The child's database poller detected a routine/annotation change and asked to be
                        // restarted.
                        output.Line($"\n— {DateTime.Now:HH:mm:ss} database change detected — restarting —", ConsoleColor.Cyan);
                        child = Spawn(args);
                        exitTask = child.WaitForExitAsync(CancellationToken.None);
                        continue;
                    }
                    // The child died on its own (crash, config error, port conflict). Don't respawn in a
                    // loop — hold until the next file change, then try again.
                    output.Line($"\nserver exited (code {child.ExitCode}) — waiting for file changes", ConsoleColor.Yellow);
                    var wakeBatch = await pendingBatch;
                    pendingBatch = null;
                    if (wakeBatch is null || stopping)
                    {
                        break;
                    }
                    if (Relevant(wakeBatch, baseDirFull, skipPattern, configFileSet) is not { } wakeTrigger)
                    {
                        // Irrelevant change (e.g. a *.test.sql edit) — keep holding.
                        continue;
                    }
                    output.Line($"— {DateTime.Now:HH:mm:ss} change detected ({wakeTrigger}) — restarting —", ConsoleColor.Cyan);
                    child = Spawn(args);
                    exitTask = child.WaitForExitAsync(CancellationToken.None);
                    continue;
                }

                var batch = await pendingBatch;
                pendingBatch = null;
                if (batch is null)
                {
                    break;
                }
                if (Relevant(batch, baseDirFull, skipPattern, configFileSet) is not { } trigger)
                {
                    continue;
                }
                output.Line($"\n— {DateTime.Now:HH:mm:ss} change detected ({trigger}) — restarting —", ConsoleColor.Cyan);
                StopChild(child);
                child = Spawn(args);
                exitTask = child.WaitForExitAsync(CancellationToken.None);
            }
            return 0;
        }
        finally
        {
            foreach (var w in watchers)
            {
                w.Dispose();
            }
            StopChild(child);
        }
    }

    /// <summary>
    /// First relevant path in the batch (cwd-relative, for display), or null when the whole batch is
    /// noise. Relevant: a config file, or a *.sql file under the watched tree that matches the
    /// SqlFileSource FilePattern and does NOT match SkipPattern (a test-file edit must not bounce the
    /// server).
    /// </summary>
    private static string? Relevant(List<string> batch, string? baseDirFull, string skipPattern, HashSet<string> configFileSet)
    {
        foreach (var path in batch.Distinct(StringComparer.Ordinal))
        {
            var full = Path.GetFullPath(path);
            var rel = Path.GetRelativePath(Environment.CurrentDirectory, full).Replace('\\', '/');
            if (configFileSet.Contains(full))
            {
                return rel;
            }
            if (baseDirFull is not null
                && full.StartsWith(baseDirFull, StringComparison.Ordinal)
                && rel.EndsWith(".sql", StringComparison.OrdinalIgnoreCase)
                && WatchUtils.MatchesCwdRelativePattern(rel, skipPattern) is false)
            {
                return rel;
            }
        }
        return null;
    }

    private static Process Spawn(string[] args)
    {
        var exe = Environment.ProcessPath ?? "dotnet";
        var psi = new ProcessStartInfo(exe)
        {
            UseShellExecute = false, // stdout/stderr inherited — the child's logs are the console output
        };
        // Under `dotnet NpgsqlRestClient.dll ...` ProcessPath is the dotnet host; argv[0] is the dll path.
        if (string.Equals(Path.GetFileNameWithoutExtension(exe), "dotnet", StringComparison.OrdinalIgnoreCase))
        {
            psi.ArgumentList.Add(Environment.GetCommandLineArgs()[0]);
        }
        foreach (var a in args)
        {
            psi.ArgumentList.Add(a);
        }
        psi.Environment[ChildEnv] = Environment.ProcessId.ToString();
        return Process.Start(psi)!;
    }

    private static void StopChild(Process child)
    {
        try
        {
            if (child.HasExited)
            {
                return;
            }
            if (OperatingSystem.IsWindows())
            {
                // No SIGTERM for console children on Windows; a dev server has nothing needing teardown.
                child.Kill(entireProcessTree: true);
            }
            else
            {
                kill(child.Id, SIGTERM); // graceful: Kestrel drains and stops
                if (child.WaitForExit(5000) is false)
                {
                    child.Kill(entireProcessTree: true);
                }
            }
            child.WaitForExit();
        }
        catch
        {
            // already gone
        }
    }
}