#include <boost/asio.hpp>
#include <boost/asio/use_future.hpp>
#include <future>
#include <iostream>

namespace asio = boost::asio;

asio::awaitable<int> calculate_value()
{
    asio::steady_timer timer(co_await asio::this_coro::executor);
    timer.expires_after(std::chrono::seconds(1));

    // 这里的 async_wait 是这样的：
    // 1. 告诉操作系统："1秒后叫醒我"
    // 2. 操作系统内核开始计时
    // 3. 你的线程继续做其他事
    // 4. 1秒后，操作系统主动通知你的程序
    // 所以这里在这 1 秒期间内，不占用任何CPU资源。
    co_await timer.async_wait(asio::use_awaitable);
    co_return 42;

    /*
        2025-12-16 按照我目前的理解，这个
        协程和线程的底层核心
    */
}

asio::awaitable<void> process_task()
{
    try {
        std::cout << "开始计算...\n";
        int result = co_await calculate_value();   // 等待子协程
        std::cout << "计算结果: " << result << "\n";
    } catch (const std::exception& e) {
        std::cerr << "计算错误: " << e.what() << "\n";
        throw;   // 重新抛出，让调用者知道
    }
}

int test1()
{
    asio::io_context io;

    // 使用 use_future 获取 future
    // co_spawn 只是安排协程，并无动作和运行。
    std::future<void> fut = asio::co_spawn(io, process_task(), asio::use_future);

    // 在工作线程中运行 io_context
    std::thread io_thread([&io]() { io.run(); });

    std::cout << "主线程等待协程完成...\n";

    try {
        // 等待协程完成
        fut.get();
        std::cout << "协程成功完成\n";
    } catch (const std::exception& e) {
        std::cerr << "协程异常: " << e.what() << "\n";
    }

    io_thread.join();
    return 0;
}

// 这是一个阻塞版本的Worker
class Worker
{
public:
    Worker() = default;

    bool Run()
    {
        isOk_ = false;
        if (!simulateCal()) {
            return false;
        }
        std::cout << "Done..." << calData_ << std::endl;
        return true;
    }

private:
    bool simulateCal()
    {
        std::this_thread::sleep_for(std::chrono::seconds(3));
        calData_ = 12;
        return true;
    }

private:
    bool isOk_{};
    int calData_{};
};

int testRun()
{
    Worker wk;
    return wk.Run();
}

// 上面阻塞版本的Worker改成协程版本
class WorkerCoroutine
{
public:
    WorkerCoroutine(asio::io_context& io) : io_(io), pool_(std::thread::hardware_concurrency())
    {
    }

    asio::awaitable<bool> Run()
    {
        isOk_ = false;
        bool success = co_await simulateCal();
        if (!success) {
            co_return false;
        }

        std::cout << "Done..." << calData_ << std::endl;
        isOk_ = true;
        co_return true;
    }

private:
    asio::awaitable<bool> simulateCal()
    {
        // 核心代码在这里
        // 从这里可以看出，协程只适合能通知唤醒的阻塞，比如 socket.recv 虽然阻塞
        // 但是可以被 OS 唤醒。不适合直接的阻塞比如 从一个驱动中读取数组，然后驱动很慢有阻塞这种。
        // 非要用的话，需要把真正的阻塞（不是睡眠那种阻塞而是真正的耗时阻塞，比如计算）包装成异步。

        // 测试可唤醒异步
        // asio::steady_timer timer(io_);
        // timer.expires_after(std::chrono::seconds(3));
        // co_await timer.async_wait(asio::use_awaitable);

        // 测试包装后的真正阻塞
        // auto f = std::async(std::launch::async, [this]() { return realBlock(); });
        // 不能这么写。
        // co_await f.get();

        // auto ex = co_await asio::this_coro::executor;
        // auto r = co_await asio::co_spawn(io_, readBlockCorouitine, asio::use_awaitable);

        // 这个虽然能执行，但是实际只是因为这里只有一个协程。
        // co_await readBlockCorouitine();

        bool result = co_await asio::co_spawn(
            pool_, [this]() -> asio::awaitable<bool> { co_return co_await readBlockCorouitine(); }, asio::use_awaitable);

        calData_ = 12;
        co_return true;
    }

    // 真正阻塞的函数
    bool realBlock()
    {
        std::this_thread::sleep_for(std::chrono::seconds(3));
        return true;
    }

    asio::awaitable<bool> readBlockCorouitine()
    {
        std::cout << "模拟耗时开启..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(3));
        std::cout << "模拟耗时结束..." << std::endl;
        co_return true;
    }

private:
    asio::io_context& io_;
    bool isOk_{};
    int calData_{};
    asio::thread_pool pool_;
};

int testRunCoroutine()
{
    asio::io_context io;
    WorkerCoroutine wk(io);

    // 使用 use_future 获取 future
    std::future<bool> result_future = asio::co_spawn(io,
                                                     wk.Run(),   // 注意：这里要传 wk.Run() 而不是 wk
                                                     asio::use_future);

    // 在工作线程运行 io_context
    std::thread io_thread([&io]() { io.run(); });

    std::cout << "开始异步计算，主线程可以继续...\n";

    bool result = false;
    try {
        // 等待异步结果
        result = result_future.get();
    } catch (const std::exception& e) {
        std::cerr << "协程异常: " << e.what() << "\n";
    }

    io_thread.join();
    return result ? 0 : 1;   // 返回 0 表示成功
}

int main()
{

#ifdef _WIN32
    SetConsoleOutputCP(CP_UTF8);
#endif

    testRunCoroutine();

    return 0;
}