#include "web_server.h"

#include <fstream>
#include <sstream>

#include "config/config_manager.h"
#include "nlohmann/json.hpp"
#include "spdlog/spdlog.h"

WebServer::WebServer(SystemMonitor::SystemMonitor& monitor, DeviceManager& deviceManager,
					 LiveDataCache& liveDataCache, AlarmService& alarm_service,
					 LightController& lightController,	
					 DoorController& doorController, 
					 uint16_t port)
	: crow::Crow<crow::CORSHandler>(),
	  m_monitor(monitor),
	  m_device_manager(deviceManager),
	  m_live_data_cache(liveDataCache),
	  m_alarm_service(alarm_service),
	  m_light_controller(lightController),	// <--- 初始化成员
	  m_door_controller(doorController),
	  m_port(port) {
	auto& cors = this->get_middleware<crow::CORSHandler>();
	cors.global()
		.origin("*")
		.headers("Content-Type", "Authorization")
		.methods("GET"_method, "POST"_method, "OPTIONS"_method);

	this->loglevel(crow::LogLevel::Warning);
	setup_routes();
}

WebServer::~WebServer() {
	stop();
}

void WebServer::start() {
	if (m_thread.joinable()) {
		spdlog::warn("Web server is already running.");
		return;
	}
	m_thread = std::thread([this]() {
		spdlog::info("Starting Web server on port {}", m_port);
		this->bindaddr("0.0.0.0").port(m_port).run();
		spdlog::info("Web server has stopped.");
	});
}

void WebServer::stop() {
	crow::Crow<crow::CORSHandler>::stop();
	if (m_thread.joinable()) {
		m_thread.join();
	}
}

void WebServer::set_shutdown_handler(std::function<void()> handler) {
	m_shutdown_handler = handler;
}

bool WebServer::validate_video_config(const std::string& json_string, std::string& error_message) {
	try {
		auto config = nlohmann::json::parse(json_string);

		if (!config.is_object()) {
			error_message = "Root is not an object.";
			return false;
		}

		// 1. 验证 'video_service'
		if (!config.contains("video_service") || !config["video_service"].is_object()) {
			error_message = "Missing 'video_service' object.";
			return false;
		}
		if (!config["video_service"].contains("enabled") ||
			!config["video_service"]["enabled"].is_boolean()) {
			error_message = "'video_service' must have 'enabled' (boolean).";
			return false;
		}

		// 2. 验证 'video_streams'
		if (!config.contains("video_streams") || !config["video_streams"].is_array()) {
			error_message = "Missing 'video_streams' array.";
			return false;
		}

		// 3. 验证 'video_streams' 中的每个元素
		for (const auto& stream : config["video_streams"]) {
			if (!stream.is_object()) {
				error_message = "Item in 'video_streams' is not an object.";
				return false;
			}
			// 检查必需的键
			for (const char* key : {"id", "input_url", "module_type"}) {
				if (!stream.contains(key) || !stream[key].is_string() ||
					stream[key].get<std::string>().empty()) {
					error_message = "Stream missing or invalid key: '" + std::string(key) + "'.";
					return false;
				}
			}
			if (!stream.contains("enabled") || !stream["enabled"].is_boolean()) {
				error_message = "Stream missing or invalid key: 'enabled' (boolean).";
				return false;
			}
			if (!stream.contains("module_config") || !stream["module_config"].is_object()) {
				error_message = "Stream missing 'module_config' (object).";
				return false;
			}

			// 4. 验证 'module_config' 的关键字段
			const auto& mod_cfg = stream["module_config"];
			for (const char* key : {"model_path", "label_path"}) {
				if (!mod_cfg.contains(key) || !mod_cfg[key].is_string() ||
					mod_cfg[key].get<std::string>().empty()) {
					error_message =
						"module_config missing or empty key: '" + std::string(key) + "'.";
					return false;
				}
			}
			if (!mod_cfg.contains("class_num") || !mod_cfg["class_num"].is_number_integer() ||
				mod_cfg["class_num"].get<int>() <= 0) {
				error_message =
					"module_config missing or invalid 'class_num' (must be "
					"integer > 0).";
				return false;
			}
			if (!mod_cfg.contains("rknn_thread_num") ||
				!mod_cfg["rknn_thread_num"].is_number_integer()) {
				error_message = "module_config missing 'rknn_thread_num' (integer).";
				return false;
			}
		}

		return true;  // 所有检查通过

	} catch (const nlohmann::json::parse_error& e) {
		error_message = "Invalid JSON: " + std::string(e.what());
		return false;
	} catch (const std::exception& e) {
		error_message = "Validation error: " + std::string(e.what());
		return false;
	}
}

