#ifndef DIGRAPH_H_
#define DIGRAPH_H_

#include "graph.h"
#include "algorithm/breadth_first_search.h"

namespace graph {

template<typename T>
class Digraph : public Graph<T> {
public:
  Digraph() = default;

  explicit Digraph(std::unordered_map<T, std::unordered_set<T>> G);

  // Return true if there is a path from u to v
  bool contains(const T& u, const T& v);

  // Add edge e(u,v)
  void insert(const T& u, const T& v);

  // Remove edge e(u,v)
  void remove(const T& u, const T& v);

  // Reverse graph directions
  auto reverse();

  //
  auto contains(const T& u);

  friend std::ostream& operator<<<>(std::ostream& os, Digraph<T>& G);

};

template<typename T>
Digraph<T>::Digraph(std::unordered_map<T, std::unordered_set<T>> G) {
  this->adjList = G;
}

template<typename T>
bool Digraph<T>::contains(const T& u, const T& v) {
  return algo::BreadthFirstSearch<T>(this->adjList).query(u, v);
}

template<typename T>
void Digraph<T>::insert(const T& u, const T& v) {
  this->adjList[u].insert(v);
  this->adjList[v];
}

template<typename T>
void Digraph<T>::remove(const T& u, const T& v) {
  this->adjList[u].erase(v);
}

template<typename T>
auto Digraph<T>::reverse() {
  std::unordered_map<T, std::unordered_set<T>> revMatrix;
  
  for (const auto& u : this->vertices()) {
    for (const auto& v : this->adjList[u]) {
      revMatrix[v].insert(u);
    }
  }

  return revMatrix;
}

template<typename T>
auto Digraph<T>::contains(const T& u) {
  return this->adjList.count(u);
}

template<typename T>
std::ostream& operator<<(std::ostream& os, Digraph<T>& G) {
  os << "V: " << G.V() << " E: " << G.E() << '\n';
  for (const auto& u : G.vertices()) {
    if (!G.adjList[u].empty()) {
      for (const auto& v : G.adjList[u]) {
        os << u << "->" << v << ' ';
      }
      os << '\n';
    }
  }
  os << '\n';
  return os;
}

} // namespace graph

#endif