#include "ehs/json/JsonArray.h"
#include "ehs/json/JsonObj.h"
#include "ehs/json/JsonBool.h"
#include "ehs/json/JsonNum.h"
#include "ehs/json/JsonStr.h"

namespace ehs
{
	JsonArray::~JsonArray()
	{
		for (UInt_64 i = 0; i < size; ++i)
			delete data[i];

		delete[] data;
	}

	JsonArray::JsonArray()
		: JsonBase(JsonType::ARRAY), size(0), extra(0), rawSize(0), data(nullptr)
	{
	}

	JsonArray::JsonArray(const UInt_64 extra)
		: JsonBase(JsonType::ARRAY), size(0), extra(extra), rawSize(extra), data(new JsonBase*[rawSize])
	{
	}

	JsonArray::JsonArray(const UInt_64 size, const UInt_64 extra)
		: JsonBase(JsonType::ARRAY), size(size), extra(extra), rawSize(size + extra), data(new JsonBase*[rawSize])
	{
	}

	JsonArray::JsonArray(JsonArray&& ja) noexcept
		: JsonBase(ja), size(ja.size), extra(ja.extra), rawSize(ja.rawSize), data(ja.data)
	{
		ja.size = 0;
		ja.extra = 0;
		ja.rawSize = 0;
		ja.data = nullptr;
	}

	JsonArray::JsonArray(const JsonArray& ja)
		: JsonBase(ja), size(ja.size), extra(ja.extra), rawSize(ja.rawSize), data(new JsonBase*[ja.rawSize])
	{
		for (UInt_64 i = 0; i < size; ++i)
		{
			switch (ja.data[i]->GetType())
			{
				case JsonType::OBJ:
					data[i] = (JsonBase*)new JsonObj(*(JsonObj*)ja.data[i]);
					break;
				case JsonType::ARRAY:
					data[i] = (JsonBase*)new JsonArray(*(JsonArray*)ja.data[i]);
					break;
				case JsonType::BOOL:
					data[i] = (JsonBase*)new JsonBool(*(JsonBool*)ja.data[i]);
					break;
				case JsonType::NUM:
					data[i] = (JsonBase*)new JsonNum(*(JsonNum*)ja.data[i]);
					break;
				case JsonType::STR:
					data[i] = (JsonBase*)new JsonStr(*(JsonStr*)ja.data[i]);
					break;
				default:
					data[i] = new JsonBase();
					break;
			}
		}
	}

	JsonArray& JsonArray::operator=(JsonArray&& ja) noexcept
	{
		if (this == &ja)
			return *this;

		JsonBase::operator=(ja);

		size = ja.size;
		extra = ja.extra;
		rawSize = ja.rawSize;
		delete[] data;
		data = ja.data;

		ja.size = 0;
		ja.extra = 0;
		ja.rawSize = 0;
		ja.data = nullptr;

		return *this;
	}

	JsonArray& JsonArray::operator=(const JsonArray& ja)
	{
		if (this == &ja)
			return *this;

		JsonBase::operator=(ja);

		size = ja.size;
		extra = ja.size;
		rawSize = ja.rawSize;

		delete[] data;
		data = new JsonBase*[rawSize];
		for (UInt_64 i = 0; i < ja.size; ++i)
		{
			switch (ja.data[i]->GetType())
			{
				case JsonType::OBJ:
					data[i] = (JsonBase*)new JsonObj(*(JsonObj*)ja.data[i]);
					break;
				case JsonType::ARRAY:
					data[i] = (JsonBase*)new JsonArray(*(JsonArray*)ja.data[i]);
					break;
				case JsonType::BOOL:
					data[i] = (JsonBase*)new JsonBool(*(JsonBool*)ja.data[i]);
					break;
				case JsonType::NUM:
					data[i] = (JsonBase*)new JsonNum(*(JsonNum*)ja.data[i]);
					break;
				case JsonType::STR:
					data[i] = (JsonBase*)new JsonStr(*(JsonStr*)ja.data[i]);
					break;
				default:
					data[i] = new JsonBase(JsonType::NULLOBJ);
					break;
			}
		}

		return *this;
	}

