#include "factory/application/document.h"
#include "factory/application/simulation_service.h"
#include "factory/core/puzzles.h"
#include <chrono>
#include <gtest/gtest.h>
#include <thread>

using namespace factory;
class MemoryRepository final : public ProjectRepository {
public:
  mutable Project stored;
  bool failure{};
  Project load(const std::string&) const override {
    if (failure)
      throw std::runtime_error("read failed");
    return stored;
  }
  void save(const Project& p, const std::string&) const override {
    if (failure)
      throw std::runtime_error("write failed");
    stored = p;
  }
};
TEST(Document, UndoRedoDirtyStateAndBranching) {
  auto repo = std::make_shared<MemoryRepository>();
  Document doc(repo);
  EXPECT_FALSE(doc.dirty());
  doc.edit([](Project& p) { p.name = "Changed"; });
  EXPECT_TRUE(doc.dirty());
  doc.undo();
  EXPECT_FALSE(doc.dirty());
  doc.redo();
  doc.save("memory");
  EXPECT_FALSE(doc.dirty());
  doc.undo();
  doc.edit([](Project& p) { p.name = "New branch"; });
  EXPECT_FALSE(doc.canRedo());
  EXPECT_TRUE(doc.dirty());
}
TEST(Document, FailedLoadAndSavePreserveCurrentDraft) {
  auto repo = std::make_shared<MemoryRepository>();
  Document doc(repo);
  doc.edit([](Project& p) { p.name = "Unsaved"; });
  repo->failure = true;
  EXPECT_THROW(doc.load("bad"), std::runtime_error);
  EXPECT_THROW(doc.save("bad"), std::runtime_error);
  EXPECT_EQ(doc.project().name, "Unsaved");
  EXPECT_TRUE(doc.dirty());
  EXPECT_TRUE(doc.path().empty());
}
TEST(Preflight, DetectsConnectivityBeforeStarting) {
  EXPECT_FALSE(preflight(makePuzzle(0)).empty());
  for (int i = 0; i < PuzzleCount; ++i)
    EXPECT_TRUE(preflight(makePuzzle(i, true)).empty());
}
TEST(Service, PausedSingleStepsAndRepeatedShutdownAreSafe) {
  SimulationService service;
  for (int i = 0; i < 20; ++i) {
    service.start(makePuzzle(0, true), false);
    EXPECT_TRUE(service.active());
    EXPECT_FALSE(service.playing());
    service.stepOnce();
    EXPECT_EQ(service.snapshot().tick, 1);
    service.setSpeed(4);
    service.setPlaying(true);
    service.setPlaying(false);
    service.stop();
    EXPECT_FALSE(service.active());
  }
  EXPECT_THROW(service.setSpeed(3), std::invalid_argument);
}
TEST(Service, BackgroundProgressStopsWhenPaused) {
  SimulationService service;
  service.setSpeed(4);
  service.start(makePuzzle(0, true));
  const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
  while (service.snapshot().tick < 2 && std::chrono::steady_clock::now() < deadline)
    std::this_thread::sleep_for(std::chrono::milliseconds(5));
  ASSERT_GE(service.snapshot().tick, 2);
  service.setPlaying(false);
  const auto paused = service.snapshot().tick;
  std::this_thread::sleep_for(std::chrono::milliseconds(60));
  EXPECT_EQ(service.snapshot().tick, paused);
}
