#include <cassert>
#include <functional>
#include <iostream>
#include <memory>
#include <typeindex>
#include <unordered_map>
#include <vector>

#include "../src/device/EventBus.h"
class ProdA {};
class ProdB {};

class ConsA {
  public:
    int counter = 0;
    void surProdA(const ProdA &) { counter++; }
};

class ConsB {
  public:
    int counter = 0;
    void surProdA(const ProdA &) { counter++; }
    void surProdB(const ProdB &) { counter++; }
};

class ConsC {
  public:
    int counter = 0;
    void surProdB(const ProdB &) { counter++; }
};

int main() {
    std::cout << "--- Starting EventBus Test ---" << std::endl;

    EventBus bus;

    // Consumer
    ConsA consA;
    ConsB consB;
    ConsC consC;

    // Setup abonnement

    // ConsA react to ProdA
    bus.subscribe<ProdA>([&consA](const ProdA &e) { consA.surProdA(e); });

    // ConsB react to ProdA and ProdB
    bus.subscribe<ProdA>([&consB](const ProdA &e) { consB.surProdA(e); });
    bus.subscribe<ProdB>([&consB](const ProdB &e) { consB.surProdB(e); });

    // ConsC react to ProdB
    bus.subscribe<ProdB>([&consC](const ProdB &e) { consC.surProdB(e); });

    // Test of publishement

    assert(consA.counter == 0);
    assert(consB.counter == 0);
    assert(consC.counter == 0);
    std::cout << "--- Publishing of ProdA ---" << std::endl;
    ProdA prodA;

    bus.publish(prodA);

    assert(consA.counter == 1);
    assert(consB.counter == 1);
    assert(consC.counter == 0);

    std::cout << "--- Publishing of ProdB ---" << std::endl;
    ProdB prodB;
    bus.publish(prodB);
    assert(consA.counter == 1);
    assert(consB.counter == 2);
    assert(consC.counter == 1);

    std::cout << "--- SUCCESS ---" << std::endl;

    return 0;
}