#include "RUQCoreLayer.h"
#include "RUQCoreBtn.h"
#include "RUUtils.h"

NS_RU_BEGIN

void QCoreLayerDelegate::completedAnimationSequenceNamed(const char *name, int seqId,int tag)
{
    if (_completedAniCallBack) {
        _completedAniCallBack(string(name));
    }
}

void QCoreLayerDelegate::registerCompletedAniCallBack(std::function<void(string name)> callback)
{
    _completedAniCallBack = callback;
}

int QCoreLayer::_count = 0;
QCoreLayer * QCoreLayer::Layer(const string& file, bool batchReader)
{
    auto *lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
    lib->registerNodeLoader("QCoreLayer",QCoreLayerLoader::loader());
    lib->registerNodeLoader("QCoreBtn",QCoreBtnLoader::loader());
    
    redream::REDReader *reader = new redream::REDReader(lib);
    reader->setBatchNode(batchReader);
    QCoreLayer * node = dynamic_cast<QCoreLayer*>(reader->readNodeGraphFromFile(file.c_str()));
    node->setAnimManager(reader->getAnimationManagers());
    node->_ccbName = file;
    reader->release();
    return node;
}
QCoreLayer* QCoreLayer::LayerBatchReader(string file,unordered_set<string> plistSt){
    auto *lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
    lib->registerNodeLoader("QCoreLayer",QCoreLayerLoader::loader());
    lib->registerNodeLoader("QCoreBtn",QCoreBtnLoader::loader());
    redream::REDReader *reader = new redream::REDReader(lib);
    reader->setPlist(plistSt,plistSt);
    reader->setBatchNode(true);
    QCoreLayer * node = dynamic_cast<QCoreLayer*>(reader->readNodeGraphFromFile(file.c_str()));
    node->setAnimManager(reader->getAnimationManagers());
    node->_ccbName = file;
    reader->release();
    return node;
}
QCoreLayer* QCoreLayer::LayerBatchReader(string file,unordered_set<string> plistSt,unordered_set<string> repleacPlistSt){
    auto *lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
    lib->registerNodeLoader("QCoreLayer",QCoreLayerLoader::loader());
    lib->registerNodeLoader("QCoreBtn",QCoreBtnLoader::loader());
    redream::REDReader *reader = new redream::REDReader(lib);
    reader->setPlist(plistSt,repleacPlistSt);
    reader->setBatchNode(true);
    QCoreLayer * node = dynamic_cast<QCoreLayer*>(reader->readNodeGraphFromFile(file.c_str()));
    node->setAnimManager(reader->getAnimationManagers());
    node->_ccbName = file;
    reader->release();
    return node;
}

QCoreLayer::QCoreLayer()
{
    _mAnimCtrl=nullptr;
    _count++;
    _aniDelegate = new QCoreLayerDelegate();
    _aniDelegate->autorelease();
    _aniDelegate->retain();
}

QCoreLayer::~QCoreLayer()
{
    _aniDelegate->release();
    if (_mAnimCtrl!=nullptr) {
        _mAnimCtrl->setDelegate(nullptr);
    }
    CC_SAFE_RELEASE_NULL(_mAnimCtrl);
    _count--;
}

void QCoreLayer::onExit()
{
    if (_cbOnExit != nullptr) {
        _cbOnExit(_ccbName, this);
    }
    Layer::onExit();
}

std::function<void(const string&, QCoreLayer*)> QCoreLayer::setCbOnExit(std::function<void(const string&, QCoreLayer*)> cb)
{
    auto t = _cbOnExit;
    _cbOnExit = cb;
    return t;
}

void QCoreLayer::setCcbiName(const string& name)
{
    _ccbName = name;
}

