using System.Diagnostics;

Stopwatch totalSw = Stopwatch.StartNew();

Task<HttpResponseMessage> resp1 = GetWithTimingAsync("https://www.baidu.com", "百度");
Task<HttpResponseMessage> resp2 = GetWithTimingAsync("https://www.qq.com", "QQ");
Task<HttpResponseMessage> resp3 = GetWithTimingAsync("https://bing.com", "Bing");

await Task.WhenAll(resp1, resp2, resp3);
totalSw.Stop();
Console.WriteLine($"总耗时: {totalSw.ElapsedMilliseconds} ms");

static async Task<HttpResponseMessage> GetWithTimingAsync(string url, string name)
{
    Stopwatch sw = Stopwatch.StartNew();
    HttpClient client = new HttpClient();
    try
    {
        HttpResponseMessage response = await client.GetAsync(url);
        sw.Stop();
        Console.WriteLine($"{name} 请求耗时: {sw.ElapsedMilliseconds} ms, 状态码: {response.StatusCode}");
        return response;
    }
    catch (Exception ex)
    {
        sw.Stop();
        Console.WriteLine($"{name} 请求失败，耗时: {sw.ElapsedMilliseconds} ms, 异常: {ex.Message}");
        throw;
    }
    finally
    {
        client.Dispose();
    }
}

using System.Net;
using System.Net.Sockets;

await RunTCPEchoServer();

static async Task RunTCPEchoServer()
{
    var listener = new TcpListener(IPAddress.Loopback, 5000);
    listener.Start();
    Console.WriteLine("Server started on 127.0.0.1:5000");
    while (true)
    {
        var client = await listener.AcceptTcpClientAsync();

        _ = HandleClient(client);
    }
}

static async Task HandleClient(TcpClient client)
{
    using var c = client;
    var stream = c.GetStream();

    var buffer = new byte[1024];

    while (true)
    {
        int n = await stream.ReadAsync(buffer);

        if (n == 0)
            break;

        await stream.WriteAsync(buffer.AsMemory(0, n));
    }
}

_ = RunMyIntervalTaskAsync(); // just ignore Task handle

// wait forever
TaskCompletionSource src = new TaskCompletionSource();
await src.Task;

async static Task RunMyIntervalTaskAsync()
{
    while (true)
    {
        Console.WriteLine("Do task");
        await Task.Delay(3000);
    }
}

class Program
{
    public async static Task Main()
    {
        int val = await GetNumberAsync();
        Console.WriteLine(val);
    }

    static Task<int> GetNumberAsync()
    {
        TaskCompletionSource<int> src = new();
        Thread thread = new Thread(() =>
        {
            Thread.Sleep(3000);
            src.SetResult(1);
        })
        { IsBackground = true };
        thread.Start();
        return src.Task;
    }
}
// 运行结果: 3s后输出1

static async Task<int> FooAsync()
{
    Console.WriteLine("A");

    int x = await GetNumberAsync();

    Console.WriteLine("B");

    return x + 1;
}

static Task<int> GetNumberAsync()
{
    TaskCompletionSource<int> src = new();
    Thread thread = new Thread(() =>
    {
        Thread.Sleep(3000);
        src.SetResult(1);
    })
    { IsBackground = true };
    thread.Start();
    return src.Task;
}

// 上面是用户代码，下面是编译器伪代码，看个意思，代码并不严谨

static Task<int> FooAsyncAfterInterpreted()
{
    FooAsyncStateMachine stateMachine = new FooAsyncStateMachine();

    stateMachine.builder = AsyncTaskMethodBuilder<int>.Create();
    // 初始值-1
    stateMachine.state = -1;

    // 执行一次MoveNext
    stateMachine.builder.Start(ref stateMachine);

    return stateMachine.builder.Task;
}

private struct FooAsyncStateMachine : IAsyncStateMachine
{
    public int state;
    public AsyncTaskMethodBuilder<int> builder;

