//
// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
//
// 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)
//
// Official repository: https://github.com/boostorg/json
//

// Test that header file is self-contained.
#include <boost/json/value_ref.hpp>

#include <boost/json/value.hpp>
#include <boost/json/serialize.hpp>

#include "test_suite.hpp"

BOOST_JSON_NS_BEGIN

//----------------------------------------------------------

// From the javadoc

    class my_type
    {
        json::value jv_;

    public:
        my_type( std::initializer_list< json::value_ref > init )
            : jv_(init)
        {
        }
    };

//----------------------------------------------------------

class value_ref_test
{
public:
    using init_list =
        std::initializer_list<value_ref>;

    void
    testCtors()
    {
        // scalars
        (void)value_ref((signed char)1);
        (void)value_ref((short)1);
        (void)value_ref((int)1);
        (void)value_ref((long)1);
        (void)value_ref((long long)1);
        (void)value_ref((unsigned char)1);
        (void)value_ref((unsigned short)1);
        (void)value_ref((unsigned int)1);
        (void)value_ref((unsigned long)1);
        (void)value_ref((unsigned long long)1);
        (void)value_ref((float)1.);
        (void)value_ref((double)1.);
        (void)value_ref(true);
        (void)value_ref(nullptr);

        // string_view, char const*
        (void)(value_ref)string_view("test");
        (void)(value_ref)("test");

        // init-list
        value_ref({1,2,3,4,5});

        // value
        (value_ref)value();
        {
            value jv;
            (value_ref)jv;
        }
        {
            value const jv;
            (value_ref)jv;
        }

        // object
        (value_ref)object();
        {
            object o;
            (value_ref)o;
        }
        {
            object const o{};
            (value_ref)o;
        }

        // array
        (value_ref)object();
        {
            array a;
            (value_ref)a;
        }
        {
            array const a{};
            (value_ref)a;
        }

        // string
        (value_ref)string();
        {
            string s;
            (value_ref)s;
        }
        {
            string const s{};
            (value_ref)s;
        }

        // construct from a const rvalue
        {
            const value val;
            (void)value_ref(std::move(val));
        }
    }

    void
    testInitList()
    {
        // string_view, char const*
        (void)init_list{string_view("test")};
        (void)init_list{"test"};

        // scalars
        (void)init_list{(short)1};
        (void)init_list{(int)1};
        (void)init_list{(long)1};
        (void)init_list{(long long)1};
        (void)init_list{(unsigned short)1};
        (void)init_list{(unsigned int)1};
        (void)init_list{(unsigned long)1};
        (void)init_list{(unsigned long long)1};
        (void)init_list{(float)1.};
        (void)init_list{(double)1.};
        (void)init_list{true};
        (void)init_list{nullptr};

        // bool
        {
            bool b = true;
            auto const cb = b;
            BOOST_TEST(value_ref::make_value(init_list{b}, {}).at(0).is_bool());
            BOOST_TEST(value_ref::make_value(init_list{cb}, {}).at(0).is_bool());
        }

        // value
        (void)init_list{value()};
        {
            value jv;
            (void)init_list{jv};
        }
        {
            value const jv{};
            (void)init_list{jv};
        }

        // object
        (void)init_list{object()};
        {
            object o;
            (void)init_list{o};
        }
        {
            object const o{};
            (void)init_list{o};
        }

        // array
        (void)init_list{object()};
        {
            array a;
            (void)init_list{a};
        }
        {
            array const a{};
            (void)init_list{a};
        }

        // string
        (void)init_list{string()};
        {
            string s;
            (void)init_list{s};
        }
        {
            string const s{};
            (void)init_list{s};
        }

        // init_list
        (void)init_list{{1,2,3,4,5}};
        (void)init_list{{{1,2},{3,4,5}}};
        (void)init_list{{1,2,{3,{4,5}}}};

        {
            init_list init =
                { { "key", true } };
            (void)init;
        }
    }

    void
    make_value(
        init_list init,
        string_view s)
    {
        auto const jv =
            value_ref(init).make_value({});
        auto const js = serialize(jv);
        BOOST_TEST(js == s);
    }