bool QCoreLayer::setCBSpriteName(string spriteName,string spriteFrameName)
{
    if(!hasChileByName(spriteName)){
        return false;
    }
    Sprite* temp = getSprite(spriteName);
    if (temp!= nullptr) {
        SpriteFrame * spf = SpriteFrameCache::getInstance()->getSpriteFrameByName(spriteFrameName);
        if (spf == nullptr){
            Texture2D * texture = Director::getInstance()->getTextureCache()->addImage(spriteFrameName);
            if ( texture != nullptr ){
                Size sz = texture->getContentSize();
                spf = SpriteFrame::createWithTexture(texture, Rect(0, 0, sz.width, sz.height));
            }
        }
        if (spf != nullptr) {
            temp->setSpriteFrame(spf);
            return true;
        }
    }
    return false;
}
bool QCoreLayer::onAssignREDMemberVariable(cocos2d::Ref* pTarget, const char* pMemberVariableName, Node* pNode)
{
    if (pTarget == this&&pNode != this&&strcmp(pMemberVariableName,"")!=0)
    {
        _mapChilden.insert(pair<string, Node*>(string(pMemberVariableName),pNode));
        return true;
    }
    // RED_MEMBERVARIABLEASSIGNER_GLUE_WEAK(this, "name", Node*, aaa::node_bind);
    return false;
}

SEL_MenuHandler QCoreLayer::onResolveREDCCMenuItemSelector(Ref * pTarget, const char * pSelectorName)
{
    
    return nullptr;
}

Control::Handler QCoreLayer::onResolveREDCCControlSelector(Ref * pTarget, const char * pSelectorName)
{
    
    return nullptr;
}

cocos2d::SEL_CallFuncN QCoreLayer::onResolveREDCCCallFuncSelector(cocos2d::Ref * pTarget, const char* pSelectorName) {
//        RED_SELECTORRESOLVER_CALLFUNC_GLUE(this, "onCallback1", TimelineCallbackTestLayer::onCallback1); //void(Node*)
    string selectorName(pSelectorName) ;
    string event = string("__CCCallFuncSelector__")+selectorName ;
    if(_timelineCallbackListeners.find(event) == _timelineCallbackListeners.end())
    {
        EventListenerCustom* ecl = EventListenerCustom::create(event, [this,pTarget,selectorName](EventCustom*){
            auto iter = _timelineCallbacks.find(selectorName) ;
            if(iter != _timelineCallbacks.end() && iter->second && pTarget == dynamic_cast<Ref*>(this))
            {
                iter->second();
            }
        });
        Node* node  = dynamic_cast<Node*>(pTarget);
        if(node)
        {
            _director->getEventDispatcher()->addEventListenerWithSceneGraphPriority(ecl, node);
            _timelineCallbackListeners[event] = ecl;
        }
    }
    return CC_CALLFUNCN_SELECTOR(QCoreLayer::onTimeLineCallback);
    return nullptr;
};

bool QCoreLayer::onAssignREDCustomProperty(cocos2d::Ref* target, const char* memberVariableName, const cocos2d::Value& value) {
    _customProperties.insert(std::pair<std::string, Value>(std::string(memberVariableName), value));
    return true;
}

void QCoreLayer::onNodeLoaded(cocos2d::Node * node,  redream::NodeLoader * nodeLoader)
{
    
}

void QCoreLayer::registerCompletedAniCallBack(std::function<void(string name)> callback)
{
    _aniDelegate->registerCompletedAniCallBack(callback);
}

void QCoreLayer::setAnimManager(redream::REDReader::REDAnimationManagerMapPtr map)
{
    auto it = map->find(this);
    CC_SAFE_RELEASE_NULL(_mAnimCtrl);
    _mAnimCtrl = it->second;
    _mAnimCtrl->setDelegate(_aniDelegate);
    CC_SAFE_RETAIN(_mAnimCtrl);
    
    
    M_SNODE::iterator it1 = _mapChilden.begin();
    for (; it1 !=_mapChilden.end(); it1++) {
        QCoreLayer* cl = dynamic_cast<QCoreLayer*>(it1->second);
        if (cl != nullptr &&!(it1->first.empty()))
        {
            cl->setAnimManager(map);
        }
    }
}

