#include "RedreamLoader.hpp"

RedreamLoader::RedreamLoader() {
}

RedreamLoader::~RedreamLoader() {
    _mapChilden.clear();
    if (_loaderReboltRedManager != nullptr) {
        _loaderReboltRedManager->release();
        _loaderReboltRedManager = nullptr;
    }
}

RedreamLoader* RedreamLoader::Layer(string file) {
    auto lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
    lib->registerNodeLoader("RedreamLoader",RedreamLoaderLoader::loader());
    redream::REDReader* reader = new redream::REDReader(lib);
    RedreamLoader* node = (RedreamLoader*)reader->readNodeGraphFromFile(file.c_str());
    reader->autorelease();
    return node;
}

RedreamLoader* RedreamLoader::LayerWithLib(string file,redream::NodeLoaderLibrary* lib) {
    lib->registerNodeLoader("RedreamLoader",RedreamLoaderLoader::loader());
    redream::REDReader* reader = new redream::REDReader(lib);
    RedreamLoader* node = (RedreamLoader*)reader->readNodeGraphFromFile(file.c_str());
    reader->autorelease();
    return node;
}

RedreamLoader* RedreamLoader::ReboltLayer(string file) {
    auto reboltlib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
    reboltlib->registerNodeLoader("RedreamLoader",RedreamLoaderLoader::loader());
    redream::REDReader* reboltReader = new redream::REDReader(reboltlib);
    RedreamLoader* tmpNode = nullptr;
    try {
        tmpNode = (RedreamLoader*)reboltReader->readNodeGraphFromFile(file.c_str());
        redream::ReboltRedManager* reboltM = reboltReader->getReboltRedManager();
        reboltM->retain();
        reboltM->setNotifyDevelopmentDelegate(tmpNode);
        auto reboltmangs = reboltReader->getReboltRedManagerMapPtr();
        for (auto it = reboltmangs->begin(); it != reboltmangs->end(); it++) {
            auto rrm = it->second;
            rrm->setNotifyDevelopmentDelegate(tmpNode);
        }
        tmpNode->_loaderReboltRedManager = reboltM;
        reboltReader->release();
    } catch (string str) {
        CCLOG("loader error : %s", str.c_str());
        assert(false);
    }
    return tmpNode;
}

RedreamLoader* RedreamLoader::ReboltLayerWithLib(string file,redream::NodeLoaderLibrary* reboltlib) {
    reboltlib->registerNodeLoader("RedreamLoader",RedreamLoaderLoader::loader());
    redream::REDReader* reboltReader = new redream::REDReader(reboltlib);
    RedreamLoader* tmpNode = nullptr;
    try {
        tmpNode = (RedreamLoader*)reboltReader->readNodeGraphFromFile(file.c_str());
        redream::ReboltRedManager* reboltM = reboltReader->getReboltRedManager();
        reboltM->retain();
        reboltM->setNotifyDevelopmentDelegate(tmpNode);
        auto reboltmangs = reboltReader->getReboltRedManagerMapPtr();
        for (auto it = reboltmangs->begin(); it != reboltmangs->end(); it++) {
            auto rrm = it->second;
            rrm->setNotifyDevelopmentDelegate(tmpNode);
        }
        tmpNode->_loaderReboltRedManager = reboltM;
        reboltReader->release();
    } catch (string str) {
        CCLOG("loader error : %s", str.c_str());
        assert(false);
    }
    return tmpNode;
}

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

cocos2d::extension::Control::Handler RedreamLoader::onResolveREDCCControlSelector(cocos2d::Ref* pTarget,const char* pSelectorName) {
    //RED_SELECTORRESOLVER_CCCONTROL_GLUE(this, "OnClickCCBButton", RedreamLoader::OnClickCCBButton);
    return nullptr;
}

cocos2d::SEL_CallFuncN RedreamLoader::onResolveREDCCCallFuncSelector(cocos2d::Ref* pTarget,const char* pSelectorName) {
    //RED_SELECTORRESOLVER_CALLFUNC_GLUE(this,"onCCBTimeLineCallBacks",RedreamLoader::onCCBTimeLineCallBacks);
    return nullptr;
}

bool RedreamLoader::onAssignREDMemberVariable(cocos2d::Ref* pTarget,const char* pMemberVariableName,cocos2d::Node* node) {
    if (pTarget == this && node != this && strcmp(pMemberVariableName,"") != 0) {
        _mapChilden.insert(pair<string,Node*>(string(pMemberVariableName),node));
        return true;
    }
    return false;
}

void RedreamLoader::onNodeLoaded(cocos2d::Node* node,redream::NodeLoader* nodeLoader) {
    //loaded after
}

void RedreamLoader::completedAnimationSequenceNamed(const char* name,int seqId,int tag) {
}

Node* RedreamLoader::getByName(std::string name) {
    return _mapChilden[name];
}

Sprite* RedreamLoader::getSprite(std::string name) {
    return (Sprite*)_mapChilden[name];
}

Label* RedreamLoader::getLabel(std::string name) {
    return (Label*)_mapChilden[name];
}

ParticleSystemQuad* RedreamLoader::getParticle(std::string name) {
    return (ParticleSystemQuad*)_mapChilden[name];
}

redream::REDNodeButton* RedreamLoader::getREDNodeButton(std::string name) {
    return dynamic_cast<redream::REDNodeButton*>(_mapChilden[name]);
}

RedreamLoader* RedreamLoader::getSubLoader(std::string name) {
    return (RedreamLoader*)_mapChilden[name];
}

void RedreamLoader::stopAnimAll() {
    this->stopAllActions();
}

float RedreamLoader::playAnim(std::string anim) {
    Ref* obj = this->getUserObject();
    redream::REDAnimationManager* ret = dynamic_cast<redream::REDAnimationManager*>(obj);
    if (ret != nullptr) {
        ret->runAnimationsForSequenceNamed(anim.c_str());
        return ret->getSequenceDuration(anim.c_str());
    }
    return 0;
}

float RedreamLoader::getAnimTime(std::string anim) {
    Ref* obj = this->getUserObject();
    redream::REDAnimationManager* ret = dynamic_cast<redream::REDAnimationManager*>(obj);
    if (ret != nullptr) {
        return ret->getSequenceDuration(anim.c_str());
    }
    return 0;
}

redream::ReboltRedManager* RedreamLoader::getReboltManager() {
    return _loaderReboltRedManager;
}

void RedreamLoader::onNotifyDevelopment(redream::ReboltRedManager* reboltRedManager,redream::NotifyDevelopmentWaiter* waiter,std::string notify,std::string param,bool reboltIsWait,Node* outNode) {
    if (_reboltCallBack != nullptr) {
        _reboltCallBack(reboltRedManager,waiter,notify,param,reboltIsWait,outNode);
    }
}