//
//  zip_iterator_test.cxx
//  iterator-test
//
//  Created by Sam Jaffe on 8/11/20.
//  Copyright © 2020 Sam Jaffe. All rights reserved.
//

#include "iterator/zip_iterator.hpp"

#include <forward_list>
#include <list>
#include <vector>

#include "xcode_gtest_helper.h"

TEST(ZipIteratorTest, CategoryIsMostRestrictiveOfTypes) {
  std::vector<int> rnd{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  std::list<int> bid{1, 2, 3};
  std::forward_list<int> fwd{1, 2, 3};
  {
    auto zit = make_zip_iterator(rnd.begin(), ss.begin());
    testing::StaticAssertTypeEq<decltype(zit)::iterator_category,
                                std::random_access_iterator_tag>();
  }
  {
    auto zit = make_zip_iterator(rnd.begin(), bid.begin());
    testing::StaticAssertTypeEq<decltype(zit)::iterator_category,
                                std::bidirectional_iterator_tag>();
  }
  {
    auto zit = make_zip_iterator(rnd.begin(), fwd.begin());
    testing::StaticAssertTypeEq<decltype(zit)::iterator_category,
                                std::forward_iterator_tag>();
  }
  {
    auto zit = make_zip_iterator(bid.begin(), fwd.begin());
    testing::StaticAssertTypeEq<decltype(zit)::iterator_category,
                                std::forward_iterator_tag>();
  }
}

TEST(ZipIteratorTest, CannotInvokeOperatorArrow) {
  std::vector<int> is{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  auto zit = make_zip_iterator(is.begin(), ss.begin());
  testing::StaticAssertTypeEq<decltype(zit.operator->()), void>();
}

TEST(ZipIteratorTest, CanCombineParallelObjects) {
  std::vector<int> is{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  auto zit = make_zip_iterator(is.begin(), ss.begin());
  EXPECT_THAT(std::get<0>(*zit), 1);
  EXPECT_THAT(std::get<1>(*zit), "A");
}

TEST(ZipIteratorTest, AdvancingMovesAllElements) {
  std::vector<int> is{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  auto zit = make_zip_iterator(is.begin(), ss.begin());
  zit++;
  EXPECT_THAT(std::get<0>(*zit), 2);
  EXPECT_THAT(std::get<1>(*zit), "B");
}

TEST(ZipIteratorTest, CanDecrement) {
  std::vector<int> is{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  auto zit = make_zip_iterator(is.begin(), ss.begin());
  ++zit;
  zit--;
  EXPECT_THAT(std::get<0>(*zit), 1);
  EXPECT_THAT(std::get<1>(*zit), "A");
}

TEST(ZipIteratorTest, CanMoveByAnyAmount) {
  std::vector<int> is{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  auto zit = make_zip_iterator(is.begin(), ss.begin());
  zit = 2 + zit;
  EXPECT_THAT(std::get<0>(*zit), 3);
  EXPECT_THAT(std::get<1>(*zit), "C");
  zit = zit - 2;
  EXPECT_THAT(std::get<0>(*zit), 1);
  EXPECT_THAT(std::get<1>(*zit), "A");
}

TEST(ZipIteratorTest, CanMarkDistance) {
  std::vector<int> is{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  auto zit = make_zip_iterator(is.begin(), ss.begin());
  auto zend = make_zip_iterator(is.end(), ss.end());
  EXPECT_THAT(zend - zit, 3);
}

TEST(ZipIteratorTest, CanRandomAccess) {
  std::vector<int> is{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  auto zit = make_zip_iterator(is.begin(), ss.begin());
  EXPECT_THAT(std::get<0>(zit[1]), 2);
  EXPECT_THAT(std::get<1>(zit[1]), "B");
}

TEST(ZipIteratorTest, CanCompareIterators) {
  std::vector<int> is{1, 2, 3};
  std::vector<std::string> ss{"A", "B", "C"};
  auto const zit = make_zip_iterator(is.begin(), ss.begin());
  auto const zend = make_zip_iterator(is.end(), ss.end());
  EXPECT_THAT(zit, testing::Eq(make_zip_iterator(is.begin(), ss.begin())));
  EXPECT_THAT(zit, testing::Ne(zend));
  EXPECT_THAT(zit, testing::Lt(zend));
  EXPECT_THAT(zit, testing::Le(zend));
  EXPECT_THAT(zit, testing::Le(zit));
  EXPECT_THAT(zend, testing::Gt(zit));
  EXPECT_THAT(zend, testing::Ge(zit));
  EXPECT_THAT(zend, testing::Ge(zend));
}