    // 会把局部变量的上下文存储在状态机里面
    private int x;
    private TaskAwaiter<int> awaiter;

    private void MoveNext()
    {
        int result;

        try
        {
            TaskAwaiter<int> localAwaiter;
            // state == -1，执行第一个await之前的代码
            if (state == -1)
            {
                Console.WriteLine("A");

                Task<int> task = GetNumberAsync();
                localAwaiter = task.GetAwaiter();

                if (!localAwaiter.IsCompleted)
                {
                    // state == 0: 等待第一个await中
                    state = 0;
                    awaiter = localAwaiter;

                    builder.AwaitUnsafeOnCompleted(
                        ref localAwaiter,
                        ref this);

                    return;
                }
            }
            // 从state == 0，也就是等待第一个await中恢复过来
            else if (state == 0)
            {
                localAwaiter = awaiter;
                awaiter = default;
                state = -1;
            }

            x = localAwaiter.GetResult();

            Console.WriteLine("B");

            result = x + 1;
        }
        // state=-2 -> 已完成
        catch (Exception ex)
        {
            state = -2;
            builder.SetException(ex);
            return;
        }

        state = -2;
        builder.SetResult(result);
    }

    public void SetStateMachine(IAsyncStateMachine stateMachine)
    {
        builder.SetStateMachine(stateMachine);
    }
}

class Program
{
    public async static Task Main()
    {
        Console.WriteLine($"1: {Environment.CurrentManagedThreadId}");
        int val = await GetNumberAsync();
        Console.WriteLine($"2: {Environment.CurrentManagedThreadId}");
    }

    static Task<int> GetNumberAsync()
    {
        Console.WriteLine($"3: {Environment.CurrentManagedThreadId}");
        TaskCompletionSource<int> src = new(TaskCreationOptions.RunContinuationsAsynchronously);
        Thread thread = new Thread(() =>
        {
            Console.WriteLine($"4: {Environment.CurrentManagedThreadId}");
            Thread.Sleep(3000);
            src.SetResult(1);
        })
        { IsBackground = true };
        thread.Start();
        return src.Task;
    }
}
// 输出：
// 1: 1
// 3: 1
// 4: 4
// 2: 5

// 当不使用RunContinuationsAsynchronously参数的时候输出：
// 1: 1
// 3: 1
// 4: 4
// 2: 4

private async Task BadHandleClientAsync1(TcpClient client)
{
    using var stream = client.GetStream();

    while (true)
    {
        byte[] requestBytes = await ReadFrameAsync(stream);

        byte[] decrypted = Decrypt(requestBytes);
        byte[] decompressed = Decompress(decrypted);
        Request request = DeserializeLargeJson(decompressed);
        // CPU-heavy: 复杂业务计算，里面可能有非常复杂的数学计算，图像处理，耗时很长
        Response response = RunComplexBusinessRules(request);
        byte[] responseJson = SerializeLargeJson(response);
        byte[] compressed = Compress(responseJson);
        byte[] encrypted = Encrypt(compressed);
        byte[] responseBytes = BuildFrame(encrypted);

        await stream.WriteAsync(responseBytes, 0, responseBytes.Length);
    }
}

private async Task BadHandleClientAsync2(TcpClient client)
{
    using var stream = client.GetStream();

    while (true)
    {
        byte[] requestBytes = await ReadFrameAsync(stream);

        byte[] responseBytes = await Task.Run(() =>
        {
            byte[] decrypted = Decrypt(requestBytes);
            byte[] decompressed = Decompress(decrypted);
            Request request = DeserializeLargeJson(decompressed);
            Response response = RunComplexBusinessRules(request);
            byte[] responseJson = SerializeLargeJson(response);
            byte[] compressed = Compress(responseJson);
            byte[] encrypted = Encrypt(compressed);
            return BuildFrame(encrypted);
        });
        await stream.WriteAsync(responseBytes, 0, responseBytes.Length);
    }
}

