using System;
using Status = OperationStatus;

/// <summary>
/// Represents a generic type for any operation's result
/// </summary>
public class OperationResult<TValue>
{
    public OperationResult(Exception exception)
        : this(Status.InternalError)
    {
        this.Exception = exception;
    }

    public OperationResult(Status status, string message)
        : this(status)
    {
        this.Message = message;
    }

    public OperationResult(Status status, TValue value = default(TValue))
    {
        this.Status = status;
        this.Success = status == Status.Success;
        this.Value = value;
    }

    /// <summary>
    /// If Success is false and an exception has been caught internally, this field will contain the exception.
    /// </summary>
    public Exception Exception { get; private set; }

    /// <summary>
    /// Returns message if the operation was not successful.
    /// </summary>
    public string Message { get; private set; }

    /// <summary>
    /// The status for the operation.
    /// </summary>
    public Status Status { get; private set; }

    /// <summary>
    /// Returns true if the operation was successful.
    /// </summary>
    /// <remarks>If Success is false, use the Exception property to help determine the reason.</remarks>
    public bool Success { get; private set; }

    /// <summary>
    /// The result obtained during the operation.
    /// </summary>
    public TValue Value { get; private set; }
}

/// <summary>
/// Represents a status of an operation
/// </summary>
public enum OperationStatus
{
    /// <summary>
    /// Indicates that the status has not been set.
    /// </summary>
    Undefined = 0,

    /// <summary>
    /// The operation was successful.
    /// </summary>
    Success,

    /// <summary>
    /// The requested resource does not exist.
    /// </summary>
    NotFound,

    /// <summary>
    /// The operation is not allowed.
    /// </summary>
    NotAllowed,

    /// <summary>
    /// The operation is not supported at the moment.
    /// </summary>
    NotSupported,

    /// <summary>
    /// The operation is not valid (for example it contains an inconsistent data).
    /// </summary>
    NotValid,

    /// <summary>
    /// An internal error has occured.
    /// </summary>
    InternalError
}

private static ActionResult ToActionResult<TValue>(IOperationResult<TValue> source, Func<TValue, ActionResult> onSuccess)
{
    switch (source.Status)
    {
        case OperationStatus.InternalError:
            var exception = source.Exception;
            return exception == null
                ? new HttpStatusCodeResult(HttpStatusCode.InternalServerError)
                : new HttpStatusCodeResult(HttpStatusCode.InternalServerError, exception.Message);
        case OperationStatus.NotAllowed:
            return new HttpStatusCodeResult(HttpStatusCode.Forbidden, source.Message);
        case OperationStatus.NotSupported:
        case OperationStatus.NotValid:
            return new HttpStatusCodeResult(HttpStatusCode.MethodNotAllowed, source.Message);
        case OperationStatus.NotFound:
            return new HttpStatusCodeResult(HttpStatusCode.NotFound, source.Message);
        case OperationStatus.Success:
            return onSuccess(source.Value);
    }

    throw new NotImplementedException($"Conversion is not implemented for the following OperationStatus value: {source.Status}");
}

public async Task<ActionResult<MyResult>> GetData([FromBody] MyParameters parameters)
{
    var result = await _myService.GetDataAsync(parameters);
	   
    return ToActionResult(result, value => this.Json(value));
}

private static ActionResult ToActionResult<TValue>(IOperationResult<TValue> source, Func<TValue, ActionResult> onSuccess)

internal static ActionResult ToActionResult<TValue>(this IOperationResult<TValue> source, Func<TValue, ActionResult> onSuccess)

public async Task<ActionResult<MyResult>> GetData([FromBody] MyParameters parameters)
{
    return await _myService.GetDataAsync(parameters).ToActionResult(this.Json);
}

private static ActionResult ToActionResult<TValue>(IOperationResult<TValue> source, Func<TValue, ActionResult> onSuccess)

internal static ActionResult ToActionResult<TValue>(this IOperationResult<TValue> source, Func<TValue, ActionResult> onSuccess)

public async Task<ActionResult<MyResult>> GetData([FromBody] MyParameters parameters)
{
    return await _myService.GetDataAsync(parameters).ToActionResult(this.Json);
}

TResult DoSomething()

Task<TResult> DoSomethingAsync()