#include <zip.hpp>

#include "helpers.hpp"

#include <iterator>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>

#include "catch.hpp"

using iter::zip;
using itertest::BasicIterable;
using itertest::SolidInt;

TEST_CASE("zip: Simple case, same length", "[zip]") {
  using Tu = std::tuple<int, char, double>;
  using ResVec = const std::vector<Tu>;
  std::vector<int> iv{10, 20, 30};
  std::string s{"hey"};
  double arr[] = {1.0, 2.0, 4.0};

  auto z = zip(iv, s, arr);
  ResVec v(std::begin(z), std::end(z));
  ResVec vc{Tu{10, 'h', 1.0}, Tu{20, 'e', 2.0}, Tu{30, 'y', 4.0}};
  REQUIRE(v == vc);
}

TEST_CASE("zip: const iteration", "[zip][const]") {
  using Tu = std::tuple<int, char, double>;
  using ResVec = const std::vector<Tu>;
  std::vector<int> iv{10, 20, 30};
  std::string s{"hey"};
  double arr[] = {1.0, 2.0, 4.0};

  const auto z = zip(iv, s, arr);

  ResVec v(std::begin(z), std::end(z));
  ResVec vc{Tu{10, 'h', 1.0}, Tu{20, 'e', 2.0}, Tu{30, 'y', 4.0}};
  REQUIRE(v == vc);
}

TEST_CASE("zip: const iterators can be compared to non-const iterators",
    "[zip][const]") {
  std::vector<int> v;
  std::string s;
  auto z = zip(std::vector<int>{}, s);
  const auto& cz = z;
  (void)(std::begin(z) == std::end(cz));
}

TEST_CASE(
    "zip: three sequences, one sequence has different begin and end", "[zip]") {
  using Tu = std::tuple<int, char, double>;
  using ResVec = const std::vector<Tu>;
  std::vector<int> iv{10, 20, 30};
  CharRange cr('d');
  double arr[] = {1.0, 2.0, 4.0};

  auto z = zip(iv, cr, arr);
  ResVec v(std::begin(z), std::end(z));
  ResVec vc{Tu{10, 'a', 1.0}, Tu{20, 'b', 2.0}, Tu{30, 'c', 4.0}};
  REQUIRE(v == vc);
}

TEST_CASE("zip: One empty, all empty", "[zip]") {
  std::vector<int> iv = {1, 2, 3};
  std::string s{};
  auto z = zip(iv, s);
  REQUIRE_FALSE(std::begin(z) != std::end(z));
  auto z2 = zip(s, iv);
  REQUIRE_FALSE(std::begin(z2) != std::end(z2));
}

TEST_CASE("zip: terminates on shortest sequence", "[zip]") {
  std::vector<int> iv{1, 2, 3, 4, 5};
  std::string s{"hi"};
  auto z = zip(iv, s);

  REQUIRE(std::distance(std::begin(z), std::end(z)) == 2);
}

TEST_CASE("zip: Empty", "[zip]") {
  auto z = zip();
  REQUIRE_FALSE(std::begin(z) != std::end(z));
}

TEST_CASE("zip: Modify sequence through zip", "[zip]") {
  std::vector<int> iv{1, 2, 3};
  std::vector<int> iv2{1, 2, 3, 4};
  for (auto&& [a, b] : zip(iv, iv2)) {
    a = -1;
    b = -1;
  }

  const std::vector<int> vc{-1, -1, -1};
  const std::vector<int> vc2{-1, -1, -1, 4};
  REQUIRE(iv == vc);
  REQUIRE(iv2 == vc2);
}

TEST_CASE("zip: binds reference when it should", "[zip]") {
  BasicIterable<char> bi{'x', 'y', 'z'};
  zip(bi);
  REQUIRE_FALSE(bi.was_moved_from());
}

TEST_CASE("zip: moves rvalues", "[zip]") {
  BasicIterable<char> bi{'x', 'y', 'z'};
  zip(std::move(bi));
  REQUIRE(bi.was_moved_from());
}

TEST_CASE("zip: Can bind ref and move in single zip", "[zip]") {
  BasicIterable<char> b1{'x', 'y', 'z'};
  BasicIterable<char> b2{'a', 'b'};
  zip(b1, std::move(b2));
  REQUIRE_FALSE(b1.was_moved_from());
  REQUIRE(b2.was_moved_from());
}

TEST_CASE("zip: doesn't move or copy elements of iterable", "[zip]") {
  constexpr SolidInt arr[] = {{6}, {7}, {8}};
  for (auto&& t : zip(arr)) {
    (void)std::get<0>(t);
  }
}

TEST_CASE("zip: postfix ++", "[zip]") {
  const std::vector<int> v = {1};
  auto z = zip(v);
  auto it = std::begin(z);
  it++;
  REQUIRE(it == std::end(z));
}

TEST_CASE("zip: iterator meets requirements", "[zip]") {
  std::string s{};
  auto c = zip(s);
  REQUIRE(itertest::IsIterator<decltype(std::begin(c))>::value);
  auto c2 = zip(s, s);
  REQUIRE(itertest::IsIterator<decltype(std::begin(c2))>::value);
}

template <typename... Ts>
using ImpT = decltype(zip(std::declval<Ts>()...));
TEST_CASE("zip: has correct ctor and assign ops", "[zip]") {
  using T = ImpT<std::string&, std::vector<double>, std::vector<std::string>>;
  REQUIRE(itertest::IsMoveConstructibleOnly<T>::value);
}