#include <rcp.h>
#include <cassert>
#include <vector>

static int mybase_construct;
static int mybase_destruct;
static int myderived_construct;
static int myderived_destruct;

class MyBase
{
    rcp_managed_root(MyBase);

protected:
    MyBase(int x, int y)
    {
        this->x = x;
        this->y = y;
        mybase_construct++;
    }

    virtual ~MyBase()
    {
        mybase_destruct++;
    }

public:
    int x;
    int y;
};

class MyDerived : public MyBase
{
    rcp_managed(MyDerived);

protected:
    MyDerived(double v) : MyBase(1, 2)
    {
        this->v = v;
        myderived_construct++;
    }

    virtual ~MyDerived()
    {
        myderived_destruct++;
    }

public:
    double v;
};

void test_class_hierarchy()
{
    {
        rcp<MyBase> mybase = MyBase::create(4, 5);
        rcp<MyDerived> myderived = MyDerived::create(42.5);
    }
    assert(mybase_construct == 2);
    assert(mybase_destruct == 2);
    assert(myderived_construct == 1);
    assert(myderived_destruct == 1);
}

void test_dereference()
{
    rcp<MyBase> mybase = MyBase::create(2, 3);
    assert(mybase->x == 2);
    assert(mybase->y == 3);
    assert((*mybase).x == 2);
    assert((*mybase).y == 3);
}

void test_booleans()
{
    rcp<MyBase> mybase = MyBase::create(2, 3);
    assert(mybase);
    rcp<MyDerived> myderived;
    assert(!myderived);
}

void test_create()
{
    typedef rcp<MyBase> MyB;
    MyB myb = MyB::create(8, 9);
    assert(myb->x == 8);
}

struct MyObj
{
    rcp_managed_root(MyObj);
public:
    int v = {42};
    template <typename R>
    void add_to(R & receiver)
    {
        receiver.add(this);
    }
};
struct Receiver
{
    std::vector<rcp<MyObj>> objects;
    void add(MyObj * o)
    {
        objects.push_back(rcp<MyObj>(o));
    }
};

void test_multi_construct_from_raw_pointers()
{
    Receiver r;
    auto myo = MyObj::create();
    for (size_t i = 0u; i < 5u; i++)
    {
        myo->add_to(r);
    }
    for (size_t i = 0u; i < 5u; i++)
    {
        assert(r.objects[i]->v == 42);
    }
}

int main(int argc, char * argv[])
{
    test_class_hierarchy();
    test_dereference();
    test_booleans();
    test_create();
    test_multi_construct_from_raw_pointers();
    return 0;
}