#include "systems/save_storage.h"
#include <QByteArray>
#include <QString>
#include <gtest/gtest.h>

using namespace Game::Systems;

class MissionProgressTest : public ::testing::Test {
protected:
  void SetUp() override {
    storage = std::make_unique<SaveStorage>(":memory:");
    QString error;
    bool initialized = storage->initialize(&error);
    ASSERT_TRUE(initialized) << "Failed to initialize: " << error.toStdString();
  }

  void TearDown() override { storage.reset(); }

  std::unique_ptr<SaveStorage> storage;
};

TEST_F(MissionProgressTest, SaveCampaignMissionResult) {
  QString error;
  bool saved =
      storage->save_mission_result("mission_1", "campaign", "test_campaign",
                                   true, "victory", "normal", 300.5F, &error);

  EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
}

TEST_F(MissionProgressTest, SaveSkirmishMissionResult) {
  QString error;
  bool saved = storage->save_mission_result("mission_1", "skirmish", "", true,
                                            "victory", "hard", 150.0F, &error);

  EXPECT_TRUE(saved) << "Failed to save: " << error.toStdString();
}

TEST_F(MissionProgressTest, GetMissionProgress) {
  QString error;
  storage->save_mission_result("mission_2", "campaign", "test_campaign", true,
                               "victory", "normal", 200.0F, &error);

  QVariantMap progress = storage->get_mission_progress("mission_2", &error);

  EXPECT_TRUE(error.isEmpty())
      << "Failed to get progress: " << error.toStdString();
  EXPECT_EQ(progress["mode"].toString(), QString("campaign"));
  EXPECT_EQ(progress["campaign_id"].toString(), QString("test_campaign"));
  EXPECT_TRUE(progress["completed"].toBool());
  EXPECT_EQ(progress["result"].toString(), QString("victory"));
  EXPECT_EQ(progress["difficulty"].toString(), QString("normal"));
  EXPECT_DOUBLE_EQ(progress["completion_time"].toDouble(), 200.0);
}

TEST_F(MissionProgressTest, CampaignAndSkirmishSeparate) {
  QString error;

  // Save campaign result
  storage->save_mission_result("mission_1", "campaign", "test_campaign", true,
                               "victory", "normal", 100.0F, &error);

  // Save skirmish result for same mission
  storage->save_mission_result("mission_1", "skirmish", "", false, "defeat",
                               "hard", 50.0F, &error);

  // Both should exist independently (most recent will be returned)
  QVariantMap progress = storage->get_mission_progress("mission_1", &error);
  EXPECT_TRUE(error.isEmpty());

  // Since we don't have a filter in get_mission_progress, it returns the most
  // recent This is acceptable as the game context will determine which mode to
  // use
}

TEST_F(MissionProgressTest, UpdateMissionProgress) {
  QString error;

  // First save
  storage->save_mission_result("mission_3", "campaign", "test_campaign", false,
                               "defeat", "normal", 100.0F, &error);
  EXPECT_TRUE(error.isEmpty());

  // Update with victory
  storage->save_mission_result("mission_3", "campaign", "test_campaign", true,
                               "victory", "normal", 250.0F, &error);
  EXPECT_TRUE(error.isEmpty());

  QVariantMap progress = storage->get_mission_progress("mission_3", &error);
  EXPECT_TRUE(progress["completed"].toBool());
  EXPECT_EQ(progress["result"].toString(), QString("victory"));
  EXPECT_DOUBLE_EQ(progress["completion_time"].toDouble(), 250.0);
}

TEST_F(MissionProgressTest, UnlockNextMission) {
  QString error;

  // First, we need to ensure campaign missions exist
  // We'll manually insert them for this test
  // In real usage, ensure_campaign_missions_in_db would be called

  // This test would need campaign missions to be set up first
  // For now, we'll just test the unlock mechanism doesn't crash
  bool unlocked =
      storage->unlock_next_mission("test_campaign", "mission_1", &error);

  // This will fail because no missions are set up, but it shouldn't crash
  EXPECT_FALSE(unlocked);
  EXPECT_FALSE(error.isEmpty());
}

TEST_F(MissionProgressTest, SaveMultipleMissionResults) {
  QString error;

  storage->save_mission_result("mission_1", "campaign", "campaign_1", true,
                               "victory", "normal", 100.0F, &error);
  storage->save_mission_result("mission_2", "campaign", "campaign_1", true,
                               "victory", "normal", 150.0F, &error);
  storage->save_mission_result("mission_3", "campaign", "campaign_1", false,
                               "defeat", "hard", 200.0F, &error);
  storage->save_mission_result("skirmish_1", "skirmish", "", true, "victory",
                               "easy", 50.0F, &error);

  EXPECT_TRUE(error.isEmpty());

  QVariantMap progress1 = storage->get_mission_progress("mission_1", &error);
  EXPECT_TRUE(progress1["completed"].toBool());

  QVariantMap progress2 = storage->get_mission_progress("mission_2", &error);
  EXPECT_TRUE(progress2["completed"].toBool());

  QVariantMap progress3 = storage->get_mission_progress("mission_3", &error);
  EXPECT_FALSE(progress3["completed"].toBool());

  QVariantMap progress_skirmish =
      storage->get_mission_progress("skirmish_1", &error);
  EXPECT_TRUE(progress_skirmish["completed"].toBool());
  EXPECT_EQ(progress_skirmish["mode"].toString(), QString("skirmish"));
}