/*
 * 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 {

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);
    }

    T getOkay()
    {
        return std::get<T>(m_value);
    }

    E getError()
    {
        return 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 bookmouse

#endif