#include "BehaviorPerform.h"


void BehaviorPerformPlugin::mapReset(const QString& path)
{

}

void BehaviorPerformPlugin::execute(std::shared_ptr<const EntityInitialRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
{

}

void BehaviorPerformPlugin::execute(std::shared_ptr<const EntityPreparedRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
{

}

void BehaviorPerformPlugin::execute(std::shared_ptr<const SyncRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
{

}

void BehaviorPerformPlugin::execute(std::shared_ptr<const DeduceRequest> in, QList<std::shared_ptr<RespondDefault>>& out)
{

}

void BehaviorPerformPlugin::recoveryFrom(const QJsonObject& obj)
{
}

void BehaviorPerformPlugin::saveTo(QJsonObject& obj) const
{
}

std::shared_ptr<Serializable> BehaviorPerformPlugin::newDefault() const
{
	return std::make_shared<BehaviorPerformPlugin>();
}

void BehaviorPerformPlugin::bindEntity(std::weak_ptr<WsEntity> host)
{
	this->_bind_entity = host;
}

QString BehaviorPerformPlugin::name() const
{
	return NAME(BehaviorPerformPlugin);
}

#include <MessageLoader.h>
MapKernal::MapKernal(std::shared_ptr<MessageLoader> ins)
	:_bind_loader(ins) {
}

QList<QString> MapKernal::compareTypes() const
{
	return _compare_types.keys();
}

void MapKernal::registCompare(std::shared_ptr<CompareDelegate> ins)
{
	_compare_types[ins->name()] = ins;
	emit this->compareTypeListChanged();
}

std::shared_ptr<CompareDelegate> MapKernal::getCompare(const QString& name) const
{
	if (!_compare_types.contains(name))
		return nullptr;
	return _compare_types[name];
}

void MapKernal::registConvert(std::shared_ptr<ConvertDelegate> ins)
{
	_convert_types[ins->name()] = ins;
	emit this->convertTypeListChanged();
}

QList<QString> MapKernal::convertTypes() const
{
	return _convert_types.keys();
}

std::shared_ptr<ConvertDelegate> MapKernal::getConvert(const QString& name) const
{
	if (!_convert_types.contains(name))
		return nullptr;
	return _convert_types[name];
}

void MapKernal::registExecute(std::shared_ptr<ExecuteDelegate> ins)
{
	_execute_types[ins->typeName()] = ins;
}

void MapKernal::initial()
{
	// 注册基础数据类型
	registData(std::make_shared<GeneralData>());
	for (auto key : _bind_loader->allType())
		registData(_bind_loader->makeDefault(key));

	// 注册可用节点类型
	registNode(std::make_shared<SequenceNode>(this->shared_from_this()));
	registNode(std::make_shared<SelectorNode>(this->shared_from_this()));
	registNode(std::make_shared<ParallelNode>(this->shared_from_this()));
	registNode(std::make_shared<CompareNode>(this->shared_from_this()));
	registNode(std::make_shared<ExecuteNode>(this->shared_from_this()));
	registNode(std::make_shared<ModifiedNode>(this->shared_from_this()));
	registNode(std::make_shared<BehaviorMapNode>(this->shared_from_this()));
}

QJSEngine& MapKernal::bindEngine()
{
	return this->_core_engine;
}

void MapKernal::registData(std::shared_ptr<TopicData> init)
{
	if (_variable_types.contains(init->topicString()))
		throw new UniException(QString(u8"重复注册类型数据{%1}").arg(init->topicString()));

	_variable_types[init->topicString()] = init;
}

QList<QString> MapKernal::dataTypes() const
{
	return _variable_types.keys();
}

std::shared_ptr<TopicData> MapKernal::getData(const QString& topic) const
{
	return _variable_types[topic];
}

QList<QString> MapKernal::executeTypes() const
{
	return _execute_types.keys();
}

std::shared_ptr<ExecuteDelegate> MapKernal::getExecute(const QString& name) const
{
	return _execute_types[name];
}

void MapKernal::registNode(std::shared_ptr<LogicalNode> ins)
{
	_logicalnode_types[ins->typeName()] = ins;
}

QList<QString> MapKernal::nodeTypes() const
{
	return _logicalnode_types.keys();
}

std::shared_ptr<LogicalNode> MapKernal::getNode(const QString& name) const
{
	return _logicalnode_types[name];
}

std::shared_ptr<Serializable> MapKernal::newDefault() const
{
	return nullptr;
}


#include <QJsonArray>
#include <QJsonObject>
void MapKernal::recoveryFrom(const QJsonObject& obj)
{
	QStringList compares, converts, executes, variable_keys;
	STRLIST_PEAK(executes);
	STRLIST_PEAK(variable_keys);
	STRLIST_PEAK(compares);
	STRLIST_PEAK(converts);

	// 执行器类型校验
	for (auto key : executes) {
		if (this->executeTypes().contains(key))
			continue;
		throw new UniException("当前环境不包含指定执行器类型：" + key);
	}	
	
	// 变量类型校验
	for (auto key : variable_keys) {
		if (this->dataTypes().contains(key))
			continue;
		throw new UniException("当前环境不包含指定变量类型：" + key);
	}

	this->_compare_types.clear();
	// 提取比较器代码
	auto compare_array = obj["compare_objs"].toArray();
	for (auto idx = 0; idx < compare_array.size(); ++idx) {
		auto compare_obj = compare_array.at(idx);
		auto func_name = compare_obj["name"].toString();
		auto func_obj = compare_obj["define_obj"].toObject();

		auto compare_ins = std::make_shared<CompareDelegate>(_core_engine, func_name);
		compare_ins->recoveryFrom(func_obj);

		this->registCompare(compare_ins);
	}

	this->_convert_types.clear();
	// 提取转换器代码
	auto convert_array = obj["convert_objs"].toArray();
	for (auto idx = 0; idx < convert_array.size(); ++idx) {
		auto convert_obj = convert_array.at(idx);
		auto func_name = convert_obj["name"].toString();
		auto func_obj = convert_obj["define_obj"].toObject();

		auto convert_ins = std::make_shared<ConvertDelegate>(this->shared_from_this(), _core_engine, func_name);
		convert_ins->recoveryFrom(func_obj);

		this->registConvert(convert_ins);
	}
}


void MapKernal::saveTo(QJsonObject& obj) const
{
	// 保存比较器代码
	QStringList compares = this->compareTypes();
	STRLIST_SAVE(compares);
	QJsonArray compare_array;
	for (auto ins_key : compares) {
		auto ins_compare = this->getCompare(ins_key);

		QJsonObject compare_obj, ins_entity;
		compare_obj["name"] = ins_key;
		ins_compare->saveTo(ins_entity);
		compare_obj["define_obj"] = ins_entity;

		compare_array.append(compare_obj);
	}
	obj["compare_objs"] = compare_array;

	// 保存转换器代码
	QStringList converts = this->convertTypes();
	STRLIST_SAVE(converts);
	QJsonArray convert_array;
	for (auto ins_key : converts) {
		auto ins_convert = this->getConvert(ins_key);

		QJsonObject convert_obj, ins_entity;
		convert_obj["name"] = ins_key;
		ins_convert->saveTo(ins_entity);
		convert_obj["define_obj"] = ins_entity;

		convert_array.append(convert_obj);
	}
	obj["convert_objs"] = convert_array;

	// 保存执行器清单
	QStringList executes = this->executeTypes();
	STRLIST_SAVE(executes);

	// 保存变量类型清单
	QStringList variable_keys = this->dataTypes();
	STRLIST_SAVE(variable_keys);
}

LogicalNode::LogicalNode(NodeKind t, std::shared_ptr<MapKernal> kernal)
	:_node_type(t), _bind_kernal(kernal) {
}

void LogicalNode::_set_parent_node(std::weak_ptr<LogicalNode> pnode)
{
	this->_parent_bind = pnode;
}

NodeKind LogicalNode::nodeKind() const
{
	return _node_type;
}

int LogicalNode::depth() const
{
	auto node_temp = this->parent().lock();
	if (!node_temp) return 0;

	return this->parent().lock()->depth() + 1;
}

std::shared_ptr<BehaviorMapNode> LogicalNode::bindMap() const
{
	auto node_temp = this->parent().lock();
	if (!node_temp) return nullptr;

	while (node_temp->nodeKind() != NodeKind::MAPNODE) {
		node_temp = node_temp->parent().lock();
	}

	return std::dynamic_pointer_cast<BehaviorMapNode>(node_temp);
}

std::shared_ptr<MapKernal> LogicalNode::getKernal() const
{
	return _bind_kernal;
}

void LogicalNode::setID(int unique_id)
{
	this->_node_id = unique_id;
}

int LogicalNode::getID() const
{
	return this->_node_id;
}

QString LogicalNode::rtName() const
{
	return QString(u8"%1(%2)").arg(this->typeName()).arg(getID());
}

std::weak_ptr<LogicalNode> LogicalNode::parent() const
{
	return this->_parent_bind;
}

BehaviorMapNode::BehaviorMapNode(std::shared_ptr<MapKernal> core)
	:LogicalNode(NodeKind::MAPNODE, core) {
}

void BehaviorMapNode::setVariable(const QString& key, IO_TYPE t, std::shared_ptr<TopicData> ins)
{
	if (_variables.contains(key))
		if (_variables[key].second->topicString() != ins->topicString())
			throw new UniException(u8"不同数据类型数据绑定同一个名称！");
	_variables[key] = std::make_pair(t, ins);
}

QList<QString> BehaviorMapNode::inputVariableKeys() const
{
	QList<QString> keys;
	for (auto key : this->_variables.keys())
		if (this->_variables[key].first == IO_TYPE::INPUT)
			keys << key;

	return keys;
}

QList<QString> BehaviorMapNode::outputVariableKeys() const
{
	QList<QString> keys;
	for (auto key : this->_variables.keys())
		if (this->_variables[key].first == IO_TYPE::OUTPUT)
			keys << key;

	return keys;
}

void BehaviorMapNode::removeVariable(const QString& key)
{
	this->_variables.remove(key);
}

std::shared_ptr<TopicData> BehaviorMapNode::getVariable(const QString& key) const
{
	if (!_variables.contains(key))
		return nullptr;

	return _variables[key].second;
}

void BehaviorMapNode::resetName(const QString& val)
{
	this->_map_name = val;
}

std::shared_ptr<Serializable> BehaviorMapNode::newDefault() const
{
	return std::make_shared<BehaviorMapNode>(this->getKernal());
}

void BehaviorMapNode::recoveryFrom(const QJsonObject& obj)
{

}

void BehaviorMapNode::saveTo(QJsonObject& obj) const
{

}

QList<std::shared_ptr<LogicalNode>> BehaviorMapNode::getForwards() const
{
	return children();
}

bool BehaviorMapNode::fallback(std::shared_ptr<LogicalNode> node, ExecuteResult ste)
{
	this->_state_value = ste;
	return true;
}

void BehaviorMapNode::reset()
{
	this->_state_value = ExecuteResult::UNDEFINED;
}

QString BehaviorMapNode::typeName() const
{
	return _map_name;
}

ExecuteResult BehaviorMapNode::execute()
{
	return _state_value;
}

QHash<QString, std::shared_ptr<TopicData>> BehaviorMapNode::inputList() const
{
	QHash<QString, std::shared_ptr<TopicData>> list;
	for (auto key : this->_variables.keys()) {
		if (this->_variables[key].first == IO_TYPE::INPUT && key.contains(u8"::"))
			list[key] = _variables[key].second;
	}

	return list;
}

QHash<QString, std::shared_ptr<TopicData>> BehaviorMapNode::outputList() const
{
	QHash<QString, std::shared_ptr<TopicData>> list;
	for (auto key : this->_variables.keys()) {
		if (this->_variables[key].first == IO_TYPE::OUTPUT && key.contains(u8"::"))
			list[key] = _variables[key].second;
	}

	return list;
}


SequenceNode::SequenceNode(std::shared_ptr<MapKernal> kernal)
	: LogicalNode(NodeKind::SEQUENCENODE, kernal) {
}

QList<std::shared_ptr<LogicalNode>> SequenceNode::getForwards() const
{
	for (auto item : children()) {
		// 子节点执行失败，提前结束
		if (_state_map.contains(item->getID())) {
			if (_state_map[item->getID()] != ExecuteResult::SUCCESS)
				return QList<std::shared_ptr<LogicalNode>>();
		}

		// 获取新节点
		if (!_state_map.contains(item->getID()))
			return QList<std::shared_ptr<LogicalNode>>() << item;
	}

	// 全部成功
	return QList<std::shared_ptr<LogicalNode>>();
}

QString SequenceNode::typeName() const
{
	return u8"顺序";
}

ExecuteResult SequenceNode::execute() {
	if (children().size() >= _state_map.size())
		return ExecuteResult::FAILURE;

	for (auto ste : this->_state_map) {
		switch (ste) {
		case ExecuteResult::SUCCESS:
			break;
		default:
			return ExecuteResult::FAILURE;
		}
	}

	return ExecuteResult::SUCCESS;
}

QHash<QString, std::shared_ptr<TopicData>> SequenceNode::inputList() const
{
	return QHash<QString, std::shared_ptr<TopicData>>();
}

QHash<QString, std::shared_ptr<TopicData>> SequenceNode::outputList() const
{
	return QHash<QString, std::shared_ptr<TopicData>>();
}

void SequenceNode::recoveryFrom(const QJsonObject& obj)
{
	QStringList state_items;
	STRLIST_PEAK(state_items);
	for (auto kv : state_items) {
		auto kv_pair = kv.split(u8":");
		_state_map[kv_pair[0].toInt()] = (ExecuteResult)kv_pair[1].toInt();
	}
}

void SequenceNode::saveTo(QJsonObject& obj) const
{
	QStringList state_items;
	for (auto inv : _state_map.keys()) {
		state_items << QString(u8"%1:%2").arg(inv).arg((int)_state_map[inv]);
	}

	STRLIST_SAVE(state_items);
}

bool SequenceNode::fallback(std::shared_ptr<LogicalNode> node, ExecuteResult ste)
{
	this->_state_map[node->getID()] = ste;
	return true;
}

std::shared_ptr<Serializable> SequenceNode::newDefault() const
{
	return std::make_shared<SequenceNode>(this->getKernal());
}

void SequenceNode::reset()
{
	this->_state_map.clear();
}

QList<std::shared_ptr<LogicalNode>> LogicalNode::children() const
{
	return _child_list;
}

void LogicalNode::insert(std::shared_ptr<LogicalNode> node, int index /*= -1*/)
{
	for (auto it : _child_list)
		if (it->getID() == node->getID())
			return;

	if (node->parent().lock())
		node->parent().lock()->remove(node);

	_child_list.insert(index, node);
	node->_set_parent_node(this->shared_from_this());
}

void LogicalNode::remove(std::shared_ptr<LogicalNode> node)
{
	_child_list.removeAll(node);
}

SelectorNode::SelectorNode(std::shared_ptr<MapKernal> kernal)
	: LogicalNode(NodeKind::SEQUENCENODE, kernal) {
}

QList<std::shared_ptr<LogicalNode>> SelectorNode::getForwards() const
{
	for (auto item : children()) {
		// 子节点执行失败，提前结束
		if (_state_map.contains(item->getID())) {
			if (_state_map[item->getID()] == ExecuteResult::SUCCESS)
				return QList<std::shared_ptr<LogicalNode>>();
		}

		// 获取新节点
		if (!_state_map.contains(item->getID()))
			return QList<std::shared_ptr<LogicalNode>>() << item;
	}

	// 全部成功
	return QList<std::shared_ptr<LogicalNode>>();
}

bool SelectorNode::fallback(std::shared_ptr<LogicalNode> node, ExecuteResult ste)
{
	_state_map[node->getID()] = ste;
	return true;
}

std::shared_ptr<Serializable> SelectorNode::newDefault() const
{
	return std::make_shared<SelectorNode>(this->getKernal());
}

void SelectorNode::recoveryFrom(const QJsonObject& obj)
{
	QStringList state_items;
	STRLIST_PEAK(state_items);
	for (auto kv : state_items) {
		auto kv_pair = kv.split(u8":");
		_state_map[kv_pair[0].toInt()] = (ExecuteResult)kv_pair[1].toInt();
	}
}

void SelectorNode::saveTo(QJsonObject& obj) const
{
	QStringList state_items;
	for (auto inv : _state_map.keys()) {
		state_items << QString(u8"%1:%2").arg(inv).arg((int)_state_map[inv]);
	}

	STRLIST_SAVE(state_items);
}

void SelectorNode::reset()
{
	_state_map.clear();
}

QString SelectorNode::typeName() const
{
	return u8"选择";
}

ExecuteResult SelectorNode::execute()
{
	for (auto value : _state_map) {
		if (value == ExecuteResult::SUCCESS)
			return ExecuteResult::SUCCESS;
	}
	return ExecuteResult::FAILURE;
}

QHash<QString, std::shared_ptr<TopicData>> SelectorNode::inputList() const
{
	return {};
}

QHash<QString, std::shared_ptr<TopicData>> SelectorNode::outputList() const
{
	return {};
}

QList<std::shared_ptr<LogicalNode>> ParallelNode::getForwards() const
{
	if (this->children().size() == _state_map.size())
		return QList<std::shared_ptr<LogicalNode>>();
	return this->children();
}

bool ParallelNode::fallback(std::shared_ptr<LogicalNode> node, ExecuteResult ste)
{
	_state_map[node->getID()] = ste;
	return children().size() == _state_map.size();
}

void ParallelNode::reset()
{
	_state_map.clear();
}

QString ParallelNode::typeName() const
{
	return u8"并行";
}

ExecuteResult ParallelNode::execute()
{
	for (auto ste : this->_state_map)
		if (ste != ExecuteResult::SUCCESS)
			return ExecuteResult::FAILURE;

	return ExecuteResult::SUCCESS;
}

std::shared_ptr<Serializable> ParallelNode::newDefault() const
{
	return std::make_shared<ParallelNode>(this->getKernal());
}

ParallelNode::ParallelNode(std::shared_ptr<MapKernal> kernal)
	: LogicalNode(NodeKind::PARALLELNODE, kernal) {
}

QHash<QString, std::shared_ptr<TopicData>> ParallelNode::inputList() const
{
	return QHash<QString, std::shared_ptr<TopicData>>();
}

QHash<QString, std::shared_ptr<TopicData>> ParallelNode::outputList() const
{
	return QHash<QString, std::shared_ptr<TopicData>>();
}

void ParallelNode::recoveryFrom(const QJsonObject& obj)
{
	QStringList state_items;
	STRLIST_PEAK(state_items);
	for (auto kv : state_items) {
		auto kv_pair = kv.split(u8":");
		_state_map[kv_pair[0].toInt()] = (ExecuteResult)kv_pair[1].toInt();
	}
}

void ParallelNode::saveTo(QJsonObject& obj) const
{
	QStringList state_items;
	for (auto inv : _state_map.keys()) {
		state_items << QString(u8"%1:%2").arg(inv).arg((int)_state_map[inv]);
	}

	STRLIST_SAVE(state_items);
}

void CompareNode::reset() {
}

QString CompareNode::typeName() const
{
	return QString(u8"%1<%2>").arg(u8"比较", delegateName());
}

ExecuteResult CompareNode::execute()
{
	if (this->_bind_delegate) {
		auto vl = _data_map[u8"左值"];
		auto vb = _data_map[u8"右值"];
		if (this->_bind_delegate->compare(vl, vb))
			return ExecuteResult::SUCCESS;
	}
	return ExecuteResult::FAILURE;
}

void CompareNode::insert(std::shared_ptr<LogicalNode> node, int index /*= -1*/)
{
}

QList<std::shared_ptr<LogicalNode>> CompareNode::getForwards() const
{
	return QList<std::shared_ptr<LogicalNode>>();
}

bool CompareNode::fallback(std::shared_ptr<LogicalNode> node, ExecuteResult ste) {
	return true;
}

std::shared_ptr<Serializable> CompareNode::newDefault() const
{
	return std::make_shared<CompareNode>(getKernal());
}

CompareNode::CompareNode(std::shared_ptr<MapKernal> ins)
	: LogicalNode(NodeKind::COMPARENODE, ins) {
	_data_map[u8"左值"] = std::make_shared<GeneralData>();
	_data_map[u8"右值"] = std::make_shared<GeneralData>();
}

QString CompareNode::delegateName() const
{
	if (_bind_delegate)
		return _bind_delegate->name();
	return u8"";
}

void CompareNode::bindDelegate(std::shared_ptr<CompareDelegate> ins)
{
	this->_bind_delegate = ins;
}

QHash<QString, std::shared_ptr<TopicData>> CompareNode::inputList() const
{
	return _data_map;
}

QHash<QString, std::shared_ptr<TopicData>> CompareNode::outputList() const
{
	return QHash<QString, std::shared_ptr<TopicData>>();
}

#include <QJsonObject>
void CompareNode::recoveryFrom(const QJsonObject& obj)
{
	auto vala = obj[u8"ValL"];
	auto valb = obj[u8"ValR"];

	_data_map[u8"左值"]->recoveryFrom(vala.toObject());
	_data_map[u8"右值"]->recoveryFrom(valb.toObject());

	QString delegate_name = "";
	STRING_PEAK(delegate_name);

	auto deins = getKernal()->getCompare(delegate_name);
	bindDelegate(deins);
}

void CompareNode::saveTo(QJsonObject& obj) const
{
	QJsonObject vala, valb;
	_data_map[u8"左值"]->saveTo(vala);
	_data_map[u8"右值"]->saveTo(valb);

	obj[u8"ValL"] = vala;
	obj[u8"ValR"] = valb;

	QString delegate_name = "";
	if (_bind_delegate) {
		delegate_name = _bind_delegate->name();
	}

	STRING_SAVE(delegate_name);
}

#include <QJsonDocument>
QString GeneralData::topicString() const
{
	return u8"GeneralData";
}

std::shared_ptr<Serializable> GeneralData::newDefault() const
{
	return std::make_shared<GeneralData>();
}

void GeneralData::recoveryFrom(const QJsonObject& obj)
{
	_element_bind = obj;
}

void GeneralData::saveTo(QJsonObject& obj) const
{
	obj = _element_bind;
}

CompareDelegate::CompareDelegate(QJSEngine& bind_engine, const QString& func)
	:_script_engine(bind_engine), _function_name(func) {
}

QString CompareDelegate::name() const
{
	return _function_name;
}

bool CompareDelegate::compare(std::shared_ptr<TopicData> vleft, std::shared_ptr<TopicData> vright)
{
	return true;
}

#include <exception>
std::shared_ptr<Serializable> CompareDelegate::newDefault() const
{
	return nullptr;
}

void CompareDelegate::recoveryFrom(const QJsonObject& obj)
{
}

void CompareDelegate::saveTo(QJsonObject& obj) const
{
}

ConvertDelegate::ConvertDelegate(std::shared_ptr<MapKernal> host, QJSEngine& bind_engine, const QString& func)
	: _host_bind(host), _script_engine(bind_engine), _function_name(func) {
}

QString ConvertDelegate::name() const
{
	return _function_name;
}

QList<std::pair<ConvertDelegate::DATA_TOPIC_STRING, QString>> ConvertDelegate::inputTable() const
{
	return _input_table;
}

void ConvertDelegate::inputReset(const QList<std::pair<DATA_TOPIC_STRING, QString>>& table)
{
	this->_input_table = table;
}

std::pair<ConvertDelegate::DATA_TOPIC_STRING, QString> ConvertDelegate::outputVariable() const
{
	return _output_appoint;
}

void ConvertDelegate::outputReset(std::pair<DATA_TOPIC_STRING, QString> appoint)
{
	this->_output_appoint = appoint;
}

std::shared_ptr<TopicData> ConvertDelegate::convert(const QList<std::shared_ptr<TopicData>>& input_variables)
{
	return nullptr;
}

std::shared_ptr<Serializable> ConvertDelegate::newDefault() const
{
	return nullptr;
}

void ConvertDelegate::recoveryFrom(const QJsonObject& obj)
{

}

void ConvertDelegate::saveTo(QJsonObject& obj) const
{

}

ExecuteNode::ExecuteNode(std::shared_ptr<MapKernal> ins)
	: LogicalNode(NodeKind::ACTIONNODE, ins) {
}

QString ExecuteNode::delegateName() const
{
	if (_bind_delegate)
		return _bind_delegate->typeName();
	return "";
}

void ExecuteNode::bindDelegate(std::shared_ptr<ExecuteDelegate> ins)
{
	_bind_delegate = ins;
}

QList<std::shared_ptr<LogicalNode>> ExecuteNode::getForwards() const
{
	return QList<std::shared_ptr<LogicalNode>>();
}

QString ExecuteNode::typeName() const
{
	return QString(u8"执行<%1>").arg(delegateName());
}

QHash<QString, std::shared_ptr<TopicData>> ExecuteNode::inputList() const
{
	if (_bind_delegate)
		return _bind_delegate->inputList();
	return QHash<QString, std::shared_ptr<TopicData>>();
}

QHash<QString, std::shared_ptr<TopicData>> ExecuteNode::outputList() const
{
	if (_bind_delegate)
		return _bind_delegate->outputList();
	return QHash<QString, std::shared_ptr<TopicData>>();
}

void ExecuteNode::insert(std::shared_ptr<LogicalNode> node, int index /*= -1*/)
{
}

void ExecuteNode::reset()
{
	if (_bind_delegate)
		_bind_delegate->reset();
}

ExecuteResult ExecuteNode::execute()
{
	if (_bind_delegate)
		return _bind_delegate->execute();
	return ExecuteResult::FAILURE;
}

bool ExecuteNode::fallback(std::shared_ptr<LogicalNode> node, ExecuteResult ste)
{
	return true;
}

std::shared_ptr<Serializable> ExecuteNode::newDefault() const
{
	return std::make_shared<ExecuteNode>(this->getKernal());
}

void ExecuteNode::recoveryFrom(const QJsonObject& obj)
{
	QString delegate_name = "";
	STRING_PEAK(delegate_name);

	auto de_ins = getKernal()->getExecute(delegate_name);
	this->bindDelegate(de_ins);

	if (obj.contains("data_json")) {
		auto delegate_json = obj["data_json"].toObject();
		de_ins->recoveryFrom(delegate_json);
	}
}

void ExecuteNode::saveTo(QJsonObject& obj) const
{
	QString delegate_name = "";
	if (_bind_delegate)
		delegate_name = _bind_delegate->typeName();

	STRING_SAVE(delegate_name);

	if (_bind_delegate) {
		QJsonObject data_json;
		this->_bind_delegate->saveTo(data_json);
		obj["data_json"] = data_json;
	}
}

ModifiedNode::ModifiedNode(std::shared_ptr<MapKernal> kernal)
	: LogicalNode(NodeKind::MODIFYNODE, kernal) {
}

ModifyType ModifiedNode::modifyType() const
{
	return _type_appoint;
}

void ModifiedNode::resetModify(ModifyType t)
{
	this->_type_appoint = t;
}

void ModifiedNode::insert(std::shared_ptr<LogicalNode> node, int index /*= -1*/)
{
	if (children().size())
		return;

	LogicalNode::insert(node);
}

QString ModifiedNode::typeName() const
{
	switch (modifyType())
	{
	case ModifyType::ALWAYS_SUCCESS:
		return u8"修饰<永远成功>";
	case ModifyType::ALWAYS_FAILURE:
		return u8"修饰<永远失败>";
	case ModifyType::RESULT_INVENTER:
		return u8"修饰<结果反转>";
	default:
		return u8"修饰<>";
	}
}

QHash<QString, std::shared_ptr<TopicData>> ModifiedNode::inputList() const
{
	return {};
}

QHash<QString, std::shared_ptr<TopicData>> ModifiedNode::outputList() const
{
	return {};
}

void ModifiedNode::reset()
{
	this->_result_store = ExecuteResult::UNDEFINED;
}

QList<std::shared_ptr<LogicalNode>> ModifiedNode::getForwards() const
{
	return children();
}

bool ModifiedNode::fallback(std::shared_ptr<LogicalNode> node, ExecuteResult ste)
{
	this->_result_store = ste;
	return true;
}

ExecuteResult ModifiedNode::execute()
{
	switch (_type_appoint)
	{
	case ModifyType::RESULT_INVENTER:
		if (_result_store == ExecuteResult::SUCCESS) {
			return ExecuteResult::FAILURE;
		}
		else {
			return ExecuteResult::SUCCESS;
		}
	case ModifyType::ALWAYS_SUCCESS:
		return ExecuteResult::SUCCESS;
	case ModifyType::ALWAYS_FAILURE:
	case ModifyType::NONE:
		return ExecuteResult::FAILURE;
	}
}

std::shared_ptr<Serializable> ModifiedNode::newDefault() const
{
	return std::make_shared<ModifiedNode>(this->getKernal());
}

void ModifiedNode::recoveryFrom(const QJsonObject& obj)
{

}

void ModifiedNode::saveTo(QJsonObject& obj) const
{

}