#include <gtest/gtest.h>
#include <string>
#include <vector>
#include <chrono>
#include "app.hpp"

// ============================================================================
// Test Fixture for CmsEngine
// ============================================================================
class CmsEngineTest : public ::testing::Test {
protected:
    void SetUp() override {
        engine = new CmsEngine();
    }

    void TearDown() override {
        delete engine;
    }

    CmsEngine* engine;
};

// ============================================================================
// Tests for CmsEngine constructor
// ============================================================================

/**
 * @brief Test constructor initializes system context correctly
 */
TEST_F(CmsEngineTest, testConstructorNormalInitialization) {
    const SystemStateContext& ctx = engine->getSystemContext();
    EXPECT_EQ(ctx.currentMode, RunMode::Idle);
    EXPECT_EQ(ctx.consistencyMark, 0);
    EXPECT_EQ(ctx.contextSnapshot, R"({"mode":"Idle","version":"1.0.0"})");
}

/**
 * @brief Test constructor initializes empty containers
 */
TEST_F(CmsEngineTest, testConstructorEmptyContainers) {
    EXPECT_TRUE(engine->getAllPlans().empty());
    std::string summary = engine->getSummary();
    EXPECT_NE(summary.find("Events          : 0"), std::string::npos);
}

// ============================================================================
// Tests for ingestEvent
// ============================================================================

/**
 * @brief Test ingestEvent with valid event
 */
TEST_F(CmsEngineTest, testIngestEventValidEvent) {
    EventRecord event;
    event.id = "EVT-001";
    event.priority = 100;
    event.status = EventStatus::Pending;

    bool result = engine->ingestEvent(event);
    EXPECT_TRUE(result);

    const EventRecord* found = engine->findEventById("EVT-001");
    ASSERT_NE(found, nullptr);
    EXPECT_EQ(found->priority, 100);
    EXPECT_EQ(found->status, EventStatus::Pending);
}

/**
 * @brief Test ingestEvent with empty event ID
 */
TEST_F(CmsEngineTest, testIngestEventEmptyId) {
    EventRecord event;
    event.id = "";
    event.priority = 100;

    bool result = engine->ingestEvent(event);
    EXPECT_FALSE(result);

    const EventRecord* found = engine->findEventById("");
    EXPECT_EQ(found, nullptr);
}

/**
 * @brief Test ingestEvent with priority exceeding maximum
 */
TEST_F(CmsEngineTest, testIngestEventPriorityExceedsMax) {
    EventRecord event;
    event.id = "EVT-002";
    event.priority = 256;

    bool result = engine->ingestEvent(event);
    EXPECT_FALSE(result);

    const EventRecord* found = engine->findEventById("EVT-002");
    EXPECT_EQ(found, nullptr);
}

/**
 * @brief Test ingestEvent with priority at boundary (255)
 */
TEST_F(CmsEngineTest, testIngestEventPriorityAtBoundary) {
    EventRecord event;
    event.id = "EVT-003";
    event.priority = 255;

    bool result = engine->ingestEvent(event);
    EXPECT_TRUE(result);

    const EventRecord* found = engine->findEventById("EVT-003");
    ASSERT_NE(found, nullptr);
    EXPECT_EQ(found->priority, 255);
}

/**
 * @brief Test ingestEvent with priority at zero
 */
TEST_F(CmsEngineTest, testIngestEventPriorityZero) {
    EventRecord event;
    event.id = "EVT-004";
    event.priority = 0;

    bool result = engine->ingestEvent(event);
    EXPECT_TRUE(result);

    const EventRecord* found = engine->findEventById("EVT-004");
    ASSERT_NE(found, nullptr);
    EXPECT_EQ(found->priority, 0);
}

/**
 * @brief Test ingestEvent with multiple events
 */
TEST_F(CmsEngineTest, testIngestEventMultipleEvents) {
    EventRecord event1;
    event1.id = "EVT-001";
    event1.priority = 50;

    EventRecord event2;
    event2.id = "EVT-002";
    event2.priority = 150;

    EXPECT_TRUE(engine->ingestEvent(event1));
    EXPECT_TRUE(engine->ingestEvent(event2));

    const EventRecord* found1 = engine->findEventById("EVT-001");
    const EventRecord* found2 = engine->findEventById("EVT-002");
    ASSERT_NE(found1, nullptr);
    ASSERT_NE(found2, nullptr);
    EXPECT_EQ(found1->priority, 50);
    EXPECT_EQ(found2->priority, 150);
}

