#include "iterator/unkeyed_iterator.hpp"

#include <map>
#include <vector>

#include <gmock/gmock.h>

#include "iterator/end_aware_iterator.hpp"

using value_iterator = iterator::unkeyed_iterator<std::map<int, int>::iterator>;

TEST(UnkeyedIteratorTest, IteratorOnlyReturnsValues) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  std::vector<int> const expected{2, 3};
  std::vector<int> const result{value_iterator{map.begin()},
                                value_iterator{map.end()}};
  EXPECT_THAT(result, expected);
}

TEST(UnkeyedIteratorTest, CanModifyIteratedCollectionValues) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  value_iterator uit{map.begin()};
  *uit = 4;
  EXPECT_THAT(map[1], 4);
}

TEST(UnkeyedIteratorTest, PreIncrementAdvancesIterator) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  value_iterator it(map.begin());
  EXPECT_THAT(*it, 2);
  EXPECT_THAT(*++it, 3);
  EXPECT_THAT(*it, 3);
}

TEST(UnkeyedIteratorTest, PostIncrementReturnsCopyOfPrev) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  value_iterator it(map.begin());
  EXPECT_THAT(*it, 2);
  EXPECT_THAT(*it++, 2);
  EXPECT_THAT(*it, 3);
}

TEST(UnkeyedIteratorTest, PreDecrementAdvancesIterator) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  value_iterator it(++map.begin());
  EXPECT_THAT(*it, 3);
  EXPECT_THAT(*--it, 2);
  EXPECT_THAT(*it, 2);
}

TEST(UnkeyedIteratorTest, PostDecrementReturnsCopyOfPrev) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  value_iterator it(++map.begin());
  EXPECT_THAT(*it, 3);
  EXPECT_THAT(*it--, 3);
  EXPECT_THAT(*it, 2);
}

TEST(UnkeyedIteratorTest, EqualityIsPassthrough) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  EXPECT_THAT(++value_iterator(map.begin()), value_iterator(++map.begin()));
  EXPECT_THAT(value_iterator(map.begin()),
              testing::Ne(value_iterator(++map.begin())));
}

TEST(UnkeyedIteratorTest, IffBaseIteratorEmptyIsEndThenEmptyIsEnd) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  EXPECT_THAT(value_iterator(), testing::Ne(value_iterator(map.end())));
  iterator::end_aware_iterator<decltype(map.end())> end(map.end());
  EXPECT_THAT(iterator::unkeyed_iterator<decltype(end)>(),
              iterator::unkeyed_iterator<decltype(end)>(end));
}

TEST(UnkeyedIteratorTest, CanPointToObject) {
  std::map<int, int> map{{1, 2}, {2, 3}};
  EXPECT_THAT(value_iterator(map.begin()).operator->(), &(map.begin()->second));
}