#include <product.hpp>

#include "helpers.hpp"

#include <vector>
#include <string>
#include <iterator>

#include "catch.hpp"

using iter::product;
using Vec = const std::vector<int>;

TEST_CASE("product: basic test, two sequences", "[product]") {
  using TP = std::tuple<int, char>;
  using ResType = std::vector<TP>;

  Vec n1 = {0, 1};
  const std::string s{"abc"};

  auto p = product(n1, s);
  ResType v(std::begin(p), std::end(p));
  ResType vc = {
      TP{0, 'a'}, TP{0, 'b'}, TP{0, 'c'}, TP{1, 'a'}, TP{1, 'b'}, TP{1, 'c'}};

  REQUIRE(v == vc);
}

TEST_CASE("product: three sequences", "[product]") {
  using TP = std::tuple<int, char, int>;
  using ResType = const std::vector<TP>;

  Vec n1 = {0, 1};
  const std::string s{"ab"};
  Vec n2 = {2};

  auto p = product(n1, s, n2);
  ResType v(std::begin(p), std::end(p));

  ResType vc = {TP{0, 'a', 2}, TP{0, 'b', 2}, TP{1, 'a', 2}, TP{1, 'b', 2}};

  REQUIRE(v == vc);
}

TEST_CASE("product: empty when any iterable is empty", "[product]") {
  Vec n1 = {0, 1};
  Vec n2 = {0, 1, 2};
  Vec emp = {};

  SECTION("first iterable is empty") {
    auto p = product(emp, n1, n2);
    REQUIRE(std::begin(p) == std::end(p));
  }

  SECTION("middle iterable is empty") {
    auto p = product(n1, emp, n2);
    REQUIRE(std::begin(p) == std::end(p));
  }

  SECTION("last iterable is empty") {
    auto p = product(n1, n2, emp);
    REQUIRE(std::begin(p) == std::end(p));
  }
}

TEST_CASE("product: single iterable", "[product]") {
  const std::string s{"ab"};
  using TP = std::tuple<char>;
  using ResType = const std::vector<TP>;

  auto p = product(s);
  ResType v(std::begin(p), std::end(p));
  ResType vc = {TP{'a'}, TP{'b'}};

  REQUIRE(v == vc);
}

TEST_CASE("product: no arguments gives one empty tuple", "[product") {
  auto p = product();
  auto it = std::begin(p);
  REQUIRE(it != std::end(p));
  REQUIRE(*it == std::make_tuple());
  ++it;
  REQUIRE(it == std::end(p));
}

TEST_CASE("product: binds to lvalues and moves rvalues", "[product]") {
  itertest::BasicIterable<char> bi{'x', 'y'};
  itertest::BasicIterable<int> bi2{0, 1};

  SECTION("First ref'd, second moved") {
    product(bi, std::move(bi2));
    REQUIRE_FALSE(bi.was_moved_from());
    REQUIRE(bi2.was_moved_from());
  }

  SECTION("First moved, second ref'd") {
    product(std::move(bi), bi2);
    REQUIRE(bi.was_moved_from());
    REQUIRE_FALSE(bi2.was_moved_from());
  }
}

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

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

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