#include "helpers.hpp"

#include <combinations.hpp>

#include <set>

#include <vector>

#include <string>

#include <iterator>

#include "catch.hpp"

using iter::combinations;

using itertest::BasicIterable;

using itertest::SolidInt;

using CharCombSet = std::vector<std::vector<char>>;

TEST_CASE("combinations: Simple combination of 4", "[combinations]") {

std::string s{"ABCD"};

CharCombSet sc;

for (auto v : combinations(s, 2)) {

sc.emplace_back(std::begin(v), std::end(v));

}

CharCombSet ans =

{{'A','B'}, {'A','C'}, {'A','D'}, {'B','C'}, {'B','D'}, {'C','D'}};

REQUIRE( ans == sc );

}

TEST_CASE("combinations: iterators can be compared", "[combinations]") {

std::string s{"ABCD"};

auto c = combinations(s, 2);

auto it = std::begin(c);

REQUIRE( it == std::begin(c) );

REQUIRE_FALSE( it != std::begin(c) );

++it;

REQUIRE( it != std::begin(c) );

REQUIRE_FALSE( it == std::begin(c) );

}

TEST_CASE("combinations: operator->", "[combinations]") {

std::string s{"ABCD"};

auto c = combinations(s, 2);

auto it = std::begin(c);

REQUIRE( it->size() == 2 );

}

TEST_CASE("combinations: size too large gives no results", "[combinations]") {

std::string s{"ABCD"};

auto c = combinations(s, 5);

REQUIRE( std::begin(c) == std::end(c) );

}

TEST_CASE("combinations: size 0 gives nothing", "[combinations]") {

std::string s{"ABCD"};

auto c = combinations(s, 0);

REQUIRE( std::begin(c) == std::end(c) );

}

TEST_CASE("combinations: binds to lvalues, moves rvalues", "[combinations]") {

BasicIterable<char> bi{'x', 'y', 'z'};

SECTION("binds to lvalues") {

combinations(bi, 1);

REQUIRE_FALSE( bi.was_moved_from() );

}

SECTION("moves rvalues") {

combinations(std::move(bi), 1);

REQUIRE( bi.was_moved_from() );

}

}

TEST_CASE("combinations: doesn't move or copy elements of iterable",

"[combinations]") {

constexpr SolidInt arr[] = {{6}, {7}, {8}};

for (auto&& i : combinations(arr, 1)) {

(void)i;

}

}

TEST_CASE("combinations: iterator meets requirements", "[combinations]") {

std::string s{"abc"};

auto c = combinations(s, 1);

REQUIRE( itertest::IsIterator<decltype(std::begin(c))>::value );

auto&& row = *std::begin(c);

REQUIRE( itertest::IsIterator<decltype(std::begin(row))>::value );

}