#include <catch2/catch.hpp>
#include <filesystem>
#include <fstream>
#include <iostream>

#include "daggy/loggers/dag_run/FileSystemLogger.hpp"
#include "daggy/loggers/dag_run/OStreamLogger.hpp"

namespace fs = std::filesystem;

using namespace daggy;
using namespace daggy::loggers::dag_run;

const TaskSet SAMPLE_TASKS{
    {"work_a",
     Task{.job{{"command", std::vector<std::string>{"/bin/echo", "a"}}},
          .children{"c"}}},
    {"work_b",
     Task{.job{{"command", std::vector<std::string>{"/bin/echo", "b"}}},
          .children{"c"}}},
    {"work_c",
     Task{.job{{"command", std::vector<std::string>{"/bin/echo", "c"}}}}}};

inline DAGRunID testDAGRunInit(DAGRunLogger &logger, const std::string &name,
                               const TaskSet &tasks)
{
  auto runID  = logger.startDAGRun(name, tasks);
  auto dagRun = logger.getDAGRun(runID);

  REQUIRE(dagRun.tasks == tasks);

  REQUIRE(dagRun.taskRunStates.size() == tasks.size());
  auto nonQueuedTask =
      std::find_if(dagRun.taskRunStates.begin(), dagRun.taskRunStates.end(),
                   [](const auto &a) { return a.second != +RunState::QUEUED; });
  REQUIRE(nonQueuedTask == dagRun.taskRunStates.end());

  REQUIRE(dagRun.dagStateChanges.size() == 1);
  REQUIRE(dagRun.dagStateChanges.back().newState == +RunState::QUEUED);
  return runID;
}

/*
TEST_CASE("Filesystem Logger", "[filesystem_logger]") {
    const fs::path logRoot{"fs_logger_unit"};
    auto cleanup = [&]() {
        if (fs::exists(logRoot)) {
            fs::remove_all(logRoot);
        }
    };

    //cleanup();
    daggy::loggers::dag_run::FileSystemLogger logger(logRoot);

    SECTION("DAGRun Starts") {
        testDAGRunInit(logger, "init_test", SAMPLE_TASKS);
    }

    // cleanup();
}
*/

TEST_CASE("ostream_logger", "[ostream_logger]")
{
  // cleanup();
  std::stringstream ss;
  daggy::loggers::dag_run::OStreamLogger logger(ss);

  SECTION("DAGRun Starts")
  {
    testDAGRunInit(logger, "init_test", SAMPLE_TASKS);
  }

  // cleanup();
}