using System.Collections.Concurrent;

public class Program
{
    public static async Task Main()
    {
        var cpuQueue = new CpuWorkQueue(
            workerCount: 2,
            capacity: 10,
            name: "dedicated-cpu-worker");

        var tasks = new List<Task<int>>();

        Console.WriteLine($"Main thread: {Thread.CurrentThread.ManagedThreadId}");
        Console.WriteLine("Start enqueue CPU tasks...");
        Console.WriteLine();

        for (int i = 0; i < 6; i++)
        {
            int taskId = i;

            Task<int> task = cpuQueue.Enqueue(() =>
            {
                Console.WriteLine(
                    $"Task {taskId} started on thread {Thread.CurrentThread.ManagedThreadId}");

                // 模拟 CPU 密集型计算
                var result = HeavyCpuCompute(taskId);

                Console.WriteLine(
                    $"Task {taskId} finished on thread {Thread.CurrentThread.ManagedThreadId}");

                return result;
            });

            tasks.Add(task);
        }

        Console.WriteLine("All tasks have been enqueued.");
        Console.WriteLine("Main thread is not blocked while CPU workers are running.");
        Console.WriteLine();

        int[] results = await Task.WhenAll(tasks);

        Console.WriteLine();
        Console.WriteLine("All CPU tasks finished.");
        Console.WriteLine("Results:");

        foreach (var result in results)
        {
            Console.WriteLine(result);
        }
    }

    private static int HeavyCpuCompute(int input)
    {
        // 真实场景里这里通常是复杂计算、压缩、加密、图像处理、规则引擎等。
        // Sleep这里只是演示工作队列调度效果
        Thread.Sleep(2000);

        return input * input;
    }
}

public sealed class CpuWorkQueue
{
    private readonly BlockingCollection<Action> _queue;
    private readonly Thread[] _workers;

    public CpuWorkQueue(int workerCount, int capacity = 1024, string name = "cpu-worker")
    {
        if (workerCount <= 0)
            throw new ArgumentOutOfRangeException(nameof(workerCount));

        if (capacity <= 0)
            throw new ArgumentOutOfRangeException(nameof(capacity));

        _queue = new BlockingCollection<Action>(boundedCapacity: capacity);
        _workers = new Thread[workerCount];

        for (int i = 0; i < workerCount; i++)
        {
            var index = i;

            _workers[i] = new Thread(WorkerLoop)
            {
                IsBackground = true,
                Name = $"{name}-{index}"
            };

            _workers[i].Start();
        }
    }

    public Task<T> Enqueue<T>(Func<T> work)
    {
        var tcs = new TaskCompletionSource<T>(
            TaskCreationOptions.RunContinuationsAsynchronously);

        var item = new Action(() =>
        {
            try
            {
                var result = work();
                tcs.TrySetResult(result);
            }
            catch (Exception ex)
            {
                tcs.TrySetException(ex);
            }
        });

        // 不要无限排队。队列满了就明确失败，形成背压。
        if (!_queue.TryAdd(item))
        {
            tcs.TrySetException(
                new InvalidOperationException("CPU work queue is full."));
        }

        return tcs.Task;
    }

    private void WorkerLoop()
    {
        foreach (var work in _queue.GetConsumingEnumerable())
        {
            work();
        }
    }
}

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

public sealed class SingleThreadSynchronizationContext : SynchronizationContext
{
    private readonly BlockingCollection<(SendOrPostCallback Callback, object? State)> _queue = new();

    private readonly int _ownerThreadId;

    public SingleThreadSynchronizationContext()
    {
        _ownerThreadId = Thread.CurrentThread.ManagedThreadId;
    }

    public override void Post(SendOrPostCallback d, object? state)
    {
        // 异步投递，不阻塞调用方
        _queue.Add((d, state));
    }

