#include <chrono>
#include <coroutine>
#include <functional>
#include <iostream>
#include <queue>
#include <string>
#include <thread>

using task = std::function<void(const std::string&)>;

class executor {
private:
    std::thread work_thread_;
    std::queue<task> tasks_;

public:
    void add_task(task t) { tasks_.emplace(std::move(t)); }

    void run() {
        work_thread_ = std::thread([this]() {
            uint64_t times = 1;
            std::cout << "executor thread: " << std::this_thread::get_id() << "\n";
            while (true) {
                auto& task = tasks_.front();
                task(std::to_string(times));
                times++;
                tasks_.pop();

                using namespace std::chrono_literals;
                std::this_thread::sleep_for(1000ms);
            }
            });

        if (work_thread_.joinable()) {
            work_thread_.join();
        }
    }
};

class coroutine_task {
public:
    struct promise_type {
        std::suspend_never initial_suspend() noexcept { return {}; }

        std::suspend_always final_suspend() noexcept { return {}; }

        void unhandled_exception() noexcept {}

        coroutine_task get_return_object() noexcept {
            auto tk = coroutine_task{
                std::coroutine_handle<promise_type>::from_promise(*this) };
            return tk;
        }

        /*void return_value(int v) noexcept {}*/
        void return_void() noexcept {}

        std::suspend_always yield_value(std::string&& from) noexcept {
            value_ = std::move(from);
            return {};
        }

        std::string value_;
    };

private:
    std::coroutine_handle<promise_type> coro_;

public:
    coroutine_task(std::coroutine_handle<promise_type> h) : coro_(h) {}

    ~coroutine_task() {
        if (coro_) {
            coro_.destroy();
        }
    }

    std::string value() { return coro_.promise().value_; }
};

template <typename R, typename Executor = executor>
struct awaitable {
private:
    R buf_;
    Executor& e_;
    std::coroutine_handle<> coro_handle_;

public:
    awaitable(Executor& e) : e_(e) {}

    bool await_ready() noexcept { return false; }

    R await_resume() noexcept { return buf_; }

    void await_suspend(std::coroutine_handle<> p) noexcept {
        coro_handle_ = p;
    }

    void async_start() {
        e_.add_task([this](const R& times) {
            std::cout << "async resume thread: " << std::this_thread::get_id() << "\n";
            buf_ = times;
            coro_handle_.resume();
            });
    }
};

auto async_read(executor& e) {
    awaitable<std::string> aw{ e };
    aw.async_start();
    return aw;
}

coroutine_task coro_read1(executor& e) {
    std::cout << "coro_read1 begin thread: " << std::this_thread::get_id() << "\n";
    for (;;) {
        auto value = co_await async_read(e);
        std::cout << "1、coro_read1: " << value << " thread: " << std::this_thread::get_id() << "\n";
        value = co_await async_read(e);
        std::cout << "2、coro_read1: " << value << " thread: " << std::this_thread::get_id() << "\n";
    }
}

coroutine_task coro_read2(executor& e) {
    std::cout << "coro_read2 begin thread: " << std::this_thread::get_id() << "\n";
    for (;;) {
        auto value = co_await async_read(e);
        std::cout << "coro_read2: " << value << " thread: " << std::this_thread::get_id() << "\n";
    }
}

int main() {
    executor e;

    auto cr1 = coro_read1(e);
    auto cr2 = coro_read2(e);

    e.run();
    return 0;
}