//
//  HJSONParseUtils.cpp
//  SteveMaggieCpp
//
//  Created by Katarzyna Kalinowska-Górska on 19.05.2017.
//
//

#include <stdio.h>
#include "HJSONParseUtils.h"

bool HJSONParseUtils::hasMemberBool(const Value& json, const char* memberName)
{
    return json.IsObject() && json.HasMember(memberName) && json[memberName].IsBool();
}

bool HJSONParseUtils::hasMemberInt(const Value& json, const char* memberName)
{
    return json.IsObject() && json.HasMember(memberName) && json[memberName].IsInt();
}

bool HJSONParseUtils::hasMemberFloat(const Value& json, const char* memberName)
{
    return json.IsObject() && json.HasMember(memberName) && (json[memberName].IsFloat() || json[memberName].IsInt());
}

bool HJSONParseUtils::hasMemberString(const Value& json, const char* memberName)
{
    return json.IsObject() && json.HasMember(memberName) && json[memberName].IsString();
}

bool HJSONParseUtils::hasMemberArray(const Value& json, const char* memberName)
{
    return json.IsObject() && json.HasMember(memberName) && json[memberName].IsArray();
}

bool HJSONParseUtils::hasMemberObject(const Value& json, const char* memberName)
{
    return json.IsObject() && json.HasMember(memberName) && json[memberName].IsObject();
}

bool HJSONParseUtils::hasMemberPoint(const Value& json, const char* memberName)
{
    return json.IsObject() && json.HasMember(memberName) && HJSONParseUtils::isPoint(json[memberName]);
}

cocos2d::Point HJSONParseUtils::getMemberPoint(const Value& json, const char* memberName)
{
    return HJSONParseUtils::getPoint(json[memberName]);
}

bool HJSONParseUtils::isPoint(const Value& json)
{
    return HJSONParseUtils::hasMemberFloat(json, "x") && HJSONParseUtils::hasMemberFloat(json, "y");
}

cocos2d::Point HJSONParseUtils::getPoint(const Value& json)
{
    auto x = json["x"].GetFloat();
    auto y = json["y"].GetFloat();
    return cocos2d::Point(x,y);
}

bool HJSONParseUtils::hasMemberSize(const Value& json, const char* memberName)
{
    return json.HasMember(memberName) && HJSONParseUtils::isSize(json[memberName]);
}

cocos2d::Point HJSONParseUtils::getMemberSize(const Value& json, const char* memberName)
{
    return HJSONParseUtils::getSize(json[memberName]);
}

bool HJSONParseUtils::isSize(const Value& json)
{
    return json.IsObject() && ((HJSONParseUtils::hasMemberFloat(json, "w") && HJSONParseUtils::hasMemberFloat(json, "h")) || (HJSONParseUtils::hasMemberFloat(json, "width") && HJSONParseUtils::hasMemberFloat(json, "height")));
}

cocos2d::Size HJSONParseUtils::getSize(const Value& json)
{
    auto w = -1, h = -1;
    if(HJSONParseUtils::hasMemberFloat(json, "w")){
        w = json["w"].GetFloat();
        h = json["h"].GetFloat();
    }
    else {
        w = json["width"].GetFloat();
        h = json["height"].GetFloat();
    }
    
    return cocos2d::Size(w,h);
}

bool HJSONParseUtils::hasMemberRect(const Value& json, const char* memberName)
{
    return json.HasMember(memberName) && HJSONParseUtils::isRect(json[memberName]);
}

cocos2d::Rect HJSONParseUtils::getMemberRect(const Value& json, const char* memberName)
{
   return HJSONParseUtils::getRect(json[memberName]);
}
    
bool HJSONParseUtils::isRect(const Value& json)
{
    return json.IsObject() && HJSONParseUtils::hasMemberFloat(json, "x") && HJSONParseUtils::hasMemberFloat(json, "y") && HJSONParseUtils::hasMemberFloat(json, "w") && HJSONParseUtils::hasMemberFloat(json, "h");
}

cocos2d::Rect HJSONParseUtils::getRect(const Value& json)
{
    auto x = json["x"].GetFloat();
    auto y = json["y"].GetFloat();
    auto w = json["w"].GetFloat();
    auto h = json["h"].GetFloat();
    return cocos2d::Rect(x,y,w,h);
}

bool HJSONParseUtils::hasMemberColor3B(const Value& json, const char* memberName)
{
    return json.HasMember(memberName) && HJSONParseUtils::isColor3B(json[memberName]);
}

cocos2d::Color3B HJSONParseUtils::getMemberColor3B(const Value& json, const char* memberName)
{
    return HJSONParseUtils::getColor3B(json[memberName]);
}

bool HJSONParseUtils::isColor3B(const Value& json)
{
    return json.IsObject() && HJSONParseUtils::hasMemberInt(json, "r") && HJSONParseUtils::hasMemberInt(json, "g") && HJSONParseUtils::hasMemberInt(json, "b");
}

cocos2d::Color3B HJSONParseUtils::getColor3B(const Value& json)
{
    auto r = json["r"].GetInt();
    auto g = json["g"].GetInt();
    auto b = json["b"].GetInt();
    return cocos2d::Color3B(r,g,b);
}

bool HJSONParseUtils::hasMemberColor4F(const Value& json, const char* memberName)
{
    return json.HasMember(memberName) && HJSONParseUtils::isColor4F(json[memberName]);
}

cocos2d::Color4F HJSONParseUtils::getMemberColor4F(const Value& json, const char* memberName)
{
    return HJSONParseUtils::getColor4F(json[memberName]);
}

