#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,
					 VideoServiceManager& videoManager,	 // [修复 5.2] 对应头文件添加参数
					 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_video_manager(videoManager),
	  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) {
				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 req_deviceId = j_body["device_id"].s();
			std::string action = j_body["action"].s();

			spdlog::info("Web API: Light Control. Device: {}, Action: {}", req_deviceId, action);

			// 1. 定义要控制的设备列表 (将前端的联动逻辑移到这里)
			std::vector<std::string> target_devices;

			// 如果是总控开关 351，则添加所有相关设备
			if (req_deviceId == "351") {
				// 顺序很重要，建议把不太重要的放后面
				target_devices = {"353", "350", "351", "352", "354", "349"};
			} else {
				// 普通设备，只控制自己
				target_devices.push_back(req_deviceId);
			}

			// 2. [关键优化] 启动后台线程执行物理控制 (Fire-and-Forget)
			// 这样前端会立刻收到 200 OK，切换页面也不会断连
			// 复制必要的变量到 lambda
			LightController* ctrl = &m_light_controller;
			std::string act = action;
			std::vector<std::string> thread_targets = target_devices;  // 拷贝一份

			std::thread([ctrl, thread_targets, act]() {
				for (const auto& id : thread_targets) {
					// 依次控制，防止网关拥堵
					bool ok = ctrl->ControlLight(id, act);
					if (!ok) {
						// 失败稍微停顿一下
						std::this_thread::sleep_for(std::chrono::milliseconds(50));
					}
					// 成功也稍微停顿一下，让网关喘口气 (例如 20ms)
					std::this_thread::sleep_for(std::chrono::milliseconds(20));
				}
				spdlog::info("Async Light Control Finished for {} devices.", thread_targets.size());
			}).detach();  // 分离线程

			// 3. 处理"智能模式"冲突 (保持之前的逻辑，但要针对列表里的所有设备)
			// 也就是：如果我手动关了灯，那么关联这个灯的摄像头必须退出智能模式
			try {
				std::string config_path = ConfigManager::getInstance().getVideoConfigPath();
				std::ifstream ifs(config_path);
				if (ifs.is_open()) {
					nlohmann::json json_config;
					ifs >> json_config;
					ifs.close();

					bool config_changed = false;
					std::vector<std::string> affected_streams;

					if (json_config.contains("video_streams") &&
						json_config["video_streams"].is_array()) {
						for (auto& stream : json_config["video_streams"]) {
							if (!stream.contains("module_config"))
								continue;
							auto& mc = stream["module_config"];

							bool is_associated = false;

							// 检查该摄像头的 light_device_ids 是否包含我们这次操作的 *任何一个* 灯
							// 这样无论是单控还是群控，只要涉及到了，就关闭智能模式
							std::vector<std::string> cam_lights;
							if (mc.contains("light_device_ids") &&
								mc["light_device_ids"].is_array()) {
								cam_lights = mc["light_device_ids"].get<std::vector<std::string>>();
							} else if (mc.contains("light_device_id") &&
									   mc["light_device_id"].is_string()) {
								cam_lights.push_back(mc["light_device_id"].get<std::string>());
							}

							for (const auto& target_id : target_devices) {
								for (const auto& cam_light_id : cam_lights) {
									if (target_id == cam_light_id) {
										is_associated = true;
										break;
									}
								}
								if (is_associated)
									break;
							}

							// 如果关联且处于智能模式，强制关闭
							if (is_associated) {
								int current_mode = mc.value("mode", 1);
								if (current_mode == 2) {
									mc["mode"] = 1;
									config_changed = true;

									std::string stream_id = stream.value("id", "");
									if (!stream_id.empty()) {
										auto service = m_video_manager.getService(stream_id);
										if (service) {
											service->set_analysis_mode(1);
											affected_streams.push_back(stream_id);
										}
									}
								}
							}
						}
					}

					if (config_changed) {
						std::ofstream ofs(config_path);
						if (ofs.is_open()) {
							ofs << json_config.dump(4);
							ofs.close();
							spdlog::info("Manual Override: Disabled Smart Mode for: {}",
										 fmt::join(affected_streams, ", "));
						}
					}
				}
			} catch (...) {
				// 忽略非关键错误
			}

			crow::json::wvalue response_json;
			response_json["status"] = "success";
			response_json["message"] = "Command received. Executing in background.";
			return crow::response(200, 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);
			}
		});

	/**
	 * @brief POST /api/video/zone
	 * 单独修改指定视频流的 intrusion_zone (多边形区域)
	 * @body JSON:
	 * {
	 * "stream_id": "cam_01_intrusion",
	 * "intrusion_zone": [[100, 100], [500, 100], [500, 500], [100, 500]]
	 * }
	 */
	CROW_ROUTE((*this), "/api/video/zone").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 update zone request: {}", e.what());
			return crow::response(400, "{\"error\":\"Invalid JSON format.\"}");
		}

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

		std::string target_stream_id = j_body["stream_id"].s();
		const auto& new_zone = j_body["intrusion_zone"];

		// 验证 intrusion_zone 是否为数组，且至少有3个点（构成多边形）
		if (new_zone.t() != crow::json::type::List || new_zone.size() < 3) {
			return crow::response(
				400, "{\"error\":\"'intrusion_zone' must be an array with at least 3 points.\"}");
		}

		// 2. 读取当前配置文件
		std::string config_path = ConfigManager::getInstance().getVideoConfigPath();
		std::ifstream ifs(config_path);
		if (!ifs.is_open()) {
			spdlog::error("Failed to open video config file: {}", config_path);
			return crow::response(500, "{\"error\":\"Config file not found.\"}");
		}

		nlohmann::json json_config;
		try {
			ifs >> json_config;
		} catch (const std::exception& e) {
			ifs.close();
			spdlog::error("Failed to parse video config file: {}", e.what());
			return crow::response(500, "{\"error\":\"Existing config file is corrupt.\"}");
		}
		ifs.close();

		// 3. 查找并更新目标流
		bool found = false;
		if (json_config.contains("video_streams") && json_config["video_streams"].is_array()) {
			for (auto& stream : json_config["video_streams"]) {
				if (stream.contains("id") && stream["id"] == target_stream_id) {
					// 确保 module_config 存在
					if (!stream.contains("module_config")) {
						stream["module_config"] = nlohmann::json::object();
					}

					// 转换 crow::json 到 nlohmann::json
					// 注意：这里需要手动转换一下格式，或者直接解析 req.body 为 nlohmann::json
					try {
						auto body_nlohmann = nlohmann::json::parse(req.body);
						stream["module_config"]["intrusion_zone"] = body_nlohmann["intrusion_zone"];
						found = true;
					} catch (const std::exception& e) {
						return crow::response(
							400, "{\"error\":\"Failed to parse intrusion_zone data.\"}");
					}
					break;
				}
			}
		}

		if (!found) {
			return crow::response(404, "{\"error\":\"Stream ID not found.\"}");
		}

		// 4. 写回文件
		std::ofstream ofs(config_path);
		if (!ofs.is_open()) {
			spdlog::error("Failed to open video config file for writing: {}", config_path);
			return crow::response(500, "{\"error\":\"Failed to save config file.\"}");
		}

		ofs << json_config.dump(4);	 // 4空格缩进
		ofs.close();

		spdlog::info("Updated intrusion_zone for stream: {}", target_stream_id);

		crow::json::wvalue response_json;
		response_json["status"] = "success";
		response_json["message"] = "Zone updated. Call /api/service/reload to apply changes.";

		return crow::response(200, response_json);
	});
	/**
	 * @brief 切换检测模式接口
	 * @method POST
	 * @url /api/video/mode
	 * @body JSON { "stream_id": "cam_01", "mode": 1 }
	 * - mode: 1 (普通报警), 2 (快速响应)
	 */
	CROW_ROUTE((*this), "/api/video/mode").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) {
			return crow::response(400, "{\"error\":\"Invalid JSON.\"}");
		}

		if (!j_body.has("stream_id") || !j_body.has("mode")) {
			return crow::response(400, "{\"error\":\"Missing 'stream_id' or 'mode'.\"}");
		}

		std::string stream_id = j_body["stream_id"].s();
		int mode = j_body["mode"].i();

		// 1. 【运行时更新】 立即生效
		auto service = m_video_manager.getService(stream_id);
		if (service) {
			// 调用内存中的对象修改状态
			bool result = service->set_analysis_mode(mode);
			if (!result) {
				spdlog::warn("Failed to set runtime mode for stream {}", stream_id);
				// 注意：这里即使运行时失败，只要配置能保存，也可以继续往下走，或者直接返回错误
				// return crow::response(400, "{\"status\":\"error\", \"message\":\"Failed to switch
				// runtime mode.\"}");
			}
		} else {
			// 如果服务没运行（比如禁用了），我们依然允许修改配置文件，这样下次启动就生效了
			spdlog::warn("Stream {} not running, but config will be updated.", stream_id);
		}

		// 2. 【持久化更新】 保存到 JSON 文件
		std::string config_path = ConfigManager::getInstance().getVideoConfigPath();
		std::ifstream ifs(config_path);
		if (!ifs.is_open()) {
			return crow::response(500, "{\"error\":\"Config file not found.\"}");
		}

		nlohmann::json json_config;
		try {
			ifs >> json_config;
		} catch (...) {
			return crow::response(500, "{\"error\":\"Config file corrupt.\"}");
		}
		ifs.close();

		bool found_config = false;
		if (json_config.contains("video_streams") && json_config["video_streams"].is_array()) {
			for (auto& stream : json_config["video_streams"]) {
				if (stream.contains("id") && stream["id"] == stream_id) {
					// 找到对应流，修改 module_config 中的 mode
					if (!stream.contains("module_config")) {
						stream["module_config"] = nlohmann::json::object();
					}
					stream["module_config"]["mode"] = mode;	 // [关键] 写入 mode
					found_config = true;
					break;
				}
			}
		}

		if (!found_config) {
			return crow::response(404, "{\"error\":\"Stream ID not found in config.\"}");
		}

		// 写回文件
		std::ofstream ofs(config_path);
		if (!ofs.is_open()) {
			return crow::response(500, "{\"error\":\"Failed to save config.\"}");
		}
		ofs << json_config.dump(4);
		ofs.close();

		spdlog::info("Updated mode to {} for stream {} (Saved to file)", mode, stream_id);

		return crow::response(200,
							  "{\"status\":\"success\", \"message\":\"Mode switched and saved.\"}");
	});
}