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

using namespace origin;
using namespace eop;
using std::cout;

int root(int x) { return 0; }
bool root2(int x, int y) { return 0; }
bool root3(int x, char c, long z) { return false; }

struct root_func : std::unary_function<bool, int> {
    int operator()(bool) const {
        return 1;
    }
};

struct root2_func : std::binary_function<char, bool, int> {
    int operator()(char, bool) const {
        return 1;
    }
};

// NOTE: All functional concepts are adapted to function pointers, not function
// types. This is to say that we specialize on Result(*)(Args...) rather than
// Result(Args...). The reason for this is that a template accepting a function
// parameter is parameterized by a function pointer. The type of the function
// pointer can be accessed as decltype(*f), generating the non-pointer
// signature.

template <typename F>
void test(F f) {
    cout << "--- " << typestr<F>() << " ---\n";
    cout << "  * arguments: " << typestr<typename arguments<F>::type>() << "\n";
    cout << "  * result: " << typestr<typename result_type<F>::type>() << "\n";
    cout << "Procedure? " << Procedure<F>::check::value << "\n";
    cout << "RegularProcedure? " << RegularProcedure<F>::check::value << "\n";
    cout << "FunctionalProcedure? " << FunctionalProcedure<F>::check::value << "\n";
    cout << "UnaryFunction? " << UnaryFunction<F>::check::value << "\n";
    cout << "BinaryFunction? " << BinaryFunction<F>::check::value << "\n";
    cout << "HomogenousFunction? " << HomogenousFunction<F>::check::value << "\n";
    cout << "Predicate? " << eop::Predicate<F>::check::value << "\n";
    cout << "UnaryPredicate? " << UnaryPredicate<F>::check::value << "\n";
    cout << "BinaryPredicate? " << BinaryPredicate<F>::check::value << "\n";
    cout << "HomogenousPredicate? " << HomogenousPredicate<F>::check::value << "\n";
    cout << "Operation? " << Operation<F>::check::value << "\n";

    cout << "\n";
}

int main() {
    test(root);
    test(root2);
    test(root_func());
    test(root2_func());

    // TODO: Fix ostream?
    // cout << origin::Regular<std::ostream>::check::value << "\n";

    // TODO: Fix regular so that we can check it with void types/
    // cout << origin::Regular<void>::check::value << "\n";

    return 0;
}