package mcp.util;

import java.util.Optional;

public sealed interface Result<E, T extends Throwable> permits Err, Ok {
   
    default boolean isError() {
        return this instanceof Err;
    }
    
    default boolean isOk() {
        return this instanceof Ok;
    }
    
    default E unwrap() throws T {
        return switch (this) {
            case Err<E, T> err -> throw err.throwable();
            case Ok<E, T> ok -> ok.value();
        };
    }
    
    default E unwrapOrElse(E defaultValue) {
        try {
            return isError() ? defaultValue : unwrap();
        } catch (Throwable e) {
            return defaultValue;
        }
    }
    
    default Optional<E> toOptional() {
        try {
            return isError() ? Optional.empty() : Optional.of(unwrap());
        } catch (Throwable e) {
            return Optional.empty();
        }
    }

    @SuppressWarnings("unchecked")
    default <R> Result<R, T> map(java.util.function.Function<? super E, ? extends R> mapper) {
        return switch (this) {
            case Ok<E, T> ok -> new Ok<>(mapper.apply(ok.value()));
            case Err<E, T> err -> (Err<R, T>) err;
        };
    }

    @SuppressWarnings("unchecked")
    default <R> Result<R, T> flatMap(java.util.function.Function<? super E, ? extends Result<R, T>> mapper) {
        return switch (this) {
            case Ok<E, T> ok -> mapper.apply(ok.value());
            case Err<E, T> err -> (Err<R, T>) err;
        };
    }

    @SuppressWarnings("unchecked")
    default <F extends Throwable> Result<E, F> mapError(java.util.function.Function<? super T, ? extends F> mapper) {
        return switch (this) {
            case Ok<E, T> ok -> (Ok<E, F>) ok;
            case Err<E, T> err -> new Err<>(mapper.apply(err.throwable()));
        };
    }
}