using System.Threading.Channels;

using NpgsqlRest;

namespace NpgsqlRestClient;

/// <summary>

/// Shared file-watching primitives used by both watch modes: the test runner's in-process watch

/// (<see cref="Testing.TestRunner"/>) and the server watch supervisor (<see cref="WatchSupervisor"/>).

/// </summary>

public static class WatchUtils

{

/// <summary>A cwd-relative path against a cwd-relative glob (leading "./" tolerated on the pattern).</summary>

public static bool MatchesCwdRelativePattern(string relativePath, string pattern)

{

pattern = pattern.Replace('\\', '/');

if (pattern.StartsWith("./"))

{

pattern = pattern[2..];

}

return Parser.IsPatternMatch(relativePath, pattern);

}

/// <summary>

/// The deepest fixed (wildcard-free) directory of a glob pattern — same logic file discovery uses.

/// Null when the directory does not exist.

/// </summary>

public static string? GetWatchBaseDir(string pattern)

{

if (string.IsNullOrWhiteSpace(pattern))

{

return null;

}

int firstWildcard = pattern.IndexOfAny(['*', '?']);

if (firstWildcard < 0)

{

var dir = Path.GetDirectoryName(pattern);

return string.IsNullOrEmpty(dir) ? "." : dir;

}

int lastSlash = pattern.LastIndexOf('/', firstWildcard);

var baseDir = lastSlash >= 0 ? pattern[..lastSlash] : ".";

return Directory.Exists(baseDir) ? baseDir : null;

}

/// <summary>

/// First change (blocking), then a quiet period so editor write bursts coalesce into one batch.

/// Returns null when cancelled.

/// </summary>

public static async Task<List<string>?> NextChangeBatchAsync(ChannelReader<string> reader, CancellationToken ct)

{

string first;

try

{

first = await reader.ReadAsync(ct);

}

catch (OperationCanceledException)

{

return null;

}

var batch = new List<string> { first };

while (true)

{

try { await Task.Delay(300, ct); } catch (OperationCanceledException) { return null; }

bool any = false;

while (reader.TryRead(out var more))

{

batch.Add(more);

any = true;

}

if (!any) return batch;

}

}

/// <summary>

/// A recursive *.sql FileSystemWatcher over a directory, feeding full paths into the channel.

/// </summary>

public static FileSystemWatcher NewSqlWatcher(string fullDir, ChannelWriter<string> writer)

{

var w = new FileSystemWatcher(fullDir, "*.sql")

{

IncludeSubdirectories = true,

NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.Size,

};

void OnFsEvent(object s, FileSystemEventArgs e) => writer.TryWrite(e.FullPath);

w.Changed += OnFsEvent;

w.Created += OnFsEvent;

w.Renamed += (s, e) => writer.TryWrite(e.FullPath);

w.EnableRaisingEvents = true;

return w;

}

/// <summary>

/// True when the ecosystem-standard DOTNET_USE_POLLING_FILE_WATCHER is set — the escape hatch for

/// environments where inotify events don't cross the filesystem boundary (Docker Desktop bind mounts,

/// some network shares).

/// </summary>

public static bool UsePollingWatcher =>

Environment.GetEnvironmentVariable("DOTNET_USE_POLLING_FILE_WATCHER") is { } v

&& (v == "1" || string.Equals(v, "true", StringComparison.OrdinalIgnoreCase));

/// <summary>

/// Polling fallback: scans *.sql under <paramref name="fullDir"/> plus the extra files every second

/// and writes changed/new paths into the channel. Runs until the token is cancelled.

/// </summary>

public static void StartPollingWatcher(string fullDir, IReadOnlyList<string> extraFiles, ChannelWriter<string> writer, CancellationToken ct)

{

_ = Task.Run(async () =>

{

var known = new Dictionary<string, DateTime>(StringComparer.Ordinal);

void Scan(bool emit)

{

IEnumerable<string> files = Directory.Exists(fullDir)

? Directory.EnumerateFiles(fullDir, "*.sql", SearchOption.AllDirectories)

: [];

foreach (var f in files.Concat(extraFiles))

{

DateTime mtime;

try { mtime = File.GetLastWriteTimeUtc(f); } catch { continue; }

if (known.TryGetValue(f, out var prev))

{

if (prev != mtime)

{

known[f] = mtime;

if (emit) writer.TryWrite(f);

}

}

else

{

known[f] = mtime;

if (emit) writer.TryWrite(f);

}

}

}

Scan(emit: false);

while (ct.IsCancellationRequested is false)

{

try { await Task.Delay(1000, ct); } catch (OperationCanceledException) { break; }

Scan(emit: true);

}

}, CancellationToken.None);

}

}