#include "ZMLCCParticleSystemQuadLoader.h"

#include "common/CocosConfig.h"

using namespace cocos2d;

#define PROPERTY_EMITERMODE "emitterMode"
#define PROPERTY_POSITIONTYPE "positionType"
#define PROPERTY_POSVAR "posVar"
#define PROPERTY_EMISSIONRATE "emissionRate"
#define PROPERTY_EmitFirstFrameEnabled "emitFirstFrameEnabled"
#define PROPERTY_DURATION "duration"
#define PROPERTY_TOTALPARTICLES "totalParticles"
#define PROPERTY_LIFE "life"
#define PROPERTY_STARTSIZE "startSize"
#define PROPERTY_ENDSIZE "endSize"
#define PROPERTY_STARTSPIN "startSpin"
#define PROPERTY_ENDSPIN "endSpin"
#define PROPERTY_ANGLE "angle"
#define PROPERTY_STARTCOLOR "startColor"
#define PROPERTY_ENDCOLOR "endColor"
#define PROPERTY_BLENDFUNC "blendFunc"
#define PROPERTY_GRAVITY "gravity"
#define PROPERTY_SPEED "speed"
#define PROPERTY_TANGENTIALACCEL "tangentialAccel"
#define PROPERTY_RADIALACCEL "radialAccel"
#define PROPERTY_TEXTURE "texture"
#define PROPERTY_STARTRADIUS "startRadius"
#define PROPERTY_ENDRADIUS "endRadius"
#define PROPERTY_ROTATEPERSECOND "rotatePerSecond"

#define PROPERTY_DISPLAYFRAME "displayFrame"

