//MIT License
//
//Copyright (c) 2019 Mindaugas Vinkelis
//
//Permission is hereby granted, free of charge, to any person obtaining a copy
//of this software and associated documentation files (the "Software"), to deal
//in the Software without restriction, including without limitation the rights
//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//copies of the Software, and to permit persons to whom the Software is
//furnished to do so, subject to the following conditions:
//
//The above copyright notice and this permission notice shall be included in all
//copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
//SOFTWARE.

#include <forward_list>
#include <bitsery/traits/forward_list.h>
#include <bitsery/ext/std_set.h>
#include <bitsery/ext/std_map.h>
#include <bitsery/ext/pointer.h>
#include <bitsery/ext/std_smart_ptr.h>

#include <gmock/gmock.h>
#include "serialization_test_utils.h"


using testing::ContainerEq;
using testing::Eq;

//forward declare, for testing with std::unordered_map
class HasherForNonDefaultConstructible;

class NonDefaultConstructible {
    int32_t i{0};
    friend class HasherForNonDefaultConstructible;




    friend class bitsery::Access;
    NonDefaultConstructible() = default;

    template <typename S>
    void serialize(S& s) {
        s.value4b(i);
    }

public:

    explicit NonDefaultConstructible(int32_t v):i{v} {}

    bool operator == (const NonDefaultConstructible& other) const {
        return i == other.i;
    }

    bool operator < (const NonDefaultConstructible& other) const {
        return i < other.i;
    }
};

class HasherForNonDefaultConstructible {
public:
    size_t operator()(const NonDefaultConstructible& o) const {
        return std::hash<int32_t>()(o.i);
    }
};




TEST(DeserializeNonDefaultConstructible, Container) {
    SerializationContext ctx{};
    std::vector<NonDefaultConstructible> data{};
    data.emplace_back(1);
    data.emplace_back(2);
    data.emplace_back(3);
    std::vector<NonDefaultConstructible> res{};

    ctx.createSerializer().container(data, 10);
    ctx.createDeserializer().container(res, 10);

    EXPECT_THAT(res, ContainerEq(data));
}
//this test is here, because when object is not constructible we cannot simple "resize" container
TEST(DeserializeNonDefaultConstructible, ResultContainerShouldShrink) {
    SerializationContext ctx{};
    std::vector<NonDefaultConstructible> data{};
    data.emplace_back(1);
    std::vector<NonDefaultConstructible> res{};
    res.emplace_back(2);
    res.emplace_back(3);
    res.emplace_back(4);

    ctx.createSerializer().container(data, 10);
    ctx.createDeserializer().container(res, 10);

    EXPECT_THAT(res, ContainerEq(data));
}

TEST(DeserializeNonDefaultConstructible, ResultStdForwardListShouldShrink) {
    // forward list doesn't have .erase function, bet has erase_after
    // in this case, if new size is 0 it must call clear, so we need to check two cases
    {
        // 1) when result should have more than 0 elements
        SerializationContext ctx{};
        std::forward_list<NonDefaultConstructible> data{};
        data.push_front(NonDefaultConstructible{1});
        std::forward_list<NonDefaultConstructible> res{};
        res.push_front(NonDefaultConstructible{21});
        res.push_front(NonDefaultConstructible{14});

        ctx.createSerializer().container(data, 10);
        ctx.createDeserializer().container(res, 10);

        auto resIt = res.begin();
        for (auto it = data.begin(); it != data.end(); ++it, ++resIt) {
            EXPECT_THAT(*resIt, Eq(*it));
        }
        EXPECT_THAT(resIt, Eq(res.end()));

    }
    {
        // 1) when result should have 0 elements
        SerializationContext ctx{};
        std::forward_list<NonDefaultConstructible> data{};
        std::forward_list<NonDefaultConstructible> res{};
        res.push_front(NonDefaultConstructible{1});
        res.push_front(NonDefaultConstructible{14});

        ctx.createSerializer().container(data, 10);
        ctx.createDeserializer().container(res, 10);

        EXPECT_THAT(res.begin(), Eq(res.end()));

    }

    {
        // also check if correctly expands if source is bigger than destination
        SerializationContext ctx{};
        std::forward_list<NonDefaultConstructible> data{};
        data.push_front(NonDefaultConstructible{1});
        data.push_front(NonDefaultConstructible{14});
        std::forward_list<NonDefaultConstructible> res{};

        ctx.createSerializer().container(data, 10);
        ctx.createDeserializer().container(res, 10);

        auto resIt = res.begin();
        for (auto it = data.begin(); it != data.end(); ++it, ++resIt) {
            EXPECT_THAT(*resIt, Eq(*it));
        }
        EXPECT_THAT(resIt, Eq(res.end()));
    }
}

