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

namespace Sony.Filtr.Functional
{
    public static class ResultExtensions
    {
        public static T FirstOrDefaultTryCatch<T>(this IEnumerable<T> source, Func<T, bool> predicate)
        {
            var safePredicate = predicate.TryCatch();

            return source.FirstOrDefault(t => { var result = safePredicate(t); return result.IsOk && result.Value; });
        }

        public static async Task<Result<TResult>> Prompt<T, TResult>(this Result<T> result, Func<T, Task<TResult>>[] prompts, Func<TResult, bool> isAcceptable)
        {
            if (result.IsFailed) { return Result<TResult>.FromException(result.Exception); }

            foreach (var prompt in prompts)
            {
                var promptResult = await prompt.TryCatch()(result.Value);

                if (promptResult.IsOk && isAcceptable(promptResult.Value)) { return promptResult; }
            }

            return Result<TResult>.FromException(new Exception("All prompts failed"));
        }

        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 async Task<T> Flatten<T>(this Task<Result<T>> resultTask, Func<Exception, T> exceptionTransform)
        {
            Result<T> result = await resultTask;

            return result.IsFailed ?
                exceptionTransform(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<TOut>> BindFinalize<TIn, TOut>(this Task<Result<TIn>> input, Func<TIn, TOut> func, Action<TIn> finalizer)
        {
            var result = await input;

            if (result.IsOk)
            {
                var toReturn = func.TryCatch()(result.Value);

                finalizer(result.Value);

                return toReturn;
            }

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

        public static async Task<Result<T>> TapAsync<T>(this Result<T> result, Func<T, Task> action)
        {
            if (result.IsFailed) { return result; }

            Func<T, Task<bool>> func = async input => {
                await action(input);
                return true;
            };

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

            return result;
        }

        public static async Task<Result<(T, T1)>> BindAndTupleAsync<T, T1>(this Task<Result<T>> sourceResult, Func<T, Task<T1>> func)
        {
            var source = await sourceResult;
            if (source.IsFailed) { return Result<(T, T1)>.FromException(source.Exception); }

            var result = await func.TryCatch()(source.Value);

            return result.IsOk ? (source.Value, result.Value) : Result<(T, T1)>.FromException(result.Exception);
        }

        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;
        }
    }
}