	JsonArray::operator JsonBase* const *() const
	{
		return data;
	}

	JsonArray::operator JsonBase**()
	{
		return data;
	}

	UInt_64 JsonArray::RawSize() const
	{
		return rawSize;
	}

	UInt_64 JsonArray::Extra() const
	{
		return extra;
	}

	UInt_64 JsonArray::Size() const
	{
		return size;
	}

	void JsonArray::Insert(const UInt_64 index, const JsonBase* const value)
	{
		if (size + 1 >= rawSize)
			rawSize = size + extra;

		JsonBase** result = new JsonBase*[rawSize];

		for (UInt_64 i = 0; i < index; ++i)
			result[i] = data[i];

		switch (value->GetType())
		{
			case JsonType::OBJ:
				result[index] = (JsonBase*)new JsonObj(*(JsonObj*)value);
				break;
			case JsonType::ARRAY:
				result[index] = (JsonBase*)new JsonArray(*(JsonArray*)value);
				break;
			case JsonType::BOOL:
				result[index] = (JsonBase*)new JsonBool(*(JsonBool*)value);
				break;
			case JsonType::NUM:
				result[index] = (JsonBase*)new JsonNum(*(JsonNum*)value);
				break;
			case JsonType::STR:
				result[index] = (JsonBase*)new JsonStr(*(JsonStr*)value);
				break;
			default:
				result[index] = new JsonBase(JsonType::NULLOBJ);
				break;
		}

		for (UInt_64 i = index; i < size; ++i)
			result[i + 1] = data[i];

		delete[] data;

		data = result;
		++size;
	}

