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

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

// The purpose of this test to make sure that the concept_assert macro will
// actually assert the filter calls based on the concepts.

using namespace origin;

template <typename Model>
void print_model_result() {
/*
    std::cout << typestr<Model>() << "::result_type <=> "
              << typestr<typename Model::traits::result_type>() << "\n";
*/
}

template <
    typename T,
    typename = typename concept_assert<PolymorphicClass<T>>::type>
void test_polymorphic_class() { }

template <
    typename T, typename U,
    typename = typename concept_assert<SameType<T, U>>::type>
void test_same_type() { }

template <typename T>
void test_lvalue_reference(typename concept_assert<LvalueReference<T>>::type* = 0)
{ }

template <typename T>
void test_rvalue_reference(typename concept_assert<RvalueReference<T>>::type* = 0)
{ }

template <typename T>
void test_has_destructor(typename concept_assert<HasDestructor<T>>::type* = 0)
{ }

template <typename T>
void test_has_virtual_destructor(typename concept_assert<HasVirtualDestructor<T>>::type* = 0)
{ }

template <typename T, typename... Args>
void test_has_constructor(typename concept_assert<HasConstructor<T, Args...>>::type* = 0)
{ }

template <typename T>
void test_default_constructible(typename concept_assert<DefaultConstructible<T>>::type* = 0)
{ }

template <typename T>
void test_move_constructible(typename concept_assert<MoveConstructible<T>>::type* = 0)
{ }

template <typename T>
void test_copy_constructible(typename concept_assert<CopyConstructible<T>>::type* = 0)
{ }

template <typename T>
void test_trivially_destructible(typename concept_assert<TriviallyDestructible<T>>::type* = 0)
{ }

template <typename T>
void test_trivially_default_constructible(typename concept_assert<TriviallyDefaultConstructible<T>>::type* = 0)
{ }

template <typename T>
void test_trivially_copy_constructible(typename concept_assert<TriviallyCopyConstructible<T>>::type* = 0)
{ }

template <typename T>
void test_move_assignable(typename concept_assert<MoveAssignable<T>>::type* = 0)
{ print_model_result<MoveAssignable<T>>(); }

template <typename T>
void test_copy_assignable(typename concept_assert<CopyAssignable<T>>::type* = 0)
{ print_model_result<CopyAssignable<T>>(); }

template <typename T>
void test_trivially_copy_assignable(typename concept_assert<TriviallyCopyAssignable<T>>::type* = 0)
{ print_model_result<TriviallyCopyAssignable<T>>(); }

template <typename T, typename U>
void test_has_swap(typename concept_assert<HasSwap<T, U>>::type* = 0)
{ }

template <typename T>
void test_swappable(typename concept_assert<Swappable<T>>::type* = 0)
{ }

template <typename T, typename U>
void test_explicitly_convertible(typename concept_assert<ExplicitlyConvertible<T, U>>::type* = 0)
{ }

template <typename T, typename U>
void test_convertible(typename concept_assert<Convertible<T, U>>::type* = 0)
{ }

template <typename T, typename U>
void test_has_equal_to(typename concept_assert<HasEqualTo<T, U>>::type* = 0)
{ print_model_result<HasEqualTo<T,U>>(); }

template <typename T, typename U>
void test_has_less(typename concept_assert<HasLess<T, U>>::type* = 0)
{ print_model_result<HasLess<T,U>>(); }

template <typename T>
void test_has_dereference(typename concept_assert<HasDereference<T>>::type* = 0)
{ print_model_result<HasDereference<T>>(); }

template <typename T>
void test_has_address_of(typename concept_assert<HasAddressOf<T>>::type* = 0)
{ print_model_result<HasAddressOf<T>>(); }

template <typename T, typename U>
void test_has_subscript(typename concept_assert<HasSubscript<T,U>>::type* = 0)
{ print_model_result<HasSubscript<T,U>>(); }

template <
    typename F,
    typename = typename concept_assert<Callable<F, int, int>>::type>
void test_callable(F func)
{ print_model_result<Callable<F, int, int>>(); }

template <
    typename P,
    typename = typename concept_assert<Predicate<P, int, int>>::type>
void test_predicate(P func)
{ print_model_result<Predicate<P, int, int>>(); }

template <
    typename T,
    typename = typename concept_assert<LessThanComparable<T>>::type>
void test_less_than_comparable()
{ }

template <
    typename T,
    typename = typename concept_assert<EqualityComparable<T>>::type>
void test_equality_comparable()
{ }

template <
    typename T,
    typename = typename concept_assert<FreeStoreAllocatable<T>>::type>
void test_free_store_allocatable()
{ }

template <
    typename T,
    typename = typename concept_assert<Semiregular<T>>::type>
void test_semiregular()
{ }

template <
    typename T,
    typename = typename concept_assert<Regular<T>>::type>
void test_regular()
{ }



struct Trivial { };

struct SemiReg {
    SemiReg() { }
    SemiReg(SemiReg&&) { }
    SemiReg(SemiReg const&) { }
    ~SemiReg() { }
};

