#include <DuinoMemory.hpp>
using namespace DuinoMemory;

S_ptr<Foo> ptr = make_shared<Foo>();

if (ptr)
{
    ptr->do_something();
}

// Share ownership safely
S_ptr<Foo> other = ptr;
Serial.println(ptr.count()); // 2

// example.ino
#include <DuinoMemory.hpp>         // Import library.

// Declare and initialize a null (nullptr) U_ptr.
DuinoMemory::U_ptr<Foo> foo{ };   

// Declare and initialize a null (nullptr) S_ptr.
DuinoMemory::S_ptr<Bar> bar{ };   

void some_func(Foo* some_foo, Bar* some_bar) {
    //-------------------------------------------------------------------------
    // Common use cases
    //-------------------------------------------------------------------------

    // Use allocation function (recommended).
    foo = DuinoMemory::make_unique<Foo>();       

    // Also exists with parameters. The number and types of arguments must match 
    // an existing constructor of the template type.
    bar = DuinoMemory::make_shared<Bar>(param);  

    // You can also make polymorphic instantiations with either S_ptr or U_ptr, 
    // with or without parameters. Make sure Bar has a virtual destructor.
    bar = DuinoMemory::make_shared<Bar, BarDerived>(param);

    // foo being a U_ptr, some_ptr will be destroyed when exiting the scope of
    // this function. For that reason, some_ptr must not belong to any
    // SmartPointer. Here foo takes ownership of some_ptr.
    foo = some_foo;

    // Initializes reference count at 1. Reference count decreases whenever one
    // S_ptr referencing it is assigned a new value or goes out of scope. When
    // count reaches 0, some_ptr will be destroyed. For that reason, some_bar 
    // must not belong to any SmartPointer, as it may lead to undefined behavior.
    bar = some_bar;

    // Perfectly fine if the function allocates and returns a raw pointer or
    // preferably in this case, a U_ptr<Foo>.
    foo = a_function_returning_raw_or_unique();

    // bar and bar2 point to the same object (reference count incremented).
    DuinoMemory::S_ptr<Bar> bar2 = bar;
    DuinoMemory::S_ptr<Bar> bar3{ bar };    // Copy ctor
    size_t count = bar.count();  // 3

    // Proper way of transferring ownership with U_ptr.
    DuinoMemory::U_ptr<Foo> new_owner = foo.release();  // now foo == nullptr

    // If you need to copy data (same method for S_ptr). Foo must have a
    // copy constructor.
    DuinoMemory::U_ptr<Foo> copy = DuinoMemory::make_unique<Foo>{ *foo };

    //-------------------------------------------------------------------------
    // Not recommended
    //-------------------------------------------------------------------------
    
    // Code smell; defeats the purpose of a smart pointer
    foo = new Foo{ };

    //-------------------------------------------------------------------------
    // DON'T DO THAT
    //-------------------------------------------------------------------------

    // Already belongs to foo. Undefined behavior.
    DuinoMemory::U_ptr<Foo> foo_undefined = some_ptr;
    DuinoMemory::S_ptr<Foo> foo_undefined_shared = some_ptr;

    // Undefined behavior: double reference count. Whichever reaches zero first
    // deletes the raw pointer.
    DuinoMemory::S_ptr<Bar> bar_undefined = bar.get(); 

    // Likewise, with U_ptr: double delete. Expect a crash.
    DuinoMemory::U_ptr<Foo> other_undefined = foo.get(); 

    //-------------------------------------------------------------------------
    // COMPILATION ERROR
    //-------------------------------------------------------------------------
    
    // U_ptr does not support copy.
    DuinoMemory::U_ptr<Foo> foo_1{ foo };
    foo_1 = foo;
}

//-------------------------------------------------------------------------
// Common use cases
//-------------------------------------------------------------------------
DuinoMemory::U_ptr<Foo> foo_array[capacity]; // OK
DuinoMemory::S_ptr<Bar> bar_array[capacity]; // OK

//-------------------------------------------------------------------------
// Not recommended
//-------------------------------------------------------------------------

// Resizing will cause heap fragmentation that can lead to crashes and resets.
DuinoMemory::U_ptr<Foo> foo_array = new DuinoMemory::U_ptr<Foo>[capacity];
DuinoMemory::S_ptr<Bar> bar_array = new DuinoMemory::S_ptr<Bar>[capacity];

void cleanup() {
    // Object will be destroyed when exiting the function.
    DuinoMemory::U_ptr<Foo> _tmp = foo.release();          

    // Decrements the reference count. If it reaches 0, object gets destroyed.
    bar2 = nullptr;
}

/**
 * Note:
 *   Dereferencing a null SmartPointer (* or ->) leads to 
 *   undefined behavior.
 *   Always check that the pointer is valid before dereferencing:
 *       if (ptr) { ptr->method(); }
 */
if (foo)
{
    // Dereference operator *
    Foo copy = *foo;
}

if (bar)
{
    // Dereference operator ->
    bar->method();
}

// Get the raw pointer (can be nullptr).
Bar* ptr = bar.get();

// get reference count (S_ptr only). If either raw pointer or reference count is 
// nullptr, returns 0.
size_t ref_count = bar.count();

if (foo)               // Same as if (foo != nullptr)
{
    do_something();
}

if (!foo)              // Same as if (foo == nullptr)
{
    crash(ErrorCode::NULLPTR);
}

// Works also with S_ptr
if (bar)
{
    bar->do_something();
}

if (!bar)
{
    log("ERROR -> nullptr detected");
}

struct Base {
    virtual void say() { Serial.println("Base"); }
    virtual ~Base() = default;
};

struct Derived : public Base {
    void say() override { Serial.println("Derived"); }
};

// U_ptr with derived
DuinoMemory::U_ptr<Base> up = DuinoMemory::make_unique<Base, Derived>();
up->say();  // Prints "Derived"

// S_ptr with derived
DuinoMemory::S_ptr<Base> sp = DuinoMemory::make_shared<Base, Derived>();
sp->say();  // Prints "Derived"

// Reference counting
DuinoMemory::S_ptr<Base> sp2 = sp;
Serial.println(sp.count()); // 2
sp = nullptr;
Serial.println(sp2.count()); // 1

struct Base {
    virtual ~Base() {}   // Required
};

struct Derived : Base {
    ~Derived() {
        // resources freed correctly
    }
};

DuinoMemory::S_ptr<Base> ptr = DuinoMemory::make_shared<Base, Derived>(); // Safe
DuinoMemory::U_ptr<Base> ptr2 = DuinoMemory::make_unique<Base, Derived>();// Safe

Foo* raw = new Foo();
S_ptr<Foo> a{ raw };
S_ptr<Foo> b{ raw };    // DANGER: double delete
U_ptr<Foo> c = b.get(); // DANGER: double delete

U_ptr<Foo> a = make_unique<Foo>();
U_ptr<Foo> b = a.release(); // SAFE, a == nullptr.

S_ptr<Foo> a = make_shared<Foo>();
S_ptr<Foo> b = a;      // SAFE
S_ptr<Foo> c{ b };     // SAFE

// Undefined behavior.
DuinoMemory::U_ptr<Foo[]> foo_array{ };    
DuinoMemory::S_ptr<Bar[]> bar_array{ };