#pragma once

#if !defined(MIJIN_CONTAINER_OPTIONAL_HPP_INCLUDED)
#define MIJIN_CONTAINER_OPTIONAL_HPP_INCLUDED 1

#include <cstdint>
#include <functional>
#include <utility>
#include "../debug/assert.hpp"
#include "../util/concepts.hpp"
#include "../util/traits.hpp"

namespace mijin
{

//
// public defines
//

//
// public constants
//

//
// public types
//

namespace impl
{
template<typename T>
struct OptionalStorage
{
    alignas(T) std::uint8_t data[sizeof(T)]; // NOLINT(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
    std::uint8_t used = 0;

    [[nodiscard]]
    constexpr bool empty() const noexcept { return !used; } // NOLINT(clang-analyzer-core.uninitialized.UndefReturn)

    template<typename... TArgs>
    constexpr void emplace(TArgs&&... args) noexcept
    {
        MIJIN_ASSERT(!used, "Attempting to emplace in an already set OptionalStorage!");
        used = 1;
        ::new (data) T(std::forward<TArgs>(args)...);
    }

    void clear()
    {
        MIJIN_ASSERT(used, "Attempting to clear an empty OptionalStorage!");
        get().~T();
        used = 0;
    }

    [[nodiscard]] constexpr T& get() noexcept { return *reinterpret_cast<T*>(data); }
    [[nodiscard]] constexpr const T& get() const noexcept { return *reinterpret_cast<const T*>(data); }
};

template<pointer_type T>
struct OptionalStorage<T>
{
    static constexpr T invalidPointer() noexcept { return reinterpret_cast<T>(1); }
    
    T ptr = invalidPointer();

    [[nodiscard]]
    constexpr bool empty() const noexcept { return ptr == invalidPointer(); }

    void emplace(T value) noexcept
    {
        ptr = value;
    }

    void clear()
    {
        ptr = invalidPointer();
    }

    [[nodiscard]] T& get() noexcept { return ptr; }
    [[nodiscard]] const T& get() const noexcept { return ptr; }
};

template<reference_type T>
struct OptionalStorage<T>
{
    using pointer_t = std::remove_reference_t<T>*;

    pointer_t ptr = nullptr;

    [[nodiscard]]
    constexpr bool empty() const noexcept { return ptr == nullptr; }

    void emplace(T value) noexcept
    {
        ptr = &value;
    }

    void clear()
    {
        ptr = nullptr;
    }

    T get() noexcept { return *ptr; }
    const T get() const noexcept { return *ptr; } // NOLINT(readability-const-return-type) T already is a reference
};
}
struct NullOptional {};
static constexpr NullOptional NULL_OPTIONAL;

template<typename TValue>
class Optional
{
public:
    using value_t = TValue;
private:
    impl::OptionalStorage<TValue> storage_ = {};
public:
    constexpr Optional() = default;
    constexpr Optional(NullOptional) noexcept {}
    inline Optional(const Optional& other) noexcept;
    inline Optional(Optional&& other) noexcept;
    inline Optional(TValue value) noexcept;
    inline ~Optional() noexcept;
public:
    Optional& operator =(const Optional& other) noexcept;
    Optional& operator =(Optional&& other) noexcept;
    Optional& operator =(TValue value) noexcept;
    Optional& operator =(NullOptional) noexcept;
public:
    [[nodiscard]]
    constexpr bool operator ==(NullOptional) const noexcept { return empty(); }
    template<typename TOther>
    [[nodiscard]]
    constexpr bool operator ==(const Optional<TOther>& other) const noexcept;
    template<typename T>
    [[nodiscard]]
    constexpr bool operator ==(const T& value) const noexcept;
    template<typename T>
    [[nodiscard]]
    constexpr bool operator !=(const T& value) const noexcept { return !(*this == value); }
    [[nodiscard]]
    constexpr explicit operator bool() const noexcept { return !empty(); }
    [[nodiscard]]
    constexpr bool operator !() const noexcept { return empty(); }
    [[nodiscard]]
    constexpr std::remove_reference_t<TValue>& operator*() noexcept { return get(); }
    [[nodiscard]]
    constexpr const std::remove_reference_t<TValue>& operator*() const noexcept { return get(); }
    [[nodiscard]]
    constexpr std::remove_reference_t<TValue>* operator->() noexcept { return &get(); }
    [[nodiscard]]
    constexpr const std::remove_reference_t<TValue>* operator->() const noexcept { return &get(); }
public:
    template<typename... Types>
    void emplace(Types&&... params) noexcept;
public:
    [[nodiscard]] inline std::remove_reference_t<TValue>& get() noexcept;
    [[nodiscard]] inline const std::remove_reference_t<TValue>& get() const noexcept;
    [[nodiscard]] constexpr bool empty() const noexcept { return storage_.empty(); }
    inline void reset() noexcept;