    public override void Send(SendOrPostCallback d, object? state)
    {
        // 如果已经在目标线程上，直接执行
        if (Thread.CurrentThread.ManagedThreadId == _ownerThreadId)
        {
            d(state);
            return;
        }

        using var done = new ManualResetEventSlim(false);
        Exception? exception = null;

        Post(s =>
        {
            try
            {
                d(s);
            }
            catch (Exception ex)
            {
                exception = ex;
            }
            finally
            {
                done.Set();
            }
        }, state);

        done.Wait();

        if (exception != null)
        {
            throw exception;
        }
    }

    public void RunOnCurrentThread()
    {
        foreach (var workItem in _queue.GetConsumingEnumerable())
        {
            workItem.Callback(workItem.State);
        }
    }

    public void Complete()
    {
        _queue.CompleteAdding();
    }
}

class Program
{
    static async Task Main()
    {
        var context = new SingleThreadSynchronizationContext();

        SynchronizationContext.SetSynchronizationContext(context);

        Console.WriteLine($"Main start thread: {Thread.CurrentThread.ManagedThreadId}");

        var task = DoAsync();

        task.ContinueWith(_ => context.Complete());

        context.RunOnCurrentThread();

        await task;

        Console.WriteLine("Program finished.");
    }

    static async Task DoAsync()
    {
        Console.WriteLine($"Before await thread: {Thread.CurrentThread.ManagedThreadId}");

        await Task.Delay(1000);

        Console.WriteLine($"After await thread: {Thread.CurrentThread.ManagedThreadId}");
    }
}

// 输出
/*
Main start thread: 1
Before await thread: 1
After await thread: 1
Program finished.
*/

using System.Collections.Concurrent;

public sealed class SingleThreadTaskScheduler : TaskScheduler, IDisposable
{
    private readonly BlockingCollection<Task> _tasks = new();
    private readonly Thread _thread;

    public SingleThreadTaskScheduler(string name = "SingleThreadTaskScheduler")
    {
        _thread = new Thread(Run)
        {
            IsBackground = true,
            Name = name
        };

        _thread.Start();
    }

    private void Run()
    {
        foreach (var task in _tasks.GetConsumingEnumerable())
        {
            TryExecuteTask(task);
        }
    }

    protected override void QueueTask(Task task)
    {
        _tasks.Add(task);
    }

    protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
    {
        // 为了保证所有 Task 都在专用线程执行，这里禁止 inline
        return false;
    }

    protected override IEnumerable<Task>? GetScheduledTasks()
    {
        return _tasks.ToArray();
    }

    public void Dispose()
    {
        _tasks.CompleteAdding();
    }
}


class Program
{
    static void Main()
    {
        using var scheduler = new SingleThreadTaskScheduler();

        var factory = new TaskFactory(scheduler);

        Console.WriteLine($"Main thread: {Thread.CurrentThread.ManagedThreadId}");

        Task task1 = factory.StartNew(() =>
        {
            Console.WriteLine($"Task1 thread: {Thread.CurrentThread.ManagedThreadId}");
            Console.WriteLine($"Task1 scheduler is custom: {TaskScheduler.Current == scheduler}");
        });

        Task<int> task2 = factory.StartNew(() =>
        {
            Console.WriteLine($"Task2 thread: {Thread.CurrentThread.ManagedThreadId}");
            Console.WriteLine($"Task2 scheduler is custom: {TaskScheduler.Current == scheduler}");
            return 123;
        });

        Task.WaitAll(task1, task2);
    }
}

