#pragma once

#include "componentbasic.h"
#include <messagebasic.h>
#include <QJsonObject>
#include <QJSEngine>

class MessageLoader;
class CompareKernel;
class ConvertKernel;
class LogicalNode;

/// <summary>
/// 通用数据类型
/// </summary>
struct COMPONENTBASIC_EXPORT GeneralData : public TopicData {
	QJsonObject _element_bind;

	QString topicString() const override;
	std::shared_ptr<Serializable> newDefault() const override;

	void recoveryFrom(const QJsonObject& obj) override;
	void saveTo(QJsonObject& obj) const override;
};
// ==================================================================================

/// <summary>
/// 行为树实例化节点
/// </summary>
class COMPONENTBASIC_EXPORT MapKernal : virtual public Serializable {
private:
	/// <summary>
	/// 绑定载入器
	/// </summary>
	std::shared_ptr<MessageLoader> _bind_loader;

	/// <summary>
	/// {Topic，default-value}
	/// </summary>
	QHash<QString, std::shared_ptr<TopicData>> _variable_types;

	/// <summary>
	/// 比较器
	/// </summary>
	QHash<QString, std::shared_ptr<CompareKernel>> _compare_types;
	/// <summary>
	/// 转换器
	/// </summary>
	QHash<QString, std::shared_ptr<ConvertKernel>> _convert_types;

	/// <summary>
	/// 所有可用的节点类型
	/// </summary>
	QHash<QString, std::shared_ptr<LogicalNode>> _logicalnode_types;

public:
	MapKernal(std::shared_ptr<MessageLoader> ins);
	virtual ~MapKernal() = default;

	/// <summary>
	/// 获取MessageLoader单例
	/// </summary>
	/// <returns></returns>
	std::shared_ptr<MessageLoader> messageLoader() const;

	// 数据类型管理 ======================================================
	/// <summary>
	/// 注册数据类型
	/// </summary>
	/// <param name="init"></param>
	virtual void registData(std::shared_ptr<TopicData> init);
	/// <summary>
	/// 获取所有可用数据类型
	/// </summary>
	/// <returns></returns>
	virtual QList<QString> dataTypes() const;
	/// <summary>
	/// 获取指定topic的数据类型
	/// </summary>
	/// <param name="topic"></param>
	/// <returns></returns>
	virtual std::shared_ptr<TopicData> getData(const QString &topic);



	// 比较器类型管理 ======================================================
	/// <summary>
	/// 注册比较器
	/// </summary>
	/// <param name="ins"></param>
	virtual void registCompare(std::shared_ptr<CompareKernel> ins);
	/// <summary>
	/// 获取比较器类型
	/// </summary>
	/// <returns></returns>
	virtual QList<QString> compareTypes() const;
	/// <summary>
	/// 获取比较器单例实例
	/// </summary>
	/// <param name="name"></param>
	/// <returns></returns>
	virtual std::shared_ptr<CompareKernel> getCompare(const QString& name);



	// 转换器类型管理 ======================================================
	/// <summary>
	/// 注册转换器
	/// </summary>
	/// <param name="ins"></param>
	virtual void registConvert(std::shared_ptr<ConvertKernel> ins);
	/// <summary>
	/// 转换器类型名称
	/// </summary>
	/// <returns></returns>
	virtual QList<QString> convertTypes() const;
	/// <summary>
	/// 获取指定类型的转换器
	/// </summary>
	/// <param name="name"></param>
	/// <returns></returns>
	virtual std::shared_ptr<ConvertKernel> getConvert(const QString& name);


	// 通过 Serializable 继承
	std::shared_ptr<Serializable> newDefault() const override;
	void recoveryFrom(const QJsonObject& obj) override{}
	void saveTo(QJsonObject& obj) const override{}
};

/// <summary>
/// 比较关系实例
/// </summary>
class COMPONENTBASIC_EXPORT CompareKernel {
private:
	QJSEngine& _script_engine;
	QString _function_name;

public:
	CompareKernel(QJSEngine& bind_engine, const QString& func);

	QString name() const;
	bool compare(std::shared_ptr<TopicData> vleft, std::shared_ptr<TopicData> vright);
};

/// <summary>
/// 数据转换实例
/// </summary>
class COMPONENTBASIC_EXPORT ConvertKernel {
public:
	typedef QString DATA_TOPIC_STRING;