struct OstreamRef {
    OstreamRef(std::ostream&) { }
};

struct DeletedTors {
    DeletedTors() = delete;
    DeletedTors(DeletedTors&&) = delete;
    DeletedTors(DeletedTors const&) = delete;
    ~DeletedTors() = delete;
};
class PrivateTors {
    PrivateTors() { }
    PrivateTors(PrivateTors&&) { }
    PrivateTors(PrivateTors const&) { }
    ~PrivateTors() { }
};

struct Poly {
    virtual ~Poly() { }
};

// NOTE: This is currently excluded because the functional component isn't
// actually IN the core libraries.
// NOTE: We MUST derive from functors, otherwise, we can't find the member
// operator - or we could simply assume that it's true.
/*
struct Call : binary_function<int, int, int> {
    int operator()(int, int) { return 0; }
};
*/

struct AnonCall {
    int operator()(int, int) { return 0; }
};

void call(int, int) { }

/*
struct Pred : binary_function<int, int, bool> {
    bool operator()(int, int) { return false; }
};
*/

struct AnonPred {
    bool operator()(int, int) { return false; }
};

bool pred(int, int) { return false; }


template <typename T, typename U>
struct foo {
    static size_t const value = sizeof(T() + U());
};

int main() {
    using std::cout;

    test_lvalue_reference<int&>();
    test_rvalue_reference<int&&>();
    // test_rvalue_reference<int&>(); // OK

    test_polymorphic_class<Poly>();
    // test_polymorphic_class<int>(); // OK

    test_same_type<int, int>();
    // test_same_type<int, int const>(); // OK

    test_has_destructor<int>();
    test_has_destructor<Poly>();
    // test_has_destructor<DeletedTors>(); // OK
    // test_has_destructor<PrivateTors>(); // OK

    test_has_virtual_destructor<Poly>();
    // test_has_virtual_destructor<int>(); // OK

    test_trivially_destructible<int>();
    // test_trivially_destructible<Poly>(); // OK

    test_has_constructor<int>();
    test_has_constructor<int, int>();
    test_has_constructor<int, int const&>();
    test_has_constructor<Trivial>();
    test_has_constructor<Trivial, Trivial const&>();
    test_has_constructor<OstreamRef, std::ostream&>();
    // test_has_constructor<OstreamRef, bool>(); // OK

    test_default_constructible<int>();
    test_default_constructible<Trivial>();
    test_default_constructible<SemiReg>();
    // test_default_constructible<DeletedTors>(); // OK
    // test_default_constructible<PrivateTors>(); // OK

    test_move_constructible<int>();
    test_move_constructible<SemiReg>();
    // test_move_constructible<DeletedTors>(); // OK
    // test_move_constructible<PrivateTors>(); // OK

    test_copy_constructible<int>();
    test_copy_constructible<SemiReg>();
    // test_copy_constructible<DeletedTors>(); // OK
    // test_copy_constructible<PrivateTors>(); // OK

    test_trivially_default_constructible<int>();
    // test_trivially_default_constructible<std::pair<int, int>>(); // OK
    test_trivially_copy_constructible<int>();
    // test_trivially_copy_constructible<std::pair<int, int>>(); // OK

    test_explicitly_convertible<int*, char*>();
    // test_explicitly_convertible<int, Trivial>(); OK
    test_convertible<int*, int const*>();
    // test_convertible<Trivial, int>(); OK
    // test_convertible<int*, char*>(); OK

    test_move_assignable<int>();
    test_copy_assignable<int>();
    test_trivially_copy_assignable<int>();
    // test_trivially_copy_assignable<std::pair<int, int>>(); OK

    // NOTE: There is no explicit swap for builtin types unless we enable the
    // std::swap algorithm.
    // test_has_swap<int, int>();
    // test_has_swap<int, double>(); // Yup, this actually works...
    // test_swappable<int>();
    test_swappable<std::string>(); // OK

    test_has_equal_to<int, int>();
    // test_has_equal_to<Trivial, int>(); // OK

    test_has_less<int, int>();
    // test_has_less<Trivial, int>();

    test_has_dereference<int*>();
    test_has_dereference<int const*>();
    // test_has_dereference<int>();  // OK

    test_has_address_of<int>();
    test_has_address_of<int const>();

    test_has_subscript<int*, size_t>();
    test_has_subscript<int[5], size_t>();
    // test_has_subscript<double, char>(); // OK

    // test_callable(Call());
    test_callable(AnonCall());
    test_callable(call);
    // test_callable(5); // OK

//     test_predicate(Pred());
//     test_predicate(AnonPred());
//     test_predicate(pred);


    test_less_than_comparable<int>();
    // test_less_than_comparable<Trivial>(); // OK
    test_equality_comparable<int>();
    // test_equality_comparable<Trivial>(); OK

    test_free_store_allocatable<int>();

    test_semiregular<int>();
    test_semiregular<Trivial>();
    // test_semiregular<OstreamRef>(); // OK

    test_regular<int>();
    // test_regular<Trivial>(); OK
}