#include "Json_Utilities.hpp"

// std::string 构造
Json_Value::Json_Value(std::string str) : private_type(TYPE_STR), p_mem(malloc(sizeof(str)))
{
    if (p_mem != nullptr)
        new (p_mem) std::string(str);
    else
        this->private_type = TYPE_NULL;
}

// Json_Arry 构造
Json_Value::Json_Value(Json_Arry arry) : private_type(TYPE_ARRY), p_mem(malloc(sizeof(arry)))
{
    if (p_mem != nullptr)
        new (p_mem) Json_Arry(arry);
    else
        this->private_type = TYPE_NULL;
}

// Json_Object 构造
Json_Value::Json_Value(Json_Object object) : private_type(TYPE_OBJ), p_mem(malloc(sizeof(object)))
{
    if (p_mem != nullptr)
        new (p_mem) Json_Object(object);
    else
        this->private_type = TYPE_NULL;
}

// 整数值 构造
Json_Value::Json_Value(int64_t num_integer) : private_type(TYPE_NUM_INTEGER), p_mem(malloc(sizeof(num_integer)))
{
    if (p_mem != nullptr)
        *(decltype(num_integer) *)p_mem = num_integer;
    else
        this->private_type = TYPE_NULL;
}

// 浮点值 构造
Json_Value::Json_Value(double num_float) : private_type(TYPE_NUM_FLOAT), p_mem(malloc(sizeof(num_float)))
{
    if (p_mem != nullptr)
        *(decltype(num_float) *)p_mem = num_float;
    else
        this->private_type = TYPE_NULL;
}

// Boolean 逻辑值构造
Json_Value::Json_Value(bool boolean) : private_type(TYPE_BOOLEAN), p_mem(malloc(sizeof(boolean)))
{
    if (p_mem != nullptr)
        *(decltype(boolean) *)p_mem = boolean;
    else
        this->private_type = TYPE_NULL;
}

// 浅拷贝构造
Json_Value::Json_Value(const Json_Value &temp) : private_type(TYPE_NULL), p_mem(nullptr)
{
    // 执行深拷贝
    *this = temp;
}

// 深拷贝
Json_Value &Json_Value::operator=(const Json_Value &another)
{
    if (this != &another)
    {
        // 先析构释放内存
        this->~Json_Value();

        // 重新赋值
        this->private_type = another.type;
        switch (another.type)
        {
        case TYPE_STR:
            this->p_mem = malloc(sizeof(std::string));
            if (this->p_mem != nullptr)
                new (this->p_mem) std::string(*((std::string *)another.p_mem));
            break;
        case TYPE_ARRY:
            this->p_mem = malloc(sizeof(Json_Arry));
            if (this->p_mem != nullptr)
                new (this->p_mem) Json_Arry(*((Json_Arry *)another.p_mem));
            break;
        case TYPE_OBJ:
            this->p_mem = malloc(sizeof(Json_Object));
            if (this->p_mem != nullptr)
                new (this->p_mem) Json_Object(*((Json_Object *)another.p_mem));
            break;
        case TYPE_NUM_INTEGER:
            this->p_mem = malloc(sizeof(int64_t));
            if (this->p_mem != nullptr)
                *((int64_t *)this->p_mem) = *((int64_t *)another.p_mem);
            break;
        case TYPE_NUM_FLOAT:
            this->p_mem = malloc(sizeof(double));
            if (this->p_mem != nullptr)
                *((double *)this->p_mem) = *((double *)another.p_mem);
            break;
        case TYPE_BOOLEAN:
            this->p_mem = malloc(sizeof(bool));
            if (this->p_mem != nullptr)
                *((bool *)this->p_mem) = *((bool *)another.p_mem);
            break;
        default:
            this->p_mem = nullptr;
        }
    }

    return *this;
}

// 析构
Json_Value::~Json_Value()
{
    this->private_type = TYPE_NULL;

    if (this->p_mem != nullptr)
    {
        // 对象析构
        switch (this->type)
        {
        case TYPE_STR:
            ((std::string *)p_mem)->~basic_string();
            break;
        case TYPE_ARRY:
            ((Json_Arry *)p_mem)->~Json_Arry();
            break;
        case TYPE_OBJ:
            ((Json_Object *)p_mem)->~Json_Object();
            break;
        default:
            break;
        };

        // 释放内存
        free(p_mem);
    }
}

// 作为直接值获取
std::string Json_Value::asString(void)
{
    if (this->type == TYPE_STR)
        return *(std::string *)this->p_mem;
    else
        return std::string("");
}

// 作为 Json_Arry 获取
Json_Arry Json_Value::asArry(void)
{
    if (this->type == TYPE_ARRY)
        return *(Json_Arry *)this->p_mem;
    else
        return Json_Arry();
}

// 作为 Json_Object 获取
Json_Object Json_Value::asObject(void)
{
    if (this->type == TYPE_OBJ)
        return *(Json_Object *)this->p_mem;
    else
        return Json_Object();
}

// 作为 int64 获取
int64_t Json_Value::asInteger(void)
{
    if (this->type == TYPE_NUM_INTEGER)
        return *(int64_t *)this->p_mem;
    else
        return 0;
}

// 作为 double 获取
double Json_Value::asFloat(void)
{
    if (this->type == TYPE_NUM_FLOAT)
        return *(double *)this->p_mem;
    else
        return 0;
}

// 作为 Boolean 逻辑值获取
bool Json_Value::asBoolean(void)
{
    if (this->type == TYPE_BOOLEAN)
        return *(bool *)this->p_mem;
    else
        return 0;
}

// 是否为空
bool Json_Value::isNull(void)
{
    return (this->private_type == TYPE_NULL);
}

// =================================================================================================

// 浅拷贝构造
Json_Pair::Json_Pair(const Json_Pair &temp)
{
    *this = temp;
}

// 深拷贝
Json_Pair &Json_Pair::operator=(const Json_Pair &another)
{
    if (this != &another)
    {
        this->Null_Flag = another.Null_Flag;
        this->private_key_str = another.private_key_str;
        this->private_value = another.private_value;
    }

    return *this;
}

// 空判定
bool Json_Pair::isNull()
{
    return this->Null_Flag;
}

// =================================================================================================

// 深拷贝
Json_Arry &Json_Arry::operator=(const Json_Arry &another)
{
    if (this != &another)
    {
        this->private_element_list = another.private_element_list;
    }

    return *this;
}

// 获取元素大小
size_t Json_Arry::size(void)
{
    return this->private_element_list.size();
}

// 数组索引重载
Json_Value Json_Arry::operator[](size_t index)
{
    if (index < this->private_element_list.size())
        return this->private_element_list[index];
    else
        return Json_Value();
}

// 是否为空
bool Json_Arry::isNull(void)
{
    return (this->private_element_list.size() == 0);
}

// =================================================================================================

// 深拷贝
Json_Object &Json_Object::operator=(const Json_Object &another)
{
    if (this != &another)
    {
        this->private_element_list = another.private_element_list;
    }

    return *this;
}

// 获取元素大小
size_t Json_Object::size(void)
{
    return this->private_element_list.size();
}

// 数组索引重载
Json_Pair Json_Object::operator[](size_t index)
{
    if (index < this->private_element_list.size())
        return this->private_element_list[index];
    else
        return Json_Pair();
}

// 由Key 查找值
Json_Value Json_Object::get(std::string key)
{
    for (auto pair : this->private_element_list)
        if (pair.key == key)
            return pair.value;

    return Json_Value();
}

// 是否为空
bool Json_Object::isNull(void)
{
    return (this->private_element_list.size() == 0);
}