float QCoreLayer::getAnimTime(std::string animName)
{
    return _mAnimCtrl->getSequenceDuration(animName.c_str());
}

void QCoreLayer::playAnim(std::string animName, const std::function<void(float)> &cbFinishAnim, std::string cbScheduleKey)
{
    CCASSERT(!animName.empty(), "时间线名字不能为空");
    _mAnimCtrl->runAnimationsForSequenceNamed(animName.c_str());
    if (cbFinishAnim) {
        float animTime = getAnimTime(animName);
        if (cbScheduleKey.empty()) {
            cbScheduleKey = "playAnim_" + Value(randomInt(1, 1000000)).asString();
        }
        scheduleOnce(cbFinishAnim, animTime, cbScheduleKey);
    }
}

void QCoreLayer::playAnimAndRemoveSelf(std::string animName)
{
    _mAnimCtrl->runAnimationsForSequenceNamed(animName.c_str());
    registerCompletedAniCallBack([=](string timeLineName){
        if (timeLineName == animName) {
            this->removeFromParent();
        }
    });
}

bool QCoreLayer::isValidAnim(std::string animName)
{
    bool ret = true;
    if (_mAnimCtrl->getSequenceId(animName.c_str()) == -1) {
        ret = false;
    }
    
    return ret;
}

void QCoreLayer::setAnimationSpeed(float tRate)
{
    if(_mAnimCtrl){
        _mAnimCtrl->setAnimationSpeed(tRate);
    }else{
        CCAssert(false, "QCoreLayer setAnimationSpeed failed");
    }
}

Spawn* QCoreLayer::getNodeAniByName(std::string timeLineName, std::string nodeName,const Vec2& orginPos)
{
    auto tNode = getByName(nodeName);
    return _mAnimCtrl->getNodeAniByName(timeLineName.c_str(),tNode,orginPos);
}

void QCoreLayer::changeToOtherParent(Node* newParent)
{
    this->retain();
    
    std::function<void(const string&, QCoreLayer*)> cbBack = _cbOnExit;
    _cbOnExit = nullptr;
    
    this->removeFromParentAndCleanup(false);
    
    _cbOnExit = cbBack;
    
    newParent->addChild(this);
    this->release();
}

bool QCoreLayer::hasChileByName(std::string name)
{
    auto iter = _mapChilden.find(name);
    if (iter != _mapChilden.end()) {
        return true;
    }else{
        return false;
    }
}

Node* QCoreLayer::getByName(std::string name)
{
    //    return _mapChilden[name];
    auto iter = _mapChilden.find(name);
    CCASSERT(iter != _mapChilden.end(), "ccb无这个变量？？？");
    return iter->second;
}

Sprite* QCoreLayer::getSprite(std::string name)
{
    auto iter = _mapChilden.find(name);
    CCASSERT(iter != _mapChilden.end(), "ccb无这个变量？？？");
    return dynamic_cast<Sprite*>(iter->second);
}
Label* QCoreLayer::getLabel(std::string name)
{
    //    return (Label*)_mapChilden[name];
    auto iter = _mapChilden.find(name);
    CCASSERT(iter != _mapChilden.end(), "ccb无这个变量？？？");
    return dynamic_cast<Label*>(iter->second);
}
ParticleSystemQuad* QCoreLayer::getParticle(std::string name)
{
    //    return (ParticleSystemQuad*)_mapChilden[name];
    auto iter = _mapChilden.find(name);
    CCASSERT(iter != _mapChilden.end(), "ccb无这个变量？？？");
    return dynamic_cast<ParticleSystemQuad*>(iter->second);
}
ZMLCCParticleSystemQuad* QCoreLayer::getZMLCCParticle(std::string name)
{
    //    return (ParticleSystemQuad*)_mapChilden[name];
    auto iter = _mapChilden.find(name);
    CCASSERT(iter != _mapChilden.end(), "ccb无这个变量？？？");
    return dynamic_cast<ZMLCCParticleSystemQuad*>(iter->second);
}
RRP::RParticleSystem* QCoreLayer::getRParticle(std::string name)
{
    auto iter = _mapChilden.find(name);
    CCASSERT(iter != _mapChilden.end(), "ccb无这个变量？？？");
    return dynamic_cast<RRP::RParticleSystem*>(iter->second);
}
QCoreLayer* QCoreLayer::getCoreLayer(std::string name)
{
    //    return (QCoreLayer*)_mapChilden[name];
    auto iter = _mapChilden.find(name);
    CCASSERT(iter != _mapChilden.end(), "ccb无这个变量？？？");
    return dynamic_cast<QCoreLayer*>(iter->second);
}