	/// <summary>
	/// 构建转换器
	/// </summary>
	/// <param name="host">数据类型管理核心</param>
	/// <param name="bind_engine"></param>
	/// <param name="func"></param>
	ConvertKernel(std::shared_ptr<MapKernal> host, QJSEngine& bind_engine, const QString& func);
	/// <summary>
	/// 转换器名称：JS函数名
	/// </summary>
	/// <returns></returns>
	QString name() const;

	/// <summary>
	/// 输入变量类型绑定表
	/// </summary>
	/// <returns>list{pair{类型名称,绑定输入变量名}}</returns>
	QList<std::pair<DATA_TOPIC_STRING, QString>> inputTable() const;
	/// <summary>
	/// 重置输入变量类型表
	/// </summary>
	/// <param name="table">list{pair{类型名称,绑定输入变量名}}</param>
	void inputReset(const QList<std::pair<DATA_TOPIC_STRING, QString>> &table);
	/// <summary>
	/// 输入变量
	/// </summary>
	/// <returns>pair{类型名称,绑定输出变量名}</returns>
	std::pair<DATA_TOPIC_STRING, QString> outputVariable() const;
	/// <summary>
	/// 重置输出变量类型名
	/// </summary>
	/// <param name="appoint"></param>
	void outputReset(std::pair<DATA_TOPIC_STRING, QString> appoint);

	/// <summary>
	/// 执行转换
	/// </summary>
	/// <param name="input_variables">输入变量列表</param>
	/// <returns></returns>
	std::shared_ptr<TopicData> convert(const QList<std::shared_ptr<TopicData>>& input_variables);

private:
	std::shared_ptr<MapKernal> _host_bind;

	QJSEngine& _script_engine;
	QString _function_name;

	QList<std::pair<DATA_TOPIC_STRING, QString>> _input_table;
	std::pair<DATA_TOPIC_STRING, QString> _output_appoint;
};




/// <summary>
/// 执行结果
/// </summary>
enum class LogicalResult {
	UNDEFINED,	// 未定义
	SUCCESS,	// 成功
	FAILURE		// 失败
};
/// <summary>
/// 逻辑节点类型
/// </summary>
enum class NodeKind {
	MAPNODE,		// 逻辑树节点
	SEQUENCENODE,	// 顺序节点
	SELECTORNODE,	// 选择节点
	PARALLELNODE,	// 并行节点
	COMPARENODE,	// 比较节点
	ACTIONNODE,		// 动作节点
};
/// <summary>
/// 所有逻辑节点的基类
/// </summary>
class COMPONENTBASIC_EXPORT LogicalNode : virtual public Serializable {
private:
	int _node_id = 0;
	NodeKind _node_type = NodeKind::ACTIONNODE;
	std::weak_ptr<LogicalNode> _parent_bind;
	QList<std::shared_ptr<LogicalNode>> _child_list;

public:
	LogicalNode(NodeKind t = NodeKind::ACTIONNODE);
	virtual ~LogicalNode() = default;

	/// <summary>
	/// 获取节点类型
	/// </summary>
	/// <returns></returns>
	NodeKind nodeKind() const;

	/// <summary>
	/// 重置父节点
	/// </summary>
	/// <param name="pnode"></param>
	void setParent(std::weak_ptr<LogicalNode> pnode);
	/// <summary>
	/// 回退节点
	/// </summary>
	/// <returns></returns>
	std::weak_ptr<LogicalNode> parent() const;
	/// <summary>
	/// 获取包含树图节点
	/// </summary>
	/// <returns></returns>
	std::shared_ptr<LogicalNode> bindMap() const;

	/// <summary>
	/// 设置节点id
	/// </summary>
	/// <param name="unique_id"></param>
	void setID(int unique_id);
	/// <summary>
	/// 提取节点id
	/// </summary>
	/// <returns></returns>
	int getID() const;
	/// <summary>
	/// 实例化节点名称
	/// </summary>
	/// <returns></returns>
	QString runtimeName() const;

	/// <summary>
	/// 重置内部状态
	/// </summary>
	virtual void reset() = 0;
	/// <summary>
	/// 获取节点名称
	/// </summary>
	/// <returns></returns>
	virtual QString typeName() const = 0;
	/// <summary>
	/// 执行逻辑节点
	/// </summary>
	/// <param name="core"></param>
	/// <returns></returns>
	virtual LogicalResult execute() = 0;
	/// <summary>
	/// 声明输入变量的内部标识和数据接口
	/// </summary>
	/// <returns>map{name, type-ins}</returns>
	virtual QHash<QString, std::shared_ptr<TopicData>> inputList() const = 0;
	/// <summary>
	/// 声明输出变量的内部标识和数据接口
	/// </summary>
	/// <returns>map{name, type-ins}</returns>
	virtual QHash<QString, std::shared_ptr<TopicData>> outputList() const = 0;

