//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 <bitsery/ext/inheritance.h>
#include <bitsery/ext/pointer.h>
#include <bitsery/ext/std_smart_ptr.h>

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

using bitsery::ext::BaseClass;
using bitsery::ext::VirtualBaseClass;

using bitsery::ext::InheritanceContext;
using bitsery::ext::PointerLinkingContext;
using bitsery::ext::PolymorphicContext;
using bitsery::ext::StandardRTTI;

using bitsery::ext::PointerOwner;
using bitsery::ext::PointerObserver;
using bitsery::ext::ReferencedByPointer;
using bitsery::ext::StdSmartPtr;

using testing::Eq;

using TContext = std::tuple<PointerLinkingContext, InheritanceContext, PolymorphicContext<StandardRTTI>>;
using SerContext = BasicSerializationContext<TContext>;

//this is useful for PolymorphicContext to bind classes to serializer/deserializer
using TSerializer = typename SerContext::TSerializer;
using TDeserializer = typename SerContext::TDeserializer;

/*
 * base class
 */
struct Base {
    Base() = default;

    explicit Base(uint64_t v) : x{v} {}

    uint64_t x{};

    virtual ~Base() = default;
};

template<typename S>
void serialize(S& s, Base& o) {
    s.value8b(o.x);
}

struct Derived1 : Base {
    Derived1() = default;

    Derived1(uint64_t x_, uint64_t y_) : Base{x_}, y1{y_} {}

    friend bool operator==(const Derived1& lhs, const Derived1& rhs) {
        return lhs.x == rhs.x && lhs.y1 == rhs.y1;
    }

    uint64_t y1{};
};

template<typename S>
void serialize(S& s, Derived1& o) {
    s.ext(o, BaseClass<Base>{});
    s.value8b(o.y1);
}

struct Derived2 : Base {
    uint64_t y1{};
    uint64_t y2{};
};

template<typename S>
void serialize(S& s, Derived2& o) {
    s.ext(o, BaseClass<Base>{});
    s.value8b(o.y1);
    s.value8b(o.y2);
}

// polymorphic structure that contains polymorphic pointer, to test memory resource propagation
struct PolyPtrWithPolyPtrBase {
    std::unique_ptr<Base> ptr{};

    virtual ~PolyPtrWithPolyPtrBase() = default;
};

template<typename S>
void serialize(S& s, PolyPtrWithPolyPtrBase& o) {
    s.ext(o.ptr, StdSmartPtr{});
}

struct DerivedPolyPtrWithPolyPtr : PolyPtrWithPolyPtrBase {

};

template<typename S>
void serialize(S& s, DerivedPolyPtrWithPolyPtr& o) {
    s.ext(o.ptr, StdSmartPtr{});
}


//define relationships between base class and derived classes for runtime polymorphism

namespace bitsery {
    namespace ext {

        template<>
        struct PolymorphicBaseClass<Base> : PolymorphicDerivedClasses<Derived1, Derived2> {
        };

        template<>
        struct PolymorphicBaseClass<PolyPtrWithPolyPtrBase> : PolymorphicDerivedClasses<DerivedPolyPtrWithPolyPtr> {
        };

    }
}

// this class is for testing
struct TestAllocInfo {
    void* ptr;
    size_t bytes;
    size_t alignment;
    size_t typeId;

    friend bool operator==(const TestAllocInfo& lhs, const TestAllocInfo& rhs) {
        return std::tie(lhs.ptr, lhs.bytes, lhs.alignment, lhs.typeId) ==
               std::tie(rhs.ptr, rhs.bytes, rhs.alignment, rhs.typeId);
    }
};

struct MemResourceForTest : public bitsery::ext::MemResourceBase {

    void* allocate(size_t bytes, size_t alignment, size_t typeId) override {
        const auto res = bitsery::ext::MemResourceNewDelete{}.allocate(bytes, alignment, typeId);
        allocs.push_back({res, bytes, alignment, typeId});
        return res;
    }

    void deallocate(void* ptr, size_t bytes, size_t alignment, size_t typeId) noexcept override {
        deallocs.push_back({ptr, bytes, alignment, typeId});
        bitsery::ext::MemResourceNewDelete{}.deallocate(ptr, bytes, alignment, typeId);
    }

    std::vector<TestAllocInfo> allocs{};
    std::vector<TestAllocInfo> deallocs{};
};

class SerializeExtensionPointerWithAllocator : public testing::Test {
public:

    TContext plctx{};
    SerContext sctx{};

    typename SerContext::TSerializer& createSerializer() {
        auto& res = sctx.createSerializer(plctx);
        std::get<2>(plctx).clear();
        //bind serializer with classes
        std::get<2>(plctx).registerBasesList<SerContext::TSerializer>(
            bitsery::ext::PolymorphicClassesList<Base, PolyPtrWithPolyPtrBase>{});
        return res;
    }