TEST(DeserializeNonDefaultConstructible, StdSet) {
    SerializationContext ctx{};
    std::set<NonDefaultConstructible> data;
    data.insert(NonDefaultConstructible{1});
    data.insert(NonDefaultConstructible{2});
    std::set<NonDefaultConstructible> res{};
    data.insert(NonDefaultConstructible{3});

    ctx.createSerializer().ext(data, bitsery::ext::StdSet{10});
    ctx.createDeserializer().ext(res, bitsery::ext::StdSet{10});

    EXPECT_THAT(res, ContainerEq(data));
}

TEST(DeserializeNonDefaultConstructible, StdMap) {
    SerializationContext ctx{};
    std::unordered_map<NonDefaultConstructible, NonDefaultConstructible, HasherForNonDefaultConstructible> data;
    data.emplace(NonDefaultConstructible{2}, NonDefaultConstructible{3});

    std::unordered_map<NonDefaultConstructible, NonDefaultConstructible, HasherForNonDefaultConstructible> res{};
    data.emplace(NonDefaultConstructible{2}, NonDefaultConstructible{3});
    data.emplace(NonDefaultConstructible{4}, NonDefaultConstructible{4});

    auto& ser = ctx.createSerializer();
    ser.ext(data, bitsery::ext::StdMap{10},[](decltype(ser)& ser, NonDefaultConstructible& key, NonDefaultConstructible& value) {
        ser.object(key);
        ser.object(value);
    });
    auto& des = ctx.createDeserializer();
    des.ext(res, bitsery::ext::StdMap{10},[](decltype(des)& des, NonDefaultConstructible& key, NonDefaultConstructible& value) {
        des.object(key);
        des.object(value);
    });

    EXPECT_THAT(res, ContainerEq(data));
}


struct NonPolymorphicPointers {
    NonDefaultConstructible* pp;
    std::unique_ptr<NonDefaultConstructible> up;
    std::shared_ptr<NonDefaultConstructible> sp;
    std::weak_ptr<NonDefaultConstructible> wp;
};

template <typename S>
void serialize(S& s, NonPolymorphicPointers& o) {
    s.ext(o.pp, bitsery::ext::PointerOwner{});
    s.ext(o.up, bitsery::ext::StdSmartPtr{});
    s.ext(o.sp, bitsery::ext::StdSmartPtr{});
    s.ext(o.wp, bitsery::ext::StdSmartPtr{});
}

TEST(DeserializeNonDefaultConstructible, NonPolymorphicPointerAndSmartPointer) {
    using SerContext = BasicSerializationContext<bitsery::ext::PointerLinkingContext>;
    SerContext ctx{};
    NonPolymorphicPointers data{};
    data.pp = new NonDefaultConstructible{3};
    data.up = std::unique_ptr<NonDefaultConstructible>(new NonDefaultConstructible{54});
    data.sp = std::shared_ptr<NonDefaultConstructible>(new NonDefaultConstructible{-481});
    data.wp = data.sp;

    NonPolymorphicPointers res{};
    bitsery::ext::PointerLinkingContext plctx1{};
    ctx.createSerializer(plctx1).object(data);
    ctx.createDeserializer(plctx1).object(res);

    EXPECT_THAT(*res.pp, Eq(*data.pp));
    delete res.pp;
    delete data.pp;
    EXPECT_THAT(*res.up, Eq(*data.up));
    EXPECT_THAT(*res.sp, Eq(*data.sp));
    EXPECT_THAT(*(res.wp.lock()), Eq(*(data.wp.lock())));
}

class PolymorphicNDCBase {
public:
    virtual ~PolymorphicNDCBase() = 0;
    template <typename S>
    void serialize(S& ) {}
};


PolymorphicNDCBase::~PolymorphicNDCBase() = default;

