#pragma once

#include <array>
template <typename T>
using Bytes = std::array<std::byte, sizeof(T)>;

// bit_cast used for going between ulong, float, etc. It's a new C++20 feature
#ifdef __cpp_lib_bit_cast
#include <bit>
using std::bit_cast;

// Fallback in case we're using C++17
#else
// bit-for-bit convert one type to another. In C++ the only non-UB way to do this is *memcpy*. Nearly every other
// option is a strict aliasing violation.
template<class To, class From>
std::enable_if_t<
	sizeof(To) == sizeof(From),
	To>
bit_cast(const From &src) noexcept
{
	To dst;
	std::memcpy(&dst, &src, sizeof(To));
	return dst;
}
#endif


/** Converts a 16-bit host integer or float value to bytes in big-endian (Network) order.
@tparam Value The host 16-bit type (Int16, UInt16). Usually inferred.
@param a_Value The input integer or float value.
@return The resulting bytes. */
template<typename Value, std::enable_if_t<sizeof(Value) == 2, bool> = true>
inline Bytes<Value> HostToNetwork(Value a_Value)
{
	UInt16 Bits = bit_cast<UInt16>(a_Value);
	return
	{
		std::byte(Bits >> 8),
		std::byte(Bits)
	};
}

/** Converts a 32-bit host integer or float value to bytes in big-endian (Network) order.
@tparam Value The host 32-bit type (Int32, UInt32, float). Usually inferred.
@param a_Value The input integer or float value.
@return The resulting bytes. */
template<typename Value, std::enable_if_t<sizeof(Value) == 4, bool> = true>
inline Bytes<Value> HostToNetwork(Value a_Value)
{
	UInt32 Bits = bit_cast<UInt32>(a_Value);
	return
	{
		std::byte(Bits >> 24),
		std::byte(Bits >> 16),
		std::byte(Bits >> 8),
		std::byte(Bits)
	};
}

/** Converts a 64-bit host integer or float value to bytes in big-endian (Network) order.
@tparam Value The host 64-bit type (Int64, UInt64, double). Usually inferred.
@param a_Value The input integer or float value.
@return The resulting bytes. */
template<typename Value, std::enable_if_t<sizeof(Value) == 8, bool> = true>
inline Bytes<Value> HostToNetwork(Value a_Value)
{
	UInt64 Bits = bit_cast<UInt64>(a_Value);
	return
	{
		std::byte(Bits >> 56),
		std::byte(Bits >> 48),
		std::byte(Bits >> 40),
		std::byte(Bits >> 32),
		std::byte(Bits >> 24),
		std::byte(Bits >> 16),
		std::byte(Bits >> 8),
		std::byte(Bits)
	};
}

/** Reads a 16-bit integer or float value from big-endian (Network) bytes.
@tparam Value The desired 16-bit type (Int16, UInt16)
@param a_Value The input bytes.
@return The resulting integer or float value. */
template<typename Value, std::enable_if_t<sizeof(Value) == 2, bool> = true>
inline Value NetworkToHost(Bytes<Value> a_Value)
{
	UInt16 val = UInt16(
		UInt16(a_Value[0]) << 8 |
		UInt16(a_Value[1]));
	return bit_cast<Value>(val);
}

/** Reads a 32-bit integer or float value from big-endian (Network) bytes.
@tparam Value The desired 32-bit type (Int32, UInt32, float)
@param a_Value The input bytes.
@return The resulting integer or float value. */
template<typename Value, std::enable_if_t<sizeof(Value) == 4, bool> = true>
inline Value NetworkToHost(Bytes<Value> a_Value)
{
	UInt32 val = UInt32(
		UInt32(a_Value[0]) << 24 |
		UInt32(a_Value[1]) << 16 |
		UInt32(a_Value[2]) << 8 |
		UInt32(a_Value[3]));
	return bit_cast<Value>(val);
}

/** Reads a 64-bit integer or float value from big-endian (Network) bytes.
@tparam Value The desired 64-bit type (Int64, UInt64, double)
@param a_Value The input bytes.
@return The resulting integer or float value. */
template<typename Value, std::enable_if_t<sizeof(Value) == 8, bool> = true>
inline Value NetworkToHost(Bytes<Value> a_Value)
{
	UInt64 val = UInt64(
		UInt64(a_Value[0]) << 56 |
		UInt64(a_Value[1]) << 48 |
		UInt64(a_Value[2]) << 40 |
		UInt64(a_Value[3]) << 32 |
		UInt64(a_Value[4]) << 24 |
		UInt64(a_Value[5]) << 16 |
		UInt64(a_Value[6]) << 8 |
		UInt64(a_Value[7]));
	return bit_cast<Value>(val);
}

/** Reads an integer or float type from its big-endian (Network) bytes.
@tparam Value The desired result type (Int16 / 32 / 64, UInt16 / 32 / 64, float, double).
@param a_Mem A pointer to the first input byte. Length is inferred from the result type.
@return The resulting integer or float value.

Consider using NetworkToHost when the data is owned since it provides additional type safety (length is known). */
template<typename Value>
inline Value NetworkBufToHost(const std::byte* a_Mem)
{
	// Copy unfortunately needed to add the length information required by the rest of the API.
	// Gets completely optimised out in my testing.
	Bytes<Value> bytes;
	std::copy(a_Mem, a_Mem + sizeof(Value), bytes.begin());
	return NetworkToHost<Value>(bytes);
}