QCoreBtn* QCoreLayer::getCoreBtn(std::string name)
{
    //    return (QCoreLayer*)_mapChilden[name];
    auto iter = _mapChilden.find(name);
    CCASSERT(iter != _mapChilden.end(), "ccb无这个变量？？？");
    return dynamic_cast<QCoreBtn*>(iter->second);
}

Value QCoreLayer::getCustomeProperty(const char* name) {
    std::map<std::string, Value>::iterator iter = _customProperties.find(std::string(name));
    if (iter != _customProperties.end()) {
        return iter->second;
    }
    return Value();
}

void QCoreLayer::updateAnimSpeed(float speed)
{
    if (speed > 0) {
        _mAnimCtrl->updateSpeed(speed);
    }
}

redream::NodeLoaderLibrary* QCoreLayer::sharedLibrary()
{
    auto *lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
    lib->registerNodeLoader("QCoreLayer", QCoreLayerLoader::loader());
    lib->registerNodeLoader("QCoreBtn", QCoreBtnLoader::loader());
    
    return lib;
}

static redream::NodeLoaderLibrary * s_globalLoaderLibary = nullptr;
void QCoreLayer::registerNodeLoaderLibrary(tuple<const char *, redream::NodeLoader *> nodeLoaderArr)
{
    if (s_globalLoaderLibary == nullptr)
    {
        redream::NodeLoaderLibrary * ccNodeLoaderLibrary = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
        s_globalLoaderLibary = ccNodeLoaderLibrary;
        s_globalLoaderLibary->retain();
    }
    s_globalLoaderLibary->registerNodeLoader(get<0>(nodeLoaderArr), get<1>(nodeLoaderArr));
}

QCoreLayer * QCoreLayer::loadFromRED(string pREDFileName,Ref* owner)
{
    redream::REDReader * ccbReader = new redream::REDReader(s_globalLoaderLibary);
//    ccbReader->autorelease();
    QCoreLayer * node = (QCoreLayer*)ccbReader->readNodeGraphFromFile(pREDFileName.c_str(), owner);
    if (node != nullptr) {
        node->setAnimManager(ccbReader->getAnimationManagers());
        node->_ccbName = pREDFileName;
    }
    ccbReader->release();
    return node;
}

void QCoreLayer::SmartScaleHeightNode(Node* layer, Size designSize)
{
    Size frameSize = Director::getInstance()->getVisibleSize();
    Size contentSize = layer->getContentSize();
    
    if ((frameSize.height / frameSize.width) < (1136.0 / designSize.width)) {
        contentSize.width = frameSize.width;
        float targetScale = contentSize.width / designSize.width;
        
        layer->setScale(targetScale, 1);
        layer->setContentSize(contentSize);
    } else if ((frameSize.height / frameSize.width) > (1136.0 / designSize.width)) {
        contentSize.height = frameSize.height;
        float targetScale = contentSize.height / designSize.height;
        
        layer->setScale(1, targetScale);
        layer->setContentSize(contentSize);
    }
}

NS_RU_END