//
// immer: immutable data structures for C++
// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente
//
// This software is distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt
//

#include <immer/algorithm.hpp>
#include <immer/box.hpp>
#include <immer/flex_vector.hpp>
#include <immer/map.hpp>
#include <immer/set.hpp>
#include <immer/vector.hpp>

#include <boost/optional.hpp>
#include <boost/variant.hpp>

#include <catch2/catch_test_macros.hpp>

struct rec_vec
{
    int data;
    immer::vector<immer::box<rec_vec>> children;
};

TEST_CASE("recursive vector")
{
    auto v1 = rec_vec{42,
                      {rec_vec{12, {}},
                       rec_vec{13, {rec_vec{5, {}}, rec_vec{7, {}}}},
                       rec_vec{15, {}}}};
    CHECK(v1.data == 42);
    CHECK(v1.children[0]->data == 12);
    CHECK(v1.children[1]->children[0]->data == 5);
}

struct rec_fvec
{
    int data;
    immer::flex_vector<immer::box<rec_fvec>> children;
};

TEST_CASE("recursive flex_vector")
{
    auto v1 = rec_fvec{42,
                       {rec_fvec{12, {}},
                        rec_fvec{13, {rec_fvec{5, {}}, rec_fvec{7, {}}}},
                        rec_fvec{15, {}}}};
    CHECK(v1.data == 42);
    CHECK(v1.children[0]->data == 12);
    CHECK(v1.children[1]->children[0]->data == 5);
}

struct rec_map
{
    int data;
    immer::map<std::string, immer::box<rec_map>> children;
};

TEST_CASE("recursive map")
{
    auto v1 = rec_map{42, {}};
    auto v2 = rec_map{43, v1.children.set("hello", rec_map{12, {}})};
    auto v3 = rec_map{44, v2.children.set("world", rec_map{13, {}})};

    CHECK(v3.data == 44);
    CHECK(v3.children["hello"]->data == 12);
    CHECK(v3.children["world"]->data == 13);
}

struct rec_set
{
    int data;
    immer::set<immer::box<rec_set>> children;

    bool operator==(const rec_set& other) const
    {
        return data == other.data && children == other.children;
    }
    bool operator!=(const rec_set& other) const { return !(*this == other); }
};

namespace std {

template <>
struct hash<rec_set>
{
    auto operator()(const rec_set& s)
    {
        return std::hash<decltype(s.data)>{}(s.data) ^
               immer::accumulate(
                   s.children, std::size_t{}, [](auto ac, auto v) {
                       return std::hash<decltype(v)>{}(v);
                   });
    }
};

} // namespace std

TEST_CASE("recursive set")
{
    auto v1 = rec_set{42, {}};
    auto v2 = rec_set{43, v1.children.insert(rec_set{12, {}})};
    auto v3 = rec_set{44, v2.children.insert(rec_set{13, {}})};

    CHECK(v3.data == 44);
    CHECK(v3.children.count(rec_set{12, {}}) == 1);
    CHECK(v3.children.count(rec_set{13, {}}) == 1);
    CHECK(v3.children.count(rec_set{14, {}}) == 0);
}

namespace example1 {

struct a_type;

struct b_type
{
    b_type(int a, immer::box<a_type> val);
    int a;
    immer::box<a_type> val;
};

struct a_type
{
    a_type();
    // this does not work with std::optional, because it seems like
    // `immer::box<b_type>` is still not considered complete at this point...
    boost::optional<immer::box<b_type>> b;
};

b_type::b_type(int a, immer::box<a_type> val)
    : a(a)
    , val(val)
{
}

a_type::a_type()
    : b{}
{
}

} // namespace example1

TEST_CASE("recursive optional")
{
    auto x = example1::a_type{};
    auto y = example1::b_type{42, x};
    CHECK(y.a == 42);
}

namespace example2 {

struct empty_t
{};

struct a_type;

struct b_type
{
    b_type(int a, immer::box<a_type> val);
    int a;
    immer::box<a_type> val;
};

struct a_type
{
    a_type();
    // this does not work with std::variant, because it seems like
    // `immer::box<b_type>` is still not considered complete at this point...
    boost::variant<empty_t, b_type> b;
};

b_type::b_type(int a, immer::box<a_type> val)
    : a(a)
    , val(val)
{
}

a_type::a_type()
    : b{}
{
}

} // namespace example2

TEST_CASE("recursive variant")
{
    auto x = example2::a_type{};
    auto y = example2::b_type{42, x};
    CHECK(y.a == 42);
}