private void Button_Click(object sender, EventArgs e)
{
    button.Enabled = false;
    textBox.Text = "Loading...";

    DoHttpGetAsync("https://example.com/user", userResult =>
    {
        // 回到 UI 线程
        this.BeginInvoke(new Action(() =>
        {
            textBox.Text = "User loaded: " + userResult;

            DoHttpGetAsync("https://example.com/orders?user=" + userResult, ordersResult =>
            {
                // 再回到 UI 线程
                this.BeginInvoke(new Action(() =>
                {
                    textBox.Text += Environment.NewLine + "Orders loaded: " + ordersResult;

                    DoHttpGetAsync("https://example.com/detail?order=" + ordersResult, detailResult =>
                    {
                        // 再回到 UI 线程
                        this.BeginInvoke(new Action(() =>
                        {
                            textBox.Text += Environment.NewLine + "Detail loaded: " + detailResult;

                            DoHttpPostAsync("https://example.com/log", detailResult, logResult =>
                            {
                                // 再回到 UI 线程
                                this.BeginInvoke(new Action(() =>
                                {
                                    textBox.Text += Environment.NewLine + "Log saved: " + logResult;
                                    button.Enabled = true;
                                }));
                            },
                            ex =>
                            {
                                this.BeginInvoke(new Action(() =>
                                {
                                    MessageBox.Show("Save log failed: " + ex.Message);
                                    button.Enabled = true;
                                }));
                            });
                        }));
                    },
                    ex =>
                    {
                        this.BeginInvoke(new Action(() =>
                        {
                            MessageBox.Show("Load detail failed: " + ex.Message);
                            button.Enabled = true;
                        }));
                    });
                }));
            },
            ex =>
            {
                this.BeginInvoke(new Action(() =>
                {
                    MessageBox.Show("Load orders failed: " + ex.Message);
                    button.Enabled = true;
                }));
            });
        }));
    },
    ex =>
    {
        this.BeginInvoke(new Action(() =>
        {
            MessageBox.Show("Load user failed: " + ex.Message);
            button.Enabled = true;
        }));
    });
}

private async void Button_Click(object sender, EventArgs e)
{
    button.Enabled = false;
    textBox.Text = "Loading...";

    try
    {
        string user = await DoHttpGetAsync("https://example.com/user");
        textBox.Text = "User loaded: " + user;

        string orders = await DoHttpGetAsync("https://example.com/orders?user=" + user);
        textBox.Text += Environment.NewLine + "Orders loaded: " + orders;

        string detail = await DoHttpGetAsync("https://example.com/detail?order=" + orders);
        textBox.Text += Environment.NewLine + "Detail loaded: " + detail;

        string log = await DoHttpPostAsync("https://example.com/log", detail);
        textBox.Text += Environment.NewLine + "Log saved: " + log;
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
    finally
    {
        button.Enabled = true;
    }
}

var gameContext = new GameSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(gameContext);

while (running)
{
    // 尽早处理窗口消息，避免系统认为程序无响应
    PollEvents();

    // 处理投递回主线程的回调：
    // - async/await continuation
    // - RunInLoop/Post 回调
    // - 其他用户态主线程任务
    gameContext.ExecutePendingCallbacks();

    // 计算时间
    double dt = timer.GetDeltaTime();

    // 更新世界
    Update(dt);

    // 尽量靠近渲染前再采样关键输入
    PollInputLate();

    // 渲染当前帧
    Render();

    // 提交帧，可能阻塞在 VSync
    Present();
}

public sealed class GameSynchronizationContext : SynchronizationContext
{
    private readonly ConcurrentQueue<(SendOrPostCallback Callback, object? State)> _queue = new();

    public override void Post(SendOrPostCallback d, object? state)
    {
        _queue.Enqueue((d, state));
    }

    public void ExecutePendingCallbacks()
    {
        while (_queue.TryDequeue(out var item))
        {
            try
            {
                item.Callback(item.State);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Async continuation exception: " + ex);
            }
        }
    }
}

private void PollEvents()
{
    // 操作系统来的事件：键盘/鼠标/手柄输入，窗口状态(resize/关闭/最小化/移动/失去获得焦点/DPI变化)，文件拖拽，窗口重绘
    PollWindowEvents();
    // linux有timerfd，会比较方便
    PollTimerEvents();
}

private static SocketAsyncContext?[] s_registeredContexts = [];
private static readonly Queue<int> s_registeredContextsFreeList = [];