/*
 * libfud
 * Copyright 2024 Dominick Allen
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef FUD_RESULT_HPP
#define FUD_RESULT_HPP

#include <utility>
#include <variant>

namespace fud {

/** \brief A result type which contains either a T on success or an E on error. */
template <typename T, typename E>
class [[nodiscard]] Result {
  public:
    using ResultType = Result<T, E>;
    static ResultType okay(const T& okay)
    {
        return ResultType{okay};
    }

    static ResultType okay(T&& okay)
    {
        return ResultType{std::move(okay)};
    }

    static ResultType error(const E& error)
    {
        return ResultType{error};
    }

    static ResultType error(E&& error)
    {
        return ResultType{std::move(error)};
    }

    [[nodiscard]] constexpr bool isOkay() const
    {
        return (m_value.index() == 0);
    }

    [[nodiscard]] constexpr bool isError() const
    {
        return (m_value.index() == 1);
    }

    [[nodiscard]] T getOkay() const
    {
        return std::get<T>(m_value);
    }

    [[nodiscard]] E getError() const
    {
        return std::get<E>(m_value);
    }

    [[nodiscard]] T&& getOkay()
    {
        return std::move(std::get<T>(m_value));
    }

    [[nodiscard]] E&& getError()
    {
        return std::move(std::get<E>(m_value));
    }

  private:
    explicit Result() : m_value()
    {
    }

    explicit Result(const T& value) : m_value{value}
    {
    }

    explicit Result(const E& value) : m_value{value}
    {
    }

    explicit Result(T&& value) : m_value{std::move(value)}
    {
    }

    explicit Result(E&& value) : m_value{std::move(value)}
    {
    }

    std::variant<T, E> m_value;
};

} // namespace fud

#endif