//
//  RUReboltLayer.cpp
//  red_utils
//
//  Created by ZhengSong on 2023/1/6.
//

#include "RUReboltLayer.h"
#include "Rebolt/BTManger.hpp"

using namespace redream;

NS_RU_BEGIN

RUReboltLayer::RUReboltLayer() {
    
}

RUReboltLayer::~RUReboltLayer() {
    CC_SAFE_RELEASE_NULL(_rs);
}

void RUReboltLayer::setGlobalDataVar(std::string key, std::string content) {
    BTManger::getInstance()->setGlobalDataVar(key, content);
}

RUReboltLayer* RUReboltLayer::createReboltLayer(const std::string& fileName, redream::NodeLoaderLibrary* ccNodeLoaderLibrary) {
    RUReboltLayer* ret = RUReboltLayer::create();
    if(ccNodeLoaderLibrary == nullptr) {
        ccNodeLoaderLibrary = NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
    }
    redream::REDReader* ccbReader = new redream::REDReader(ccNodeLoaderLibrary);
    try {
        Node* node = ccbReader->readNodeGraphFromFile(fileName.c_str());
        redream::ReboltRedManager* rs = ccbReader->getReboltRedManager();
        if(rs) {
            ret->setReboltRedManger(rs);
        }
        REDReader::ReboltRedManagerMapPtr mgrs = ccbReader->getReboltRedManagerMapPtr();
        for(auto iter : *mgrs) {
            iter.second->setNotifyDevelopmentDelegate(ret);
        }
        ret->addChild(node);
        ccbReader->release();
    } catch (string str) {
        CCLOG("加载错误 %s", str.c_str());
    }
    return ret;
}
RUReboltLayer* RUReboltLayer::creatBatchReboltLayer(const std::string& fileName,unordered_set<string> plistSt,unordered_set<string> repleacPlistSt){
    RUReboltLayer* ret = RUReboltLayer::create();
    redream::REDReader* ccbReader = new redream::REDReader(NodeLoaderLibrary::getInstance());
    try {
        ccbReader->setPlist(plistSt,repleacPlistSt);
        ccbReader->setBatchNode(true);
        
        Node* node = ccbReader->readNodeGraphFromFile(fileName.c_str());
        redream::ReboltRedManager* rs = ccbReader->getReboltRedManager();
        if(rs) {
            ret->setReboltRedManger(rs);
        }
        REDReader::ReboltRedManagerMapPtr mgrs = ccbReader->getReboltRedManagerMapPtr();
        for(auto iter : *mgrs) {
            iter.second->setNotifyDevelopmentDelegate(ret);
        }
        ret->addChild(node);
        ccbReader->autorelease();
    } catch (string str) {
        CCLOG("加载错误 %s", str.c_str());
    }
    return ret;
}

RUReboltLayer* RUReboltLayer::creatBatchReboltLayer(const std::string& fileName,unordered_set<string> plistSt){
    RUReboltLayer* ret = RUReboltLayer::create();
    redream::REDReader* ccbReader = new redream::REDReader(NodeLoaderLibrary::getInstance());
    try {
        ccbReader->setPlist(plistSt,plistSt);
        ccbReader->setBatchNode(true);
        Node* node = ccbReader->readNodeGraphFromFile(fileName.c_str());
        redream::ReboltRedManager* rs = ccbReader->getReboltRedManager();
        if(rs) {
            ret->setReboltRedManger(rs);
        }
        REDReader::ReboltRedManagerMapPtr mgrs = ccbReader->getReboltRedManagerMapPtr();
        for(auto iter : *mgrs) {
            iter.second->setNotifyDevelopmentDelegate(ret);
        }
        ret->addChild(node);
        ccbReader->release();
    } catch (string str) {
        CCLOG("加载错误 %s", str.c_str());
    }
    return ret;
}

void RUReboltLayer::onNotifyDevelopment(redream::ReboltRedManager* reboltRedManager, redream::NotifyDevelopmentWaiter* waiter, std::string notify, std::string param, bool reboltIsWait, Node* outNode) {
    if(_onNotifyCallback){
        ReboltNotifyData reboltNotifyData;
        reboltNotifyData.reboltRedManager = reboltRedManager;
        reboltNotifyData.waiter = waiter;
        reboltNotifyData.notify = notify;
        reboltNotifyData.param = param;
        reboltNotifyData.reboltIsWait = reboltIsWait;
        reboltNotifyData.outNode = outNode;
        
        _onNotifyCallback(reboltNotifyData);
    }
}

std::string RUReboltLayer::runBehaviacWhitFunName(std::string name, std::map<std::string, bool> boolMap, std::map<std::string, std::string> stringMap) {
    if(_rs) {
        return _rs->runBehaviacWhitFunName(name, boolMap, stringMap);
    }
    CCASSERT(_rs, "没有设置ReboltRedManger");
    return "";
}

void RUReboltLayer::setReboltRedManger(redream::ReboltRedManager* rs) {
    _rs = rs;
    CC_SAFE_RETAIN(_rs);
}

void RUReboltLayer::setCoderDataVar(std::string key, std::string content) {
    CCASSERT(_rs, "请先setReboltRedManger");
    if(_rs) {
        _rs->setCoderDataVar(key, content);
    }
}

bool RUReboltLayer::hasBehaviacWithFuncName(std::string name) {
    auto treeMap = _rs->getTreeTypeNameMap();
    auto funNameIdMapIt = treeMap.find("func");
	if(funNameIdMapIt != treeMap.end()){
		map<std::string, std::string> funNameIdMap = funNameIdMapIt->second;
		auto nameIdIt = funNameIdMap.find(name);
		if(nameIdIt != funNameIdMap.end()){
			return true;
		}
    }
    return false;
}

void RUReboltLayer::registerOnNotify(const std::function<void(const ReboltNotifyData&)>& notifyCallback){
    _onNotifyCallback = notifyCallback;
}

void RUReboltLayer::registerOnExit(const std::function<void()>& func) {
    _onExitCb = func;
}

void RUReboltLayer::registerOnEnter(const std::function<void()>& func) {
    _onEnterCb = func;
}

void RUReboltLayer::onExit() {
    Layer::onExit();
    if(_onExitCb) {
        _onExitCb();
    }
}

void RUReboltLayer::onEnter() {
    Layer::onEnter();
    if(_onEnterCb) {
        _onEnterCb();
    }
}

NS_RU_END