#pragma once

#ifndef MIJIN_UTIL_PROPERTY_HPP_INCLUDED
#define MIJIN_UTIL_PROPERTY_HPP_INCLUDED 1

#include <memory>
#include <utility>
#include "../debug/assert.hpp"

namespace mijin
{

//
// public defines
//

//
// public types
//

template<typename T, typename TGet = const T&, typename TSet = T>
class PropertyStorage
{
public:
    using value_t = T;
    using get_t = TGet;
    using set_t = TSet;

    virtual ~PropertyStorage() noexcept = default;

    [[nodiscard]] virtual TGet getValue() = 0;
    virtual void setValue(TSet value) = 0;
};

template<typename T>
class SimplePropertyStorage : public PropertyStorage<T>
{
private:
    T value_;
public:
    SimplePropertyStorage() noexcept = default;
    SimplePropertyStorage(const SimplePropertyStorage& other) noexcept(noexcept(T(other.value_))) = default;
    SimplePropertyStorage(SimplePropertyStorage&& other) noexcept(noexcept(T(std::move(other.value_)))) = default;
    explicit SimplePropertyStorage(T value) noexcept(noexcept(T(std::move(value)))) : value_(std::move(value)) {}

    SimplePropertyStorage& operator=(const SimplePropertyStorage& other) noexcept(noexcept(value_ = other.value_)) = default;
    SimplePropertyStorage& operator=(SimplePropertyStorage&& other) noexcept(noexcept(value_ = std::move(other.value_))) = default;

    const T& getValue() noexcept override { return value_; }
    void setValue(T value) override { value_ = std::move(value); }
};

template<typename T, typename TGet = const T&, typename TSet = T>
class Property
{
private:
    using storage_t = PropertyStorage<T, TGet, TSet>;
    using storage_ptr_t = std::unique_ptr<storage_t>;

    storage_ptr_t storage_;
public:
    class PropertyProxy
    {
    private:
        Property* base_;
    public:
        explicit PropertyProxy(Property* base) noexcept : base_(base) {}

        operator TGet() noexcept { return base_->get(); }
        PropertyProxy& operator=(TSet value) noexcept(noexcept(std::declval<T&>() = std::move(value)))
        {
            base_->set(std::move(value));
            return *this;
        }
    };

    Property() noexcept = default;
    explicit Property(storage_ptr_t storage) noexcept : storage_(std::move(storage)) {}
    Property(Property&&) noexcept = default;

    Property& operator=(Property&&) noexcept = default;
    PropertyProxy operator*() noexcept { return PropertyProxy(this); }
    std::remove_reference_t<TGet>* operator->() const noexcept { return &get(); }

    [[nodiscard]] TGet get() const noexcept
    {
        MIJIN_ASSERT_FATAL(storage_ != nullptr, "Cannot get value from an unset property.");
        return storage_->getValue();
    }
    void set(TSet value) noexcept(noexcept(std::declval<T&>() = std::move(value)))
    {
        MIJIN_ASSERT_FATAL(storage_ != nullptr, "Cannot set value of an unset property.");
        storage_->setValue(std::move<TSet>(value));
    }
};

template<typename TStorage>
Property(std::unique_ptr<TStorage>) -> Property<typename TStorage::value_t, typename TStorage::get_t, typename TStorage::set_t>;

template<typename T>
Property<T> makeSimpleProperty(T value) noexcept(noexcept(std::declval<T&>() = std::move(value)))
{
    return Property(std::make_unique<SimplePropertyStorage<T>>(std::move(value)));
}
}

#endif // MIJIN_UTIL_PROPERTY_HPP_INCLUDED