#pragma once

#include <type_traits>

// A somewhat implementation of the expected monad, proposed here:
// https://isocpp.org/files/papers/n4015.pdf

// A class used to differentiate errors and values when they are of the same type.
template <typename Error>
class Unexpected
{

    static_assert(!std::is_same<Error, void>::value, "Cannot have an Unexpected void");

public:
    Unexpected() = delete;

    constexpr explicit Unexpected(const Error &error) : mValue(error) {}
    constexpr explicit Unexpected(Error &&error) : mValue(std::move(error)) {}

    // For implicit conversions when doing makeUnexpected(other)
    template <typename Other>
    constexpr explicit Unexpected(const Unexpected<Other> &error) : mValue(error.value()) {}
    template <typename Other>
    constexpr explicit Unexpected(Unexpected<Other> &&error) : mValue(std::move(error.value())) {}

    constexpr const Error &value() const &
    {
        return mValue;
    }
    Error &value() &
    {
        return mValue;
    }

    constexpr const Error &&value() const &&
    {
        return std::move(mValue);
    }
    Error &&value() &&
    {
        return std::move(mValue);
    }

private:
    Error mValue;
};

template <class Error>
Unexpected<typename std::decay<Error>::type> makeUnexpected(Error &&e)
{
    return Unexpected<typename std::decay<Error>::type>(std::forward<Error>(e));
}

template <typename Error>
bool operator==(const Unexpected<Error> &lhs, const Unexpected<Error> &rhs)
{
    return lhs.value() == rhs.value();
}

template <typename Error>
bool operator!=(const Unexpected<Error> &lhs, const Unexpected<Error> &rhs)
{
    return lhs.value() != rhs.value();
}

namespace detail {

namespace tags {
struct Expected
{};
struct Unexpected
{};
} // namespace tags

// Write functions here when storage related and when Type != void
template <typename Error, typename Type>
struct StorageBase
{
protected:
    // Rule of 5 {{{

    constexpr void copyPartFromOther(const StorageBase &other)
    {
        if (isValue) {
            mValue = other.mValue;
        } else {
            mError = other.mError;
        }
    }

    void movePartFromOther(StorageBase &&other)
    {
        if (isValue) {
            mValue = std::move(other.mValue);
        } else {
            mError = std::move(other.mError);
        }
    }

    StorageBase(const StorageBase &other) : isValue(other.isValue)
    {
        copyPartFromOther(other);
    }

    StorageBase(StorageBase &&other) : isValue(other.isValue)
    {
        movePartFromOther(std::move(other));
    }

    constexpr StorageBase &operator=(const StorageBase &other)
    {
        isValue = other.isValue;
        copyPartFromOther(other);
        return *this;
    }

    constexpr StorageBase &operator=(StorageBase &&other)
    {
        isValue = other.isValue;
        movePartFromOther(other);
        return *this;
    }

    ~StorageBase()
    {
        if (isValue) {
            mValue.~Type();
        } else {
            mError.~Unexpected<Error>();
        }
    }

    // }}}

    template <typename... Args>
    constexpr StorageBase(tags::Expected, Args &&... args)
        : mValue(std::forward<Args>(args)...), isValue(true)
    {
    }

    template <typename... Args>
    constexpr StorageBase(tags::Unexpected, Args &&... args)
        : mError(std::forward<Args>(args)...), isValue(false)
    {
    }

    union
    {
        Unexpected<Error> mError;
        Type mValue;
    };
    bool isValue;
};

// Write functions here when storage related and when Type == void
template <typename Error>
struct StorageBase<Error, void>
{
protected:
    constexpr StorageBase(tags::Expected) : isValue(true) {}

    template <typename... Args>
    constexpr StorageBase(tags::Unexpected, Args &&... args)
        : mError(std::forward<Args>(args)...), isValue(false)
    {
    }

    Unexpected<Error> mError;
    bool isValue;
};

// Write functions here when storage related, whether Type is void or not
template <typename Error, typename Type>
struct Storage : StorageBase<Error, Type>
{
protected:
    // Forward the construction to StorageBase
    using StorageBase<Error, Type>::StorageBase;
};

// Write functions here when dev API related and when Type != void
template <typename Error, typename Type>
struct ExpectedBase : detail::Storage<Error, Type>
{
    constexpr ExpectedBase() : detail::Storage<Error, Type>(detail::tags::Expected{}) {}

    template <typename OtherError>
    constexpr ExpectedBase(const Unexpected<OtherError> &error)
        : detail::Storage<Error, Type>(detail::tags::Unexpected{}, error)
    {
    }
    template <typename OtherError>
    constexpr ExpectedBase(Unexpected<OtherError> &&error)
        : detail::Storage<Error, Type>(detail::tags::Unexpected{}, std::move(error))
    {
    }

    constexpr ExpectedBase(const Type &value)
        : detail::Storage<Error, Type>(detail::tags::Expected{}, value)
    {
    }
    constexpr ExpectedBase(Type &&value)
        : detail::Storage<Error, Type>(detail::tags::Expected{}, std::move(value))
    {
    }

    constexpr const Type &value() const &
    {
        return this->mValue;
    }
};

// Write functions here when dev API related and when Type == void
template <typename Error>
struct ExpectedBase<Error, void> : detail::Storage<Error, void>
{
    // Rewrite constructors for unexpected because Expected doesn't have direct access to it.
    template <typename OtherError>
    constexpr ExpectedBase(const Unexpected<OtherError> &error)
        : detail::Storage<Error, void>(detail::tags::Unexpected{}, error)
    {
    }
    template <typename OtherError>
    constexpr ExpectedBase(Unexpected<OtherError> &&error)
        : detail::Storage<Error, void>(detail::tags::Unexpected{}, std::move(error))
    {
    }
};

} // namespace detail

// Write functions here when dev API related, whether Type is void or not
template <typename Error, typename Type = void>
class Expected : public detail::ExpectedBase<Error, Type>
{
    static_assert(!std::is_same<Error, void>::value, "Expected with void Error is not implemented");

public:
    using detail::ExpectedBase<Error, Type>::ExpectedBase;

    constexpr const Error &error() const &
    {
        return this->mError.value();
    }
};