Result.cs

namespace ResultPattern;

/// <summary>
/// Base Result class that represents the outcome of an operation without a value.
/// </summary>
public class Result
{
    public bool IsSuccess { get; }
    public bool IsFailure => !IsSuccess;
    public string? Error { get; }

    // Protected constructor for base class
    protected Result(bool isSuccess, string? error)
    {
        if (isSuccess && error != null)
            throw new InvalidOperationException("A success result cannot have an error");
        if (!isSuccess && string.IsNullOrWhiteSpace(error))
            throw new InvalidOperationException("A failure result must have an error");

        IsSuccess = isSuccess;
        Error = error;
    }

    // Factory methods for creating Results
    public static Result Success() => new(true, null);
    public static Result Failure(string error) => new(false, error);

    // Factory methods for creating generic Results
    public static Result<T> Success<T>(T value) => Result<T>.Success(value);
    public static Result<T> Failure<T>(string error) => Result<T>.Failure(error);

    public void Match(Action onSuccess, Action<string> onFailure)
    {
        if (IsSuccess)
            onSuccess();
        else
            onFailure(Error!);
    }

    public TResult Match<TResult>(Func<TResult> onSuccess, Func<string, TResult> onFailure)
        => IsSuccess ? onSuccess() : onFailure(Error!);
}

/// <summary>
/// Generic Result class that inherits from base Result and adds a value.
/// </summary>
public class Result<T> : Result
{
    private readonly T? _value;

    public T? Value => IsSuccess ? _value : default;

    private Result(bool isSuccess, T? value, string? error)
        : base(isSuccess, error)
    {
        if (isSuccess && value == null)
            throw new InvalidOperationException("A success result must have a value");

        _value = value;
    }

    public new static Result<T> Success(T value) => new(true, value, null);
    public new static Result<T> Failure(string error) => new(false, default, error);

    public Result<TNew> Map<TNew>(Func<T, TNew> mapper)
        => IsSuccess ? Result<TNew>.Success(mapper(Value!)) : Result<TNew>.Failure(Error!);

    public async Task<Result<TNew>> MapAsync<TNew>(Func<T, Task<TNew>> mapper)
        => IsSuccess ? Result<TNew>.Success(await mapper(Value!)) : Result<TNew>.Failure(Error!);

    public Result<TNew> Bind<TNew>(Func<T, Result<TNew>> binder)
        => IsSuccess ? binder(Value!) : Result<TNew>.Failure(Error!);

    public async Task<Result<TNew>> BindAsync<TNew>(Func<T, Task<Result<TNew>>> binder)
        => IsSuccess ? await binder(Value!) : Result<TNew>.Failure(Error!);

    public T Unwrap() => IsSuccess ? Value! : throw new InvalidOperationException($"Cannot unwrap failure result: {Error}");

    public T UnwrapOr(T defaultValue) => IsSuccess ? Value! : defaultValue;

    public new void Match(Action<T> onSuccess, Action<string> onFailure)
    {
        if (IsSuccess)
            onSuccess(Value!);
        else
            onFailure(Error!);
    }

    public new TResult Match<TResult>(Func<T, TResult> onSuccess, Func<string, TResult> onFailure)
        => IsSuccess ? onSuccess(Value!) : onFailure(Error!);
}

// Extension methods
public static class ResultExtensions
{
    public static Result<T> ToResult<T>(this T value)
        => Result<T>.Success(value);

    public static Result<T> ToFailure<T>(this string error)
        => Result<T>.Failure(error);
        
    // Combine multiple results
    public static Result CombineAll(this IEnumerable<Result> results)
    {
        var failureResults = results.Where(r => r.IsFailure).ToList();
        
        if (failureResults.Any())
        {
            var errorMessage = string.Join(Environment.NewLine, 
                failureResults.Select(r => r.Error));
            return Result.Failure(errorMessage);
        }
        
        return Result.Success();
    }
}