// ============================================================================
// Tests for findPlanById
// ============================================================================

/**
 * @brief Test findPlanById with existing plan
 */
TEST_F(CmsEngineTest, testFindPlanByIdExistingPlan) {
    TaskPlan plan;
    plan.name = "Test Plan";
    plan.type = PlanType::Centralized;
    plan.status = PlanStatus::Drafting;
    plan.resourceQuota = 0.8;
    plan.constraints = "Test constraints";

    EXPECT_TRUE(engine->createTaskPlan(plan));
    ASSERT_FALSE(plan.id.empty());

    const TaskPlan* found = engine->findPlanById(plan.id);
    ASSERT_NE(found, nullptr);
    EXPECT_EQ(found->name, "Test Plan");
    EXPECT_EQ(found->type, PlanType::Centralized);
    EXPECT_EQ(found->status, PlanStatus::Drafting);
    EXPECT_DOUBLE_EQ(found->resourceQuota, 0.8);
    EXPECT_EQ(found->constraints, "Test constraints");
}

/**
 * @brief Test findPlanById with non-existent plan
 */
TEST_F(CmsEngineTest, testFindPlanByIdNonExistent) {
    const TaskPlan* found = engine->findPlanById("NONEXISTENT");
    EXPECT_EQ(found, nullptr);
}

/**
 * @brief Test findPlanById with empty string
 */
TEST_F(CmsEngineTest, testFindPlanByIdEmptyString) {
    const TaskPlan* found = engine->findPlanById("");
    EXPECT_EQ(found, nullptr);
}

/**
 * @brief Test findPlanById after multiple plans created
 */
TEST_F(CmsEngineTest, testFindPlanByIdMultiplePlans) {
    TaskPlan plan1;
    plan1.name = "Plan Alpha";
    engine->createTaskPlan(plan1);

    TaskPlan plan2;
    plan2.name = "Plan Beta";
    engine->createTaskPlan(plan2);

    const TaskPlan* found1 = engine->findPlanById(plan1.id);
    const TaskPlan* found2 = engine->findPlanById(plan2.id);
    ASSERT_NE(found1, nullptr);
    ASSERT_NE(found2, nullptr);
    EXPECT_EQ(found1->name, "Plan Alpha");
    EXPECT_EQ(found2->name, "Plan Beta");
}

// ============================================================================
// Tests for updatePlanStatus
// ============================================================================

/**
 * @brief Test updatePlanStatus with valid plan
 */
TEST_F(CmsEngineTest, testUpdatePlanStatusValidPlan) {
    TaskPlan plan;
    plan.name = "Status Test";
    plan.status = PlanStatus::Drafting;
    engine->createTaskPlan(plan);

    bool result = engine->updatePlanStatus(plan.id, PlanStatus::Approved);
    EXPECT_TRUE(result);

    const TaskPlan* updated = engine->findPlanById(plan.id);
    ASSERT_NE(updated, nullptr);
    EXPECT_EQ(updated->status, PlanStatus::Approved);
}

/**
 * @brief Test updatePlanStatus with non-existent plan
 */
TEST_F(CmsEngineTest, testUpdatePlanStatusNonExistent) {
    bool result = engine->updatePlanStatus("NONEXISTENT", PlanStatus::Approved);
    EXPECT_FALSE(result);
}

/**
 * @brief Test updatePlanStatus with empty plan ID
 */
TEST_F(CmsEngineTest, testUpdatePlanStatusEmptyId) {
    bool result = engine->updatePlanStatus("", PlanStatus::Approved);
    EXPECT_FALSE(result);
}

/**
 * @brief Test updatePlanStatus multiple times on same plan
 */
TEST_F(CmsEngineTest, testUpdatePlanStatusMultipleUpdates) {
    TaskPlan plan;
    plan.name = "Multi Update";
    plan.status = PlanStatus::Drafting;
    engine->createTaskPlan(plan);

    EXPECT_TRUE(engine->updatePlanStatus(plan.id, PlanStatus::Approved));
    EXPECT_TRUE(engine->updatePlanStatus(plan.id, PlanStatus::Active));
    EXPECT_TRUE(engine->updatePlanStatus(plan.id, PlanStatus::Completed));

    const TaskPlan* updated = engine->findPlanById(plan.id);
    ASSERT_NE(updated, nullptr);
    EXPECT_EQ(updated->status, PlanStatus::Completed);
}

/**
 * @brief Test updatePlanStatus does not affect other plans
 */
