SimsWorld/ComponentBasic/BehaviorPerform.cpp

#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>
#include "exec_delegate.h"
MapKernel::MapKernel(std::shared_ptr<MessageLoader> ins)
	:_bind_loader(ins) {
	auto output = std::make_shared<ConsolePresent>();
	this->_execute_types[output->typeName()] = output;
}

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

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

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

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

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

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

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

struct JsonString : public TopicData {
	QString _string_content;

	// ͨ<><CDA8> TopicData <20>̳<EFBFBD>
	std::shared_ptr<Serializable> newDefault() const override
	{
		return std::shared_ptr<JsonString>();
	}
	void recoveryFrom(const QJsonObject& obj) override
	{
		STRING_PEAK(_string_content);
	}
	void saveTo(QJsonObject& obj) const override
	{
		STRING_SAVE(_string_content);
	}
	QString topicString() const override
	{
		return NAME(JsonString);
	}
};

void MapKernel::initial()
{
	// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	registData(std::make_shared<GeneralData>());
	registData(std::make_shared<JsonString>());
	for (auto key : _bind_loader->allType())
		registData(_bind_loader->makeDefault(key));

	// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD>ýڵ<C3BD><DAB5><EFBFBD><EFBFBD><EFBFBD>
	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& MapKernel::bindEngine()
{
	return this->_core_engine;
}

void MapKernel::registData(std::shared_ptr<TopicData> init)
{
	if (_variable_types.contains(init->topicString()))
		throw new UniException(QString(u8"<EFBFBD>ظ<EFBFBD>ע<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>{%1}").arg(init->topicString()));

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

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

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

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

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

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

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

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

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


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

	// ִ<><D6B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3>
	for (auto key : executes) {
		if (this->executeTypes().contains(key))
			continue;
		throw new UniException("<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD>ִ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͣ<EFBFBD>" + key);
	}

	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><D0A3>
	for (auto key : variable_keys) {
		if (this->dataTypes().contains(key))
			continue;
		throw new UniException("<EFBFBD><EFBFBD>ǰ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͣ<EFBFBD>" + key);
	}

	this->_compare_types.clear();
	// <20><>ȡ<EFBFBD>Ƚ<EFBFBD><C8BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	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();
	// <20><>ȡת<C8A1><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	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 MapKernel::saveTo(QJsonObject& obj) const
{
	// <20><><EFBFBD><EFBFBD><EFBFBD>Ƚ<EFBFBD><C8BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	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;

	// <20><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
	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;

	// <20><><EFBFBD><EFBFBD>ִ<EFBFBD><D6B4><EFBFBD><EFBFBD><EFBFBD>嵥
	QStringList executes = this->executeTypes();
	STRLIST_SAVE(executes);

	// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>嵥
	QStringList variable_keys = this->dataTypes();
	STRLIST_SAVE(variable_keys);
}

LogicalNode::LogicalNode(NodeKind t, std::shared_ptr<MapKernel> 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<MapKernel> 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<MapKernel> 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"<EFBFBD><EFBFBD>ͬ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݰ<EFBFBD><EFBFBD><EFBFBD>ͬһ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ƣ<EFBFBD>");
	_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;
}

QList<QString> BehaviorMapNode::internalVariableKeys() const
{
	QList<QString> keys;
	for (auto key : this->_variables.keys())
		if (this->_variables[key].first == IO_TYPE::INTERNAL)
			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::rtName() const
{
	return QString(u8"<EFBFBD><EFBFBD>Ϊ<EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD><%1>(%2)").arg(_map_name).arg(getID());
}

QString BehaviorMapNode::typeName() const
{
	return u8"<EFBFBD><EFBFBD>Ϊ<EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD>";
}

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<MapKernel> kernal)
	: LogicalNode(NodeKind::SEQUENCENODE, kernal) {
}

QList<std::shared_ptr<LogicalNode>> SequenceNode::getForwards() const
{
	for (auto item : children()) {
		// <20>ӽڵ<D3BD>ִ<EFBFBD><D6B4>ʧ<EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD>
		if (_state_map.contains(item->getID())) {
			if (_state_map[item->getID()] != ExecuteResult::SUCCESS)
				return QList<std::shared_ptr<LogicalNode>>();
		}

		// <20><>ȡ<EFBFBD>½ڵ<C2BD>
		if (!_state_map.contains(item->getID()))
			return QList<std::shared_ptr<LogicalNode>>() << item;
	}

	// ȫ<><C8AB><EFBFBD>ɹ<EFBFBD>
	return QList<std::shared_ptr<LogicalNode>>();
}

QString SequenceNode::typeName() const
{
	return u8"˳<EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD>";
}

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<MapKernel> kernal)
	: LogicalNode(NodeKind::SEQUENCENODE, kernal) {
}