    void
    testMakeValue()
    {
        // scalars
        make_value({(short)-1}, "[-1]");
        make_value({(int)-2}, "[-2]");
        make_value({(long)-3}, "[-3]");
        make_value({(long long)-4}, "[-4]");
        make_value({(unsigned short)1}, "[1]");
        make_value({(unsigned int)2}, "[2]");
        make_value({(unsigned long)3}, "[3]");
        make_value({(unsigned long long)4}, "[4]");
        //make_value({(float)1.}, "[1]");
        //make_value({(double)1.}, "[1]");
        make_value({true}, "[true]");
        make_value({nullptr}, "[null]");

        // string_view
        make_value({string_view("5")}, "[\"5\"]");
        make_value({"6"}, "[\"6\"]");

        // value
        {
            make_value({value(1)}, "[1]");
            value const v(1);
            make_value({v}, "[1]");
            make_value({value(2)}, "[2]");
        }

        // object
        {
            make_value({object({{"k1",1},{"k2",2}})}, "[{\"k1\":1,\"k2\":2}]");
            object const obj({{"k1",1},{"k2",2}});
            make_value({obj}, "[{\"k1\":1,\"k2\":2}]");
        }

        // array
        {
            make_value({array({1,2,3})}, "[[1,2,3]]");
            array const arr({1,2,3});
            make_value({arr}, "[[1,2,3]]");
        }

        // string
        {
            make_value({string("test")}, "[\"test\"]");
            string const str("test");
            make_value({str}, "[\"test\"]");
        }

        // init list with size != 2
        {
            make_value({{1,2,3}}, "[[1,2,3]]");
        }

        // `string` as key
        {
            make_value({
                {string("k1"), 1},
                {string("k2"), 2}},
                "{\"k1\":1,\"k2\":2}");
        }

        // object/array conversion

        make_value(
            {1,2,{3,{4,5}}},
            "[1,2,[3,[4,5]]]" );

        make_value(
            {{"k1",1}},
            "{\"k1\":1}");

        make_value(
            {{"k1",1}, {"k2",2}},
            "{\"k1\":1,\"k2\":2}");

        make_value(
            {{"k1",1}, {"k2",{{"k3",3}, {"k4",4}}}},
            "{\"k1\":1,\"k2\":{\"k3\":3,\"k4\":4}}");

        make_value({value(1)}, "[1]");
        make_value({array({1,2,3,4})}, "[[1,2,3,4]]");
    }

    using kv_init_list =
        std::initializer_list<
            std::pair<string_view, value_ref>>;

    void
    make_object(
        kv_init_list init,
        string_view s)
    {
        auto const jv = value(object(init));
        auto const js = serialize(jv);
        BOOST_TEST(js == s);
    }

    void
    testObjects()
    {
        make_object({
            {"k1",1}
            }, "{\"k1\":1}");
        make_object({
            {"k1",1}, {"k2",2}
            }, "{\"k1\":1,\"k2\":2}");
        make_object({
            {"k1", {1,2}}, {"k2", {1,2,3}}
            }, "{\"k1\":[1,2],\"k2\":[1,2,3]}");
        make_object({
            {"k1", {{"k2",2}, {"k3",3}}}
            }, "{\"k1\":{\"k2\":2,\"k3\":3}}");
    }

    void
    testMoveFrom()
    {
        {
            string a = "abcdefghijklmnopqrstuvwxyz";
            BOOST_TEST(!a.empty());
            array b{std::move(a), string()};
            BOOST_TEST(a.empty());
        }
        {
            string a = "abcdefghijklmnopqrstuvwxyz";
            BOOST_TEST(!a.empty());
            array b{a, string()};
            BOOST_TEST(!a.empty());
        }
        {
            string const a = "abcdefghijklmnopqrstuvwxyz";
            BOOST_TEST(!a.empty());
            array b{a, string()};
            BOOST_TEST(!a.empty());
        }
        {
            array a{value()};
            BOOST_TEST(a.begin() != a.end());
            array b{std::move(a), array()};
            BOOST_TEST(a.begin() == a.end());
        }
        {
            array a{value()};
            BOOST_TEST(a.begin() != a.end());
            array b{a, array()};
            BOOST_TEST(a.begin() != a.end());
        }
        {
            const array a{value()};
            BOOST_TEST(a.begin() != a.end());
            array b{a, array()};
            BOOST_TEST(a.begin() != a.end());
        }
        {
            object a{{"a", 1}, {"b", 2}};
            BOOST_TEST(a.capacity() > 0);
            array b{std::move(a), object()};
            BOOST_TEST(a.capacity() == 0);
        }
        {
            object a{{"a", 1}, {"b", 2}};
            BOOST_TEST(a.capacity() > 0);
            array b{a, object()};
            BOOST_TEST(a.capacity() > 0);
        }
        {
            const object a{{"a", 1}, {"b", 2}};
            BOOST_TEST(a.capacity() > 0);
            array b{a, object()};
            BOOST_TEST(a.capacity() > 0);
        }
    }

    void
    run()
    {
        testCtors();
        testInitList();
        testMakeValue();
        testObjects();
        testMoveFrom();
    }
};

TEST_SUITE(value_ref_test, "boost.json.value_ref");

BOOST_JSON_NS_END