#include <boost/test/unit_test.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/assign/std/vector.hpp>
#include <boost/assign/std/list.hpp>
#include <boost/static_assert.hpp>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
#include <boost/iterator/reverse_iterator.hpp>

// custom include
#include <fundament/flat_iterator.h>

BOOST_AUTO_TEST_SUITE(test_flat_iterator)

BOOST_AUTO_TEST_CASE(test_derive_inner_iterator_type) 
{
  using namespace LibFundament::Details;
  BOOST_STATIC_ASSERT((
    boost::is_same<
      derive_inner_iterator_type<std::vector<std::list<int> >::iterator>::type,
      std::list<int>::iterator
    >::value == true));

  BOOST_STATIC_ASSERT((
    boost::is_same<
      derive_inner_iterator_type<std::vector<std::list<int> >::iterator>::type,
      std::list<int>::const_iterator
    >::value == false));

  BOOST_STATIC_ASSERT((
    boost::is_same<
      derive_inner_iterator_type<std::vector<std::list<int> >::const_iterator>::type,
      std::list<int>::const_iterator
    >::value == true));
}

BOOST_AUTO_TEST_CASE(test_derive_value_type) 
{
  using namespace LibFundament::Details;
  BOOST_STATIC_ASSERT((
    boost::is_const<
      derive_value_type<
        std::vector<int>::iterator, 
        std::list<int>::iterator
      >::type>::value == false));

    BOOST_STATIC_ASSERT((
    boost::is_const<
      derive_value_type<
        std::vector<int>::const_iterator, 
        std::list<int>::iterator
      >::type>::value == true));

    BOOST_STATIC_ASSERT((
    boost::is_const<
      derive_value_type<
        std::vector<int>::iterator, 
        std::list<int>::const_iterator
      >::type>::value == true));

    BOOST_STATIC_ASSERT((
    boost::is_const<
      derive_value_type<
        std::vector<int>::const_iterator, 
        std::list<int>::const_iterator
      >::type>::value == true));  
}

BOOST_AUTO_TEST_CASE(test_flatten_single) 
{
  using namespace boost::assign;
  using namespace LibFundament;

	typedef std::list<int> inner_container_type;
  typedef std::vector<inner_container_type> outer_container_type;

  outer_container_type elements(6);
  elements[1] += 1,2,3;
  elements[2] += 4,5;
  elements[4] += 6;

  BOOST_CHECK(std::equal(
   make_flat_iterator(elements.begin(), elements.end()),
   make_flat_iterator(elements.end(), elements.end()),
   list_of(1)(2)(3)(4)(5)(6).begin()));

  BOOST_CHECK(std::equal(
    boost::make_reverse_iterator(make_flat_iterator(elements.end(), elements.end())),
    boost::make_reverse_iterator(make_flat_iterator(elements.begin(), elements.end())),
    list_of(6)(5)(4)(3)(2)(1).begin()));

  inner_container_type transformed;
  std::transform(
    make_flat_iterator(elements.begin(), elements.end()),
    make_flat_iterator(elements.begin() + 2, elements.end()),
    std::back_inserter(transformed),
    std::bind2nd(std::multiplies<int>(), 2));
  BOOST_CHECK(transformed == list_of(2)(4)(6));
}

BOOST_AUTO_TEST_CASE(test_flatten_multiple) 
{
  using namespace boost::assign;
  using namespace LibFundament;

	typedef std::list<int> level_0;
  typedef std::vector<level_0> level_1;
  typedef std::vector<level_1> level_2;

  level_2 elements(10);
  elements[2] += list_of(1)(2);
  elements[4] += list_of(3)(4);

  typedef flat_iterator<level_2::iterator> flat_iterator_outer;
  typedef flat_iterator<flat_iterator_outer> flat_iterator_inner;

  flat_iterator_outer outer_begin(elements.begin(), elements.end());
  flat_iterator_outer outer_end(elements.end(), elements.end());

  flat_iterator_inner inner_begin(outer_begin, outer_end);
  flat_iterator_inner inner_end(outer_end, outer_end);

  BOOST_CHECK(std::equal(inner_begin, inner_end, list_of(1)(2)(3)(4).begin()));
}

BOOST_AUTO_TEST_SUITE_END()