namespace redream {

void ZMLCCParticleSystemQuadLoader::onHandlePropTypeIntegerLabeled(Node * pNode, Node * pParent, const char * pPropertyName, int pIntegerLabeled, REDReader * ccbReader) {
    if(strcmp(pPropertyName, PROPERTY_EMITERMODE) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setEmitterMode((ZMLCCParticleSystem::Mode)pIntegerLabeled);
    } else if (strcmp(pPropertyName, PROPERTY_POSITIONTYPE) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setPositionType((ZMLCCParticleSystem::PositionType) pIntegerLabeled);
    } else {
        NodeLoader::onHandlePropTypeIntegerLabeled(pNode, pParent, pPropertyName, pIntegerLabeled, ccbReader);
    }
}

void ZMLCCParticleSystemQuadLoader::onHandlePropTypePoint(Node * pNode, Node * pParent, const char * pPropertyName, Vec2 pPoint, REDReader * ccbReader) {
    if(strcmp(pPropertyName, PROPERTY_POSVAR) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setPosVar(pPoint);
    } else if(strcmp(pPropertyName, PROPERTY_GRAVITY) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setGravity(pPoint);
    } else {
        NodeLoader::onHandlePropTypePoint(pNode, pParent, pPropertyName, pPoint, ccbReader);
    }
}

void ZMLCCParticleSystemQuadLoader::onHandlePropTypeFloat(Node * pNode, Node * pParent, const char * pPropertyName, float pFloat, REDReader * ccbReader) {
    if(strcmp(pPropertyName, PROPERTY_EMISSIONRATE) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setEmissionRate(pFloat);
    } else if(strcmp(pPropertyName, PROPERTY_DURATION) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setDuration(pFloat);
    } else {
        NodeLoader::onHandlePropTypeFloat(pNode, pParent, pPropertyName, pFloat, ccbReader);
    }
}

void ZMLCCParticleSystemQuadLoader::onHandlePropTypeInteger(Node * pNode, Node * pParent, const char * pPropertyName, int pInteger, REDReader * ccbReader) {
    if(strcmp(pPropertyName, PROPERTY_TOTALPARTICLES) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setTotalParticles(pInteger);
    } else {
        NodeLoader::onHandlePropTypeInteger(pNode, pParent, pPropertyName, pInteger, ccbReader);
    }
}

void ZMLCCParticleSystemQuadLoader::onHandlePropTypeFloatVar(Node * pNode, Node * pParent, const char * pPropertyName, float * pFloatVar, REDReader * ccbReader) {
    if(strcmp(pPropertyName, PROPERTY_LIFE) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setLife(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setLifeVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_STARTSIZE) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setStartSize(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setStartSizeVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_ENDSIZE) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setEndSize(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setEndSizeVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_STARTSPIN) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setStartSpin(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setStartSpinVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_ENDSPIN) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setEndSpin(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setEndSpinVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_ANGLE) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setAngle(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setAngleVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_SPEED) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setSpeed(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setSpeedVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_TANGENTIALACCEL) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setTangentialAccel(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setTangentialAccelVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_RADIALACCEL) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setRadialAccel(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setRadialAccelVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_STARTRADIUS) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setStartRadius(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setStartRadiusVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_ENDRADIUS) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setEndRadius(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setEndRadiusVar(pFloatVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_ROTATEPERSECOND) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setRotatePerSecond(pFloatVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setRotatePerSecondVar(pFloatVar[1]);
    } else {
        NodeLoader::onHandlePropTypeFloatVar(pNode, pParent, pPropertyName, pFloatVar, ccbReader);
    }
}

void ZMLCCParticleSystemQuadLoader::onHandlePropTypeColor4FVar(Node * pNode, Node * pParent, const char * pPropertyName, Color4F * pColor4FVar, REDReader * ccbReader) {
    if(strcmp(pPropertyName, PROPERTY_STARTCOLOR) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setStartColor(pColor4FVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setStartColorVar(pColor4FVar[1]);
    } else if(strcmp(pPropertyName, PROPERTY_ENDCOLOR) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setEndColor(pColor4FVar[0]);
        ((ZMLCCParticleSystemQuad *)pNode)->setEndColorVar(pColor4FVar[1]);
    } else {
        NodeLoader::onHandlePropTypeColor4FVar(pNode, pParent, pPropertyName, pColor4FVar, ccbReader);
    }
}
void ZMLCCParticleSystemQuadLoader::onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, bool pCheck, REDReader * ccbReader) {
        if(strcmp(pPropertyName, PROPERTY_EmitFirstFrameEnabled) == 0) {
            ((ZMLCCParticleSystemQuad *)pNode)->setEmitFirstFrameEnabled(pCheck);
        } else {
            NodeLoader::onHandlePropTypeCheck(pNode,pParent,pPropertyName, pCheck,ccbReader);
        }
}
void ZMLCCParticleSystemQuadLoader::onHandlePropTypeBlendFunc(Node * pNode, Node * pParent, const char * pPropertyName, BlendFunc pBlendFunc, REDReader * ccbReader) {
    if(strcmp(pPropertyName, PROPERTY_BLENDFUNC) == 0) {
        ((ZMLCCParticleSystemQuad *)pNode)->setBlendFunc(pBlendFunc);
    } else {
        NodeLoader::onHandlePropTypeBlendFunc(pNode, pParent, pPropertyName, pBlendFunc, ccbReader);
    }
}

void ZMLCCParticleSystemQuadLoader::onHandlePropTypeTexture(Node * pNode, Node * pParent, const char * pPropertyName, Texture2D * pTexture2D, REDReader * ccbReader) {
    if(strcmp(pPropertyName, PROPERTY_TEXTURE) == 0) {
        if (pTexture2D == nullptr) {
            throw std::invalid_argument("ZMLCCParticleSystemQuadLoader得到一个空的Texture2D");
        }
        static_cast<ZMLCCParticleSystemQuad*>(pNode)->setTexture(pTexture2D);
        static_cast<ZMLCCParticleSystemQuad*>(pNode)->setParticlyKeyInfo(false, pTexture2D->getPath(),ccbReader->getPlist());
    } else {
        NodeLoader::onHandlePropTypeTexture(pNode, pParent, pPropertyName, pTexture2D, ccbReader);
    }
}
    
void ZMLCCParticleSystemQuadLoader::onHandlePropTypeSpriteFrame(Node * pNode, Node * pParent, const char * pPropertyName, SpriteFrame * pFrame, REDReader * ccbReader) {
    if(strcmp(pPropertyName, PROPERTY_DISPLAYFRAME) == 0) {
        bool isrotated = pFrame->isRotated();
        Vec2 offset = pFrame->getOffset();
        Vec2 originalSize = pFrame->getOriginalSize();
        auto pointRect = pFrame->getRect();
        ((ZMLCCParticleSystemQuad *)pNode)->setParticlyKeyInfo(false == pFrame->getSpriteFrameName().empty(), pFrame->getSpriteFrameName(),{pFrame->getPlist()});
        ((ZMLCCParticleSystemQuad *)pNode)->setTextureWithRect(pFrame->getTexture(), pFrame->getRect(), isrotated, offset, originalSize);
    } else {
        NodeLoader::onHandlePropTypeSpriteFrame(pNode, pParent, pPropertyName, pFrame, ccbReader);
    }
}

}