#include <Core/Any.h>
#include <Core/Type.h>
#include <Core/TypeSerializer.h>
#include <Core/Types.h>
#include <Core/Buffer.h>
#include <Core/StringConverter.h>
#include <string>

using namespace Core;

// Define IDs for default types
namespace Core
{
	// Generalized 
	template <class TValue
		, void (Buffer::*TToBuffer)(TValue)
		, TValue (Buffer::*TFromBuffer)()
		, std::string (*TToString)(TValue)
		, TValue (*TFromString)(const std::string&)>
	class CoreTypeSerializer : public TypeSerializer
	{
	public:
		// Buffer
		virtual bool supportsBuffer() const { return true; }
		virtual void toBuffer(const Any& value, Buffer& buffer) const
		{
			((&buffer)->*TToBuffer)(value.get<TValue>());
		}
		virtual void fromBuffer(Any& value, Buffer& buffer) const
		{
			value.set<TValue>(((&buffer)->*TFromBuffer)());
		}
		// String
		virtual bool supportsString() const { return true; }
		virtual std::string toString(const Any& value) const
		{
			return (*TToString)(value.get<TValue>());
		}
		virtual void fromString(Any& value, const std::string& str) const
		{
			value.set<TValue>((*TFromString)(str));
		}
	};

	class CORE_API BufferSerializer : public DefaultTypeSerializer
	{
	public:
		virtual bool supportsBuffer() const { return true; }
		virtual void toBuffer(const Any& source, Buffer& target) const
		{
			target.writeBuffer(source.get<Buffer>());
		}
		virtual void fromBuffer(Any& target, Buffer& source) const
		{
			target.set<Buffer>(source.readBuffer());
		}
	};

	void initialize()
	{
		// Register default types
		Types::registerType<int32>(TYPE_INT32, "int32", new CoreTypeSerializer<int32, &Buffer::writeInteger, &Buffer::readInteger, &StringConverter::fromInteger, &StringConverter::toInteger>());
		Types::registerType<uint32>(TYPE_UINT32, "uint32", new CoreTypeSerializer<uint32, &Buffer::writeUnsignedInteger, &Buffer::readUnsignedInteger, &StringConverter::fromUnsignedInteger, &StringConverter::toUnsignedInteger>());
		Types::registerType<int16>(TYPE_INT16, "int16", new CoreTypeSerializer<int16, &Buffer::writeShort, &Buffer::readShort, &StringConverter::fromShort, &StringConverter::toShort>());
		Types::registerType<uint16>(TYPE_UINT16, "uint16", new CoreTypeSerializer<uint16, &Buffer::writeUnsignedShort, &Buffer::readUnsignedShort, &StringConverter::fromUnsignedShort, &StringConverter::toUnsignedShort>());
		Types::registerType<int8>(TYPE_INT8, "int8", new CoreTypeSerializer<int8, &Buffer::writeChar, &Buffer::readChar, &StringConverter::fromChar, &StringConverter::toChar>());
		Types::registerType<uint8>(TYPE_UINT8, "uint8", new CoreTypeSerializer<uint8, &Buffer::writeUnsignedChar, &Buffer::readUnsignedChar, &StringConverter::fromUnsignedChar, &StringConverter::toUnsignedChar>());
		Types::registerType<bool>(TYPE_BOOLEAN, "boolean", new CoreTypeSerializer<bool, &Buffer::writeBoolean, &Buffer::readBoolean, &StringConverter::fromBoolean, &StringConverter::toBoolean>());
		Types::registerType<float>(TYPE_FLOAT, "float", new CoreTypeSerializer<float, &Buffer::writeFloat, &Buffer::readFloat, &StringConverter::fromFloat, &StringConverter::toFloat>());
		Types::registerType<double>(TYPE_DOUBLE, "double", new CoreTypeSerializer<double, &Buffer::writeDouble, &Buffer::readDouble, &StringConverter::fromDouble, &StringConverter::toDouble>());
		Types::registerType<std::string>(TYPE_STRING, "string", new CoreTypeSerializer<std::string, &Buffer::writeString, &Buffer::readString, &StringConverter::fromString, &StringConverter::toString>());
		Types::registerType<Buffer>(TYPE_BUFFER, "buffer", new BufferSerializer());
	}
}