#include "usmart_ptr.h"

// For POD types - use allocate()
usmart_ptr<int> numbers;
numbers.allocate(100);
numbers[0] = 42;
// automatically freed when numbers goes out of scope

// For classes - use create() or create_array()
usmart_ptr<MyClass> obj;
obj.create(arg1, arg2);  // calls MyClass(arg1, arg2)
obj->doSomething();
// destructor automatically called when obj goes out of scope

// Array of objects with constructors
usmart_ptr<MyClass> arr;
arr.create_array(10);  // calls default constructor for all 10 elements
// all 10 destructors called automatically

// Factory function
auto ptr = make_usmart<MyClass>(arg1, arg2);

// allocate() - raw memory, NO constructors (for POD or manual construction)
usmart_ptr<int> buf;
buf.allocate(100);
buf[0] = 42;

// create() - allocate + constructor (for single object)
usmart_ptr<MyClass> obj;
obj.create(arg1, arg2);

// create_array() - allocate + constructor for each element
usmart_ptr<MyClass> arr;
arr.create_array(10);  // 10 default-constructed objects

// create_array() with value - copy constructor for each
MyClass template_obj(42);
arr.create_array(5, template_obj);  // 5 copies of template_obj

{
    usmart_ptr<MyClass> arr;
    arr.create_array(5);  // 5 constructors called
    // ... use arr ...
}  // 5 destructors automatically called here

class Base { virtual ~Base() = default; };
class Derived : public Base { };

usmart_ptr<Derived> derived;
derived.create();

// Converting move - Derived* to Base*
usmart_ptr<Base> base(static_cast<usmart_ptr<Derived>&&>(derived));
// derived is now nullptr
// base owns the pointer, virtual destructor works correctly

usmart_ptr<Data> owner;
owner.create();

// Non-owning reference
observer_ptr<Data> obs = owner.get_observer();
obs->process();  // Safe as long as owner is alive

// Or from raw pointer
auto obs2 = make_observer(owner.get());

usmart_ptr<Data> createData() {
    usmart_ptr<Data> p;
    p.create();
    p->value = 42;
    return p;  // Move semantics
}

void process() {
    usmart_ptr<Data> data = createData();  // Takes ownership

    usmart_ptr<Data> other = static_cast<usmart_ptr<Data>&&>(data);
    // data is now nullptr
    // other owns the pointer
}

heap_t heap1, heap2;
uint8_t heap1_mem[4096], heap2_mem[4096];

heap_init(&heap1, heap1_mem, sizeof(heap1_mem));
heap_init(&heap2, heap2_mem, sizeof(heap2_mem));

usmart_ptr<int> p1(&heap1);
p1.allocate(10);

auto p2 = make_usmart<MyClass>(&heap2, arg1, arg2);

#define USMART_PTR_DEBUG printf
#include "usmart_ptr.h"

#define USMART_PTR_ENABLE_ASSERTIONS
#include "usmart_ptr.h"
// Now null pointer dereference will trigger assert