Just.Railway/Railway/ValueTaskExtensions/ResultValueTaskExtensions.cs

namespace Just.Railway.ValueTaskExtensions;

public static partial class ResultValueTaskExtensions
{
    #region Finally

    public static async ValueTask<Result> ValueTaskFinally(this ValueTask<Result> resultTask, Action action)
    {
        var result = await resultTask;
        switch (result.State)
        {
            case ResultState.Success: 
            case ResultState.Error:
                action.Invoke();
                break;

            default: throw new ResultNotInitializedException(nameof(resultTask));
        }

        return result;
    }
    public static async ValueTask<Result> ValueTaskFinally(this Result result, Func<ValueTask> action)
    {
        switch (result.State)
        {
            case ResultState.Success: 
            case ResultState.Error:
                await action.Invoke();
                break;

            default: throw new ResultNotInitializedException(nameof(result));
        }

        return result;
    }
    public static async ValueTask<Result> ValueTaskFinally(this ValueTask<Result> resultTask, Func<ValueTask> action)
    {
        var result = await resultTask;
        switch (result.State)
        {
            case ResultState.Success: 
            case ResultState.Error:
                await action.Invoke();
                break;

            default: throw new ResultNotInitializedException(nameof(resultTask));
        }

        return result;
    }
 
    #endregion

    #region ValueOr


    public static async ValueTask<T> ValueTaskValueOr<T>(this ValueTask<Result<T>> resultTask, T fallback)
    {
        var result = await resultTask.ConfigureAwait(false);
        return result.State switch
        {
            ResultState.Success => result.Value,
            ResultState.Error => fallback,
            _ => throw new ResultNotInitializedException(nameof(resultTask))
        };
    }
    public static async ValueTask<T> ValueTaskValueOr<T>(this Result<T> result, Func<Error, ValueTask<T>> fallback)
    {
        return result.State switch
        {
            ResultState.Success => result.Value,
            ResultState.Error => await fallback(result.Error!).ConfigureAwait(false),
            _ => throw new ResultNotInitializedException(nameof(result))
        };
    }
    public static async ValueTask<T> ValueTaskValueOr<T>(this ValueTask<Result<T>> resultTask, Func<Error, T> fallback)
    {
        var result = await resultTask.ConfigureAwait(false);
        return result.State switch
        {
            ResultState.Success => result.Value,
            ResultState.Error => fallback(result.Error!),
            _ => throw new ResultNotInitializedException(nameof(resultTask))
        };
    }
    public static async ValueTask<T> ValueTaskValueOr<T>(this ValueTask<Result<T>> resultTask, Func<Error, ValueTask<T>> fallback)
    {
        var result = await resultTask.ConfigureAwait(false);
        return result.State switch
        {
            ResultState.Success => result.Value,
            ResultState.Error => await fallback(result.Error!).ConfigureAwait(false),
            _ => throw new ResultNotInitializedException(nameof(resultTask))
        };
    }

    #endregion
}