#include "algorithm.hpp"

#include <boost/test/minimal.hpp>

#include <boost/lambda/lambda.hpp>
namespace bll = boost::lambda;

#include <vector>
#include <deque>
#include <iterator>

int test_main( int, char** )
{
  int const a[] = {
    1, 9, 8, 5, 0, 6, 1, 7
  };
  std::size_t const n = sizeof(a) / sizeof(a[0]);

  // all_of, any_of, none_of
  BOOST_CHECK( etude:: all_of( a, a+n, etude::less_than(10) ) );
  BOOST_CHECK( etude:: any_of( a, a+n, etude::less_than(5)  ) );
  BOOST_CHECK( etude::none_of( a, a+n, etude::less_than(0)  ) );

  BOOST_CHECK( !etude:: all_of( a, a+n, etude::less_than(5) ) );
  BOOST_CHECK( !etude:: any_of( a, a+n, etude::less_than(0) ) );
  BOOST_CHECK( !etude::none_of( a, a+n, etude::less_than(1) ) );

  // find_if_not
  BOOST_CHECK( etude::find_if_not( a, a+n, bll::_1 % 2 == 1 ) == a + 2 ); // 8

  // is_permutation
  {
    int b[n];
    std::copy( a, a+n, b );
    std::random_shuffle( b, b+n );

    BOOST_CHECK( etude::is_permutation( a, a+n, b ) );

    b[0] = 10;
    std::random_shuffle( b, b+n );
    BOOST_CHECK( !etude::is_permutation( a, a+n, b ) );
  }

  // copy_n
  {
    std::vector<int> v;
    etude::copy_n( a, 4, std::back_inserter(v) );
    BOOST_CHECK( v.size() == 4 );
    BOOST_CHECK( std::equal( a, a+4, v.begin() ) );
  }
  // copy_if
  {
    std::vector<int> v;
    etude::copy_if( a, a+n, std::back_inserter(v), etude::less_than(5) );
    BOOST_CHECK( v.size() == 3 );
    BOOST_CHECK( v[0] == 1 );
    BOOST_CHECK( v[1] == 0 );
    BOOST_CHECK( v[2] == 1 );
  }
  // is_partitioned
  BOOST_CHECK( !etude::is_partitioned( a, a+n, etude::less_than(5) ) );
  BOOST_CHECK( etude::is_partitioned( a, a+n, etude::not1( etude::equals_to(7) ) ) );
  BOOST_CHECK( etude::is_partitioned( a, a+n, etude::greater_than(10) ) ); // none
  BOOST_CHECK( etude::is_partitioned( a, a+n, bll::_1 >= 0 ) ); // all

  // patition_copy && partition_point
  {
    std::deque<int> x;
    etude::partition_copy( a, a+n, std::front_inserter(x), std::back_inserter(x),
      bll::_1 % 2 == 0 );  // 偶数を先頭に、奇数を後方に。

    BOOST_CHECK( x.size() == n );
    BOOST_CHECK( x[0] == 6 );
    BOOST_CHECK( x[1] == 0 );
    BOOST_CHECK( x[2] == 8 );
    BOOST_CHECK( x[3] == 1 );
    BOOST_CHECK( x[4] == 9 );
    BOOST_CHECK( x[5] == 5 );
    BOOST_CHECK( x[6] == 1 );
    BOOST_CHECK( x[7] == 7 );

    BOOST_CHECK( etude::partition_point( x.begin(), x.end(), bll::_1 % 2 == 0 )
      == x.begin() + 3 ); // x[2] は偶数、 x[3] は奇数。
  }

  // is_sorted
  {
    std::vector<int> v( a, a+n );
    std::sort( v.begin(), v.end() );

    // is_sorted
    BOOST_CHECK( !etude::is_sorted( a, a+n ) );
    BOOST_CHECK( etude::is_sorted( v.begin(), v.end() ) );
    BOOST_CHECK( !etude::is_sorted( v.begin(), v.end(), std::greater<int>() ) );
    BOOST_CHECK( etude::is_sorted( v.rbegin(), v.rend(), std::greater<int>() ) );

    // is_sorted_until
    BOOST_CHECK( etude::is_sorted_until( a, a+n ) == a + 2 ); // 1, 9 まで
    BOOST_CHECK( etude::is_sorted_until( a, a+n, std::greater<int>() ) == a + 1 ); // 1 まで
    BOOST_CHECK( etude::is_sorted_until( v.begin(), v.end() ) == v.end() ); // 全部
    BOOST_CHECK( etude::is_sorted_until( v.rbegin(), v.rend(), std::greater<int>() ) == v.rend() ); // 全部
  }

  // minmax
  {
    std::pair<int, int> p = etude::minmax( 1, 2 );
    BOOST_CHECK( p.first == 1 && p.second == 2 );
    p = etude::minmax( 2, 1 );
    BOOST_CHECK( p.first == 1 && p.second == 2 );
    p = etude::minmax( 23, 42, std::greater<int>() );
    BOOST_CHECK( p.first == 42 && p.second == 23 );
    p = etude::minmax( 42, 23, std::greater<int>() );
    BOOST_CHECK( p.first == 42 && p.second == 23 );
  }

  return 0;
}