#include <iostream>
#include <future>
#include <chrono>

int heavy_calculation() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 42;
}

int main() {
    // 使用 std::async 异步启动任务
    std::future<int> result_future = std::async(std::launch::async, heavy_calculation);

    std::cout << "Main thread continues working while calculation is in progress..." << std::endl;
    // ... 在这里做其他事情 ...

    std::cout << "Waiting for the result..." << std::endl;
    int result = result_future.get(); // get()会阻塞直到结果可用

    std::cout << "The calculated result is: " << result << std::endl;
    return 0;
}

// 辅助函数，打印当前线程ID和消息
void print_thread_info(const std::string& message) {
    std::cout << "[" << std::this_thread::get_id() << "] " << message << std::endl;
}

int main() {
    // === 1. 设置执行器 ===
    // a) 主事件循环，用于I/O和最终更新
    folly::EventBase mainEventBase;
    // b) CPU线程池，用于计算密集型任务
    //    创建一个有4个线程的线程池
    auto cpuExecutor = std::make_unique<folly::CPUThreadPoolExecutor>(4);

    print_thread_info("Main thread started. Setting up future chain.");
    print_thread_info("mainEventBase is running on this thread once loop starts.");

    // === 2. 创建并链接 Future 链 ===

    // 启动一个Future链，初始值为一个用户ID
    folly::makeFuture(123)

        // ---------------------------------------------------------------------
        // 阶段 1: 在默认执行器 (mainEventBase) 上运行
        // .then() 的回调默认会在添加它的线程（这里是主线程）的 EventBase 上调度
        .thenValue([&](int userID) {
            print_thread_info("Phase 1: Fetched user ID. Preparing for heavy computation.");
            // 模拟从缓存中获取的原始数据
            return "raw_data_for_user_" + std::to_string(userID);
        })

        // ---------------------------------------------------------------------
        // *** 关键部分: 切换到 CPU 线程池 ***
        // via() 确保下一个 .then() 将在 cpuExecutor 的一个线程上执行
        .via(cpuExecutor.get())

        // ---------------------------------------------------------------------
        // 阶段 2: 在 CPUThreadPoolExecutor 的一个工作线程上运行
        .thenValue([](std::string rawData) {
            print_thread_info("Phase 2: Starting heavy computation on CPU thread pool.");
            // 模拟耗时的 CPU 密集型工作
            std::this_thread::sleep_for(std::chrono::seconds(2));
            std::string processedData = "PROCESSED(" + rawData + ")";
            print_thread_info("Phase 2: Computation finished.");
            return processedData;
        })

        // ---------------------------------------------------------------------
        // *** 关键部分: 切换回主 EventBase ***
        // via() 确保下一个 .then() 将回到 mainEventBase 上执行
        .via(&mainEventBase)

        // ---------------------------------------------------------------------
        // 阶段 3: 回到主 EventBase 线程上进行最终处理
        .thenValue([&](std::string finalData) {
            print_thread_info("Phase 3: Back on main EventBase. Finalizing result.");
            std::cout << "\n>>> FINAL RESULT: " << finalData << " <<<\n" << std::endl;

            // 工作完成，停止事件循环
            print_thread_info("Phase 3: Terminating event loop.");
            mainEventBase.terminateLoopSoon();
        })

        // 异常处理
        .thenError(folly::tag_t<std::exception>{}, [&](const std::exception& e) {
            print_thread_info("An error occurred in the chain: " + std::string(e.what()));
            mainEventBase.terminateLoopSoon();
        });


    // === 3. 启动事件循环 ===
    print_thread_info("Future chain is set up. Starting event loop...");
    mainEventBase.loopForever();

    // === 4. 清理资源 ===
    // 等待所有线程池中的任务完成
    cpuExecutor->join();
    print_thread_info("Program finished.");
    return 0;
}

// Pseudocode for chaining senders
auto final_work_order = scheduler.schedule()               // Sender 1: A sender that says "run on this scheduler"
                      | then([]{ return read_file(); })   // Sender 2: A new sender that wraps Sender 1 and adds file reading
                      | then([](string data){ return parse(data); }); // Sender 3: A new sender that wraps Sender 2...

// Pseudocode for a receiver (often a lambda)
auto my_callback = receiver {
    .set_value = [](auto result){ std::cout << "Success! Result is " << result << std::endl; },
    .set_error = [](auto error){ std::cout << "Failure! Error was " << error << std::endl; },
    .set_done  = []{ std::cout << "Operation was cancelled." << std::endl; }
};

// Get a scheduler from a thread pool
thread_pool my_pool;
scheduler auto sch = my_pool.get_scheduler();

// Create a sender that will execute its subsequent work on the thread pool
sender auto start_on_pool = sch.schedule();

some_return_type  my_coroutine() {
     co_await async_read(some_buffer);
     /// runs in some io threads or worker threads
     ....
     co_await async_write(some_buffer);
     /// runs in some io threads or worker threads
     ....
     co_return;
}

task<void> just_coroutine() {
  std::cout << "just cout\n";
}

task<int> my_coroutine() {
    // task缺省实现的promise是一个lazy promise。
    // 刚进入my_coroutine的时候，在co_await promise.initial_suspend()的时候，
    // 会直接挂起来，下面的co_await just_coroutine并不会立刻执行。

    co_await just_coroutine;
    co_return 1;
}


// 注意 another coroutine也是一个lazy coroutine（因为task<> 缺省实现)
task<> another_coroutine() {

    // t是一个task<int>类型，my_coroutine直接被挂起来后，返回task，并继续运行这里
    auto t = my_coroutine();

    // co_await t的时候，会调用 t.get_handle().resume(),就是说 co_await t的时候，才会
    // 接着运行 my_coroutine里的 co_await just_coroutine。
    // 同时，本coroutine（another_coroutine)会被挂起来。
    co_await t;
    // 在 my_coroutine 被resume，并且完全执行完毕（co_await final_suspend()）的时候，本coroutine
    // 才会resume，就是说本coroutine会一直等到 t所代表的任务全部完成后，才会resume()。

    // co_await just_coroutine可能在别的线程将my_coroutine resume，task提供接口拿到 co_return结果（co_return 1)
    if (t.is_done()) {
        print(t.get_result());
     }
}

using namespace stdexec;

template <sender S1, sender S2>
auto async_answer(S1 s1, S2 s2) -> exec::task<int> {
  // Senders are implicitly awaitable (in this coroutine type):
  co_await static_cast<S2&&>(s2);
  co_return co_await static_cast<S1&&>(s1);
}

template <sender S1, sender S2>
auto async_answer2(S1 s1, S2 s2) -> exec::task<std::optional<int>> {
  co_return co_await stopped_as_optional(async_answer(s1, s2));
}

// tasks have an associated stop token
auto async_stop_token() -> exec::task<std::optional<stdexec::inplace_stop_token>> {
  co_return co_await stopped_as_optional(get_stop_token());
}

auto main() -> int {
  try {
    // Awaitables are implicitly senders:
    auto [i] = stdexec::sync_wait(async_answer2(just(42), just())).value();
    std::cout << "The answer is " << i.value() << '\n';
  } catch (std::exception& e) {
    std::cout << e.what() << '\n';
  }
}