bool WebServer::validate_main_config(const std::string& json_string, std::string& error_message) {
	try {
		auto config = nlohmann::json::parse(json_string);

		if (!config.is_object()) {
			error_message = "Root is not an object.";
			return false;
		}

		// 1. 必需的字符串类型
		for (const char* key :
			 {"device_id", "config_base_path", "mqtt_broker", "mqtt_client_id_prefix",
			  "data_storage_db_path", "data_cache_db_path", "log_level", "alarm_rules_path",
			  "piper_executable_path", "piper_model_path", "video_config_path"}) {
			if (!config.contains(key) || !config[key].is_string() ||
				config[key].get<std::string>().empty()) {
				error_message = "Missing or invalid/empty string key: '" + std::string(key) + "'.";
				return false;
			}
		}

		// 2. 必需的整数类型
		if (!config.contains("web_server_port") || !config["web_server_port"].is_number_integer()) {
			error_message = "Missing or invalid 'web_server_port' (must be integer).";
			return false;
		}

		// 3. 必需的数组类型
		if (!config.contains("tcp_server_ports") || !config["tcp_server_ports"].is_array()) {
			error_message = "Missing or invalid 'tcp_server_ports' (must be array).";
			return false;
		}
		for (const auto& port : config["tcp_server_ports"]) {
			if (!port.is_number_integer()) {
				error_message = "Item in 'tcp_server_ports' is not an integer.";
				return false;
			}
		}

		return true;  // 所有检查通过

	} catch (const nlohmann::json::parse_error& e) {
		error_message = "Invalid JSON: " + std::string(e.what());
		return false;
	} catch (const std::exception& e) {
		error_message = "Validation error: " + std::string(e.what());
		return false;
	}
}

