#include <actor-zeta.hpp>

class compute_actor final : public actor_zeta::basic_actor<compute_actor> {
public:
    explicit compute_actor(std::pmr::memory_resource* res)
        : actor_zeta::basic_actor<compute_actor>(res) {}

    // Coroutine method - returns unique_future<T>
    actor_zeta::unique_future<int> compute(int x) {
        co_return x * 2;
    }

    // Coroutine with co_await
    actor_zeta::unique_future<int> compute_chain(int x) {
        auto future = actor_zeta::send(this, address(), &compute_actor::compute, x);
        int result = co_await std::move(future);  // Wait for result
        co_return result + 10;
    }

    using dispatch_traits = actor_zeta::dispatch_traits<
        &compute_actor::compute,
        &compute_actor::compute_chain
    >;

    void behavior(actor_zeta::mailbox::message* msg) {
        auto cmd = msg->command();
        if (cmd == actor_zeta::msg_id<compute_actor, &compute_actor::compute>) {
            dispatch(this, &compute_actor::compute, msg);
        } else if (cmd == actor_zeta::msg_id<compute_actor, &compute_actor::compute_chain>) {
            dispatch(this, &compute_actor::compute_chain, msg);
        }
    }
};

// Method 1: co_await in coroutine (recommended)
actor_zeta::unique_future<int> caller_method() {
    auto future = actor_zeta::send(target, address(), &Target::compute, 21);
    int result = co_await std::move(future);  // Suspends until ready
    co_return result;
}

// Method 2: Polling (for non-coroutine code)
auto future = actor_zeta::send(target, address(), &Target::compute, 21);
while (!future.available()) {
    std::this_thread::sleep_for(std::chrono::microseconds(100));
}
int result = std::move(future).get();  // Extract ready result

// Method 3: Check and extract
auto future = actor_zeta::send(target, address(), &Target::compute, 21);
if (future.available()) {
    int result = std::move(future).get();
}

// Send message and get future for result
auto future = actor_zeta::send(actor, sender_address, &Actor::method, args...);

// Wait for result in coroutine
int result = co_await std::move(future);

#include <actor-zeta/src.hpp>