using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Sony.Filtr.Functional
{
    public static class ResultExtensions
    {
        public static Result<T> ToResult<T>(this T value)
        {
            return Result<T>.Success(value);
        }

        public static T Flatten<T>(this Result<T> result)
        {
            return result.IsFailed ?
                throw result.Exception :
                result.Value;
        }

        public static async Task<T> Flatten<T>(this Task<Result<T>> resultTask)
        {
            Result<T> result = await resultTask;

            return result.IsFailed ?
                throw result.Exception :
                result.Value;
        }

        public static Task<Result<T>> ToTask<T>(this Result<T> result)
        {
            return Task.FromResult(result);
        }

        public static Result<T1> Bind<T, T1>(this Result<T> result, Func<T, Result<T1>> func)
        {
            return result.IsOk ? func(result.Value) : Result<T1>.FromException(result.Exception);
        }

        public static Result<T1[]> BindMany<T, T1>(this Result<T[]> result, Func<T, T1> func)
        {
            if (result.IsFailed) { return Result<T1[]>.FromException(result.Exception); }

            return result.Value.Select(item => func(item)).ToArray().ToResult();
        }

        public static Result<T1> Bind<T, T1>(this Result<T> result, Func<T, T1> func)
        {
            return result.Bind(func.TryCatch());
        }

        public static async Task<Result<TOut>> Bind<TIn, TOut>(this Task<Result<TIn>> input, Func<TIn, Result<TOut>> f)
        {
            var result = await input;

            if (result.IsOk)
            {
                return f(result.Value);
            }

            return Result<TOut>.FromException(result.Exception);
        }

        public static async Task<Result<TOut>> Bind<TIn, TOut>(this Task<Result<TIn>> input, Func<TIn, TOut> f)
        {
            return await input.Bind(f.TryCatch());
        }

        public static async Task<Result<T1>> BindAsync<T, T1>(this Result<T> result, Func<T, Task<T1>> func)
        {
            if (result.IsFailed) { Result<T1>.FromException(result.Exception); }

            return await func.TryCatch()(result.Value);
        }

        public static async Task<Result<T1>> BindAsync<T, T1>(this Result<T> result, Func<T, Task<Result<T1>>> func)
        {
            if (result.IsFailed) { Result<T1>.FromException(result.Exception); }

            return await func(result.Value);
        }

        public static async Task<Result<TOut>> BindAsync<TIn, TOut>(this Task<Result<TIn>> input, Func<TIn, Task<Result<TOut>>> f)
        {
            var result = await input;

            if (result.IsOk)
            {
                return await f(result.Value);
            }

            return Result<TOut>.FromException(result.Exception);
        }

        public static async Task<Result<IEnumerable<TOut>>> BindManyAsync<TIn, TOut>(this Task<Result<IEnumerable<TIn>>> input, Func<TIn, TOut> f)
        {
            var result = await input;

            if (result.IsOk)
            {
                return result.Value
                    .Select(v => f(v))
                    .ToList();
            }

            return Result<IEnumerable<TOut>>.FromException(result.Exception);
        }

        public static async Task<Result<TOut>> BindAsync<TIn, TOut>(this Task<Result<TIn>> input, Func<TIn, Task<TOut>> f)
        {
            return await input.BindAsync(f.TryCatch());
        }

        public static async Task<Result<T>> TapAsync<T>(this Task<Result<T>> resultTask, Action action)
        {
            var result = await resultTask;
            if (result.IsOk)
            {
                action();
            }

            return result;
        }

        public static async Task<Result<T>> TapAsync<T>(this Task<Result<T>> resultTask, Func<Task> action)
        {
            var result = await resultTask;
            if (result.IsOk)
            {
                await action();
            }

            return result;
        }

        public static async Task<Result<T>> TapAsync<T>(this Task<Result<T>> resultTask, Action<T> action)
        {
            var result = await resultTask;
            if (result.IsOk)
            {
                action(result.Value);
            }

            return result;
        }

        public static async Task<Result<T>> TapAsync<T>(this Task<Result<T>> resultTask, Func<T, Task> action)
        {
            var result = await resultTask;
            if (result.IsOk)
            {
                await action(result.Value);
            }

            return result;
        }

        public static async Task<Result<T>> TapAsync<T, T1>(this Task<Result<T>> resultTask, Func<T1, Task> action, Func<T, T1> mapper)
        {
            var result = await resultTask;
            if (result.IsOk)
            {
                await action(mapper(result.Value));
            }

            return result;
        }

        public static Result<T> Tap<T>(this Result<T> result, Action<T> action)
        {
            if (result.IsOk)
            {
                action(result.Value);
            }

            return result;
        }

        public static Result<T> OnFailure<T>(this Result<T> result, Action<Exception> action)
        {
            if (result.IsFailed)
            {
                action(result.Exception);
            }

            return result;
        }

        public static Result<T> OnSuccess<T>(this Result<T> result, Action<T> action)
        {
            if (result.IsOk)
            {
                action(result.Value);
            }

            return result;
        }
    }
}