using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using StackExchange.Redis;

// Candidate reduction: use only a disposable Redis instance on loopback.
// CLIENT PAUSE ALL temporarily affects every client of that instance.
internal static class Program
{
    private const int PauseMilliseconds = 6000;
    private static int scanEvents;
    private static int otherEvents;

    private static async Task<int> Main(string[] args)
    {
        if (args.Length != 3 || !int.TryParse(args[0], out int port) || port is < 1 or > 65535
            || args[1] is not ("sync" or "async" or "healthy") || args[2] != "--disposable-instance")
        {
            Console.Error.WriteLine("Usage: <port> <sync|async|healthy> --disposable-instance");
            return 2;
        }

        Console.WriteLine($"Runtime: {RuntimeInformation.FrameworkDescription}");
        Console.WriteLine($"OS: {RuntimeInformation.OSDescription}");
        Console.WriteLine($"Package: {typeof(ConnectionMultiplexer).Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion}");
        Console.WriteLine($"Mode: {args[1]}; SyncTimeout=250; AsyncTimeout=1500; pause={PauseMilliseconds}");
        TaskScheduler.UnobservedTaskException += OnUnobserved;
        RedisKey key = $"scan-timeout-repro:{Guid.NewGuid():N}";
        ConnectionMultiplexer? control = null;
        ConnectionMultiplexer? subject = null;
        Stopwatch? pauseClock = null;
        bool callerTimedOut = false;
        bool cleanupSucceeded = false;
        int exitCode = 2;
        try
        {
            control = await ConnectionMultiplexer.ConnectAsync(Options(port, 5000, 5000));
            subject = await ConnectionMultiplexer.ConnectAsync(Options(port, 250, 1500));
            var admin = control.GetDatabase();
            await admin.HashSetAsync(key, Enumerable.Range(0, 1024)
                .Select(i => new HashEntry($"field:{i}", i)).ToArray());
            await admin.KeyExpireAsync(key, TimeSpan.FromMinutes(2));
            await subject.GetDatabase().PingAsync();

            if (args[1] != "healthy")
            {
                pauseClock = Stopwatch.StartNew();
                await admin.ExecuteAsync("CLIENT", "PAUSE", PauseMilliseconds, "ALL");
            }

            // Both entry points catch their caller-visible exception and dispose the enumerator.
            callerTimedOut = args[1] == "async"
                ? await ScanAsync(subject.GetDatabase(), key)
                : ScanSync(subject.GetDatabase(), key);

            // Let the asynchronous command timeout occur before making unreachable tasks collectible.
            // Forced GC only exposes the event; it is not a production recommendation.
            await Task.Delay(PauseMilliseconds + 2000);
            for (int i = 0; i < 5; i++)
            {
                GC.Collect();
                GC.WaitForPendingFinalizers();
                GC.Collect();
                await Task.Delay(200);
            }

            int count = Volatile.Read(ref scanEvents);
            Console.WriteLine($"Observation: callerTimeout={callerTimedOut}; scanEvents={count}; otherEvents={Volatile.Read(ref otherEvents)}");
            // 0 means the target symptom was observed, not that the library passed a test.
            exitCode = callerTimedOut && count > 0 ? 0 : 1;
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Setup/observation error: {ex}");
        }
        finally
        {
            // Do not race cleanup against an outstanding server-wide pause.
            if (pauseClock is not null)
            {
                int remaining = PauseMilliseconds + 500 - (int)pauseClock.ElapsedMilliseconds;
                if (remaining > 0) await Task.Delay(remaining);
            }
            try
            {
                if (control is not null)
                {
                    await control.GetDatabase().KeyDeleteAsync(key);
                    cleanupSucceeded = !await control.GetDatabase().KeyExistsAsync(key);
                }
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"Cleanup error: {ex.GetType().Name}: {ex.Message}");
            }
            subject?.Dispose();
            control?.Dispose();
            TaskScheduler.UnobservedTaskException -= OnUnobserved;
            Console.WriteLine($"Cleanup verified: {cleanupSucceeded}");
        }
        return cleanupSucceeded ? exitCode : 2;
    }

    private static ConfigurationOptions Options(int port, int syncTimeout, int asyncTimeout) => new()
    {
        EndPoints = { { "127.0.0.1", port } },
        AbortOnConnectFail = true,
        ConnectTimeout = 5000,
        SyncTimeout = syncTimeout,
        AsyncTimeout = asyncTimeout,
        HeartbeatInterval = TimeSpan.FromMilliseconds(100),
        AllowAdmin = true,
    };

    [MethodImpl(MethodImplOptions.NoInlining)]
    private static bool ScanSync(IDatabase db, RedisKey key)
    {
        try
        {
            using var iterator = db.HashScan(key, pattern: "field:*", pageSize: 10).GetEnumerator();
            Console.WriteLine($"MoveNext returned: {iterator.MoveNext()}");
            return false;
        }
        catch (RedisTimeoutException ex)
        {
            Console.WriteLine($"Caller exception: {ex}");
            return true;
        }
    }

    private static async Task<bool> ScanAsync(IDatabase db, RedisKey key)
    {
        try
        {
            await using var iterator = db.HashScanAsync(key, pattern: "field:*", pageSize: 10).GetAsyncEnumerator();
            Console.WriteLine($"MoveNextAsync returned: {await iterator.MoveNextAsync()}");
            return false;
        }
        catch (RedisTimeoutException ex)
        {
            Console.WriteLine($"Caller exception: {ex}");
            return true;
        }
    }

    private static void OnUnobserved(object? sender, UnobservedTaskExceptionEventArgs e)
    {
        bool scan = e.Exception.Flatten().InnerExceptions.Any(ex =>
            ex.StackTrace?.Contains("CursorEnumerable", StringComparison.Ordinal) == true
            && ex.StackTrace.Contains("AwaitedNextAsync", StringComparison.Ordinal));
        if (scan) Interlocked.Increment(ref scanEvents);
        else Interlocked.Increment(ref otherEvents);
        Console.WriteLine($"UNOBSERVED (scan={scan}): {e.Exception}");
        // Record first. SetObserved does not prevent the defect or count as its repair.
        e.SetObserved();
    }
}