// (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 <tuple>

#include <boost/assert.hpp>

#include <origin/utility/typestr.hpp>
#include <origin/meta/logic.hpp>
#include <origin/traits.hpp>

using std::cout;
using namespace origin;

template <typename T> struct viz { };
template <typename T> std::string vizstr()
{ return typestr<viz<T>>(); }

struct foo { };

struct foo2 {
    foo2& operator=(foo2&& x) = delete;
    foo2& operator=(foo2 const& x) = delete;
};

struct bar { };
bool operator<(bar const&, bar const&);

struct Abs {
    virtual void foo() = 0;
};

struct CallMe {
    int* operator()() { cout << "()\n"; return 0; }
    int const* operator()() const { cout << "() const\n"; return 0; }
    void operator()(int) { cout << "(int)\n"; }
    char operator()(std::string, std::string) { return 0;};
    void operator()(std::string&) { }
};

struct Ctorable {
    Ctorable(int) { }
    Ctorable(int, char&) { }
    Ctorable(int, char&, float) { }
};

int main()
{
    // Classification
    BOOST_ASSERT(( is_variable<int>::value ));
    BOOST_ASSERT(( is_variable<int*>::value ));
    BOOST_ASSERT(( is_variable<int&>::value ));
    BOOST_ASSERT(( is_variable<int&&>::value ));
    BOOST_ASSERT(( is_variable<int const&>::value ));
    BOOST_ASSERT(( !is_variable<Abs>::value ));

    // Ctor/Dtor
    BOOST_ASSERT(( has_default_constructor<int>::value ));
    BOOST_ASSERT(( has_move_constructor<int>::value ));
    BOOST_ASSERT(( has_copy_constructor<int>::value ));
    BOOST_ASSERT(( !has_constructor<double, std::string>::value ));

    BOOST_ASSERT(( has_constructor<std::string>::value ));
    BOOST_ASSERT(( has_default_constructor<std::string>::value ));
    BOOST_ASSERT(( has_copy_constructor<std::string>::value ));
    BOOST_ASSERT(( has_constructor<std::string, std::string const&, size_t, size_t>::value ));

    BOOST_ASSERT(( has_constructor<Ctorable, int>::value ));
    BOOST_ASSERT(( has_constructor<Ctorable, int, char>::value ));
    BOOST_ASSERT(( has_constructor<Ctorable, int, char&, float>::value ));

    // Assignment
    BOOST_ASSERT(( has_assign<int, int>::value ));
    BOOST_ASSERT(( has_assign<foo, foo>::value ));
    BOOST_ASSERT(( !has_assign<foo, int>::value ));
    BOOST_ASSERT(( !has_assign<int, foo>::value ));
    BOOST_ASSERT(( has_move_assign<int>::value ));
    BOOST_ASSERT(( has_copy_assign<int>::value ));
    BOOST_ASSERT(( has_move_assign<foo>::value ));
    BOOST_ASSERT(( has_copy_assign<foo>::value ));
    BOOST_ASSERT(( !has_move_assign<foo2>::value ));
    BOOST_ASSERT(( !has_copy_assign<foo2>::value ));

    // Comparison operators
    BOOST_ASSERT(( has_equal_to<int, int>::value ));
    BOOST_ASSERT(( has_not_equal_to<int, int>::value ));
    BOOST_ASSERT(( has_less<int, int>::value ));
    BOOST_ASSERT(( has_greater<int, int>::value ));
    BOOST_ASSERT(( has_less_equal<int, int>::value ));
    BOOST_ASSERT(( has_greater_equal<int, int>::value ));

    BOOST_ASSERT(( !has_equal_to<foo, foo>::value ));
    BOOST_ASSERT(( !has_not_equal_to<foo, foo>::value ));
    BOOST_ASSERT(( !has_less<foo, foo>::value ));
    BOOST_ASSERT(( !has_greater<foo, foo>::value ));
    BOOST_ASSERT(( !has_less_equal<foo, foo>::value ));
    BOOST_ASSERT(( !has_greater_equal<foo, foo>::value ));

    BOOST_ASSERT(( has_less<bar, bar>::value ));
    BOOST_ASSERT(( !has_less<bar, int>::value ));

    BOOST_ASSERT(( has_preincrement<int*>::value ));
    BOOST_ASSERT(( has_preincrement< std::vector<int>::iterator >::value ));

    // Misc.
    BOOST_ASSERT(( !has_dereference<int>::value ));
    BOOST_ASSERT(( has_dereference<int*>::value ));
    BOOST_ASSERT(( has_dereference<std::list<int>::iterator>::value ));


    // Call Traits - Result
    BOOST_ASSERT(( std::is_same<call_result<CallMe>::type, int*>::value ));
    BOOST_ASSERT(( std::is_same<call_result<const CallMe>::type, int const*>::value ));

    // Call Traits - Callable
    BOOST_ASSERT(( is_callable<void(*)(int), int>::value ));
    BOOST_ASSERT(( is_callable<void(*)(int), float>::value ));
    BOOST_ASSERT(( !is_callable<void(*)(int), std::string>::value ));

    BOOST_ASSERT(( is_callable<bool(*)(int), int>::value ));
    BOOST_ASSERT(( is_callable<bool(*)(int&), int&>::value ));
    // BOOST_ASSERT(( is_callable<bool(*)(int&), int const&>::value )); // Compilation failure
    BOOST_ASSERT(( is_callable<bool(*)(int const&), int const>::value ));
    BOOST_ASSERT(( is_callable<bool(*)(int const&), int&>::value ));
    BOOST_ASSERT(( is_callable<bool(*)(int const&), int const&>::value ));
    BOOST_ASSERT(( is_callable<bool(*)(int const&), int>::value ));
    BOOST_ASSERT(( is_callable<bool(*)(int&), int>::value )); // Should fail?

    BOOST_ASSERT(( !is_callable<int>::value ));
    BOOST_ASSERT(( is_callable<CallMe>::value ));
    BOOST_ASSERT(( is_callable<CallMe, int&>::value ));
    BOOST_ASSERT(( !is_callable<CallMe, int&, int>::value ));
    BOOST_ASSERT(( is_callable<CallMe, std::string, std::string>::value ));
    // BOOST_ASSERT(( !is_callable<CallMe, std::string>::value )); // string->string& conversion?
    BOOST_ASSERT(( is_callable<CallMe, std::string&>::value ));

    // TODO: More traits assertions. Lot's more assertions.
}