#pragma once

#include "Utils/UUID.hpp"
#include "cplt_fwd.hpp"

#include <string>
#include <string_view>
#include <vector>

#include <cstddef>
#include <cstdint>
#include <span>

namespace DataStreamIntegrations {
template <class TElement>
void ReadFromDataStream(DataStream& s, std::vector<TElement>& vec);
template <class TElement>
void WriteToDataStream(DataStream& s, const std::vector<TElement>& vec);

void ReadFromDataStream(DataStream& s, std::string& str);
void WriteToDataStream(DataStream& s, const std::string& str);

void WriteToDataStream(DataStream& s, const std::string_view& str);

void ReadFromDataStream(DataStream& s, uuids::uuid& uuid);
void WriteToDataStream(DataStream& s, const uuids::uuid& uuid);

template <class T>
void OperateIOAdapter(T&, int);
} // namespace DataStreamIntegrations

class SerializationAdapter
{
public:
	static constexpr bool IsSerializer()
	{
		return true;
	}

public:
	DataStream* Stream;

	template <class T>
	void Bytes(size_t byteCount, T* buffer) const
	{
		Stream->WriteBytes(byteCount, buffer);
	}

	template <class T>
	void Value(T t) const
	{
		Stream->Write(t);
	}

	template <class T>
	void Object(T& obj) const
	{
		Stream->WriteObject(obj);
	}
};

class DeserializationAdapter
{
public:
	static constexpr bool IsSerializer()
	{
		return false;
	}

public:
	DataStream* Stream;

	template <class T>
	void Bytes(size_t byteCount, T* buffer) const
	{
		Stream->WriteBytes(byteCount, buffer);
	}

	template <class T>
	void Value(T& t) const
	{
		Stream->Read(t);
	}

	template <class T>
	void Object(T& obj) const
	{
		Stream->ReadObject(obj);
	}
};

namespace DataStreamTraits {

template <class T>
concept HasMember = requires(T t)
{
	t.ReadFromDataStream(std::declval<DataStream>());
};

template <class T>
concept HasIOAdapterMember = requires(T t)
{
	t.OperateIOAdapter(std::declval<SerializationAdapter>());
	t.OperateIOAdapter(std::declval<DeserializationAdapter>());
};

template <class T>
concept HasExtension = requires(T t)
{
	DataStreamIntegrations::ReadFromDataStream(std::declval<DataStream>(), t);
};

template <class T>
concept HasIOAdapterExtension = requires(T t)
{
	DataStreamIntegrations::OperateIOAdapter(std::declval<SerializationAdapter>(), t);
	DataStreamIntegrations::OperateIOAdapter(std::declval<DeserializationAdapter>(), t);
};

} // namespace DataStreamTraits

class DataStream
{
public:
	enum Endianness
	{
		BigEndian,
		LittleEndian,
	};

private:
	Endianness mEndian;

public:
	DataStream();
	~DataStream();

	Endianness GetEndianness() const;
	void SetEndianness(Endianness endianness);

	void ReadBytes(size_t byteCount, std::byte* buffer);
	void ReadBytes(size_t byteCount, char* buffer);
	void ReadBytes(size_t byteCount, signed char* buffer);
	void ReadBytes(size_t byteCount, unsigned char* buffer);

	template <class TInserter>
	void ReadBytes(size_t byteCount, TInserter&& inserter)
	{
		for (size_t i = 0; i < byteCount; ++i) {
			uint8_t byte;
			Read(byte);

			inserter = byte;
		}
	}

	void WriteBytes(size_t byteCount, const std::byte* buffer);
	void WriteBytes(size_t byteCount, const char* buffer);
	void WriteBytes(size_t byteCount, const signed char* buffer);
	void WriteBytes(size_t byteCount, const unsigned char* buffer);

	template <class TIterator>
	void WriteBytes(TIterator&& begin, TIterator&& end)
	{
		for (; begin != end; ++begin) {
			uint8_t byte = *begin;
			Write(byte);
		}
	}

	void Write(int8_t n);
	void Write(int16_t n);
	void Write(int32_t n);
	void Write(int64_t n);

	void Read(int8_t& n);
	void Read(int16_t& n);
	void Read(int32_t& n);
	void Read(int64_t& n);

	void Write(uint8_t n);
	void Write(uint16_t n);
	void Write(uint32_t n);
	void Write(uint64_t n);

	void Read(uint8_t& n);
	void Read(uint16_t& n);
	void Read(uint32_t& n);
	void Read(uint64_t& n);

	void Write(float n);
	void Write(double n);

	void Read(float& n);
	void Read(double& n);

	template <class TObject>
	void ReadObject(TObject& obj)
	{
		using namespace DataStreamTraits;
		if constexpr (HasMember<TObject>) {
			obj.ReadFromDataStream(*this);
		} else if constexpr (HasIOAdapterMember<TObject>) {
			DeserializationAdapter adapter{ this };
			obj.OperateIOAdapter(adapter);
		} else if constexpr (HasExtension<TObject>) {
			DataStreamIntegrations::ReadFromDataStream(*this, obj);
		} else if constexpr (HasIOAdapterExtension<TObject>) {
			DeserializationAdapter adapter{ this };
			DataStreamIntegrations::OperateIOAdapter(adapter, obj);
		} else {
			static_assert(false && sizeof(TObject), "This type does not have integration with DataStream.");
		}
	}

	template <class TObject>
	void WriteObject(TObject& obj)
	{
		using namespace DataStreamTraits;
		if constexpr (HasMember<TObject>) {
			obj.WriteToDataStream(*this);
		} else if constexpr (HasIOAdapterMember<TObject>) {
			SerializationAdapter adapter{ this };
			obj.OperateIOAdapter(adapter);
		} else if constexpr (HasExtension<TObject>) {
			DataStreamIntegrations::WriteToDataStream(*this, obj);
		} else if constexpr (HasIOAdapterExtension<TObject>) {
			SerializationAdapter adapter{ this };
			DataStreamIntegrations::OperateIOAdapter(adapter, obj);
		} else {
			static_assert(false && sizeof(TObject), "This type does not have integration with DataStream.");
		}
	}
};