// (C) Copyright 2008-2009 SDML (www.sdml.info)
//
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#include <iostream>
#include <vector>
#include <list>
#include <forward_list>
#include <iterator>

#include <origin/utility/typestr.hpp>
#include <origin/iterator/concepts.hpp>

using namespace origin;
using std::cout;

// TODO: Cleverness that nees to exported somewhere useful. This segment
// adapts several STL iterators to the Origin.ForwardIterator concept.
namespace origin {
template <typename Iter, typename Container>
struct ForwardIterator<__gnu_cxx::__normal_iterator<Iter, Container>>
    : Tautology, InputIterator<__gnu_cxx::__normal_iterator<Iter, Container>>
{ ORIGIN_CONCEPT_MAP_IMPL(); };

template <typename T>
struct ForwardIterator<std::_List_iterator<T>>
    : Tautology, InputIterator<std::_List_iterator<T>>
{ ORIGIN_CONCEPT_MAP_IMPL(); };

template <typename T>
struct ForwardIterator<std::_List_const_iterator<T>>
    : Tautology, InputIterator<std::_List_const_iterator<T>>
{ ORIGIN_CONCEPT_MAP_IMPL(); };
} // namespace origin

// NOTE: Printing the type as an argument to a function will cause the type
// string to preserve references.
// TODO: I could actually parse the resulting string to generate the actual
// type. All I would have to do is find everything between the 2nd ( and the
// last ).
struct viz { };
template <typename T>
std::string str() {
    return typestr<viz (T)>();
}

template <
    typename X,
    typename = typename concept_assert<Iterator<X>>::type>
void test_iterator() {
    typedef Iterator<X> Model;
    cout << typestr<Model>() << "\n";
cout << " reference:\t" << str<typename Model::reference>() << "\n";
    cout << " postincr:\t" << str<typename Model::postincrement_result>() << "\n";
}

template <
    typename X,
    typename = typename concept_assert<InputIterator<X>>::type>
void test_input_iterator() {
    typedef InputIterator<X> Model;
    cout << typestr<Model>() << "\n";
    cout << " value:\t\t" << str<typename Model::value_type>() << "\n";
    cout << " reference:\t" << str<typename Model::reference>() << "\n";
    cout << " pointer:\t" << str<typename Model::pointer>() << "\n";
    cout << " difference:\t" << str<typename Model::difference_type>() << "\n";
    cout << " postincr:\t" << str<typename Model::postincrement_result>() << "\n";
}

template <
    typename X,
    typename = typename concept_assert<Iterator<X>>::type>
void test_output_iterator()
{ }

template <
    typename X,
    typename = typename concept_assert<ForwardIterator<X>>::type>
void test_forward_iterator()
{
    typedef ForwardIterator<X> Model;
    cout << typestr<Model>() << "\n";
    cout << " value:\t\t" << str<typename Model::value_type>() << "\n";
    cout << " reference:\t" << str<typename Model::reference>() << "\n";
    cout << " pointer:\t" << str<typename Model::pointer>() << "\n";
    cout << " difference:\t" << str<typename Model::difference_type>() << "\n";
    cout << " postincr:\t" << str<typename Model::postincrement_result>() << "\n";
}

template <
    typename X,
    typename = typename concept_assert<BidirectionalIterator<X>>::type>
void test_bidirectional_iterator() {
    typedef BidirectionalIterator<X> Model;
    cout << typestr<Model>() << "\n";
    cout << " value:\t\t" << str<typename Model::value_type>() << "\n";
    cout << " reference:\t" << str<typename Model::reference>() << "\n";
    cout << " pointer:\t" << str<typename Model::pointer>() << "\n";
    cout << " difference:\t" << str<typename Model::difference_type>() << "\n";
    cout << " postincr:\t" << str<typename Model::postincrement_result>() << "\n";
    cout << " postdecr:\t" << str<typename Model::postdecrement_result>() << "\n";
}

template <
    typename X,
    typename = typename concept_assert<RandomAccessIterator<X>>::type>
void test_random_access_iterator()
{
    typedef RandomAccessIterator<X> Model;
    cout << typestr<Model>() << "\n";
    cout << " value:\t\t" << str<typename Model::value_type>() << "\n";
    cout << " reference:\t" << str<typename Model::reference>() << "\n";
    cout << " pointer:\t" << str<typename Model::pointer>() << "\n";
    cout << " difference:\t" << str<typename Model::difference_type>() << "\n";
    cout << " postincr:\t" << str<typename Model::postincrement_result>() << "\n";
    cout << " postdecr:\t" << str<typename Model::postdecrement_result>() << "\n";
    cout << " subscript:\t" << str<typename Model::subscript_reference>() << "\n";
}

template <
    typename X,
    typename = typename concept_assert<Iterator<X>>::type>
void test_shuffle_iterator()
{ }

void test_concepts() {

    BOOST_ASSERT(( !concept_check< Iterator<int> >::value ));
    BOOST_ASSERT(( concept_check< Iterator<int*> >::value ));
    BOOST_ASSERT(( concept_check< Iterator<int const*> >::value ));
    BOOST_ASSERT(( concept_check< Iterator<std::list<int>::iterator> >::value ));
    BOOST_ASSERT(( concept_check< Iterator<std::list<int>::const_iterator> >::value ));

    test_iterator<int*>();
    test_iterator<int const*>();
    test_iterator<std::list<int>::iterator>();
    test_iterator<std::list<int>::const_iterator>();
//     test_iterator<int>(); // OK

    test_input_iterator<int*>();
    test_input_iterator<int const*>();
    test_input_iterator<std::list<int>::iterator>();
    test_input_iterator<std::list<int>::const_iterator>();

    test_forward_iterator<int*>();
    test_forward_iterator<std::list<int>::iterator>();

    BOOST_ASSERT(( concept_check< BidirectionalIterator<int*> >::value ));
    BOOST_ASSERT(( concept_check< BidirectionalIterator<int const*> >::value ));
    BOOST_ASSERT(( concept_check< BidirectionalIterator<std::list<int>::iterator> >::value ));
    BOOST_ASSERT(( concept_check< BidirectionalIterator<std::list<int>::const_iterator> >::value ));
    BOOST_ASSERT(( !concept_check< BidirectionalIterator<std::forward_list<int>::iterator> >::value ));

    test_bidirectional_iterator<int*>();
    test_bidirectional_iterator<std::list<int>::iterator>();
//     test_bidirectional_iterator<std::forward_list<int>::iterator>(); // OK

    BOOST_ASSERT(( concept_check< RandomAccessIterator<int*> >::value ));
    BOOST_ASSERT(( concept_check< RandomAccessIterator<int const*> >::value ));
    BOOST_ASSERT(( concept_check< RandomAccessIterator<std::vector<int>::iterator> >::value ));
    BOOST_ASSERT(( concept_check< RandomAccessIterator<std::vector<int>::const_iterator> >::value ));
    BOOST_ASSERT(( !concept_check< RandomAccessIterator<std::list<int>::iterator> >::value ));

    test_random_access_iterator<int*>();
    test_random_access_iterator<std::vector<int>::iterator>();
//     test_random_access_iterator<std::list<int>::iterator>(); // OK

    BOOST_ASSERT(( concept_check< OutputIterator<int*, int> >::value ));
    BOOST_ASSERT(( !concept_check< OutputIterator<int const*, int> >::value ));
}

int main() {
    test_concepts();

    return 0;
}