#include <qb/main.h>     // QB Engine: qb::Main
#include <qb/actor.h>    // Actor base class: qb::Actor, qb::ActorId
#include <qb/event.h>    // Event base class: qb::Event
#include <qb/io.h>       // For qb::io::cout (thread-safe console output)
#include <iostream>      // For std::endl

// --- 1. Define Events ---
// Event sent from Pinger to Ponger
struct PingEvent : qb::Event {
    qb::ActorId pinger_id; // So Ponger knows who to reply to
    int ping_value;

    PingEvent(qb::ActorId sender, int val) : pinger_id(sender), ping_value(val) {}
};

// Event sent from Ponger back to Pinger
struct PongEvent : qb::Event {
    int pong_value;

    explicit PongEvent(int val) : pong_value(val) {}
};

// --- 2. Define Pinger Actor ---
class PingerActor : public qb::Actor {
private:
    qb::ActorId _ponger_actor_id;
    int _pings_sent = 0;
    const int _max_pings = 3;

public:
    // Constructor: Takes the ID of the Ponger actor
    explicit PingerActor(qb::ActorId ponger_id) : _ponger_actor_id(ponger_id) {}

    bool onInit() override {
        qb::io::cout() << "PingerActor [" << id() << "] initialized. Target Ponger: " << _ponger_actor_id << ".\n";
        registerEvent<PongEvent>(*this); // Pinger needs to handle Pong replies
        registerEvent<qb::KillEvent>(*this);

        // Send the first Ping
        sendNextPing();
        return true;
    }

    void on(const PongEvent& event) {
        qb::io::cout() << "PingerActor [" << id() << "] received Pong with value: " << event.pong_value << ".\n";
        if (_pings_sent < _max_pings) {
            sendNextPing();
        } else {
            qb::io::cout() << "PingerActor [" << id() << "] finished sending pings. Requesting Ponger to stop.\n";
            push<qb::KillEvent>(_ponger_actor_id); // Tell Ponger to stop
            kill(); // Pinger stops itself
        }
    }

    void on(const qb::KillEvent& /*event*/) {
        qb::io::cout() << "PingerActor [" << id() << "] shutting down.\n";
        kill();
    }

private:
    void sendNextPing() {
        _pings_sent++;
        qb::io::cout() << "PingerActor [" << id() << "] sending Ping #" << _pings_sent << " to " << _ponger_actor_id << ".\n";
        push<PingEvent>(_ponger_actor_id, id(), _pings_sent); // Send my ID and ping value
    }
};

// --- 3. Define Ponger Actor ---
class PongerActor : public qb::Actor {
public:
    bool onInit() override {
        qb::io::cout() << "PongerActor [" << id() << "] initialized and ready for Pings.\n";
        registerEvent<PingEvent>(*this); // Ponger handles Ping requests
        registerEvent<qb::KillEvent>(*this);
        return true;
    }

    void on(const PingEvent& event) {
        qb::io::cout() << "PongerActor [" << id() << "] received Ping #" << event.ping_value << " from " << event.pinger_id << ".\n";
        // Reply with a Pong, echoing the ping value
        push<PongEvent>(event.pinger_id, event.ping_value);
    }

    void on(const qb::KillEvent& /*event*/) {
        qb::io::cout() << "PongerActor [" << id() << "] shutting down.\n";
        kill();
    }
};

// --- 4. Main Application Logic ---
int main() {
    qb::io::cout() << "--- QB Ping-Pong Actor Example ---\n";

    // Create the QB Engine instance
    qb::Main engine;

    // Add the PongerActor to core 0. We need its ID to pass to PingerActor.
    qb::ActorId ponger_id = engine.addActor<PongerActor>(0);
    if (!ponger_id.is_valid()) {
        qb::io::cout() << "Error: Failed to add PongerActor!\n";
        return 1;
    }
    qb::io::cout() << "PongerActor created on core 0 with ID: " << ponger_id << ".\n";

    // Add the PingerActor to core 0, providing it with the PongerActor's ID.
    qb::ActorId pinger_id = engine.addActor<PingerActor>(0, ponger_id);
    if (!pinger_id.is_valid()) {
        qb::io::cout() << "Error: Failed to add PingerActor!\n";
        return 1;
    }
    qb::io::cout() << "PingerActor created on core 0 with ID: " << pinger_id << ".\n";

    // Start the engine. This call will block until all actors have terminated.
    qb::io::cout() << "Starting QB engine...\n";
    engine.start(false); // false = run synchronously in this thread

    qb::io::cout() << "QB engine has stopped.\n";

    // Check if any VirtualCore encountered an error during execution
    if (engine.hasError()) {
        qb::io::cout() << "Error: Engine stopped due to an error in a VirtualCore!\n";
        return 1;
    }

    qb::io::cout() << "--- Ping-Pong Example Finished Successfully ---\n";
    return 0;
}