    template<typename TCallable, typename TErrorCallable = int>
    auto then(TCallable&& onSuccess, TErrorCallable&& onError = 0)
    {
        return thenImpl(*this, std::forward<TCallable>(onSuccess), std::forward<TErrorCallable>(onError));
    }

    template<typename TCallable, typename TErrorCallable = int>
    auto then(TCallable&& onSuccess, TErrorCallable&& onError = 0) const
    {
        return thenImpl(*this, std::forward<TCallable>(onSuccess), std::forward<TErrorCallable>(onError));
    }
private:
    template<typename TSelf, typename TCallable, typename TErrorCallable = int>
    static auto thenImpl(TSelf&& self, TCallable&& onSuccess, TErrorCallable&& onError = 0)
    {
        using result_t = std::invoke_result_t<TCallable, std::add_rvalue_reference_t<TValue>>;

        if constexpr (std::is_same_v<result_t, void>)
        {
            if (!self.empty())
            {
                std::invoke(std::forward<TCallable>(onSuccess), self.get());
            }
            else if constexpr (!std::is_same_v<TErrorCallable, int>)
            {
                std::invoke(std::forward<TErrorCallable>(onError));
            }
        }
        else if constexpr (requires(result_t obj) { {obj == NULL_OPTIONAL} -> std::convertible_to<bool>; })
        {
            if (!self.empty())
            {
                return std::invoke(std::forward<TCallable>(onSuccess), self.get());
            }
            else
            {
                if constexpr (!std::is_same_v<TErrorCallable, int>)
                {
                    std::invoke(std::forward<TErrorCallable>(onError));
                }
                return result_t(NULL_OPTIONAL);
            }
        }
        else
        {
            static_assert(always_false_v<TCallable>, "Callable must produce void or optional type.");
        }
    }
};

//
// public functions
//

template<typename TValue>
Optional<TValue>::Optional(const Optional& other) noexcept
{
    if (other) {
        emplace(other.get());
    }
}

template<typename TValue>
Optional<TValue>::Optional(Optional&& other) noexcept
{
    if (other)
    {
        if constexpr (!std::is_reference_v<TValue>) {
            emplace(std::move(other.get()));
        }
        else {
            emplace(other.get());
        }
        other.reset();
    }
}

template<typename TValue>
Optional<TValue>::Optional(TValue value) noexcept
{
    if constexpr (std::is_reference_v<TValue>) {
        emplace(value);
    }
    else {
        emplace(std::move(value));
    }
}

template<typename TValue>
Optional<TValue>::~Optional() noexcept
{
    reset();
}

template<typename TValue>
auto Optional<TValue>::operator =(const Optional& other) noexcept -> Optional&
{
    if (&other == this) {
        return *this;
    }
    reset();
    if (other) {
        emplace(other.get());
    }
    return *this;
}

template<typename TValue>
auto Optional<TValue>::operator =(Optional&& other) noexcept -> Optional&
{
    if (&other == this) {
        return *this;
    }
    reset();
    if (other)
    {
        emplace(std::move(other.get()));
        other.reset();
    }
    return *this;
}

template<typename TValue>
auto Optional<TValue>::operator =(TValue value) noexcept -> Optional&
{
    if constexpr (std::is_reference_v<TValue>) {
        emplace(value);
    }
    else {
        emplace(std::move(value));
    }
    return *this;
}

template<typename TValue>
auto Optional<TValue>::operator =(NullOptional) noexcept -> Optional&
{
    reset();
    return *this;
}

template<typename TValue>
template<typename TOther>
constexpr bool Optional<TValue>::operator ==(const Optional<TOther>& other) const noexcept
{
    if (empty())
    {
        return other.empty();
    }
    if (!other.empty())
    {
        return get() == other.get();
    }
    return false;
}

template<typename TValue>
template<typename T>
constexpr bool Optional<TValue>::operator ==(const T& value) const noexcept
{
    if (empty())
    {
        return false;
    }
    return get() == value;
}

template<typename TValue>
template<typename... Types>
void Optional<TValue>::emplace(Types&&... params) noexcept
{
    reset();
    storage_.emplace(std::forward<Types>(params)...);
    MIJIN_ASSERT(!empty(), "Something is wrong.");
}

template<typename TValue>
inline std::remove_reference_t<TValue>& Optional<TValue>::get() noexcept
{
    MIJIN_ASSERT(!empty(), "Attempting to fetch value from empty Optional!");
    return storage_.get();
}

template<typename TValue>
inline const std::remove_reference_t<TValue>& Optional<TValue>::get() const noexcept
{
    MIJIN_ASSERT(!empty(), "Attempting to fetch value from empty Optional!");
    return storage_.get();
}

template<typename TValue>
inline void Optional<TValue>::reset() noexcept
{
    if (empty()) {
        return;
    }

    storage_.clear();
}

} // namespace mijin

#endif // !defined(MIJIN_CONTAINER_OPTIONAL_HPP_INCLUDED)