//
// Created by jguegant on 1/30/16.
//

#ifndef REPOSITORY_HPP
#define REPOSITORY_HPP

#include <atomic>
#include <iostream>
#include <memory>
#include <mutex>
#include <vector>

struct DefaultSlotKey;

template <class Type, class Key = DefaultSlotKey> class Slot;

template <class Type, class Key>
class Watcher
{
public:
    Watcher(Slot<Type, Key>& slot):
            slot_(slot),
            hasBeenChanged_(false)
    {
    }

    Watcher(const Watcher&) = delete;

    Watcher & operator=(const Watcher&) = delete;

    bool hasBeenChanged() const
    {
        return hasBeenChanged_;
    }

    void triggerChanges()
    {
        hasBeenChanged_ = true;
    }

    auto get() -> decltype(std::declval<Slot<Type, Key>>().doGet())
    {
        hasBeenChanged_ = false; // Note: even if there is an update of the value between this line and the getValue one,
        // we will still have the latest version.
        // Note 2: atomic_bool automatically use a barrier and the two operations can't be inversed.
        return slot_.doGet();
    }

private:
    Slot<Type, Key>& slot_;
    std::atomic_bool hasBeenChanged_;
};


template <class Type, class Key = DefaultSlotKey>
using WatcherPtr = std::unique_ptr<Watcher<Type, Key>,
std::function<void(Watcher<Type, Key>*)>>;

template <class Type, class Key>
class Slot
{
public:
    using ThisType = Slot<Type, Key>;
    using WatcherType = Watcher<Type, Key>;
    using WatcherTypePtr = std::unique_ptr<WatcherType, std::function<void(WatcherType*)>> ;

public:
    std::shared_ptr<Type> doGet() const
    {
        return std::atomic_load(&value_);
    }

    void doSet(const std::shared_ptr<Type> &value)
    {
        std::atomic_exchange(&value_, value);
        signal();
    }

    WatcherTypePtr doGetWatcher()
    {
        WatcherTypePtr watcher(new WatcherType(*this), [this](WatcherType* toBeDelete) {
            this->unregisterWatcher(toBeDelete);});

        registerWatcher(watcher.get());

        return watcher;
    }

private:
    void registerWatcher(WatcherType* newWatcher)
    {
        std::lock_guard<std::mutex> l(watchers_mutex_);
        watchers_.push_back(newWatcher);
    }

    void unregisterWatcher(WatcherType *toBeDelete)
    {
        std::lock_guard<std::mutex> l(watchers_mutex_);
        watchers_.erase(std::remove(watchers_.begin(), watchers_.end(), toBeDelete), watchers_.end());

        delete toBeDelete;
    }

    void signal()
    {
        std::lock_guard<std::mutex> l(watchers_mutex_);
        for (auto watcher : watchers_) {
            watcher->triggerChanges();
        }
    }

private:
    std::vector<WatcherType*> watchers_;
    std::shared_ptr<Type> value_;
    std::mutex watchers_mutex_;
};

template<class... Slots>
class Repository : private Slots... {
public:
    template <class Type, class Key = DefaultSlotKey>
    std::shared_ptr<Type> get()
    {
        static_assert(std::is_base_of<Slot<Type, Key>, Repository<Slots...>>::value,
                      "Please ensure that this type or this key exists in this repository");
        return Slot<Type, Key>::doGet();
    }

    template <class Type, class Key = DefaultSlotKey>
    void set(const std::shared_ptr<Type>& value)
    {
        static_assert(std::is_base_of<Slot<Type, Key>, Repository<Slots...>>::value,
                      "Please ensure that this type or this key exists in this repository");
        Slot<Type, Key>::doSet(value);
    }

    template <class Type, class Key = DefaultSlotKey, class ...Args>
    void emplace(Args&&... args)
    {
        static_assert(std::is_base_of<Slot<Type, Key>, Repository<Slots...>>::value,
                      "Please ensure that this type or this key exists in this repository");
        Slot<Type, Key>::doSet(std::make_shared<Type>(std::forward<Args>(args)...));
    }

    template <class Type, class Key = DefaultSlotKey>
    auto getWatcher()
    {
        static_assert(std::is_base_of<Slot<Type, Key>, Repository<Slots...>>::value,
                      "Please ensure that this type or this key exists in this repository");
        return Slot<Type, Key>::doGetWatcher();
    }
};

#endif // REPOSITORY_HPP