// Copyright (c) 2017 Levon Tarakchyan
//
// Distributed under 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 "boost/config.hpp"

#include "boost/core/lightweight_test.hpp"
#include "boost/variant.hpp"
#include "boost/variant/apply_visitor.hpp"
#include "boost/variant/multivisitors.hpp"
#include "boost/lexical_cast.hpp"

#define lcs(val) boost::lexical_cast<std::string>(val)

struct construction_logger
{
    int val_;

    construction_logger(int val) : val_(val)
    {
        std::cout << val_ << " constructed\n";
    }

    construction_logger(const construction_logger& cl) :
        val_(cl.val_)
    {
        std::cout << val_ << " copy constructed\n";
    }

#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
    construction_logger(construction_logger&& cl) :
        val_(cl.val_)
    {
        std::cout << val_ << " move constructed\n";
    }
#endif

    friend std::ostream& operator << (std::ostream& os, const construction_logger& cl)
    {
        return os << cl.val_;
    }

    friend std::istream& operator << (std::istream& is, construction_logger& cl)
    {
        return is >> cl.val_;
    }
};

struct lex_streamer_explicit : boost::static_visitor<std::string>
{
    template <class T>
    std::string operator()(const T& val) const
    {
        return lcs(val);
    }

    template <class T, class V>
    std::string operator()(const T& val, const V& val2) const
    {
        return lcs(val) + '+' + lcs(val2);
    }

    template <class T, class V, class P, class S>
    std::string operator()(const T& val, const V& val2, const P& val3, const S& val4) const
    {
        return lcs(val) + '+' + lcs(val2) + '+' + lcs(val3) + '+' + lcs(val4);
    }
};

struct lvalue_rvalue_detector : boost::static_visitor<std::string>
{
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
    template <class T>
    std::string operator()(T&&) const
    {
        return std::is_lvalue_reference<T>::value ? "lvalue reference"
                                                  : "rvalue reference";
    }

    template <class T, class V>
    std::string operator()(T&& t, V&& v) const
    {
        return operator()(std::forward<T>(t)) + ", " + operator()(std::forward<V>(v));
    }

    template <class T, class V, class P>
    std::string operator()(T&& t, V&& v, P&& p) const
    {
        return operator()(std::forward<T>(t), std::forward<V>(v)) + ", " + operator()(std::forward<P>(p));
    }

    template <class T, class V, class P, class S>
    std::string operator()(T&& t, V&& v, P&& p, S&& s) const
    {
        return operator()(std::forward<T>(t), std::forward<V>(v), std::forward<P>(p)) + ", " + operator()(std::forward<S>(s));
    }
#else
    template <class T>
    std::string operator()(T&) const
    {
        return "lvalue reference";
    }

    template <class T, class V>
    std::string operator()(T&, V&) const
    {
        return "lvalue reference, lvalue reference";
    }

    template <class T, class V, class P>
    std::string operator()(T&, V&, P&) const
    {
        return "lvalue reference, lvalue reference, lvalue reference";
    }

    template <class T, class V, class P, class S>
    std::string operator()(T&, V&, P&, S&) const
    {
        return "lvalue reference, lvalue reference, lvalue reference, lvalue reference";
    }
#endif
};

typedef boost::variant<construction_logger, std::string> variant_type;

void test_const_ref_parameter(const variant_type& test_var)
{
    std::cout << "Testing const lvalue reference visitable\n";

    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), test_var) == "lvalue reference");
}

void test_const_ref_parameter2(const variant_type& test_var, const variant_type& test_var2)
{
    std::cout << "Testing const lvalue reference visitable\n";

    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), test_var, test_var2) == "lvalue reference, lvalue reference");
}

void test_const_ref_parameter4(const variant_type& test_var, const variant_type& test_var2, const variant_type& test_var3, const variant_type& test_var4)
{
    std::cout << "Testing const lvalue reference visitable with multivisitor\n";

    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), test_var, test_var2, test_var3, test_var4)
            == "lvalue reference, lvalue reference, lvalue reference, lvalue reference");
}

#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_REF_QUALIFIERS)

void test_rvalue_parameter(variant_type&& test_var)
{
    std::cout << "Testing rvalue visitable\n";

    const auto expected_val = lcs(test_var);
    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), std::move(test_var)) == "rvalue reference");
}

void test_rvalue_parameter2(variant_type&& test_var, variant_type&& test_var2)
{
    std::cout << "Testing rvalue visitable\n";

    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), std::move(test_var), std::move(test_var2)) == "rvalue reference, rvalue reference");
}

