#pragma once
//robotics
#include <robotics/message_bus.hpp>
#include <robotics/thread_pool.hpp>
#include <robotics/utils.hpp>
//local
#include "../xml/xml_context.hpp"
#include "nexus_net_network_v1.hpp"
#include "nexus_net_network_v2.hpp"
#include "rpc_network.hpp"
#include "http_network.hpp"
#include "../models/web_cloud_after_info.h"
#include "../models/web_after_v1_info.h"

extern v3::message_bus g_message_bus;
/**
 * @brief network 类用于管理和协调多种网络组件，支持网络服务的启动、停止、云端同步、授权处理及事件分发等功能。该类实现了单例模式，确保全局仅有一个 network 实例。
 */
class network : public v3::thread_pool<network>{
public:
	/**
	 * @brief 返回 network 类的单例实例指针。
	 * @return 指向唯一 network 实例的指针。
	 */
	static network* instance() {
		static network g_network;
		return &g_network;
	}
	/**
	 * @brief 析构函数，用于销毁 network 对象并在销毁前调用 stop() 方法。
	 */
	~network() {
		stop();
	}
	/**
	 * @brief 启动所有网络组件。
	 */
	void start() {
		nexus_net_v1_->start();
		nexus_net_v2_->start();
		rpc_network_->start();
	}
	/**
	 * @brief 停止所有网络服务。
	 */
	void stop() {
		nexus_net_v1_->stop();
		nexus_net_v2_->stop();
		rpc_network_->stop();
	}
	/**
	 * @brief 根据配置同步处理云端后的信息，并调用相应的网络接口。
	 * @param value 包含云端后处理信息的 web_cloud_after_info 常量引用。
	 */
	void sync_after(web_cloud_after_info const& value) {
		std::shared_ptr<web_general_config_info> config = xml_context::from<web_general_config_info>().where([](auto it) { return it->enable && it->key == 1; }).first();
		if (!config) {
			config.reset(new web_general_config_info());
			config->value = "3";
		}
		try {
			if (config->value == "1") {
				rpc_network_->invoke(value.status, value.is_show_msg, value.msg);
			}
			else if (config->value == "2") {
				web_after_v1_info info;
				info.msg = value.msg;
				if (value.status) {
					if (value.is_show_msg) {
						info.status = 2;
					}
					else {
						info.status = 1;
					}
				}
				else {
					info.status = 0;
				}
				nexus_net_v1_->invoke<void>("local_after_request", info);
			}
			else if (config->value == "3") {
				nexus_net_v2_->invoke<void>("local_after_request", value.status, value.is_show_msg, value.msg);
			}
		}
		catch (std::exception const& ec) {
			LOG_ERROR << ec;
		}
	}
	/**
	 * @brief 执行同步授权操作的回调函数。
	 */
	web_after_config_info sync_after_request() {
		web_after_config_info result;
		auto response = http_network_->request_after();
		LOG_INFO << "msg:" << response.msg << " code:" << response.code << " count:" << response.count;
		if (response.data.empty()) {
			throw std::runtime_error("没有返回数据.");
		}
		result.id = 1;
		result.modify_time = v3::datetime::current_time_stamp();
		result.value = response.data[0].value;
		result.enable = true;
		result.remarks = "售后配置信息";
		return result;
	}
	/**
	 * @brief 根据指定的键发起通用请求，并返回结果数据列表。
	 * @param key 用于请求的键值。
	 * @return 包含请求结果的 web_general_config_info 对象的 std::vector。如果没有返回数据，则抛出 std::runtime_error 异常。
	 */
	std::vector<web_general_config_info> sync_general_request(int key) {
		auto response = http_network_->request_general(key);
		LOG_INFO << "msg:" << response.msg << " code:" << response.code << " count:" << response.count;
		if (response.data.empty()) {
			throw std::runtime_error("没有返回数据.");
		}
		return response.data;
	}
	/**
	 * @brief 用于处理 cloud_after_event 事件的委托对象，传递常量引用的 web_after_config_info 向量。
	 */
	v3::delegates<web_after_config_info const&>					cloud_after_event;
	/**
	 * @brief 用于处理 cloud_general_event 事件的委托对象，传递常量引用的 web_general_config_info 向量。
	 */
	v3::delegates<std::vector<web_general_config_info> const&>	cloud_general_event;
private:
	/**
	 * @brief network 构造函数，初始化网络相关组件并绑定事件处理函数。
	 */
	network():
		v3::thread_pool<network>(){
		http_network_ = http_network::instance();
		nexus_net_v1_ = nexus_net_network_v1::instance();
		nexus_net_v2_ = nexus_net_network_v2::instance();
		rpc_network_ = rpc_network::instance();

		nexus_net_v1_->authorized_event.bind(&network::on_authorized_v1, this);
		nexus_net_v2_->authorized_event.bind(&network::on_authorized_v2, this);

		nexus_net_v2_->bind("cloud_after_response", &network::on_cloud_after_response, this);
	}
private:
	/**
	 * @brief 处理云端响应后的回调函数。
	 * @param data 包含云端响应内容的字符串。
	 */
	void on_cloud_after_response(std::string const&data) {
		REGISTER_ASYNC_FUNC(on_cloud_after_response, data);
		web_after_config_info value;
		value.id = 1;
		value.modify_time = v3::datetime::current_time_stamp();
		value.value = data;
		value.enable = true;
		value.remarks = "售后配置信息";
		cloud_after_event(value);
	}
	/**
	 * @brief 处理云端通用响应数据，并触发后续事件。
	 * @param data 从云端收到的响应数据。
	 */
	void on_cloud_general_response(std::string const& data) {
		REGISTER_ASYNC_FUNC(on_cloud_after_response, data);
		try {
			web_response_info<web_general_config_info> value;
			v3::json_convert::deserialize(data, value);
			cloud_general_event(value.data);
		}
		catch (std::exception const& ec) {
			LOG_ERROR << ec;
		}
	}
private:
	/**
	 * @brief 根据授权状态处理设备ID的设置。
	 * @param status 表示是否已授权的布尔值。
	 * @param parent_code 父设备的代码，用于设置设备ID。
	 * @param parent_name 父设备的名称。
	 */
	void on_authorized_v2(bool status, std::string const& parent_code, std::string const& parent_name) {
		if (status) {
			http_network_->set_device_id(parent_code);
			LOG_INFO << "售后服务分布式授权成功v2.";
		}
		else {
			LOG_ERROR << "售后服务分布式授权失败v2.";
		}
	}
	/**
	 * @brief 根据授权状态记录售后服务分布式授权v1的日志信息。
	 * @param status 授权状态。如果为 true，表示授权成功；如果为 false，表示授权失败。
	 */
	void on_authorized_v1(bool status) {
		if (status) {
			LOG_INFO << "售后服务分布式授权成功v1.";
		}
		else {
			LOG_ERROR << "售后服务分布式授权失败v1.";
		}
	}
private:
	http_network*		  http_network_ = nullptr;
	nexus_net_network_v1* nexus_net_v1_ = nullptr;
	nexus_net_network_v2* nexus_net_v2_ = nullptr;
	rpc_network*		  rpc_network_  = nullptr;
};