#pragma once

#include "memory.hpp"

#include "utils.hpp"

#include <Arduino.h>
#include <stdlib.h>

template <typename memType>
memType *malloc_s(unsigned int size)
{
	auto *mem = malloc(size);

	if (mem == nullptr)
	{
		Serial.println("Error: Memory allocation failed");
		while (true) {}
	}

	return static_cast<memType *>(mem);
}

template <class Target>
UniquePtr<Target>::UniquePtr(Target *target) : _target(target)
{
}

template <class Target>
UniquePtr<Target>::UniquePtr(const UniquePtr &unique_ptr)
	: _target(new Target(*(unique_ptr._target)))
{
}

template <class Target>
UniquePtr<Target>::UniquePtr(UniquePtr &&unique_ptr) noexcept
	: _target(unique_ptr._target)
{
	unique_ptr._target = nullptr;
}

template <class Target>
UniquePtr<Target> &UniquePtr<Target>::operator=(const UniquePtr &unique_ptr)
{
	if (&unique_ptr != this)
	{
		delete _target;
		_target = nullptr;
		_target = new Target(*(unique_ptr._target));
	}

	return *this;
}

template <class Target>
UniquePtr<Target> &UniquePtr<Target>::operator=(UniquePtr &&unique_ptr) noexcept
{
	if (&unique_ptr != this)
	{
		delete _target;
		_target = unique_ptr._target;
		unique_ptr._target = nullptr;
	}

	return *this;
}

template <class Target>
UniquePtr<Target>::~UniquePtr()
{
	if (this->_target != nullptr)
	{
		delete this->_target;
	}
}

template <class Target>
Target UniquePtr<Target>::operator*() const
{
	return *(this->_target);
}

template <class Target>
Target *UniquePtr<Target>::operator->() const
{
	return this->_target;
}

template <class Target, typename... Args>
UniquePtr<Target> make_unique(Args... args)
{
	return UniquePtr<Target>(new Target(args...));
}