bool HJSONParseUtils::isColor4F(const Value& json)
{
    return json.IsObject() && HJSONParseUtils::hasMemberFloat(json, "r") && HJSONParseUtils::hasMemberFloat(json, "g") && HJSONParseUtils::hasMemberFloat(json, "b") && HJSONParseUtils::hasMemberFloat(json, "a");
}

cocos2d::Color4F HJSONParseUtils::getColor4F(const Value& json)
{
    auto r = json["r"].GetFloat();
    auto g = json["g"].GetFloat();
    auto b = json["b"].GetFloat();
    auto a = json["a"].GetFloat();
    return cocos2d::Color4F(r,g,b,a);
}

bool HJSONParseUtils::checkMemberBool(const Value& json, const char* memberName, bool boolValue)
{
    return HJSONParseUtils::hasMemberBool(json, memberName) && json[memberName].GetBool() == boolValue;
}

bool HJSONParseUtils::checkMemberInt(const Value& json, const char* memberName, int intValue)
{
    return HJSONParseUtils::hasMemberInt(json, memberName) && json[memberName].GetInt() == intValue;
}

bool HJSONParseUtils::checkMemberFloat(const Value& json, const char* memberName, float floatValue)
{
    return HJSONParseUtils::hasMemberInt(json, memberName) && json[memberName].GetFloat() == floatValue;
}

bool HJSONParseUtils::checkMemberString(const Value& json, const char* memberName, std::string expectedValue)
{
    return HJSONParseUtils::hasMemberString(json, memberName) && expectedValue == json[memberName].GetString();
}

std::vector<std::string> HJSONParseUtils::parseStringArray(const Value& json)
{
    std::vector<std::string> values;
    
    if(json.IsArray()){
        for(const auto& value : json.GetArray()){
            if(value.IsString()){
                values.push_back(value.GetString());
            }
        }
    }
    else if(json.IsString()){
        values.push_back(json.GetString());
    }
    
    return values;
}

std::vector<float> HJSONParseUtils::parseFloatArray(const Value& json)
{
    std::vector<float> values;
    
    if(json.IsArray()){
        for(const auto& value : json.GetArray()){
            if(value.IsFloat() || value.IsInt()){
                values.push_back(value.GetFloat());
            }
        }
    }
    else if(json.IsFloat() || json.IsInt()){
        values.push_back(json.GetFloat());
    }
    
    return values;
}

std::vector<int> HJSONParseUtils::parseIntArray(const Value& json)
{
    std::vector<int> values;
    
    if(json.IsArray()){
        for(const auto& value : json.GetArray()){
            if(value.IsInt()){
                values.push_back(value.GetInt());
            }
        }
    }
    else if(json.IsInt()){
        values.push_back(json.GetInt());
    }
    
    return values;
}

std::vector<cocos2d::Point> HJSONParseUtils::parsePointArray(const Value& json)
{
    std::vector<cocos2d::Point> values;
    
    if(json.IsArray()){
        for(const auto& value : json.GetArray()){
            if(HJSONParseUtils::isPoint(value)){
                values.push_back(HJSONParseUtils::getPoint(value));
            }
        }
    }
    else if(HJSONParseUtils::isPoint(json)){
        values.push_back(HJSONParseUtils::getPoint(json));
    }
    
    return values;
}

std::vector<cocos2d::Size> HJSONParseUtils::parseSizeArray(const Value& json)
{
    std::vector<cocos2d::Size> values;
    
    if(json.IsArray()){
        for(const auto& value : json.GetArray()){
            if(HJSONParseUtils::isSize(value)){
                values.push_back(HJSONParseUtils::getSize(value));
            }
        }
    }
    else if(HJSONParseUtils::isSize(json)){
        values.push_back(HJSONParseUtils::getSize(json));
    }
    
    return values;
}

std::vector<cocos2d::Rect> HJSONParseUtils::parseRectArray(const Value& json)
{
    std::vector<cocos2d::Rect> values;
    
    if(json.IsArray()){
        for(const auto& value : json.GetArray()){
            if(HJSONParseUtils::isRect(value)){
                values.push_back(HJSONParseUtils::getRect(value));
            }
        }
    }
    else if(HJSONParseUtils::isRect(json)){
        values.push_back(HJSONParseUtils::getRect(json));
    }
    
    return values;
}

std::vector<std::string> HJSONParseUtils::parseMemberStringArray(const Value& json, const char* memberName)
{
    if(HJSONParseUtils::hasMemberArray(json, memberName)){
        return HJSONParseUtils::parseStringArray(json[memberName]);
    }
    
    return std::vector<std::string>();
}

std::vector<float> HJSONParseUtils::parseMemberFloatArray(const Value& json, const char* memberName)
{
    if(HJSONParseUtils::hasMemberArray(json, memberName)){
        return HJSONParseUtils::parseFloatArray(json[memberName]);
    }
    
    return std::vector<float>();
}

std::vector<int> HJSONParseUtils::parseMemberIntArray(const Value& json, const char* memberName)
{
    if(HJSONParseUtils::hasMemberArray(json, memberName)){
        return HJSONParseUtils::parseIntArray(json[memberName]);
    }
    
    return std::vector<int>();
}

std::vector<cocos2d::Point> HJSONParseUtils::parseMemberPointArray(const Value& json, const char* memberName)
{
    if(HJSONParseUtils::hasMemberArray(json, memberName)){
        return HJSONParseUtils::parsePointArray(json[memberName]);
    }
    
    return std::vector<cocos2d::Point>();
}