#ifndef MEMBUFFER_HH
#define MEMBUFFER_HH

#include "MemoryOps.hh"

#include <algorithm>
#include <cassert>
#include <cstddef>
#include <cstdlib>
#include <new>      // for bad_alloc
#include <span>
#include <type_traits>

namespace openmsx {

/** This class manages the lifetime of a block of memory.
  *
  * Its two main use cases are:
  *  1) As a safer alternative for new[] / delete[].
  *     Using this class makes sure the memory block is always properly
  *     cleaned up. Also in case of exceptions.
  *  2) As an alternative for vector<byte> ('byte' or other primitive types).
  *     The main difference with vector is that the allocated block is left
  *     uninitialized. This can be a bit more efficient if the block will
  *     anyway soon be overwritten.
  *
  * Like vector this buffer can dynamically grow or shrink. But it's not
  * optimized for this case (it doesn't keep track of extra capacity). If you
  * need frequent resizing prefer to use vector instead of this class.
  */
template<typename T, size_t ALIGNMENT = 0> class MemBuffer
{
	static_assert(std::is_trivially_copyable_v<T>);
	static_assert(std::is_trivially_destructible_v<T>);
public:
	/** Construct an empty MemBuffer, no memory is allocated.
	 */
	MemBuffer()
		: dat(nullptr)
		, sz(0)
	{
	}

	/** Construct a (uninitialized) memory buffer of given size.
	 */
	explicit MemBuffer(size_t size)
		: dat(static_cast<T*>(my_malloc(size * sizeof(T))))
		, sz(size)
	{
	}

	/** Move constructor. */
	MemBuffer(MemBuffer&& other) noexcept
		: dat(other.dat)
		, sz(other.sz)
	{
		other.dat = nullptr;
		other.sz = 0;
	}

	/** Move assignment. */
	MemBuffer& operator=(MemBuffer&& other) noexcept
	{
		std::swap(dat, other.dat);
		std::swap(sz , other.sz);
		return *this;
	}

	/** Free the memory buffer.
	 */
	~MemBuffer()
	{
		my_free(dat);
	}

	/** Returns pointer to the start of the memory buffer.
	  * This method can be called even when there's no buffer allocated.
	  */
	[[nodiscard]] const T* data() const { return dat; }
	[[nodiscard]]       T* data()       { return dat; }

	[[nodiscard]]       T* begin()       { return data(); }
	[[nodiscard]] const T* begin() const { return data(); }
	[[nodiscard]]       T* end()         { return data() + size(); }
	[[nodiscard]] const T* end()   const { return data() + size(); }

	/** Access elements in the memory buffer.
	 */
	[[nodiscard]] const T& operator[](size_t i) const
	{
		assert(i < sz);
		return dat[i];
	}
	[[nodiscard]] T& operator[](size_t i)
	{
		assert(i < sz);
		return dat[i];
	}

	[[nodiscard]] bool empty() const { return sz == 0; }
	[[nodiscard]] size_t size() const { return sz; }

	[[nodiscard]] T& front()
	{
		assert(!empty());
		return dat[0];
	}
	[[nodiscard]] const T& front() const
	{
		assert(!empty());
		return dat[0];
	}
	[[nodiscard]] T& back()
	{
		assert(!empty());
		return dat[sz - 1];
	}
	[[nodiscard]] const T& back() const
	{
		assert(!empty());
		return dat[sz - 1];
	}

	[[nodiscard]] operator std::span<      T>()       { return {data(), size()}; }
	[[nodiscard]] operator std::span<const T>() const { return {data(), size()}; }

	[[nodiscard]] std::span<const T> first(size_t n) const
	{
		assert(n <= sz);
		return std::span{*this}.first(n);
	}
	[[nodiscard]] std::span<T> first(size_t n)
	{
		assert(n <= sz);
		return std::span{*this}.first(n);
	}
	[[nodiscard]] std::span<const T> subspan(size_t offset, size_t n = std::dynamic_extent) const
	{
		assert(offset <= sz);
		assert(n == std::dynamic_extent || (offset + n <= sz));
		return std::span{*this}.subspan(offset, n);
	}
	[[nodiscard]] std::span<T> subspan(size_t offset, size_t n = std::dynamic_extent)
	{
		assert(offset <= sz);
		assert(n == std::dynamic_extent || (offset + n <= sz));
		return std::span{*this}.subspan(offset, n);
	}

	/** Grow or shrink the memory block.
	  * In case of growing, the extra space is left uninitialized.
	  * It is possible (even likely) that the memory buffer is copied
	  * to a new location after this call, so data() will return a
	  * different pointer value.
	  */
	void resize(size_t size)
	{
		if (size) {
			dat = static_cast<T*>(my_realloc(dat, size * sizeof(T)));
			sz = size;
		} else {
			clear();
		}
	}

	/** Free the allocated memory block and set the current size to 0.
	 */
	void clear()
	{
		my_free(dat);
		dat = nullptr;
		sz = 0;
	}

private:
	// If the requested alignment is less or equally strict than the
	// guaranteed alignment by the standard malloc()-like functions
	// we use those. Otherwise we use platform specific functions to
	// request aligned memory.
	// A valid alternative would be to always use the platform specific
	// functions. The only disadvantage is that we cannot use realloc()
	// in that case (there are no, not even platform specific, functions
	// to realloc memory with bigger than default alignment).
	static constexpr bool SIMPLE_MALLOC = ALIGNMENT <= alignof(std::max_align_t);

	[[nodiscard]] static void* my_malloc(size_t bytes)
	{
		if constexpr (SIMPLE_MALLOC) {
			void* result = malloc(bytes);
			if (!result && bytes) throw std::bad_alloc();
			return result;
		} else {
			// already throws bad_alloc in case of error
			return MemoryOps::mallocAligned(ALIGNMENT, bytes);
		}
	}

	static void my_free(void* p)
	{
		if constexpr (SIMPLE_MALLOC) {
			free(p);
		} else {
			MemoryOps::freeAligned(p);
		}
	}

	[[nodiscard]] void* my_realloc(void* old, size_t bytes)
	{
		if constexpr (SIMPLE_MALLOC) {
			void* result = realloc(old, bytes);
			if (!result && bytes) throw std::bad_alloc();
			return result;
		} else {
			void* result = MemoryOps::mallocAligned(ALIGNMENT, bytes);
			if (!result && bytes) throw std::bad_alloc();
			MemoryOps::freeAligned(old);
			return result;
		}
	}

private:
	T* dat;
	size_t sz;
};

} // namespace openmsx

#endif