#include "ehs/json/JsonObj.h"
#include "ehs/json/JsonVar.h"

namespace ehs
{
	JsonObj::~JsonObj()
	{
		delete[] vars;
	}

	JsonObj::JsonObj()
		: JsonBase(JsonType::OBJ), size(0), extra(0), rawSize(0), vars(nullptr)
	{
	}

	JsonObj::JsonObj(const UInt_64 size, const UInt_64 extra)
		: JsonBase(JsonType::OBJ), size(size), extra(extra), rawSize(size + extra), vars(new JsonVar[size + extra])
	{
	}

	JsonObj::JsonObj(const UInt_64 extra)
		: JsonBase(JsonType::OBJ), size(0), extra(extra), rawSize(extra), vars(new JsonVar[extra])
	{
	}

	JsonObj::JsonObj(JsonObj&& value) noexcept
		: JsonBase(value), size(value.size), extra(value.extra), rawSize(value.rawSize), vars(value.vars)
	{
		value.size = 0;
		value.extra = 0;
		value.rawSize = 0;
		value.vars = nullptr;
	}

	JsonObj::JsonObj(const JsonObj& value)
		: JsonBase(value), size(value.size), extra(value.extra), rawSize(value.rawSize), vars(new JsonVar[value.rawSize])
	{
		for (UInt_64 i = 0; i < size; ++i)
			vars[i] = value.vars[i];
	}

	JsonObj& JsonObj::operator=(JsonObj&& value) noexcept
	{
		if (this == &value)
			return *this;

		JsonBase::operator=(value);

		size = value.size;
		extra = value.extra;
		rawSize = value.rawSize;
		delete[] vars;
		vars = value.vars;

		value.size = 0;
		value.extra = 0;
		value.rawSize = 0;
		value.vars = nullptr;

		return *this;
	}

	JsonObj& JsonObj::operator=(const JsonObj& value)
	{
		if (this == &value)
			return *this;

		JsonBase::operator=(value);

		size = value.size;
		extra = value.extra;
		rawSize = value.rawSize;

		delete[] vars;
		vars = new JsonVar[value.rawSize];
		for (UInt_64 i = 0; i < value.rawSize; ++i)
			vars[i] = value.vars[i];

		return *this;
	}

	JsonObj::operator const JsonVar*() const
	{
		return vars;
	}

	JsonObj::operator JsonVar*()
	{
		return vars;
	}

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

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

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

	bool JsonObj::HasVar(const UInt_64 hashId) const
	{
		for (UInt_64 i = 0; i < size; ++i)
			if (vars[i].GetHashId() == hashId)
				return true;

		return false;
	}

	bool JsonObj::HasVar(const Str_8& identifier) const
	{
		return HasVar(identifier.Hash_64());
	}

	bool JsonObj::AddVar(const JsonVar& var)
	{
		if (!var.GetHashId() || HasVar(var.GetHashId()))
			return false;

		if (size + 1 > rawSize)
		{
			rawSize += extra ? extra : 1;
			JsonVar* result = new JsonVar[rawSize];

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

			delete[] vars;
			vars = result;
		}

		vars[size++] = var;

		return true;
	}

	const JsonVar* JsonObj::GetVar(const UInt_64 hashId) const
	{
		for (UInt_64 i = 0; i < size; ++i)
			if (vars[i].GetHashId() == hashId)
				return &vars[i];

		return nullptr;
	}

	const JsonVar* JsonObj::GetVar(const Str_8& identifier) const
	{
		return GetVar(identifier.Hash_64());
	}

	JsonVar* JsonObj::GetVar(const UInt_64 hashId)
	{
		for (UInt_64 i = 0; i < size; ++i)
			if (vars[i].GetHashId() == hashId)
				return &vars[i];

		return nullptr;
	}

	JsonVar* JsonObj::GetVar(const Str_8& identifier)
	{
		return GetVar(identifier.Hash_64());
	}

	Str_8 JsonObj::ToStr(const UInt_64 level, const bool compact) const
	{
		Str_8 result;

		result += "{";

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

		for (UInt_64 i = 0; i < size; ++i)
		{
			result += vars[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;
	}
}