#include "BattlefieldAISystem.h"
#include <iostream>
#include <fstream>
#include <json/json.h>  // 需要jsoncpp库

namespace Battlefield {

BattlefieldAISystem::BattlefieldAISystem() 
    : dataFusionEngine_(std::make_unique<DataFusionEngine>())
    , decisionSystem_(std::make_unique<TacticalDecisionSystem>())
    , visualization_(std::make_unique<Qt3DVisualization>()) {
    
    // 加载古代防御工事数据
    loadAncientFortificationData();
}

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

bool BattlefieldAISystem::initialize(const std::string& configFile) {
    // 读取配置文件
    std::ifstream configStream(configFile);
    if (!configStream.is_open()) {
        std::cerr << "无法打开配置文件: " << configFile << std::endl;
        return false;
    }
    
    Json::Value config;
    configStream >> config;
    
    // 解析配置
    if (config.isMember("data_fusion")) {
        auto fusionConfig = config["data_fusion"];
        std::map<std::string, std::string> fusionParams;
        for (auto& key : fusionConfig.getMemberNames()) {
            fusionParams[key] = fusionConfig[key].asString();
        }
        if (!dataFusionEngine_->initialize(fusionParams)) {
            return false;
        }
    }
    
    if (config.isMember("decision_system")) {
        auto decisionConfig = config["decision_system"];
        std::map<std::string, std::string> decisionRules;
        for (auto& key : decisionConfig["rules"].getMemberNames()) {
            decisionRules[key] = decisionConfig["rules"][key].asString();
        }
        decisionSystem_->setRules(decisionRules);
    }
    
    if (config.isMember("visualization")) {
        auto visConfig = config["visualization"];
        int width = visConfig.get("width", 1280).asInt();
        int height = visConfig.get("height", 720).asInt();
        std::string title = visConfig.get("title", "智能战场态势感知系统").asString();
        
        if (!visualization_->initialize(width, height, title)) {
            std::cerr << "可视化系统初始化失败" << std::endl;
            return false;
        }
    }
    
    // 设置回调
    dataFusionEngine_->setDataCallback(
        [this](const DataPacket& packet) { onDataReceived(packet); });
    dataFusionEngine_->setSituationCallback(
        [this](const BattlefieldSituation& situation) { onSituationUpdated(situation); });
    
    logSystemEvent("SystemInitialized", "Battlefield AI System initialized successfully");
    return true;
}

void BattlefieldAISystem::start() {
    if (!isRunning_) {
        isRunning_ = true;
        startTime_ = std::chrono::system_clock::now();
        
        // 启动数据融合引擎
        dataFusionEngine_->start();
        
        // 启动系统处理线程
        systemThread_ = std::thread([this]() {
            while (isRunning_) {
                // 主系统循环
                auto currentSituation = dataFusionEngine_->getCurrentSituation();
                
                // 生成决策建议
                std::map<std::string, double> constraints = {
                    {"time_limit", 300.0},
                    {"resource_limit", 0.8}
                };
                
                auto suggestions = decisionSystem_->generateSuggestions(currentSituation, constraints);
                
                // 更新可视化
                if (visualization_) {
                    visualization_->renderSituation(currentSituation);
                    visualization_->renderDecisions(suggestions);
                }
                
                // 保存历史
                situationHistory_.push_back(currentSituation);
                if (situationHistory_.size() > 1000) {  // 限制历史记录数量
                    situationHistory_.erase(situationHistory_.begin());
                }
                
                std::this_thread::sleep_for(std::chrono::milliseconds(100));  // 10Hz更新
            }
        });
        
        logSystemEvent("SystemStarted", "Battlefield AI System started");
    }
}

void BattlefieldAISystem::stop() {
    isRunning_ = false;
    
    if (systemThread_.joinable()) {
        systemThread_.join();
    }
    
    if (dataFusionEngine_) {
        dataFusionEngine_->stop();
    }
    
    logSystemEvent("SystemStopped", "Battlefield AI System stopped");
}

void BattlefieldAISystem::simulateDataInput() {
    // 模拟数据输入线程
    std::thread simulationThread([this]() {
        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_real_distribution<> lonDist(116.0, 118.0);
        std::uniform_real_distribution<> latDist(39.0, 41.0);
        
        int packetCount = 0;
        while (isRunning_ && packetCount < 100) {  // 模拟100个数据包
            DataPacket packet;
            
            // 交替使用不同数据源
            if (packetCount % 4 == 0) {
                packet.source = DataSourceType::UAV_SURVEILLANCE;
            } else if (packetCount % 4 == 1) {
                packet.source = DataSourceType::SATELLITE_IMAGERY;
            } else if (packetCount % 4 == 2) {
                packet.source = DataSourceType::EM_SIGNAL;
            } else {
                packet.source = DataSourceType::FRIENDLY_REPORT;
            }
            
            packet.timestamp = std::chrono::system_clock::now();
            packet.origin = GeoCoordinate(lonDist(gen), latDist(gen));
            
            // 添加模拟数据
            std::string mockData = "模拟战场数据包#" + std::to_string(packetCount);
            packet.payload.assign(mockData.begin(), mockData.end());
            
            packet.metadata["simulation"] = "true";
            packet.metadata["packet_id"] = std::to_string(packetCount);
            
            // 接收数据
            dataFusionEngine_->receiveData(packet);
            
            packetCount++;
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
        }
    });
    
    simulationThread.detach();
}

void BattlefieldAISystem::onDataReceived(const DataPacket& packet) {
    // 数据接收处理
    std::stringstream ss;
    ss << "收到数据包，来源: " << static_cast<int>(packet.source)
       << ", 位置: [" << packet.origin.longitude << ", " << packet.origin.latitude << "]";
    logSystemEvent("DataReceived", ss.str());
}

void BattlefieldAISystem::onSituationUpdated(const BattlefieldSituation& situation) {
    // 态势更新处理
    std::stringstream ss;
    ss << "态势更新，目标数: " << situation.enemyTargets.size()
       << ", 威胁等级: " << situation.overallThreatLevel;
    logSystemEvent("SituationUpdated", ss.str());
}

void BattlefieldAISystem::loadAncientFortificationData() {
    // 模拟加载古代防御工事数据（长城重要关隘位置）
    ancientFortifications_ = {
        GeoCoordinate(116.568, 40.431),  // 居庸关
        GeoCoordinate(115.967, 40.367),  // 八达岭
        GeoCoordinate(114.150, 40.383),  // 张家口
        GeoCoordinate(113.283, 40.083),  // 大同
        GeoCoordinate(111.800, 40.667)   // 呼和浩特附近
    };
}

} // namespace Battlefield