QList<std::shared_ptr<LogicalNode>> SelectorNode::getForwards() const
{
	for (auto item : children()) {
		// <20>ӽڵ<D3BD>ִ<EFBFBD><D6B4>ʧ<EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD>ǰ<EFBFBD><C7B0><EFBFBD><EFBFBD>
		if (_state_map.contains(item->getID())) {
			if (_state_map[item->getID()] == ExecuteResult::SUCCESS)
				return QList<std::shared_ptr<LogicalNode>>();
		}

		// <20><>ȡ<EFBFBD>½ڵ<C2BD>
		if (!_state_map.contains(item->getID()))
			return QList<std::shared_ptr<LogicalNode>>() << item;
	}

	// ȫ<><C8AB><EFBFBD>ɹ<EFBFBD>
	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"ѡ<EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD>";
}

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"<EFBFBD><EFBFBD><EFBFBD>нڵ<EFBFBD>";
}

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<MapKernel> 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() {
}

ExecuteResult CompareNode::execute()
{
	if (this->_bind_delegate) {
		auto vl = _data_map[u8"<EFBFBD><EFBFBD>ֵ"];
		auto vb = _data_map[u8"<EFBFBD><EFBFBD>ֵ"];
		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>>();
}

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

QString CompareNode::typeName() const
{
	return u8"<EFBFBD>ȽϽڵ<EFBFBD>";
}

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<MapKernel> ins)
	: LogicalNode(NodeKind::COMPARENODE, ins) {
	_data_map[u8"<EFBFBD><EFBFBD>ֵ"] = std::make_shared<GeneralData>();
	_data_map[u8"<EFBFBD><EFBFBD>ֵ"] = 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"<EFBFBD><EFBFBD>ֵ"]->recoveryFrom(vala.toObject());
	_data_map[u8"<EFBFBD><EFBFBD>ֵ"]->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"<EFBFBD><EFBFBD>ֵ"]->saveTo(vala);
	_data_map[u8"<EFBFBD><EFBFBD>ֵ"]->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<MapKernel> 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<MapKernel> 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::rtName() const
{
	return QString("%1<%2>(%3)").arg(typeName(), delegateName()).arg(getID());
}

QString ExecuteNode::typeName() const
{
	return u8"ִ<EFBFBD>нڵ<EFBFBD>";
}

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<MapKernel> 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::rtName() const
{
	QString temp_string;
	switch (modifyType())
	{
	case ModifyType::ALWAYS_SUCCESS:
		temp_string = u8"<EFBFBD><EFBFBD><EFBFBD>νڵ<EFBFBD><<3C><>Զ<EFBFBD>ɹ<EFBFBD>>";
	case ModifyType::ALWAYS_FAILURE:
		temp_string = u8"<EFBFBD><EFBFBD><EFBFBD>νڵ<EFBFBD><<3C><>Զʧ<D4B6><CAA7>>";
	case ModifyType::RESULT_INVENTER:
		temp_string = u8"<EFBFBD><EFBFBD><EFBFBD>νڵ<EFBFBD><<3C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ת>";
	default:
		temp_string = u8"<EFBFBD><EFBFBD><EFBFBD>νڵ<EFBFBD><>";
	}

	return temp_string + QString("(%1)").arg(getID());
}

QString ModifiedNode::typeName() const
{
	return u8"<EFBFBD><EFBFBD><EFBFBD>νڵ<EFBFBD>";
}

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
{

}