TEST_F(CmsEngineTest, testUpdatePlanStatusIsolation) {
    TaskPlan plan1;
    plan1.name = "Plan One";
    plan1.status = PlanStatus::Drafting;
    engine->createTaskPlan(plan1);

    TaskPlan plan2;
    plan2.name = "Plan Two";
    plan2.status = PlanStatus::Drafting;
    engine->createTaskPlan(plan2);

    engine->updatePlanStatus(plan1.id, PlanStatus::Approved);

    const TaskPlan* updated1 = engine->findPlanById(plan1.id);
    const TaskPlan* updated2 = engine->findPlanById(plan2.id);
    ASSERT_NE(updated1, nullptr);
    ASSERT_NE(updated2, nullptr);
    EXPECT_EQ(updated1->status, PlanStatus::Approved);
    EXPECT_EQ(updated2->status, PlanStatus::Drafting);
}

// ============================================================================
// Tests for registerTemplate
// ============================================================================

/**
 * @brief Test registerTemplate with valid template
 */
TEST_F(CmsEngineTest, testRegisterTemplateValid) {
    TemplateInstance tmpl;
    tmpl.templateId = "TMPL-001";
    tmpl.confidence = 0.85;
    tmpl.scenario = "combat";

    engine->registerTemplate(tmpl);

    const TemplateInstance* matched = engine->matchTemplate("combat");
    ASSERT_NE(matched, nullptr);
    EXPECT_EQ(matched->templateId, "TMPL-001");
    EXPECT_DOUBLE_EQ(matched->confidence, 0.85);
}

/**
 * @brief Test registerTemplate with multiple templates
 */
TEST_F(CmsEngineTest, testRegisterTemplateMultiple) {
    TemplateInstance tmpl1;
    tmpl1.templateId = "TMPL-A";
    tmpl1.confidence = 0.7;

    TemplateInstance tmpl2;
    tmpl2.templateId = "TMPL-B";
    tmpl2.confidence = 0.9;

    engine->registerTemplate(tmpl1);
    engine->registerTemplate(tmpl2);

    const TemplateInstance* matched = engine->matchTemplate("any");
    ASSERT_NE(matched, nullptr);
    EXPECT_EQ(matched->templateId, "TMPL-B");
    EXPECT_DOUBLE_EQ(matched->confidence, 0.9);
}

/**
 * @brief Test registerTemplate with empty template ID
 */
TEST_F(CmsEngineTest, testRegisterTemplateEmptyId) {
    TemplateInstance tmpl;
    tmpl.templateId = "";
    tmpl.confidence = 0.5;

    engine->registerTemplate(tmpl);

    const TemplateInstance* matched = engine->matchTemplate("any");
    ASSERT_NE(matched, nullptr);
    EXPECT_TRUE(matched->templateId.empty());
}

/**
 * @brief Test registerTemplate with zero confidence
 */
TEST_F(CmsEngineTest, testRegisterTemplateZeroConfidence) {
    TemplateInstance tmpl;
    tmpl.templateId = "TMPL-LOW";
    tmpl.confidence = 0.0;

    engine->registerTemplate(tmpl);

    const TemplateInstance* matched = engine->matchTemplate("any");
    ASSERT_NE(matched, nullptr);
    EXPECT_DOUBLE_EQ(matched->confidence, 0.0);
}

/**
 * @brief Test registerTemplate with maximum confidence
 */
TEST_F(CmsEngineTest, testRegisterTemplateMaxConfidence) {
    TemplateInstance tmpl;
    tmpl.templateId = "TMPL-HIGH";
    tmpl.confidence = 1.0;

    engine->registerTemplate(tmpl);

    const TemplateInstance* matched = engine->matchTemplate("any");
    ASSERT_NE(matched, nullptr);
    EXPECT_DOUBLE_EQ(matched->confidence, 1.0);
}

/**
 * @brief Test registerTemplate does not affect existing templates
 */
TEST_F(CmsEngineTest, testRegisterTemplateNoSideEffects) {
    TemplateInstance tmpl1;
    tmpl1.templateId = "TMPL-FIRST";
    tmpl1.confidence = 0.6;
    engine->registerTemplate(tmpl1);

    TemplateInstance tmpl2;
    tmpl2.templateId = "TMPL-SECOND";
    tmpl2.confidence = 0.8;
    engine->registerTemplate(tmpl2);

    const TemplateInstance* matched = engine->matchTemplate("any");
    ASSERT_NE(matched, nullptr);
    EXPECT_EQ(matched->templateId, "TMPL-SECOND");
}