//
//  ToyPlainSprite.cpp
//  SteveMaggieCpp
//
//  Created by Katarzyna Kalinowska-Górska on 17.05.2017.
//
//

#include <stdio.h>
#include "ToyPlainSprite.h"
#include "ToyJSONParseUtils.h"
#include "cocos2d.h"
#include "ToyMathUtils.h"

ToyPlainSprite* ToyPlainSprite::createWithTexture(cocos2d::Texture2D* texture)
{
    ToyPlainSprite * sprite = new (std::nothrow) ToyPlainSprite();
    if(sprite && sprite->initWithTexture(texture))
    {
        sprite->autorelease();
        return sprite;
    }
    CC_SAFE_DELETE(sprite);
    return nullptr;
}


ToyPlainSprite* ToyPlainSprite::createWithSpritePath(std::string spritePath)
{
    ToyPlainSprite * sprite = new (std::nothrow) ToyPlainSprite();
    if(sprite && sprite->initWithFile(spritePath))
    {
        sprite->autorelease();
        return sprite;
    }
    CC_SAFE_DELETE(sprite);
    return nullptr;
}

void ToyPlainSprite::loadPropertiesFromJSON(const rapidjson::Value& jsonValue, ToyLayoutViewInterface* scene, const std::string resFolder, const std::string altResFolder)
{
    this->loadCommonPropertiesFromJSON(jsonValue);
    
    if(jsonValue.HasMember("flippedX")){
        const auto& flippedXJSON = jsonValue["flippedX"];
        this->setFlippedX(flippedXJSON.GetBool());
    }

    if(jsonValue.HasMember("flippedY")){
        const auto& flippedYJSON = jsonValue["flippedY"];
        this->setFlippedY(flippedYJSON.GetBool());
    }
    
    if(jsonValue.HasMember("color")){
        const auto& color = jsonValue["color"];
        float r = color["r"].GetFloat();
        float g = color["g"].GetFloat();
        float b = color["b"].GetFloat();
        this->setColor(cocos2d::Color3B(r,g,b));
    }

}

void ToyPlainSprite::prepareSize(const rapidjson::Value& jsonValue, float& width, float& height)
{
    width = this->getBoundingBox().size.width;
    height = this->getBoundingBox().size.height;
//    width = this->getContentSize().width;
//    height = this->getContentSize().height;
}

void ToyPlainSprite::setProperty(std::string propertyName, const rapidjson::Value& newValue, ActionParseDelegate* parseDelegate)
{
    if(propertyName == "opacity"){
        auto value = newValue.GetInt();
        this->setOpacity(value);
    }
    else if(propertyName == "rotation"){
       auto value = newValue.GetFloat();
        this->setRotation(value);
    }
}

void ToyPlainSprite::callFunctionByName(std::string methodName, const rapidjson::Value* arguments, ActionParseDelegate* parseDelegate, std::function<void()> callback)
{
    auto scale = 1/cocos2d::Director::getInstance()->getContentScaleFactor();
    
    if(methodName == "setVisible"){
        if((*arguments).IsArray()){
            this->setVisible((*arguments).GetArray()[0].GetBool());
        }
    }
    else if(methodName == "setFlippedX"){
        if((*arguments).IsArray()){
            this->setFlippedX((*arguments).GetArray()[0].GetBool());
        }
    }
    else if(methodName == "setFlippedY"){
        if((*arguments).IsArray()){
            this->setFlippedY((*arguments).GetArray()[0].GetBool());
        }
    }
    else if (methodName == "setScale"){
        if((*arguments).IsArray()){
            this->setScale((*arguments).GetArray()[0].GetFloat(), (*arguments).GetArray()[0].GetFloat());
        }
    }
    else if(methodName == "setOpacity"){
        if((*arguments).IsArray()){
            this->setOpacity((*arguments).GetArray()[0].GetInt());
        }
    }
    else if(methodName == "setPositionX"){
        if((*arguments).IsArray()){
            this->setPositionX((*arguments).GetArray()[0].GetFloat()*scale);
        }
    }
    else if(methodName == "setPositionY"){
        if((*arguments).IsArray()){
            this->setPositionY((*arguments).GetArray()[0].GetFloat()*scale);
        }
    }
    else if(methodName == "setPosition"){
        if((*arguments).IsArray()){
            auto point = ToyJSONParseUtils::getPoint((*arguments).GetArray()[0]);
            ToyMathUtils::multiplyPoint(point, scale);
            this->setPosition(point);
        }
    }
    else if(methodName == "resetPosition"){
        this->setPosition(originalPosition);
    }
//    else if(methodName == "setPositionFromCenter"){
//        if((*arguments).IsArray()){
//            auto point = ToyJSONParseUtils::getPoint((*arguments).GetArray()[0]);
//            ToyMathUtils::multiplyPoint(point, scale);
//            auto parentSize = getParent()->getBoundingBox().size;
//            this->setPosition(point.x + parentSize.width/2, point.y + parentSize.height/2);
//        }
//    }
    else if(methodName == "setTextureRect"){
        if((*arguments).IsArray()){
            auto newRect = ToyJSONParseUtils::getRect((*arguments).GetArray()[0]);
            ToyMathUtils::multiplyRectPosition(newRect, scale);
            this->setTextureRect(newRect);
        }
    }
    else if(methodName == "setContentSize"){
        if((*arguments).IsArray()){
            this->setContentSize(ToyJSONParseUtils::getSize((*arguments).GetArray()[0]));
        }
    }
    else if(methodName == "setRotation"){
        if((*arguments).IsArray()){
            this->setRotation(((*arguments).GetArray()[0]).GetFloat());
        }
    }
    else if(methodName == "clipSprite"){
        if((*arguments).IsArray()){
            auto by = ToyJSONParseUtils::getPoint((*arguments)[0]);
            auto prevTextureRect = this->getTextureRect();
            this->setTextureRect(cocos2d::Rect(prevTextureRect.origin.x - by.x, prevTextureRect.origin.y - by.y, prevTextureRect.size.width, prevTextureRect.size.height));
        }
    }
    else if(methodName == "stopAnimations"){
        this->stopAllActions();
    }
    else if(methodName == "setPicture"){
        if((*arguments).IsArray()){
            std::string imagePath = ((*arguments).GetArray()[0]).GetString();
            auto texture = cocos2d::Director::getInstance()->getTextureCache()->addImage(imagePath);
            this->setTexture(texture);
            this->setTextureRect(cocos2d::Rect(cocos2d::Point::ZERO, texture->getContentSize()));
        }
    }
}