#include <permutations.hpp>

#include "helpers.hpp"

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

#include "catch.hpp"

using iter::permutations;
using IntPermSet = std::multiset<std::vector<int>>;

TEST_CASE("permutations: basic test, 3 element sequence", "[permutations]") {
  const std::vector<int> ns = {1, 7, 9};

  IntPermSet v;
  SECTION("Normal call") {
    for (auto&& st : permutations(ns)) {
      v.emplace(std::begin(st), std::end(st));
    }
  }
  SECTION("Pipe") {
    for (auto&& st : ns | permutations) {
      v.emplace(std::begin(st), std::end(st));
    }
  }

  const IntPermSet vc = {
      {1, 7, 9}, {1, 9, 7}, {7, 1, 9}, {7, 9, 1}, {9, 1, 7}, {9, 7, 1}};
  REQUIRE(v == vc);
}

TEST_CASE(
    "permutations: empty sequence has one empy permutation", "[permutations]") {
  const std::vector<int> ns{};
  auto p = permutations(ns);
  auto it = std::begin(p);
  REQUIRE((*it).empty());
  it++;
  REQUIRE(it == std::end(p));
}

TEST_CASE("permutations: iterators can be compared", "[permutations]") {
  const std::vector<int> ns = {1, 2};
  auto p = permutations(ns);
  auto it = std::begin(p);
  REQUIRE(it == std::begin(p));
  REQUIRE_FALSE(it != std::begin(p));
  REQUIRE(it != std::end(p));
  REQUIRE_FALSE(it == std::end(p));
  ++it;
  REQUIRE_FALSE(it == std::begin(p));
  REQUIRE(it != std::begin(p));
  REQUIRE_FALSE(it == std::end(p));
  REQUIRE(it != std::end(p));
  ++it;
  REQUIRE(it == std::end(p));
  REQUIRE_FALSE(it != std::end(p));
}

TEST_CASE("permutations: binds to lvalues, moves rvalues", "[permutations]") {
  itertest::BasicIterable<int> bi{1, 2};
  SECTION("binds to lvalues") {
    permutations(bi);
    REQUIRE_FALSE(bi.was_moved_from());
  }

  SECTION("moves rvalues") {
    permutations(std::move(bi));
    REQUIRE(bi.was_moved_from());
  }
}

namespace itertest {
  bool operator<(const SolidInt& lhs, const SolidInt& rhs) {
    return lhs.getint() < rhs.getint();
  }
}

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

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

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