#pragma once

#include <memory>
#include <vector>
#include <thread>
#include <string>

namespace Warfactory {
namespace Operation {

class AIGeneral;
class StrategicPlanner;
class DoctrineSystem;

/**
 * Autonomous Operation Engine
 * Handles military strategy and adaptive AI generals
 */
class OperationEngine {
public:
    OperationEngine();
    ~OperationEngine();

    bool initialize();
    void run();
    void shutdown();

    // Strategic planning and AI generals with ML
    void createOperation(const std::string& operationId, const std::string& type);
    void assignGeneral(const std::string& operationId, std::unique_ptr<AIGeneral> general);
    void adaptBehaviorFromResults(const std::string& generalId, bool success);

    // Doctrine evolution (learning from successes/failures)
    void updateDoctrine(const std::string& companyId, const std::string& lessons);
    void analyzeBattleReports(const std::vector<std::string>& reports);

private:
    void engineLoop();
    void processStrategicDecisions();
    void adaptAIBehavior(); // ML-based adaptation

    std::vector<std::unique_ptr<AIGeneral>> generals_;
    std::unique_ptr<StrategicPlanner> planner_;
    std::unique_ptr<DoctrineSystem> doctrines_;
    std::thread engineThread_;
    bool running_;

    void sendOrders();
    void receiveBattleReports();
};

} // namespace Operation
} // namespace Warfactory