#include "iterator/recursive_iterator.hpp"

#include <map>
#include <tuple>
#include <vector>

#include <gmock/gmock.h>

TEST(RecursiveIteratorSingleMapTest, IterDistanceIsContainerSize) {
  std::map<int, int> const map{{1, 1}, {2, 2}, {3, 3}};
  auto rit = make_recursive_iterator(map);
  decltype(rit) end{ };
  EXPECT_THAT(std::distance(rit, end), map.size());
}

TEST(RecursiveIteratorSingleMapTest, DataMatchesContainerIterator) {
  std::map<int, int> const map{{1, 1}, {2, 2}, {3, 3}};
  auto rit = make_recursive_iterator(map);
  // TODO: Collapse into a container instead
  for (auto it = map.begin(), end = map.end(); it != end; ++it, ++rit) {
    EXPECT_THAT(*it, *rit);
  }
}

TEST(RecursiveIteratorSingleMapTest, CanMutatePointedToData) {
  std::map<int, int> map{{1, 1}, {2, 2}, {3, 3}};
  auto rit = make_recursive_iterator(map);
  std::get<1>(*rit) = 4;
  EXPECT_THAT(map[1], 4);
}

TEST(RecursiveIteratorMapMapTest, IterDistanceIsSumOfInnerContainerSizes) {
  std::map<int, std::map<int, int>> const map{
    {1, {{1, 1}}},
    {2, {{2, 2}, {3, 3}}}
  };
  auto rit = make_recursive_iterator(map);
  decltype(rit) end{ };
  // TODO: Actually perform the summation?
  EXPECT_THAT(std::distance(rit, end), 3);
}

TEST(RecursiveIteratorMapMapTest, ElementsAreUnwrappedAsATuple) {
  std::map<int, std::map<int, int>> const map{
    {1, {{1, 1}}},
    {2, {{2, 2}, {3, 3}}}
  };
  std::vector<std::tuple<int, int, int>> const expected{
    {1, 1, 1}, {2, 2, 2}, {2, 3, 3}};
  auto rit = make_recursive_iterator(map);
  // TODO: Collapse into a container instead
  for (auto it = expected.begin(), end = expected.end(); it != end; ++it, ++rit) {
    EXPECT_THAT(std::tuple_cat(*it), *rit);
  }
}

TEST(RecursiveIteratorMapMapTest, CanMutatePointedToData) {
  std::map<int, std::map<int, int>> map{
    {1, {{1, 1}}},
    {2, {{2, 2}, {3, 3}}}
  };
  auto rit = make_recursive_iterator(map);
  std::get<2>(*rit) = 4;
  EXPECT_THAT(map[1][1], 4);
}

TEST(BoundRecursiveIteratorMapMapTest, IterDistanceSumOnNLayersSize) {
  std::map<int, std::map<int, int>> map{
    {1, {{1, 1}}},
    {2, {{2, 2}, {3, 3}}}
  };
  auto rit = make_recursive_iterator<1>(map);
  decltype(rit) end{ };
  
  EXPECT_THAT(std::distance(rit, end), map.size());
}

TEST(BoundRecursiveIteratorMapMapTest, ElementsAreUnwrappedAsATuple) {
  std::map<int, std::map<int, int>> map{
    {1, {{1, 1}}},
    {2, {{2, 2}, {3, 3}}}
  };
  auto rit = make_recursive_iterator<1>(map);
  
  // TODO: Collapse into a container instead
  for (auto it = map.begin(), end = map.end(); it != end; ++it, ++rit) {
    EXPECT_THAT(*it, *rit);
  }
}