    typename SerContext::TDeserializer& createDeserializer() {
        auto& res = sctx.createDeserializer(plctx);
        std::get<2>(plctx).clear();
        //bind deserializer with classes
        std::get<2>(plctx).registerBasesList<SerContext::TDeserializer>(
            bitsery::ext::PolymorphicClassesList<Base, PolyPtrWithPolyPtrBase>{});
        return res;
    }

    bool isPointerContextValid() {
        return std::get<0>(plctx).isValid();
    }

    virtual void TearDown() override {
        EXPECT_TRUE(isPointerContextValid());
    }
};

TEST_F(SerializeExtensionPointerWithAllocator, CanSetDefaultMemoryResourceInPointerLinkingContext) {

    MemResourceForTest memRes{};
    std::get<0>(plctx).setMemResource(&memRes);

    Base* baseData = new Derived1{2, 1};
    createSerializer().ext(baseData, PointerOwner{});
    Base* baseRes = nullptr;
    createDeserializer().ext(baseRes, PointerOwner{});

    auto dData = dynamic_cast<Derived1*>(baseData);
    auto dRes = dynamic_cast<Derived1*>(baseRes);

    EXPECT_THAT(dRes, ::testing::NotNull());
    EXPECT_THAT(*dData, *dRes);
    EXPECT_THAT(memRes.allocs.size(), Eq(1u));
    EXPECT_THAT(memRes.allocs[0].bytes, Eq(sizeof(Derived1)));
    EXPECT_THAT(memRes.allocs[0].alignment, Eq(alignof(Derived1)));
    EXPECT_THAT(memRes.allocs[0].typeId, Eq(bitsery::ext::StandardRTTI::get<Derived1>()));
    EXPECT_THAT(memRes.deallocs.size(), Eq(0u));
    delete dData;
    delete dRes;
}

TEST_F(SerializeExtensionPointerWithAllocator, CorrectlyDeallocatesPreviousInstance) {
    MemResourceForTest memRes{};
    std::get<0>(plctx).setMemResource(&memRes);

    Base* baseData = new Derived1{2, 1};
    createSerializer().ext(baseData, PointerOwner{});
    Base* baseRes = new Derived2;
    createDeserializer().ext(baseRes, PointerOwner{});

    auto dData = dynamic_cast<Derived1*>(baseData);
    auto dRes = dynamic_cast<Derived1*>(baseRes);

    EXPECT_THAT(dRes, ::testing::NotNull());
    EXPECT_THAT(*dData, *dRes);
    EXPECT_THAT(memRes.allocs.size(), Eq(1u));
    EXPECT_THAT(memRes.allocs[0].bytes, Eq(sizeof(Derived1)));
    EXPECT_THAT(memRes.allocs[0].alignment, Eq(alignof(Derived1)));
    EXPECT_THAT(memRes.allocs[0].typeId, Eq(bitsery::ext::StandardRTTI::get<Derived1>()));
    EXPECT_THAT(memRes.deallocs.size(), Eq(1u));
    EXPECT_THAT(memRes.deallocs[0].bytes, Eq(sizeof(Derived2)));
    EXPECT_THAT(memRes.deallocs[0].alignment, Eq(alignof(Derived2)));
    EXPECT_THAT(memRes.deallocs[0].typeId, Eq(bitsery::ext::StandardRTTI::get<Derived2>()));

    delete dData;
    delete dRes;
}

TEST_F(SerializeExtensionPointerWithAllocator, DefaultDeleterIsNotUsedForStdUniquePtr) {
    MemResourceForTest memRes{};
    std::get<0>(plctx).setMemResource(&memRes);

    std::unique_ptr<Base> baseData{};
    createSerializer().ext(baseData, StdSmartPtr{});
    auto baseRes = std::unique_ptr<Base>(new Derived1{45, 64});
    createDeserializer().ext(baseRes, StdSmartPtr{});

    EXPECT_THAT(memRes.allocs.size(), Eq(0u));
    EXPECT_THAT(memRes.deallocs.size(), Eq(1u));
    EXPECT_THAT(memRes.deallocs[0].bytes, Eq(sizeof(Derived1)));
    EXPECT_THAT(memRes.deallocs[0].alignment, Eq(alignof(Derived1)));
    EXPECT_THAT(memRes.deallocs[0].typeId, Eq(bitsery::ext::StandardRTTI::get<Derived1>()));
}

struct CustomBaseDeleter {
    void operator()(Base* obj) {
        delete obj;
    }
};

TEST_F(SerializeExtensionPointerWithAllocator, CustomDeleterIsNotUsedForStdUniquePtr) {
    MemResourceForTest memRes{};
    std::get<0>(plctx).setMemResource(&memRes);

    std::unique_ptr<Base, CustomBaseDeleter> baseData{};
    createSerializer().ext(baseData, StdSmartPtr{});
    auto baseRes = std::unique_ptr<Base, CustomBaseDeleter>(new Derived1{45, 64});
    createDeserializer().ext(baseRes, StdSmartPtr{});

    EXPECT_THAT(memRes.allocs.size(), Eq(0u));
    EXPECT_THAT(memRes.deallocs.size(), Eq(1u));
    EXPECT_THAT(memRes.deallocs[0].bytes, Eq(sizeof(Derived1)));
    EXPECT_THAT(memRes.deallocs[0].alignment, Eq(alignof(Derived1)));
    EXPECT_THAT(memRes.deallocs[0].typeId, Eq(bitsery::ext::StandardRTTI::get<Derived1>()));
}


