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

#include "daggy/Serialization.hpp"
#include "daggy/Utilities.hpp"
#include "daggy/executors/task/NoopTaskExecutor.hpp"

TEST_CASE("string_utilities", "[utilities_string]")
{
  std::string test = "/this/is/{{A}}/test/{{A}}";
  auto res         = daggy::globalSub(test, "{{A}}", "hello");
  REQUIRE(res == "/this/is/hello/test/hello");
}

TEST_CASE("generate_cart_values", "[cartesian_values]")
{
  std::string testParams{
      R"({"DATE": ["2021-05-06", "2021-05-07" ], "SOURCE": "name", "TYPE": ["a", "b", "c"]})"};
  auto params = daggy::configFromJSON(testParams);

  auto result = daggy::generateCartesianValues(params);
  REQUIRE(result.size() == 6);

  for (const auto& valset : result) {
    REQUIRE(valset.size() == 3);
    REQUIRE(valset.count("DATE") == 1);
    REQUIRE(valset.count("SOURCE") == 1);
    REQUIRE(valset.count("TYPE") == 1);
  }
}

TEST_CASE("string_expansion", "[utilities][parameter_expansion]")
{
  SECTION("Basic expansion")
  {
    std::string testParams{
        R"({"DATE": ["2021-05-06", "2021-05-07" ], "SOURCE": "name", "TYPE": ["a", "b", "c"]})"};
    auto params = daggy::configFromJSON(testParams);
    std::vector<std::string> cmd{"/bin/echo", "{{DATE}}", "{{SOURCE}}",
                                 "{{TYPE}}"};
    auto allCommands = daggy::interpolateValues(cmd, params);

    REQUIRE(allCommands.size() == 6);
  }

  SECTION("No expansion")
  {
    std::string testParams{
        R"({"DATE": ["2021-05-06", "2021-05-07" ], "SOURCE": "name", "TYPE": ["a", "b", "c"]})"};
    auto params = daggy::configFromJSON(testParams);
    std::vector<std::string> cmd{"/bin/echo"};
    auto allCommands = daggy::interpolateValues(cmd, params);

    REQUIRE(allCommands.size() == 1);
  }

  SECTION("Skip over unused parameters")
  {
    std::string testParams{
        R"({"DATE": ["2021-05-06", "2021-05-07" ], "SOURCE": "name", "TYPE": ["a", "b", "c"]})"};
    auto params = daggy::configFromJSON(testParams);
    std::vector<std::string> cmd{"/bin/echo", "{{DATE}}", "{{SOURCE}}"};
    auto allCommands = daggy::interpolateValues(cmd, params);

    // TYPE isn't used, so it's just |DATE| * |SOURCE|
    REQUIRE(allCommands.size() == 2);
  }

  SECTION("Expand within a command part")
  {
    std::string testParams{
        R"({"DATE": ["2021-05-06", "2021-05-07" ], "SOURCE": ["A", "B"], "TYPE": ["a", "b", "c"]})"};
    auto params = daggy::configFromJSON(testParams);
    std::vector<std::string> cmd{"/bin/touch", "{{DATE}}_{{SOURCE}}"};
    auto result = daggy::interpolateValues(cmd, params);

    // TYPE isn't used, so it's just |DATE| * |SOURCE|
    REQUIRE(result.size() == 4);
  }
}

TEST_CASE("expand_taskset", "[utilities][expand_taskset]")
{
  daggy::executors::task::NoopTaskExecutor ex;
  daggy::DAGSpec dagSpec;
  std::string testParams{R"({"DATE": ["2021-05-06", "2021-05-07" ]})"};
  dagSpec.taskConfig.variables = daggy::configFromJSON(testParams);

  std::stringstream jsonTasks;
  jsonTasks
      << R"({ "A": { "job": {"command": [ "/bin/cat", "/etc/passwd"]} )"
      << R"(, "children": ["C"], "isGenerator": true},)"
      << R"("C": { "job": {"command": [ "/bin/echo", "hello!"]} } })";

  dagSpec.tasks = daggy::tasksFromJSON(jsonTasks.str());
  REQUIRE(dagSpec.tasks.size() == 2);
  REQUIRE(dagSpec.tasks["A"].children == std::unordered_set<std::string>{"C"});
  dagSpec.tasks =
      daggy::expandTaskSet(dagSpec.tasks, ex, dagSpec.taskConfig.variables);
  REQUIRE(dagSpec.tasks.size() == 2);
  REQUIRE(dagSpec.tasks["A_0"].children ==
          std::unordered_set<std::string>{"C"});
}