	/// <summary>
	/// 新建默认实例
	/// </summary>
	/// <returns></returns>
	virtual std::shared_ptr<Serializable> newDefault() const = 0;
};

/// <summary>
/// 组合节点
/// </summary>
class COMPONENTBASIC_EXPORT ComposeNode {
private:
	QList<std::shared_ptr<LogicalNode>> _child_list;

public:
	/// <summary>
	/// 获取子节点列表
	/// </summary>
	/// <returns></returns>
	virtual QList<std::shared_ptr<LogicalNode>> children() const;
	/// <summary>
	/// 添加子节点
	/// </summary>
	/// <param name="node"></param>
	/// <param name="index"></param>
	virtual void insert(std::shared_ptr<LogicalNode> node, int index = -1);
	/// <summary>
	/// 移除子节点
	/// </summary>
	/// <param name="node"></param>
	virtual void remove(std::shared_ptr<LogicalNode> node);

	/// <summary>
	/// 获取执行入口节点
	/// </summary>
	/// <returns></returns>
	virtual QList<std::shared_ptr<LogicalNode>> getForwards() const = 0;
	/// <summary>
	/// 下行节点执行状态回返填充
	/// </summary>
	/// <param name="node"></param>
	/// <param name="ste"></param>
	/// <returns>接续执行标志</returns>
	virtual bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) = 0;
};

/// <summary>
/// 逻辑树节点输入输出类型
/// </summary>
enum class IO_TYPE {
	INPUT, OUTPUT
};
/// <summary>
/// 自定义行为树节点根节点实例
/// </summary>
class COMPONENTBASIC_EXPORT BehaviorMapNode
	: public MapKernal, public LogicalNode, public ComposeNode {
private:
	/// <summary>
	/// 地图变量表
	/// </summary>
	QHash<QString, std::pair<IO_TYPE, std::shared_ptr<TopicData>>> _variables;
	QString _map_name;
	LogicalResult _state_value;

public:
	BehaviorMapNode(std::shared_ptr<MessageLoader> core);


	/// <summary>
	/// 设置变量，如果类型错误会抛出UniException异常
	/// 节点初始化时会按照配置注册默认值变量
	/// </summary>
	virtual void setVariable(const QString& key, IO_TYPE t, std::shared_ptr<TopicData> ins);
	/// <summary>
	/// 获取指定名称的数据变量
	/// </summary>
	/// <param name="key"></param>
	/// <returns>如果不存在指定名称数据，返回nullptr，类型不确定</returns>
	virtual std::shared_ptr<TopicData> getVariable(const QString& key) const;


	/// <summary>
	/// 设置行为树节点名称
	/// </summary>
	/// <param name="val"></param>
	virtual void resetName(const QString& val);
	/// <summary>
	/// 重置执行状态
	/// </summary>
	void reset() override;
	/// <summary>
	/// 获取节点类型名称
	/// </summary>
	/// <returns></returns>
	QString typeName() const override;

	/// <summary>
	/// 提取前置节点
	/// </summary>
	/// <returns></returns>
	QList<std::shared_ptr<LogicalNode>> getForwards() const override;
	/// <summary>
	/// 填充状态
	/// </summary>
	/// <param name="node"></param>
	/// <param name="ste"></param>
	/// <returns></returns>
	bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) override;

	/// <summary>
	/// 执行状态
	/// </summary>
	/// <returns></returns>
	LogicalResult execute() override;

	/// <summary>
	/// 输入变量列表
	/// </summary>
	/// <returns></returns>
	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
	/// <summary>
	/// 输出变量列表
	/// </summary>
	/// <returns></returns>
	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;

	/// <summary>
	/// 创建新实例
	/// </summary>
	/// <param name="p"></param>
	/// <returns></returns>
	virtual std::shared_ptr<Serializable> newDefault() const override;
	void recoveryFrom(const QJsonObject& obj) override;
	void saveTo(QJsonObject& obj) const override;
};

// 行为树节点 ======================================================