TEST_F(SerializeExtensionPointerWithAllocator, CanSetMemResourcePerPointer) {
    MemResourceForTest memRes1{};
    MemResourceForTest memRes2{};
    std::get<0>(plctx).setMemResource(&memRes1);

    Base* baseData = new Derived1{2, 1};
    createSerializer().ext(baseData, PointerOwner{bitsery::ext::PointerType::Nullable, &memRes2});
    Base* baseRes = new Derived2;
    createDeserializer().ext(baseRes, PointerOwner{bitsery::ext::PointerType::Nullable, &memRes2});

    auto dData = dynamic_cast<Derived1*>(baseData);
    auto dRes = dynamic_cast<Derived1*>(baseRes);

    EXPECT_THAT(dRes, ::testing::NotNull());
    EXPECT_THAT(*dData, *dRes);
    EXPECT_THAT(memRes1.allocs.size(), Eq(0u));
    EXPECT_THAT(memRes1.deallocs.size(), Eq(0u));
    EXPECT_THAT(memRes2.allocs.size(), Eq(1u));
    EXPECT_THAT(memRes2.allocs[0].bytes, Eq(sizeof(Derived1)));
    EXPECT_THAT(memRes2.allocs[0].alignment, Eq(alignof(Derived1)));
    EXPECT_THAT(memRes2.allocs[0].typeId, Eq(bitsery::ext::StandardRTTI::get<Derived1>()));
    EXPECT_THAT(memRes2.deallocs.size(), Eq(1u));
    EXPECT_THAT(memRes2.deallocs[0].bytes, Eq(sizeof(Derived2)));
    EXPECT_THAT(memRes2.deallocs[0].alignment, Eq(alignof(Derived2)));
    EXPECT_THAT(memRes2.deallocs[0].typeId, Eq(bitsery::ext::StandardRTTI::get<Derived2>()));

    delete dData;
    delete dRes;
}


TEST_F(SerializeExtensionPointerWithAllocator, MemResourceSetPerPointerByDefaultDoNotPropagate) {
    MemResourceForTest memRes1{};
    MemResourceForTest memRes2{};
    std::get<0>(plctx).setMemResource(&memRes1);

    auto data = std::unique_ptr<PolyPtrWithPolyPtrBase>(new PolyPtrWithPolyPtrBase{});
    data->ptr = std::unique_ptr<Base>(new Derived1{5, 6});
    createSerializer().ext(data, StdSmartPtr{bitsery::ext::PointerType::Nullable, &memRes2});

    auto res = std::unique_ptr<PolyPtrWithPolyPtrBase>(new DerivedPolyPtrWithPolyPtr{});
    res->ptr = std::unique_ptr<Base>(new Derived2{});
    createDeserializer().ext(res, StdSmartPtr{bitsery::ext::PointerType::Nullable, &memRes2});


    EXPECT_THAT(memRes1.allocs.size(), Eq(1u));
    // Base* was destroyed by unique_ptr on PolyPtrWithPolyPtrBase destructor, hence == 0
    EXPECT_THAT(memRes1.deallocs.size(), Eq(0u));

    EXPECT_THAT(memRes2.allocs.size(), Eq(1u));
    EXPECT_THAT(memRes2.deallocs.size(), Eq(1u));

}

TEST_F(SerializeExtensionPointerWithAllocator, MemResourceSetPerPointerCanPropagate) {
    MemResourceForTest memRes1{};
    MemResourceForTest memRes2{};
    std::get<0>(plctx).setMemResource(&memRes1);

    auto data = std::unique_ptr<PolyPtrWithPolyPtrBase>(new PolyPtrWithPolyPtrBase{});
    data->ptr = std::unique_ptr<Base>(new Derived1{5, 6});
    createSerializer().ext(data, StdSmartPtr{bitsery::ext::PointerType::Nullable, &memRes2, true});

    auto res = std::unique_ptr<PolyPtrWithPolyPtrBase>(new DerivedPolyPtrWithPolyPtr{});
    res->ptr = std::unique_ptr<Base>(new Derived2{});
    createDeserializer().ext(res, StdSmartPtr{bitsery::ext::PointerType::Nullable, &memRes2, true});

    EXPECT_THAT(memRes1.allocs.size(), Eq(0u));
    EXPECT_THAT(memRes1.deallocs.size(), Eq(0u));
    EXPECT_THAT(memRes2.allocs.size(), Eq(2u));
    // deallocates are actually == 1, because when we destroy PolyPtrWithPolyPtrBase
    // it also destroys Base because it is managed by unique_ptr.
    // in order to do it correctly we should always use custom deleter for structures with nested pointers
    EXPECT_THAT(memRes2.deallocs.size(), Eq(1u));

}