void WebServer::setup_routes() {
	CROW_ROUTE((*this), "/api/system/id").methods("GET"_method)([this] {
		auto deviceID = ConfigManager::getInstance().getDeviceID();
		crow::json::wvalue response;
		response["deviceID"] = deviceID;
		return response;
	});

	CROW_ROUTE((*this), "/api/system/status").methods("GET"_method)([this] {
		auto cpu_util = m_monitor.getCpuUtilization();
		auto mem_info = m_monitor.getMemoryInfo();

		crow::json::wvalue response;
		response["cpu_usage_percentage"] = cpu_util.totalUsagePercentage;
		response["memory_total_kb"] = mem_info.total_kb;
		response["memory_free_kb"] = mem_info.available_kb;
		response["memory_usage_percentage"] =
			(mem_info.total_kb > 0)
				? (1.0 - static_cast<double>(mem_info.available_kb) / mem_info.total_kb) * 100.0
				: 0.0;

		return response;
	});

	CROW_ROUTE((*this), "/api/devices").methods("GET"_method)([this] {
		auto devices_info = m_device_manager.get_all_device_info();

		std::vector<crow::json::wvalue> devices_json;
		for (const auto& info : devices_info) {
			crow::json::wvalue device_obj;

			device_obj["id"] = info.id;
			device_obj["type"] = info.type;
			device_obj["is_running"] = info.is_running;

			crow::json::wvalue details_obj;
			for (const auto& pair : info.connection_details) {
				details_obj[pair.first] = pair.second;
			}
			device_obj["connection_details"] = std::move(details_obj);

			devices_json.push_back(std::move(device_obj));
		}
		auto res = crow::response(crow::json::wvalue(devices_json));
		res.set_header("Content-Type", "application/json");
		return res;
	});

	CROW_ROUTE((*this), "/api/data/latest").methods("GET"_method)([this] {
		auto latest_data_map = m_live_data_cache.get_all_data();

		crow::json::wvalue response;
		for (const auto& pair : latest_data_map) {
			response[pair.first] = crow::json::load(pair.second);
		}
		auto res = crow::response(response);
		res.set_header("Content-Type", "application/json");
		return res;
	});

	CROW_ROUTE((*this), "/api/alarms/active").methods("GET"_method)([this] {
		try {
			auto json_string = m_alarm_service.getActiveAlarmsJson().dump();

			auto res = crow::response(200, json_string);
			res.set_header("Content-Type", "application/json");
			return res;

		} catch (const std::exception& e) {
			spdlog::error("Error processing /api/alarms/active: {}", e.what());
			crow::json::wvalue error_resp;
			error_resp["error"] = "Failed to retrieve active alarms.";

			auto res = crow::response(500, error_resp.dump());
			res.set_header("Content-Type", "application/json");
			return res;
		}
	});

	CROW_ROUTE((*this), "/api/alarms/history")
		.methods("GET"_method)([this](const crow::request& req) {
			int limit = 100;
			if (req.url_params.get("limit")) {
				try {
					limit = std::stoi(req.url_params.get("limit"));
				} catch (const std::exception&) { /* ignore invalid */
				}
			}
			if (limit <= 0)
				limit = 100;

			try {
				auto json_string = m_alarm_service.getAlarmHistoryJson(limit).dump();

				auto res = crow::response(200, json_string);
				res.set_header("Content-Type", "application/json");
				return res;

			} catch (const std::exception& e) {
				spdlog::error("Error processing /api/alarms/history: {}", e.what());
				crow::json::wvalue error_resp;
				error_resp["error"] = "Failed to retrieve alarm history.";

				auto res = crow::response(500, error_resp.dump());
				res.set_header("Content-Type", "application/json");
				return res;
			}
		});

	CROW_ROUTE((*this), "/api/alarms/reload").methods("POST"_method)([this]() {
		spdlog::info("Web API: Received request to reload alarm rules...");

		bool success = m_alarm_service.reload_rules();

		if (success) {
			crow::json::wvalue response_json;
			response_json["status"] = "success";
			response_json["message"] = "Alarm rules reloaded successfully.";

			auto res = crow::response(200, response_json.dump());
			res.set_header("Content-Type", "application/json");
			return res;

		} else {
			crow::json::wvalue error_json;
			error_json["status"] = "error";
			error_json["message"] = "Failed to reload alarm rules. Check service logs for details.";
			auto res = crow::response(500, error_json.dump());
			res.set_header("Content-Type", "application/json");
			return res;
		}
	});

	CROW_ROUTE((*this), "/api/alarms/clear")
		.methods("POST"_method)([this](const crow::request& req) {
			crow::json::rvalue j_body;
			try {
				j_body = crow::json::load(req.body);
			} catch (const std::exception& e) {
				spdlog::warn("Failed to parse request body for /api/alarms/clear: {}", e.what());
				auto res = crow::response(400, "{\"error\":\"Invalid JSON body.\"}");
				res.set_header("Content-Type", "application/json");
				return res;
			}

			if (!j_body.has("rule_id") || !j_body.has("device_id")) {
				auto res = crow::response(400, "{\"error\":\"Missing 'rule_id' or 'device_id'.\"}");
				res.set_header("Content-Type", "application/json");
				return res;
			}

			std::string rule_id = j_body["rule_id"].s();
			std::string device_id = j_body["device_id"].s();

			bool success = m_alarm_service.manually_clear_alarm(rule_id, device_id);

			if (success) {
				auto res =
					crow::response(200, "{\"status\":\"success\", \"message\":\"Alarm cleared.\"}");
				res.set_header("Content-Type", "application/json");
				return res;
			} else {
				auto res = crow::response(404,
										  "{\"status\":\"error\", \"message\":\"Alarm not "
										  "found or not active.\"}");
				res.set_header("Content-Type", "application/json");
				return res;
			}
		});

	CROW_ROUTE((*this), "/api/alarms/config").methods("GET"_method)([this]() {
		std::string rules_json_string = m_alarm_service.get_rules_as_json_string();
		auto res = crow::response(200, rules_json_string);
		res.set_header("Content-Type", "application/json");
		return res;
	});

	CROW_ROUTE((*this), "/api/alarms/config")
		.methods("POST"_method)([this](const crow::request& req) {
			const std::string& new_rules_content = req.body;

			bool success = m_alarm_service.save_rules_from_json_string(new_rules_content);

			if (success) {
				crow::json::wvalue response_json;
				response_json["status"] = "success";
				response_json["message"] =
					"Rules saved successfully. A reload is required to apply.";

				auto res = crow::response(200, response_json.dump());
				res.set_header("Content-Type", "application/json");
				return res;

			} else {
				crow::json::wvalue error_json;
				error_json["status"] = "error";
				error_json["message"] =
					"Failed to save rules. Invalid JSON format or server error.";

				auto res = crow::response(400, error_json.dump());
				res.set_header("Content-Type", "application/json");
				return res;
			}
		});

	/**
	 * @brief GET /api/devices/config
	 * 获取设备配置 (devices.json) 的原始 JSON 字符串
	 */
	CROW_ROUTE((*this), "/api/devices/config").methods("GET"_method)([this]() {
		std::string rules_json_string = m_device_manager.get_config_as_json_string();
		auto res = crow::response(200, rules_json_string);
		res.set_header("Content-Type", "application/json");
		return res;
	});

	/**
	 * @brief POST /api/devices/config
	 * 保存设备配置 (devices.json) 的原始 JSON 字符串
	 */
	CROW_ROUTE((*this), "/api/devices/config")
		.methods("POST"_method)([this](const crow::request& req) {
			const std::string& new_rules_content = req.body;

			// save_config_from_json_string 内部包含 JSON 格式和 Schema 校验
			bool success = m_device_manager.save_config_from_json_string(new_rules_content);

			if (success) {
				crow::json::wvalue response_json;
				response_json["status"] = "success";
				response_json["message"] =
					"Device config saved successfully. A "
					"reload is required to apply.";

				auto res = crow::response(200, response_json.dump());
				res.set_header("Content-Type", "application/json");
				return res;

			} else {
				crow::json::wvalue error_json;
				error_json["status"] = "error";
				error_json["message"] =
					"Failed to save rules. Invalid JSON format "
					"or schema. Check service logs.";

				auto res = crow::response(400, error_json.dump());
				res.set_header("Content-Type", "application/json");
				return res;
			}
		});

	/**
	 * @brief POST /api/devices/reload
	 * 通知后端从磁盘重载 devices.json 并应用
	 */
	CROW_ROUTE((*this), "/api/devices/reload").methods("POST"_method)([this]() {
		spdlog::info("Web API: Received request to reload device rules...");

		bool success = m_device_manager.reload_config_from_file();

		if (success) {
			crow::json::wvalue response_json;
			response_json["status"] = "success";
			response_json["message"] = "Device rules reload posted successfully.";

			auto res = crow::response(200, response_json.dump());
			res.set_header("Content-Type", "application/json");
			return res;

		} else {
			crow::json::wvalue error_json;
			error_json["status"] = "error";
			error_json["message"] = "Failed to post device rules reload. Check service logs.";
			auto res = crow::response(500, error_json.dump());
			res.set_header("Content-Type", "application/json");
			return res;
		}
	});

	/**
	 * @brief GET /api/video_config
	 * 获取 video_config.json 的原始 JSON 字符串
	 */
	CROW_ROUTE((*this), "/api/video_config").methods("GET"_method)([this]() {
		std::string config_path;
		try {
			config_path = ConfigManager::getInstance().getVideoConfigPath();
		} catch (const std::exception& e) {
			spdlog::error("Failed to get video config path from ConfigManager: {}", e.what());
			auto res = crow::response(500,
									  "{\"error\":\"Server configuration error: "
									  "cannot determine config path.\"}");
			res.set_header("Content-Type", "application/json");
			return res;
		}

		std::ifstream ifs(config_path);
		if (!ifs.is_open()) {
			spdlog::error("Failed to open video config file for reading: {}", config_path);
			auto res = crow::response(404, "{\"error\":\"Video config file not found.\"}");
			res.set_header("Content-Type", "application/json");
			return res;
		}

		std::string content((std::istreambuf_iterator<char>(ifs)),
							(std::istreambuf_iterator<char>()));

		auto res = crow::response(200, content);
		res.set_header("Content-Type", "application/json");
		return res;
	});

	/**
	 * @brief POST /api/video_config
	 * 验证并保存 video_config.json
	 */
	CROW_ROUTE((*this), "/api/video_config")
		.methods("POST"_method)([this](const crow::request& req) {
			const std::string& new_config_content = req.body;
			std::string error_msg;

			if (!validate_video_config(new_config_content, error_msg)) {
				spdlog::warn("Web API: Failed to save video_config: {}", error_msg);
				crow::json::wvalue error_json;
				error_json["status"] = "error";
				error_json["message"] = "Invalid JSON format or schema: " + error_msg;
				auto res = crow::response(400, error_json.dump());
				res.set_header("Content-Type", "application/json");
				return res;
			}

			std::string config_path = ConfigManager::getInstance().getVideoConfigPath();

			std::ofstream ofs(config_path);
			if (!ofs.is_open()) {
				spdlog::error("Failed to open video config file for writing: {}", config_path);
				auto res =
					crow::response(500, "{\"error\":\"Failed to write config file on server.\"}");
				res.set_header("Content-Type", "application/json");
				return res;
			}

			auto json_data = nlohmann::json::parse(new_config_content);
			ofs << json_data.dump(4);  // 格式化写入
			ofs.close();

			// 4. 成功响应
			spdlog::info("Video config successfully updated via API at {}", config_path);
			crow::json::wvalue response_json;
			response_json["status"] = "success";
			response_json["message"] =
				"Video config saved. Send POST to /api/service/reload to apply.";
			auto res = crow::response(200, response_json.dump());
			res.set_header("Content-Type", "application/json");
			return res;
		});

	CROW_ROUTE((*this), "/api/service/reload").methods("POST"_method)([this]() {
		if (m_shutdown_handler) {
			spdlog::info("Web API: Received request to reload service...");
			m_shutdown_handler();

			auto res = crow::response(202,
									  "{\"status\":\"restarting\", "
									  "\"message\":\"Service is restarting...\"}");
			res.set_header("Content-Type", "application/json");
			return res;
		}

		spdlog::error(
			"Web API: /api/service/reload called, but shutdown handler "
			"is not set!");
		auto res =
			crow::response(500, "{\"error\":\"Shutdown handler not configured on server.\"}");
		res.set_header("Content-Type", "application/json");
		return res;
	});

	/**
	 * @brief GET /api/config
	 * 获取主 config.json 的原始 JSON 字符串
	 */
	CROW_ROUTE((*this), "/api/config").methods("GET"_method)([this]() {
		std::string config_path;
		try {
			// 1. 从 ConfigManager 获取路径
			config_path = ConfigManager::getInstance().getConfigFilePath();
			if (config_path.empty()) {
				throw std::runtime_error("ConfigManager returned an empty path.");
			}
		} catch (const std::exception& e) {
			spdlog::error("Failed to get main config path from ConfigManager: {}", e.what());
			auto res = crow::response(500,
									  "{\"error\":\"Server configuration error: "
									  "cannot determine config path.\"}");
			res.set_header("Content-Type", "application/json");
			return res;
		}

		// 2. 读取文件
		std::ifstream ifs(config_path);
		if (!ifs.is_open()) {
			spdlog::error("Failed to open main config file for reading: {}", config_path);
			auto res = crow::response(404, "{\"error\":\"Main config file not found.\"}");
			res.set_header("Content-Type", "application/json");
			return res;
		}

		// 3. 返回内容
		std::string content((std::istreambuf_iterator<char>(ifs)),
							(std::istreambuf_iterator<char>()));

		auto res = crow::response(200, content);
		res.set_header("Content-Type", "application/json");
		return res;
	});

	/**
	 * @brief POST /api/config
	 * 验证并保存主 config.json
	 */
	CROW_ROUTE((*this), "/api/config").methods("POST"_method)([this](const crow::request& req) {
		const std::string& new_config_content = req.body;
		std::string error_msg;

		if (!validate_main_config(new_config_content, error_msg)) {
			spdlog::warn("Web API: Failed to save main config: {}", error_msg);
			crow::json::wvalue error_json;
			error_json["status"] = "error";
			error_json["message"] = "Invalid JSON format or schema: " + error_msg;
			auto res = crow::response(400, error_json.dump());
			res.set_header("Content-Type", "application/json");
			return res;
		}

		std::string config_path = ConfigManager::getInstance().getConfigFilePath();
		if (config_path.empty()) {
			auto res =
				crow::response(500, "{\"error\":\"Failed to get config file path on server.\"}");
			res.set_header("Content-Type", "application/json");
			return res;
		}

		std::ofstream ofs(config_path);
		if (!ofs.is_open()) {
			spdlog::error("Failed to open main config file for writing: {}", config_path);
			auto res =
				crow::response(500, "{\"error\":\"Failed to write config file on server.\"}");
			res.set_header("Content-Type", "application/json");
			return res;
		}

		try {
			auto json_data = nlohmann::json::parse(new_config_content);
			ofs << json_data.dump(4);
			ofs.close();
		} catch (const std::exception& e) {
			spdlog::error("Failed to re-parse and dump main config: {}", e.what());
			auto res =
				crow::response(500, "{\"error\":\"Failed to serialize config for writing.\"}");
			res.set_header("Content-Type", "application/json");
			return res;
		}

		spdlog::info("Main config successfully updated via API at {}", config_path);
		crow::json::wvalue response_json;
		response_json["status"] = "success";
		response_json["message"] =
			"Main config saved. A full service restart (e.g., via "
			"/api/service/reload) is required to apply changes.";
		auto res = crow::response(200, response_json.dump());
		res.set_header("Content-Type", "application/json");
		return res;
	});
	/**
	 * @brief 灯光控制接口
	 * @method POST
	 * @url /api/light/control
	 * @body JSON { "device_id": "351", "action": "0" }
	 * - device_id: 灯控设备的ID
	 * - action: "0" (关) 或 "1" (开)
	 */
	CROW_ROUTE((*this), "/api/light/control")
		.methods("POST"_method)([this](const crow::request& req) {
			crow::json::rvalue j_body;
			try {
				j_body = crow::json::load(req.body);
			} catch (const std::exception& e) {
				spdlog::warn("Invalid JSON in light control request: {}", e.what());
				return crow::response(400, "{\"error\":\"Invalid JSON format.\"}");
			}

			// 参数校验
			if (!j_body.has("device_id") || !j_body.has("action")) {
				return crow::response(400, "{\"error\":\"Missing 'device_id' or 'action'.\"}");
			}

			std::string deviceId = j_body["device_id"].s();
			std::string action = j_body["action"].s();	// "0" or "1"

			spdlog::info("Web API: Requesting light control. Device: {}, Action: {}", deviceId,
						 action);

			// 调用控制器
			bool success = m_light_controller.ControlLight(deviceId, action);

			crow::json::wvalue response_json;
			if (success) {
				response_json["status"] = "success";
				response_json["message"] = "Light control command sent.";
				return crow::response(200, response_json);
			} else {
				response_json["status"] = "error";
				response_json["message"] = "Failed to send control command (upstream error).";
				return crow::response(502, response_json);
			}
		});
		/**
	 * @brief 门禁控制接口
	 * @method POST
	 * @url /api/door/control
	 * @body JSON { "action": "open" }
	 * - action: "open" (开门), "close" (关门), "alwaysOpen" (常开), "alwaysClose" (常闭)
	 */
	CROW_ROUTE((*this), "/api/door/control")
		.methods("POST"_method)([this](const crow::request& req) {
			crow::json::rvalue j_body;
			try {
				j_body = crow::json::load(req.body);
			} catch (const std::exception& e) {
				spdlog::warn("Invalid JSON in door control request: {}", e.what());
				return crow::response(400, "{\"error\":\"Invalid JSON format.\"}");
			}

			// 参数校验
			if (!j_body.has("action")) {
				return crow::response(400, "{\"error\":\"Missing 'action' field.\"}");
			}

			std::string action = j_body["action"].s();
            
            // 简单的安全检查，防止注入
            if (action != "open" && action != "close" && action != "alwaysOpen" && action != "alwaysClose") {
                return crow::response(400, "{\"error\":\"Invalid action. Use 'open', 'close', etc.\"}");
            }

			spdlog::info("Web API: Requesting door control. Action: {}", action);

			// 调用控制器
			bool success = m_door_controller.ControlDoor(action);

			crow::json::wvalue response_json;
			if (success) {
				response_json["status"] = "success";
				response_json["message"] = "Door control command sent.";
				return crow::response(200, response_json);
			} else {
				response_json["status"] = "error";
				response_json["message"] = "Failed to send control command to Hikvision device.";
				return crow::response(502, response_json);
			}
		});
}