class PolymorphicNDC1:public PolymorphicNDCBase {
    int8_t i{};
    friend class bitsery::Access;

    template <typename S>
    void serialize(S& s) {
        s.value1b(i);
    }
public:
    PolymorphicNDC1() = default;
    PolymorphicNDC1(int8_t v):i{v} {}
    bool operator == (const PolymorphicNDC1& other) const {
        return i == other.i;
    }
};

class PolymorphicNDC2:public PolymorphicNDCBase {
    uint16_t ui{};

    friend class bitsery::Access;

    template <typename S>
    void serialize(S& s) {
        s.value2b(ui);
    }
public:
    PolymorphicNDC2() = default;
    PolymorphicNDC2(uint16_t v):ui{v} {}
    bool operator == (const PolymorphicNDC2& other) const {
        return ui == other.ui;
    }

};


namespace bitsery {
    namespace ext {

        template<>
        struct PolymorphicBaseClass<PolymorphicNDCBase> : PolymorphicDerivedClasses<PolymorphicNDC1, PolymorphicNDC2> {
        };
    }
}


struct PolymorphicPointers {
    PolymorphicNDCBase* pp;
    std::unique_ptr<PolymorphicNDCBase> up;
    std::shared_ptr<PolymorphicNDCBase> sp;
    std::weak_ptr<PolymorphicNDCBase> wp;
};

template <typename S>
void serialize(S& s, PolymorphicPointers& o) {
    s.ext(o.pp, bitsery::ext::PointerOwner{});
    s.ext(o.up, bitsery::ext::StdSmartPtr{});
    s.ext(o.sp, bitsery::ext::StdSmartPtr{});
    s.ext(o.wp, bitsery::ext::StdSmartPtr{});
}

TEST(DeserializeNonDefaultConstructible, PolymorphicPointerAndSmartPointer) {
    using TContext = std::tuple<bitsery::ext::PointerLinkingContext, bitsery::ext::PolymorphicContext<bitsery::ext::StandardRTTI>>;
    using SerContext = BasicSerializationContext<TContext>;
    SerContext ctx{};
    PolymorphicPointers data{};
    data.pp = new PolymorphicNDC1{-4};
    data.up = std::unique_ptr<PolymorphicNDCBase>(new PolymorphicNDC2{54});
    data.sp = std::shared_ptr<PolymorphicNDCBase>(new PolymorphicNDC1{15});
    data.wp = data.sp;

    PolymorphicPointers res{};

    TContext serCtx{};
    TContext desCtx{};

    std::get<1>(serCtx).registerBasesList<typename SerContext::TSerializer>(bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});
    std::get<1>(desCtx).registerBasesList<typename SerContext::TDeserializer>(bitsery::ext::PolymorphicClassesList<PolymorphicNDCBase>{});

    ctx.createSerializer(serCtx).object(data);
    ctx.createDeserializer(desCtx).object(res);
    auto respp = dynamic_cast<PolymorphicNDC1*>(res.pp);
    auto resup = dynamic_cast<PolymorphicNDC2*>(res.up.get());
    auto ressp = dynamic_cast<PolymorphicNDC1*>(res.sp.get());
    auto reswp = dynamic_cast<PolymorphicNDC1*>(res.wp.lock().get());

    auto datapp = dynamic_cast<PolymorphicNDC1*>(data.pp);
    auto dataup = dynamic_cast<PolymorphicNDC2*>(data.up.get());
    auto datasp = dynamic_cast<PolymorphicNDC1*>(data.sp.get());
    auto datawp = dynamic_cast<PolymorphicNDC1*>(data.wp.lock().get());

    EXPECT_THAT(respp, ::testing::Ne(nullptr));
    EXPECT_THAT(resup, ::testing::Ne(nullptr));
    EXPECT_THAT(ressp, ::testing::Ne(nullptr));
    EXPECT_THAT(reswp, ::testing::Ne(nullptr));

    EXPECT_THAT(*respp, Eq(*datapp));
    delete res.pp;
    delete data.pp;
    EXPECT_THAT(*resup, Eq(*dataup));
    EXPECT_THAT(*ressp, Eq(*datasp));
    EXPECT_THAT(*reswp, Eq(*datawp));
    std::get<0>(serCtx).clearSharedState();
    std::get<0>(desCtx).clearSharedState();
}