/// <summary>
/// 顺序节点
/// </summary>
class COMPONENTBASIC_EXPORT SequenceNode
	: public ComposeNode, public LogicalNode {
private:
	QHash<int, LogicalResult> _state_map;

public:
	SequenceNode();

	QList<std::shared_ptr<LogicalNode>> getForwards() const override;
	QString typeName() const override;

	LogicalResult execute() override;
	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;

	void reset() override;
	bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) override;

	/// <summary>
	/// 新实例
	/// </summary>
	/// <param name="p"></param>
	/// <returns></returns>
	virtual std::shared_ptr<Serializable> newDefault() const override;

	void recoveryFrom(const QJsonObject& obj) override;
	void saveTo(QJsonObject& obj) const override;
};

/// <summary>
/// 选择节点
/// </summary>
class COMPONENTBASIC_EXPORT SelectorNode
	: public ComposeNode, public LogicalNode {
private:
	QHash<int, LogicalResult> _state_map;

public:
	SelectorNode();

	QList<std::shared_ptr<LogicalNode>> getForwards() const override;
	QString typeName() const override;

	LogicalResult execute() override;
	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;

	void reset() override;
	bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) override;

	/// <summary>
	/// 新实例
	/// </summary>
	/// <param name="p"></param>
	/// <returns></returns>
	virtual std::shared_ptr<Serializable> newDefault() const override;

	void recoveryFrom(const QJsonObject& obj) override;
	void saveTo(QJsonObject& obj) const override;
};

/// <summary>
/// 并行节点
/// </summary>
class COMPONENTBASIC_EXPORT ParallelNode
	: public ComposeNode, public LogicalNode {
private:
	QHash<int, LogicalResult> _state_map;

public:
	ParallelNode();

	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;

	QString typeName() const override;

	QList<std::shared_ptr<LogicalNode>> getForwards() const override;
	bool fallback(std::shared_ptr<LogicalNode> node, LogicalResult ste) override;

	LogicalResult execute() override;
	void reset() override;

	/// <summary>
	/// 新实例
	/// </summary>
	/// <param name="p"></param>
	/// <returns></returns>
	virtual std::shared_ptr<Serializable> newDefault() const override;

	void recoveryFrom(const QJsonObject& obj) override;
	void saveTo(QJsonObject& obj) const override;
};

/// <summary>
/// 比较节点
/// </summary>
class COMPONENTBASIC_EXPORT CompareNode : public LogicalNode {
private:
	std::shared_ptr<CompareKernel> _bind_delegate;
	QHash<QString, std::shared_ptr<TopicData>> _data_map;

public:
	CompareNode();

	/// <summary>
	/// 委托名称
	/// </summary>
	/// <returns></returns>
	QString delegateName() const;
	/// <summary>
	/// 绑定比较委托
	/// </summary>
	/// <param name="ins"></param>
	void bindDelegate(std::shared_ptr<CompareKernel> ins);

	QHash<QString, std::shared_ptr<TopicData>> inputList() const override;
	QHash<QString, std::shared_ptr<TopicData>> outputList() const override;

	QString typeName() const override;
	LogicalResult execute() override;

	void reset() override;

	/// <summary>
	/// 新实例
	/// </summary>
	/// <param name="p"></param>
	/// <returns></returns>
	virtual std::shared_ptr<Serializable> newDefault() const override;

	void recoveryFrom(const QJsonObject& obj) override;
	void saveTo(QJsonObject& obj) const override;
};

// 行为节点 ====================================================================

/// <summary>
/// 行为树组件
/// </summary>
class COMPONENTBASIC_EXPORT BehaviorPerformPlugin :
public RespondRoute<
	WsRespond<EntityInitialRequest, RespondDefault>,
	WsRespond<EntityPreparedRequest, RespondDefault>,
	WsRespond<SyncRequest, RespondDefault>,
	WsRespond<DeduceRequest, RespondDefault>>,
public RequestRoute<> 
{
private:
	std::weak_ptr<WsEntity> _bind_entity;

public:
	void mapReset(const QString &path);

	// 通过 ProcList 继承
	void execute(std::shared_ptr<const EntityInitialRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
	void execute(std::shared_ptr<const EntityPreparedRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
	void execute(std::shared_ptr<const SyncRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;
	void execute(std::shared_ptr<const DeduceRequest> in, QList<std::shared_ptr<RespondDefault>>& out) override;

	void recoveryFrom(const QJsonObject& obj) override;
	void saveTo(QJsonObject& obj) const override;

	std::shared_ptr<Serializable> newDefault() const override;
	void bindEntity(std::weak_ptr<WsEntity> host) override;
	QString name() const override;
};