void test_rvalue_parameter4(variant_type&& test_var, variant_type&& test_var2, variant_type&& test_var3, variant_type&& test_var4)
{
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
    std::cout << "Testing rvalue visitable with multivisitor\n";

    auto result = boost::apply_visitor(lvalue_rvalue_detector(), std::move(test_var), std::move(test_var2), std::move(test_var3), std::move(test_var4));
    std::cout << "result: " << result << std::endl;
    BOOST_TEST(result == "rvalue reference, rvalue reference, rvalue reference, rvalue reference");
#else
    (void)test_var;
    (void)test_var2;
    (void)test_var3;
    (void)test_var4;
#endif
}

#endif

#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO

#define FORWARD(x) std::forward<decltype(x)>(x)

void test_cpp14_visitor(const variant_type& test_var)
{
    std::cout << "Testing const lvalue visitable for c++14\n";

    BOOST_TEST(boost::apply_visitor([](auto&& v) { return lvalue_rvalue_detector()(FORWARD(v)); }, test_var) == "lvalue reference");
}

void test_cpp14_mutable_visitor(const variant_type& test_var)
{
    std::cout << "Testing const lvalue visitable for c++14 with inline mutable lambda\n";

    BOOST_TEST(boost::apply_visitor([](auto&& v) mutable -> auto { return lvalue_rvalue_detector()(FORWARD(v)); }, test_var) == "lvalue reference");
}

void test_cpp14_visitor(const variant_type& test_var, const variant_type& test_var2)
{
    std::cout << "Testing const lvalue visitable for c++14\n";

    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& vv) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(vv)); }, test_var, test_var2)
            == "lvalue reference, lvalue reference");
}

void test_cpp14_visitor(const variant_type& test_var, const variant_type& test_var2, const variant_type& test_var3)
{
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
    std::cout << "Testing const lvalue visitable for c++14\n";

    auto result = boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
                test_var, test_var2, test_var3);
    std::cout << "result: " << result << std::endl;
    BOOST_TEST(result == "lvalue reference, lvalue reference, lvalue reference");
#else
    (void)test_var;
    (void)test_var2;
    (void)test_var3;
#endif
}

void test_cpp14_visitor(variant_type& test_var)
{
    std::cout << "Testing lvalue visitable for c++14\n";

    BOOST_TEST(boost::apply_visitor([](auto& v) { return lvalue_rvalue_detector()(v); }, test_var) == "lvalue reference");
}

void test_cpp14_mutable_visitor(variant_type& test_var)
{
    std::cout << "Testing lvalue visitable for c++14 with inline mutable lambda\n";

    BOOST_TEST(boost::apply_visitor([](auto& v) mutable -> auto { return lvalue_rvalue_detector()(v); }, test_var) == "lvalue reference");
}

void test_cpp14_visitor(variant_type& test_var, variant_type& test_var2)
{
    std::cout << "Testing lvalue visitable for c++14\n";

    BOOST_TEST(boost::apply_visitor([](auto& v, auto& vv) { return lvalue_rvalue_detector()(v, vv); }, test_var, test_var2)
            == "lvalue reference, lvalue reference");
}

void test_cpp14_visitor(variant_type& test_var, variant_type& test_var2, variant_type& test_var3)
{
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
    std::cout << "Testing lvalue visitable for c++14\n";

    auto result = boost::apply_visitor([](auto& v, auto& t, auto& p) { return lvalue_rvalue_detector()(v, t, p); },
                test_var, test_var2, test_var3);
    std::cout << "result: " << result << std::endl;
    BOOST_TEST(result == "lvalue reference, lvalue reference, lvalue reference");
#else
    (void)test_var;
    (void)test_var2;
    (void)test_var3;
#endif
}

void test_cpp14_visitor(variant_type&& test_var)
{
    std::cout << "Testing rvalue visitable for c++14\n";

    BOOST_TEST(boost::apply_visitor([](auto&& v) { return lvalue_rvalue_detector()(FORWARD(v)); }, std::move(test_var)) == "rvalue reference");
}

void test_cpp14_visitor(variant_type&& test_var, variant_type&& test_var2)
{
    std::cout << "Testing rvalue visitable for c++14\n";

    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& vv) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(vv)); }, std::move(test_var), std::move(test_var2))
            == "rvalue reference, rvalue reference");
}

void test_cpp14_visitor(variant_type&& test_var, variant_type&& test_var2, variant_type&& test_var3)
{
#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
    std::cout << "Testing rvalue visitable for c++14\n";

    auto result = boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
                std::move(test_var), std::move(test_var2), std::move(test_var3));
    std::cout << "result: " << result << std::endl;
    BOOST_TEST(result == "rvalue reference, rvalue reference, rvalue reference");
#else
    (void)test_var;
    (void)test_var2;
    (void)test_var3;
