#include <iostream>

#include "daggy/DAG.hpp"

#include "catch.hpp"

TEST_CASE("DAG Construction Tests", "[dag]") {
    daggy::DAG<int> dag;

    REQUIRE(dag.size() == 0);
    REQUIRE(dag.empty());

    REQUIRE_NOTHROW(dag.addVertex(0));
    for (int i = 1; i < 10; ++i) {
      dag.addVertex(i);
      dag.addEdge(i-1, i);
    }

    REQUIRE(dag.size() == 10);
    REQUIRE(! dag.empty());

    // Cannot add an edge that would result in a cycle
    REQUIRE_THROWS(dag.addEdge(9, 5));

    SECTION("Visit State") {
      dag.setVisitState(daggy::VertexState::VISITING);
      for (const auto v : dag.getVertices()) {
        REQUIRE(dag.getVertexState(v) == daggy::VertexState::VISITING);
      }
    }
}

TEST_CASE("DAG Traversal Tests", "[dag]") {
    daggy::DAG<int> dag;

    const int N_VERTICES = 10;

    for (int i = 0; i < N_VERTICES; ++i) { dag.addVertex(i); }

    /*
       0 ---------------------\
       1 ---------- \          \           /-----> 8
       2 ---- 3 ---- > 5 -------> 6 -----> 7
       4 -------------------------------/  \-----> 9
    */

    std::vector<std::pair<int,int>> edges{
      {0, 6}
      , {1, 5}
      , {5, 6}
      , {6, 7}
      , {2, 3}
      , {3, 5}
      , {4, 7}
      , {7, 8}
      , {7, 9}
    };

    for (auto const [from, to] : edges) {
      dag.addEdge(from, to);
    }

    SECTION("Baisc Traversal") {
      dag.setVisitState(daggy::VertexState::UNVISITED);
      std::vector<int> visitOrder(N_VERTICES);
      size_t i = 0;
      while (! dag.allVisited()) {
        const auto & v = dag.visitNext().value();
        dag.completeVisit(v);
        visitOrder[v] = i;
        ++i;
      }

      // Ensure visit order is preserved
      for (auto const [from, to] : edges) {
        REQUIRE(visitOrder[from] <= visitOrder[to]);
      }
    }
}