	void JsonArray::Push(const JsonBase* const value)
	{
		if (size + 1 > rawSize)
		{
			rawSize = size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < size; ++i)
				result[i] = data[i];

			switch (value->GetType())
			{
				case JsonType::OBJ:
					result[size++] = (JsonBase*)new JsonObj(*(JsonObj*)value);
					break;
				case JsonType::ARRAY:
					result[size++] = (JsonBase*)new JsonArray(*(JsonArray*)value);
					break;
				case JsonType::BOOL:
					result[size++] = (JsonBase*)new JsonBool(*(JsonBool*)value);
					break;
				case JsonType::NUM:
					result[size++] = (JsonBase*)new JsonNum(*(JsonNum*)value);
					break;
				case JsonType::STR:
					result[size++] = (JsonBase*)new JsonStr(*(JsonStr*)value);
					break;
				default:
					result[size++] = new JsonBase(JsonType::NULLOBJ);
					break;
			}

			delete[] data;

			data = result;
		}
		else
		{
			switch (value->GetType())
			{
				case JsonType::OBJ:
					data[size++] = (JsonBase*)new JsonObj(*(JsonObj*)value);
					break;
				case JsonType::ARRAY:
					data[size++] = (JsonBase*)new JsonArray(*(JsonArray*)value);
					break;
				case JsonType::BOOL:
					data[size++] = (JsonBase*)new JsonBool(*(JsonBool*)value);
					break;
				case JsonType::NUM:
					data[size++] = (JsonBase*)new JsonNum(*(JsonNum*)value);
					break;
				case JsonType::STR:
					data[size++] = (JsonBase*)new JsonStr(*(JsonStr*)value);
					break;
				default:
					data[size++] = new JsonBase(JsonType::NULLOBJ);
					break;
			}
		}
	}

	void JsonArray::Push(const JsonBase& value)
	{
		if (size + 1 > rawSize)
		{
			rawSize = size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < size; ++i)
				result[i] = data[i];

			result[size++] = new JsonBase(value);

			delete[] data;

			data = result;
		}
		else
		{
			data[size++] = new JsonBase(value);
		}
	}

	void JsonArray::Push(const JsonObj& value)
	{
		if (size + 1 > rawSize)
		{
			rawSize = size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < size; ++i)
				result[i] = data[i];

			result[size++] = (JsonBase*)new JsonObj(value);

			delete[] data;

			data = result;
		}
		else
		{
			data[size++] = (JsonBase*)new JsonObj(value);
		}
	}

	void JsonArray::Push(const JsonArray& value)
	{
		if (size + 1 > rawSize)
		{
			rawSize = size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < size; ++i)
				result[i] = data[i];

			result[size++] = (JsonBase*)new JsonArray(value);

			delete[] data;

			data = result;
		}
		else
		{
			data[size++] = (JsonBase*)new JsonArray(value);
		}
	}

	void JsonArray::Push(const JsonBool& value)
	{
		if (size + 1 > rawSize)
		{
			rawSize = size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < size; ++i)
				result[i] = data[i];

			result[size++] = (JsonBase*)new JsonBool(value);

			delete[] data;

			data = result;
		}
		else
		{
			data[size++] = (JsonBase*)new JsonBool(value);
		}
	}

	void JsonArray::Push(const bool value)
	{
		if (size + 1 > rawSize)
		{
			rawSize = size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < size; ++i)
				result[i] = data[i];

			result[size++] = (JsonBase*)new JsonBool(value);

			delete[] data;

			data = result;
		}
		else
		{
			data[size++] = (JsonBase*)new JsonBool(value);
		}
	}

	void JsonArray::Push(const JsonNum& value)
	{
		if (size + 1 > rawSize)
		{
			rawSize = size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < size; ++i)
				result[i] = data[i];

			result[size++] = (JsonBase*)new JsonNum(value);

			delete[] data;

			data = result;
		}
		else
		{
			data[size++] = (JsonBase*)new JsonNum(value);
		}
	}

	void JsonArray::Push(const float value)
	{
		if (size + 1 > rawSize)
		{
			rawSize = size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < size; ++i)
				result[i] = data[i];

			result[size++] = (JsonBase*)new JsonNum(value);

			delete[] data;

			data = result;
		}
		else
		{
			data[size++] = (JsonBase*)new JsonNum(value);
		}
	}

	void JsonArray::Push(const JsonStr& value)
	{
		if (size + 1 > rawSize)
		{
			rawSize = size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < size; ++i)
				result[i] = data[i];

			result[size++] = (JsonBase*)new JsonStr(value);

			delete[] data;

			data = result;
		}
		else
		{
			data[size++] = (JsonBase*)new JsonStr(value);
		}
	}

	void JsonArray::Push(const Char_8* value, const UInt_64 size)
	{
		if (this->size + 1 > rawSize)
		{
			rawSize = this->size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < this->size; ++i)
				result[i] = data[i];

			result[this->size++] = (JsonBase*)new JsonStr(Str_8(value, size));

			delete[] data;

			data = result;
		}
		else
		{
			data[this->size++] = (JsonBase*)new JsonStr(Str_8(value, size));
		}
	}

	void JsonArray::Push(const Str_8& value)
	{
		if (this->size + 1 > rawSize)
		{
			rawSize = this->size + extra + 1;
			JsonBase** result = new JsonBase*[rawSize];

			for (UInt_64 i = 0; i < this->size; ++i)
				result[i] = data[i];

			result[this->size++] = (JsonBase*)new JsonStr(value);

			delete[] data;

			data = result;
		}
		else
		{
			data[this->size++] = (JsonBase*)new JsonStr(value);
		}
	}

	void JsonArray::Pop()
	{
		if (rawSize - --size >= extra * 2)
			rawSize -= extra;

		JsonBase** result = new JsonBase*[rawSize];
		for (UInt_64 i = 0; i < size; ++i)
			result[i] = data[i];

		delete[] data;

		data = result;
	}

	Str_8 JsonArray::ToStr(const UInt_64 level, const bool compact) const
	{
		Str_8 result = "[";

		if (!compact)
			result += "\r\n";

		for (UInt_64 i = 0; i < size; ++i)
		{
			if (!compact && (data[i]->GetType() == JsonType::OBJ || data[i]->GetType() == JsonType::ARRAY))
			{
				for (UInt_64 l = 0; l < level + 1; ++l)
					result += "\t";
			}

			result += data[i]->ToStr(level + 1, compact);

			if (i < size - 1)
				result += ",";

			if (!compact)
				result += "\r\n";
		}

		if (!compact)
		{
			for (UInt_64 l = 0; l < level; ++l)
				result += "\t";
		}

		result += "]";

		return result;
	}
}