#endif
}

#endif

void run_const_lvalue_ref_tests()
{
    const variant_type v1(1), v2(2), v3(3), v4(4);
    test_const_ref_parameter(v1);
    test_const_ref_parameter2(v1, v2);
    test_const_ref_parameter4(v1, v2, v3, v4);
}

void run_rvalue_ref_tests()
{
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
    variant_type v1(10), v2(20), v3(30);
    test_rvalue_parameter(boost::move(v1));
    test_rvalue_parameter2(boost::move(v2), boost::move(v3));

    variant_type vv1(100), vv2(200), vv3(300), vv4(400);
    test_rvalue_parameter4(boost::move(vv1), boost::move(vv2), boost::move(vv3), boost::move(vv4));
#endif
}

void run_mixed_tests()
{
    variant_type v1(1), v2(2);

#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
    std::cout << "Testing lvalue + rvalue visitable\n";
    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, variant_type(10)) == "lvalue reference, rvalue reference");

    std::cout << "Testing rvalue + lvalue visitable\n";
    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), variant_type(10), v1) == "rvalue reference, lvalue reference");

#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
    std::cout << "Testing rvalue + lvalue + rvalue visitable\n";
    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), variant_type(10), v1, variant_type(20)) == "rvalue reference, lvalue reference, rvalue reference");

    std::cout << "Testing lvalue + rvalue + lvalue + rvalue visitable\n";
    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, variant_type(10), v2, variant_type(20)) == "lvalue reference, rvalue reference, lvalue reference, rvalue reference");
#endif

#endif // #ifndef BOOST_NO_CXX11_REF_QUALIFIERS

#else // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
    std::cout << "Testing lvalue + rvalue visitable\n";
    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, v1) == "lvalue reference, lvalue reference");

    std::cout << "Testing rvalue + lvalue visitable\n";
    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), static_cast<const variant_type&>(variant_type(10)), v1) == "lvalue reference, lvalue reference");

#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
    std::cout << "Testing rvalue + lvalue + rvalue visitable\n";
    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), static_cast<const variant_type&>(variant_type(10)), v1, static_cast<const variant_type&>(variant_type(20))) == "lvalue reference, lvalue reference, lvalue reference");

    std::cout << "Testing lvalue + rvalue + lvalue + rvalue visitable\n";
    BOOST_TEST(boost::apply_visitor(lvalue_rvalue_detector(), v1, static_cast<const variant_type&>(variant_type(10)), v2, static_cast<const variant_type&>(variant_type(20))) == "lvalue reference, lvalue reference, lvalue reference, lvalue reference");
#endif
#endif
}

void run_cpp14_mixed_tests()
{
#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
    variant_type v1(1), v2(2);

    std::cout << "Testing lvalue + rvalue visitable\n";
    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t)); },
                v1, variant_type(10)) == "lvalue reference, rvalue reference");

    std::cout << "Testing rvalue + lvalue visitable\n";
    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t)); },
                variant_type(10), v1) == "rvalue reference, lvalue reference");

#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
    std::cout << "Testing rvalue + lvalue + lvalue visitable\n";
    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
                variant_type(10), v1, v2) == "rvalue reference, lvalue reference, lvalue reference");

    std::cout << "Testing lvalue + rvalue + lvalue visitable\n";
    BOOST_TEST(boost::apply_visitor([](auto&& v, auto&& t, auto&& p) { return lvalue_rvalue_detector()(FORWARD(v), FORWARD(t), FORWARD(p)); },
                v1, variant_type(10), v2) == "lvalue reference, rvalue reference, lvalue reference");
#endif
#endif
}

void run_cpp14_tests()
{
#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
    variant_type const c1(10), c2(20), c3(30);
    variant_type v1(10), v2(20), v3(30);

    test_cpp14_visitor(c1);
    test_cpp14_mutable_visitor(c1);
    test_cpp14_visitor(c2, c3);
    test_cpp14_visitor(c1, c2, c3);

    test_cpp14_visitor(v1);
    test_cpp14_mutable_visitor(v1);
    test_cpp14_visitor(v2, v3);
    test_cpp14_visitor(v1, v2, v3);

    test_cpp14_visitor(boost::move(v1));
    test_cpp14_visitor(boost::move(v2), boost::move(v3));

    variant_type vv1(100), vv2(200), vv3(300);
    test_cpp14_visitor(boost::move(vv1), boost::move(vv2), boost::move(vv3));
#endif
}



int main()
{
    run_const_lvalue_ref_tests();
    run_rvalue_ref_tests();
    run_mixed_tests();
    run_cpp14_mixed_tests();
    run_cpp14_tests();

    return boost::report_errors();
}