#include <coroutine>
#include <iostream>
#include <optional>

template<typename T>
struct Generator {
    struct promise_type {
        T value;
        
        Generator get_return_object() {
            return Generator{
                std::coroutine_handle<promise_type>::from_promise(*this)
            };
        }
        
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        
        std::suspend_always yield_value(T v) {
            value = std::move(v);
            return {};
        }
        
        void return_void() {}
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;

    ~Generator() {
        if (handle) handle.destroy();
    }

    std::optional<T> next() {
        if (!handle || handle.done()) return std::nullopt;
        handle.resume();
        return handle.promise().value;
    }
};

// 使用
Generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;
        auto temp = a;
        a = b;
        b = temp + b;
    }
}

int main() {
    auto fib = fibonacci();
    for (int i = 0; i < 10; ++i) {
        std::cout << *fib.next() << " ";
    }
    // 输出: 0 1 1 2 3 5 8 13 21 34
}

struct Awaitable {
    // 是否需要暂停
    bool await_ready() const noexcept { return false; }
    
    // 暂停时调用，可以注册回调
    void await_suspend(std::coroutine_handle<> h) const {
        // 注册回调，异步操作完成后调用 h.resume()
    }
    
    // 恢复时返回值
    int await_resume() const { return 42; }
};

#include <coroutine>
#include <future>

struct Task {
    struct promise_type {
        int result;
        
        Task get_return_object() {
            return Task{
                std::coroutine_handle<promise_type>::from_promise(*this)
            };
        }
        
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_value(int v) { result = v; }
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;
    
    int get_result() { return handle.promise().result; }
};

// 使用 co_await
Task async_compute() {
    int a = co_await some_async_operation();
    int b = co_await another_async_operation(a);
    co_return a + b;
}

#include <boost/fiber/all.hpp>
#include <iostream>

void fiber_fn(int id) {
    for (int i = 0; i < 5; ++i) {
        std::cout << "Fiber " << id << " step " << i << "\n";
        boost::fibers::yield();  // 让出 CPU
    }
}

int main() {
    boost::fibers::fiber f1(fiber_fn, 1);
    boost::fibers::fiber f2(fiber_fn, 2);
    
    f1.join();
    f2.join();
}

#include <boost/fiber/all.hpp>

using Channel = boost::fibers::buffered_channel<int>;

void producer(Channel& ch) {
    for (int i = 0; i < 10; ++i) {
        ch.push(i);
    }
    ch.close();
}

void consumer(Channel& ch) {
    int value;
    while (ch.pop(value) != boost::fibers::channel_op_status::closed) {
        std::cout << "收到: " << value << "\n";
    }
}

int main() {
    Channel ch{10};
    boost::fibers::fiber f1(producer, std::ref(ch));
    boost::fibers::fiber f2(consumer, std::ref(ch));
    f1.join();
    f2.join();
}

#include <boost/asio.hpp>
#include <coroutine>

using boost::asio::ip::tcp;

struct Session : std::enable_shared_from_this<Session> {
    tcp::socket socket;
    char data[1024];
    
    Session(tcp::socket s) : socket(std::move(s)) {}
    
    void start() { do_read(); }
    
    void do_read() {
        auto self = shared_from_this();
        socket.async_read_some(
            boost::asio::buffer(data),
            [this, self](boost::system::error_code ec, std::size_t length) {
                if (!ec) {
                    do_write(length);
                }
            }
        );
    }
    
    void do_write(std::size_t length) {
        auto self = shared_from_this();
        boost::asio::async_write(
            socket,
            boost::asio::buffer(data, length),
            [this, self](boost::system::error_code, std::size_t) {
                do_read();
            }
        );
    }
};