// Eggs.Invoke
//
// Copyright Agustin K-ballo Berge, Fusion Fenix 2020
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <eggs/invoke.hpp>

#include <iostream>
#include <string>
#include <utility>
#include <vector>

/// identity function
struct identity
{
    template <typename T>
    constexpr T&& operator()(T&& t) const noexcept
    {
        return std::forward<T>(t);
    }
};

/// algorithm that prints to `std::cout` the projection of those elements in
/// the range [iter, sentinel) that satisfy a given predicate
template <typename Iter, typename Sentinel, typename Pred, typename Proj = identity>
void print_if(Iter iter, Sentinel sentinel, Pred const& pred, Proj const& proj = {})
{
    /// Check that `INVOKE(pred, *iter)` is well-formed,
    static_assert(eggs::is_invocable<Pred const&, decltype(*iter)>::value,
        "Predicate shall accept the iterator's value type as its only argument");

    /// and that it returns something convertible to `bool`;
    static_assert(std::is_convertible<
        eggs::invoke_result_t<Pred const&, decltype(*iter)>, bool>::value,
        "Predicate return type shall be convertible to bool");

    /// ...or check both requirements at once:
    /// Check that `INVOKE<bool>(pred, *iter)` is well-formed.
    static_assert(eggs::is_invocable_r<bool, Pred const&, decltype(*iter)>::value,
        "Predicate shall accept the iterator's value type as its only argument, "
        "and its return type shall be convertible to bool");

    /// Also check that `INVOKE(proj, *iter)` is well-formed,
    static_assert(eggs::is_invocable<Proj const&, decltype(*iter)>::value,
        "Projection shall accept the iterator's value type as its only argument");

#if __cpp_generic_lambdas
    /// and that it returns something "printable" to `std::cout`.
    auto printable = [](auto const& v) -> decltype((void)(std::cout << v)) {};
    static_assert(eggs::is_invocable<decltype(printable),
        eggs::invoke_result_t<Proj const&, decltype(*iter)>>::value,
        "Projection return type shall be printable to std::cout");
#endif

    for (; iter != sentinel; ++iter)
    {
        if (eggs::invoke(pred, *iter)) // or eggs::invoke_r<bool>(pred, *iter)
            std::cout << eggs::invoke(proj, *iter) << '\n';
    }
}

/// user definition
struct User
{
    std::string name;

    bool is_superuser;

    constexpr bool is_regular_user() const noexcept { return !is_superuser; }

    friend std::ostream& operator<<(std::ostream& out, User const& user)
    {
        return out << '('
            << "name: " << user.name
            << ", is_superuser: " << user.is_superuser
            << ')';
    }
};

/// table of users
std::vector<User> const users = {
    { "Alice", true },
    { "Bob", false },
    { "Charlie", false }
};

int main()
{
    /// print all users
    ///
    /// `eggs::invoke(<lambda>, user)` is equivalent to `<lambda>(user)`.
    std::cout << "Users:\n";
    print_if(users.begin(), users.end(), [](User const&) { return true; });
    std::cout << '\n';

    /// print the names of superusers
    ///
    /// `eggs::invoke(&User::is_superuser, user)` is equivalent to
    /// `user.is_superuser` or `user->is_superuser`.
    std::cout << "Superusers:\n";
    print_if(users.begin(), users.end(), &User::is_superuser, &User::name);
    std::cout << '\n';

    /// print the names of regular users
    ///
    /// `eggs::invoke(&User::is_regular_user, user)` is equivalent to
    /// `user.is_regular_user()` or `user->is_regular_user()`.
    std::cout << "Regular users:\n";
    print_if(users.begin(), users.end(), &User::is_regular_user, &User::name);
    std::cout << '\n';

    return 0;
}