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

namespace Sony.Filtr.Functional
{
    public static class FunctionalProgramming
    {
        public static Func<double, double> Substract(double toSubstract) => x => x - toSubstract;

        public static Func<double, double> Multiply(double multiplier) => x => x * multiplier;

        public static Func<double, double> Divide(double divider) => x => x / divider;

        public static double Percentage(this double @this, double percentage) => @this * percentage / 100;

        public static R FirstOrDefault<T, R>(this T @this, Func<R, bool> predicate, R @default, params Func<T, R>[] prompts)
        {
            foreach (var prompt in prompts)
            {
                R r = prompt(@this);

                if (predicate(r)) { return r; }
            }

            return @default;
        }

        public static async Task<Result<R>> SafeExecute<R>(this Func<Task<R>> func)
        {
            try
            {
                return await func();
            }
            catch (Exception ex)
            {
                return Result<R>.FromException(ex);
            }
        }

        public static Func<R> Partial<T1, R>(this Func<T1, R> func, T1 arg)
        {
            return () => func(arg);
        }

        public static Func<T1, R> PartialLast<T1, T2, R>(this Func<T1, T2, R> func, T2 lastArg)
        {
            return t1 => func(t1, lastArg);
        }

        public static Func<T1, T2, R> PartialLast<T1, T2, T3, R>(this Func<T1, T2, T3, R> func, T3 lastArg)
        {
            return (t1, t2) => func(t1, t2, lastArg);
        }

        public static Func<T1, T2, T3, R> PartialLast<T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> func, T4 lastArg)
        {
            return (t1, t2, t3) => func(t1, t2, t3, lastArg);
        }

        public static Func<T1, T2, T3, T4, R> PartialLast<T1, T2, T3, T4, T5, R>(this Func<T1, T2, T3, T4, T5, R> func, T5 lastArg)
        {
            return (t1, t2, t3, t4) => func(t1, t2, t3, t4, lastArg);
        }

        public static Func<T2, R> Partial<T1, T2, R>(this Func<T1, T2, R> func, T1 arg)
        {
            return (t2) => func(arg, t2);
        }

        public static Func<T2, T3, R> Partial<T1, T2, T3, R>(this Func<T1, T2, T3, R> func, T1 arg)
        {
            return (t2, t3) => func(arg, t2, t3);
        }

        public static Func<T2, T3, T4, R> Partial<T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> func, T1 arg)
        {
            return (t2, t3, t4) => func(arg, t2, t3, t4);
        }

        public static Func<T1, Func<T2, R>> Curry<T1, T2, R>(this Func<T1, T2, R> func)
        {
            return t1 => t2 => func(t1, t2);
        }

        public static Func<T1, Func<T2, Func<T3, R>>> Curry<T1, T2, T3, R>(this Func<T1, T2, T3, R> func)
        {
            return t1 => t2 => t3 => func(t1, t2, t3);
        }

        public static Func<T, R> Memoize<T, R>(this Func<T, R> func) where T : IComparable
        {
            var cache = new Dictionary<T, R>();

            return arg =>
            {
                if (cache.ContainsKey(arg)) { return cache[arg]; }

                return (cache[arg] = func(arg));
            };
        }

        public static Func<IEnumerable<T>, IEnumerable<R>> MemoizeCollectionThreadSafe<T, R>(this Func<IEnumerable<T>, IEnumerable<R>> func, Func<R, T> mapResultToArgument)
            where T : IComparable
        {
            var cache = new ConcurrentDictionary<T, R>();

            return arg =>
            {
                var arg2 = arg.Except(cache.Keys);

                var response = func(arg2);

                foreach (var r in response)
                {
                    cache.GetOrAdd(mapResultToArgument(r), _ => r);
                }

                return response;
            };
        }

        public static Func<IEnumerable<T>, Task<IEnumerable<R>>> MemoizeCollectionThreadSafeAsync<T, R>(this Func<IEnumerable<T>, Task<IEnumerable<R>>> func, Func<R, T> mapResultToArgument)
            where T : IComparable
        {
            var cache = new ConcurrentDictionary<T, Lazy<R>>();

            return async arg =>
            {
                var arg2 = arg.Except(cache.Keys);

                if (arg2.Any())
                {
                    var response = await func(arg2);

                    foreach (var r in response)
                    {
                        cache.GetOrAdd(mapResultToArgument(r), new Lazy<R>(() => r));
                    }
                }

                return arg.Where(a => cache.ContainsKey(a)).Select(a => cache[a].Value).ToList();
            };
        }

        public static Func<T, TResult> LazyMemoizeThreadSafe<T, TResult>(this Func<T, TResult> f)
        {
            var cache = new ConcurrentDictionary<T, Lazy<TResult>>();

            return a => cache.GetOrAdd(a, new Lazy<TResult>(() => f(a), true)).Value;
        }

        public static Func<T, TResult> LazyMemoizeThreadSafeFirstOrDefault<T, TResult>(this Func<T, TResult> f, TResult defaultValue)
        {
            var cache = new ConcurrentDictionary<T, Lazy<TResult>>();

            return a =>
            {
                if (cache.ContainsKey(a)) { return defaultValue; }

                TResult toReturn = defaultValue;
                Func<TResult> lazyFunc = () =>
                {
                    toReturn = f(a);

                    return defaultValue;
                };

                var m = cache.GetOrAdd(a, new Lazy<TResult>(lazyFunc, true)).Value;

                return toReturn;
            };
        }

        public static Func<T2, R> PartialFirst<T1, T2, R>(Func<T1, T2, R> func, T1 arg)
        {
            return func.Partial(arg);
        }

        public static IEnumerable<R> Map<T, R>(this IEnumerable<T> ts, Func<T, R> convert)
        {
            return ts.Select(t => convert(t)).ToArray();
        }

        public static Func<TInput, Task<TOutput>> BeforeStart<TInput, TOutput>(this Func<TInput, Task<TOutput>> func, Action<TInput> action)
        {
            return async x =>
            {
                action(x);

                TOutput result = await func(x);

                return result;
            };
        }

        public static Func<Task<R>> Duration<R>(this Func<Task<R>> func, Action<R, TimeSpan> durationAction)
        {
            return async () =>
            {
                var sw = new Stopwatch();

                sw.Start();
                R result = await func();
                sw.Stop();

                durationAction(result, sw.Elapsed);

                return result;
            };
        }

        public static Func<TInput, Task<TOutput>> Duration<TInput, TOutput>(this Func<TInput, Task<TOutput>> func, Action<TInput, TOutput, TimeSpan> durationAction)
        {
            return async x =>
            {
                Stopwatch sw = new Stopwatch();

                sw.Start();
                TOutput result = await func(x);
                sw.Stop();

                durationAction(x, result, sw.Elapsed);

                return result;
            };
        }

        public static Func<TInput, Task<TOutput>> Trace<TInput, TOutput>(this Func<TInput, Task<TOutput>> func, Action<string> traceAction, Func<TInput, string> messageCreator)
        {
            Func<TInput, string> createMessageSafe = input =>
            {
                try
                {
                    return messageCreator(input);
                }
                catch (Exception ex)
                {
                    return $"Could not create trace message. Error: {ex.Message}";
                }
            };

            return async input =>
            {
                string message = createMessageSafe(input);
                traceAction($"{message} on start {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ff")}");

                try
                {
                    TOutput result = await func(input);

                    traceAction($"{message} on finish {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ff")}");

                    return result;
                }
                catch
                {
                    traceAction($"{message} on ERROR {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ff")}");
                    throw;
                }

            };
        }

        public static Func<TInput, Task<TOutput>> Retry<TInput, TOutput>(this Func<TInput, Task<TOutput>> func, int retries, TimeSpan? retryDelay = null)
        {
            if (retries < 1) { return func; }

            return async input =>
            {
                Exception lastException = null;
                for (int i = 0; i <= retries; ++i)
                {
                    try
                    {
                        return await func(input);
                    }
                    catch (AggregateException ex)
                    {
                        lastException = ex.InnerException;
                    }
                    catch (Exception ex)
                    {
                        lastException = ex;
                    }

                    if (retryDelay.HasValue)
                    {
                        await Task.Delay(retryDelay.Value);
                    }
                }

                throw lastException;
            };
        }

        public static Func<Task<TOutput>> RetryWithCacellation<TOutput>(this Func<CancellationToken, Task<TOutput>> func, int retries, TimeSpan? retryDelay = null)
        {
            return async () =>
            {
                Exception lastException = null;
                for (int i = 0; i <= retries; ++i)
                {
                    var cts = new CancellationTokenSource();
                    try
                    {
                        return await func(cts.Token);
                    }
                    catch (AggregateException ex)
                    {
                        lastException = ex.InnerException;
                    }
                    catch (Exception ex)
                    {
                        lastException = ex;
                    }
                    
                    cts.Cancel();

                    if (retryDelay.HasValue)
                    {
                        await Task.Delay(retryDelay.Value);
                    }
                }

                throw lastException;
            };
        }

        public static Func<TInput, Task<TOutput>> Timeout<TInput, TOutput>(this Func<TInput, Task<TOutput>> func, TimeSpan taskTimeout)
        {
            return async input =>
            {
                var funcTask = func(input);
                var delayTask = Task.Delay(taskTimeout);
                var firstToFinishTask = await Task.WhenAny(funcTask, delayTask);

                if (firstToFinishTask == delayTask)
                {
                    throw new TimeoutException($"Timed out: {taskTimeout.TotalSeconds} secs");
                }

                return funcTask.Result;
            };
        }

        public static Func<TInput, Task<Unit>> ToUnit<TInput>(this Func<TInput, Task> action)
        {
            return async input =>
            {
                await action(input);

                return Unit.Default;
            };
        }

        public static Func<(T1, T2, T3, T4), R> Tuple<T1, T2, T3, T4, R>(this Func<T1, T2, T3, T4, R> func)
        {
            return tuple => func(tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4);
        }

        public static Func<(T1, T2, T3), R> Tuple<T1, T2, T3, R>(this Func<T1, T2, T3, R> func)
        {
            return tuple => func(tuple.Item1, tuple.Item2, tuple.Item3);
        }

        public static Func<(T1, T2), R> Tuple<T1, T2, R>(this Func<T1, T2, R> func)
        {
            return tuple => func(tuple.Item1, tuple.Item2);
        }

        public static Func<(T1, T2, T3, T4, T5), R> Tuple<T1, T2, T3, T4, T5, R>(this Func<T1, T2, T3, T4, T5, R> func)
        {
            return tuple => func(tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4, tuple.Item5);
        }

        public static Func<T1, T2, R> UnwrapTuple<T1, T2, R>(this Func<(T1, T2), R> func)
        {
            return (t1, t2) => func((t1, t2));
        }

        public static Func<T1, T2, T3, R> UnwrapTuple<T1, T2, T3, R>(this Func<(T1, T2, T3), R> func)
        {
            return (t1, t2, t3) => func((t1, t2, t3));
        }

        public static Func<T, Tuple<T, R>> TupleResponse<T, R>(this Func<T, R> func)
        {
            return x =>
            {
                R result = func(x);

                return new Tuple<T, R>(x, result);
            };
        }

        public static Func<T, Task<R>> ToTask<T, R>(this Func<T, R> func)
        {
            return x =>
            {
                R result = func(x);

                return Task.FromResult(result);
            };
        }

        public static Func<T, Task<Unit>> ToTask<T>(this Action<T> action)
        {
            return input =>
            {

                action(input);

                return Task.FromResult(Unit.Default);
            };
        }

        public static Task<T> Catch<T, TError>(this Task<T> task, Func<TError, T> onError) where TError : Exception
        {
            var tcs = new TaskCompletionSource<T>();

            task.ContinueWith(innerTask =>
            {
                if (innerTask.IsFaulted && innerTask?.Exception?.InnerException is TError)
                    tcs.SetResult(onError((TError)innerTask.Exception.InnerException));
                else if (innerTask.IsCanceled)
                    tcs.SetCanceled();
                else if (innerTask.IsFaulted)
                    tcs.SetException(innerTask?.Exception?.InnerException ?? throw new InvalidOperationException());
                else
                    tcs.SetResult(innerTask.Result);
            });
            return tcs.Task;
        }

        public static Task<TOut> Map<TIn, TOut>(this Task<TIn> input, Func<TIn, TOut> map) => input.ContinueWith(t => map(t.Result));

        public static Func<TIn, Task<TOut>> Map<TIn, TOut, TFuncIn, TFuncOut>(this Func<TFuncIn, Task<TFuncOut>> input,
            Func<TIn, TFuncIn> inputTransform,
            Func<TFuncIn, TFuncOut, TIn, TOut> outputTransform)
        {
            Func<TIn, Task<TOut>> f = async x =>
            {
                TFuncIn funcInput = inputTransform(x);
                TFuncOut result = await input(funcInput);

                return outputTransform(funcInput, result, x);
            };

            return f;
        }

        public static Func<TIn, Task<TOut>> Map<TIn, TOut, TFuncIn, TFuncOut>(this Func<TFuncIn, Task<TFuncOut>> input,
            Func<TIn, Task<TFuncIn>> inputTransform,
            Func<TFuncIn, TFuncOut, TIn, Task<TOut>> outputTransform)
        {
            Func<TIn, Task<TOut>> f = async x =>
            {
                TFuncIn funcInput = await inputTransform(x);
                TFuncOut result = await input(funcInput);

                return await outputTransform(funcInput, result, x);
            };

            return f;
        }

        //public static Task<TOut> Apply<TIn, TOut>(this Task<TIn> task, Task<Func<TIn, TOut>> liftedFn)
        //{
        //    var tcs = new TaskCompletionSource<TOut>();
        //    liftedFn.ContinueWith(innerLiftTask =>
        //        task.ContinueWith(innerTask =>
        //            tcs.SetResult(innerLiftTask.Result(innerTask.Result))
        //    ));
        //    return tcs.Task;
        //}

        //public static Task<TOut> Apply<TIn, TOut>(this Task<Func<TIn, TOut>> liftedFn, Task<TIn> task) => task.Apply(liftedFn);

        public static Task<TOut> Select<TIn, TOut>(this Task<TIn> task, Func<TIn, TOut> projection)
        {
            var r = new TaskCompletionSource<TOut>();
            task.ContinueWith(self =>
            {
                if (self.IsFaulted) r.SetException(self.Exception.InnerExceptions);
                else if (self.IsCanceled) r.SetCanceled();
                else r.SetResult(projection(self.Result));
            });
            return r.Task;
        }

        //public static Task<Func<TMid, TOut>> Apply<TIn, TMid, TOut>(this Task<Func<TIn, TMid, TOut>> liftedFn, Task<TIn> input)
        //    => input.Apply(liftedFn.Map(FunctionalProgramming.Curry));

        public static Func<T, Task<IEnumerable<Result<R>>>> SelectMany<T, R>(this Func<T, Task<Result<IEnumerable<R>>>> func)
        {
            return async x =>
            {
                Result<IEnumerable<R>> result = await func(x);

                return result.IsFailed ?
                    new Result<R>[] { Result<R>.FromException(result.Exception) } :
                    result.Value.Select(r => Result<R>.Success(r)).ToArray();
            };
        }

        //public static Task<TOut> SelectMany<TIn, TOut>(this Task<TIn> first, Func<TIn, Task<TOut>> next)
        //{
        //    var tcs = new TaskCompletionSource<TOut>();
        //    first.ContinueWith(delegate
        //    {
        //        if (first.IsFaulted) tcs.TrySetException(first.Exception.InnerExceptions);
        //        else if (first.IsCanceled) tcs.TrySetCanceled();
        //        else
        //        {
        //            try
        //            {
        //                var t = next(first.Result);
        //                if (t == null) tcs.TrySetCanceled();
        //                else t.ContinueWith(delegate
        //                {
        //                    if (t.IsFaulted) tcs.TrySetException(t.Exception.InnerExceptions);
        //                    else if (t.IsCanceled) tcs.TrySetCanceled();
        //                    else tcs.TrySetResult(t.Result);
        //                }, TaskContinuationOptions.ExecuteSynchronously);
        //            }
        //            catch (Exception exc) { tcs.TrySetException(exc); }
        //        }
        //    }, TaskContinuationOptions.ExecuteSynchronously);
        //    return tcs.Task;
        //}

        //public static Task<TOut> SelectMany<TIn, TMid, TOut>(
        //  this Task<TIn> input, Func<TIn, Task<TMid>> f, Func<TIn, TMid, TOut> projection)
        //{
        //    return Bind(input, outer =>
        //           Bind(f(outer), inner =>
        //           Return(projection(outer, inner))));
        //}

        public static Task<TOut> Next<TIn, TOut>(this Task<TIn> task, Func<TIn, Task<TOut>> next)
        {
            if (task == null) throw new ArgumentNullException("task");
            if (next == null) throw new ArgumentNullException("next");

            var tcs = new TaskCompletionSource<TOut>();
            task.ContinueWith(delegate
            {
                if (task.IsFaulted) tcs.TrySetException(task.Exception.InnerExceptions);
                else if (task.IsCanceled) tcs.TrySetCanceled();
                else
                {
                    try
                    {
                        var t = next(task.Result);
                        if (t == null) tcs.TrySetCanceled();
                        else t.ContinueWith(delegate
                        {
                            if (t.IsFaulted) tcs.TrySetException(t.Exception.InnerExceptions);
                            else if (t.IsCanceled) tcs.TrySetCanceled();
                            else tcs.TrySetResult(t.Result);
                        }, TaskContinuationOptions.ExecuteSynchronously);
                    }
                    catch (Exception exc) { tcs.TrySetException(exc); }
                }
            }, TaskContinuationOptions.ExecuteSynchronously);
            return tcs.Task;
        }

        public static IEnumerable<Task<T>> ProcessAsComplete<T>(this IEnumerable<Task<T>> inputTasks)
        {
            // Copy the input so we know it’ll be stable, and we don’t evaluate it twice
            var inputTaskList = inputTasks.ToList();
            // Could use Enumerable.Range here, if we wanted…
            var completionSourceList = new List<TaskCompletionSource<T>>(inputTaskList.Count);
            for (int i = 0; i < inputTaskList.Count; i++)
            {
                completionSourceList.Add(new TaskCompletionSource<T>());
            }

            // At any one time, this is "the index of the box we’ve just filled".
            // It would be nice to make it nextIndex and start with 0, but Interlocked.Increment
            // returns the incremented value…
            int prevIndex = -1;

            // We don’t have to create this outside the loop, but it makes it clearer
            // that the continuation is the same for all tasks.
            Action<Task<T>> continuation = completedTask =>
            {
                int index = Interlocked.Increment(ref prevIndex);
                var source = completionSourceList[index];
                switch (completedTask.Status)
                {
                    case TaskStatus.Canceled:
                        source.TrySetCanceled();
                        break;
                    case TaskStatus.Faulted:
                        source.TrySetException(completedTask.Exception.InnerExceptions);
                        break;
                    case TaskStatus.RanToCompletion:
                        source.TrySetResult(completedTask.Result);
                        break;
                    default:
                        throw new ArgumentException("Task was not completed");
                }
            };

            foreach (var inputTask in inputTaskList)
            {
                inputTask.ContinueWith(continuation,
                                       CancellationToken.None,
                                       TaskContinuationOptions.ExecuteSynchronously,
                                       TaskScheduler.Default);
            }

            return completionSourceList.Select(source => source.Task);
        }
    }

    public static class FuncUtils
    {
        public static Func<T2, R> Partial<T1, T2, R>(Func<T1, T2, R> func, T1 firstParam)
        {
            return t2 => func(firstParam, t2);
        }

        public static Func<T2, T3, R> Partial<T1, T2, T3, R>(Func<T1, T2, T3, R> func, T1 firstParam)
        {
            return (t2, t3) => func(firstParam, t2, t3);
        }

        public static Func<T2, T3, T4, R> Partial<T1, T2, T3, T4, R>(Func<T1, T2, T3, T4, R> func, T1 firstParam)
        {
            return (t2, t3, t4) => func(firstParam, t2, t3, t4);
        }

        public static Func<T2, T3, T4, T5, R> Partial<T1, T2, T3, T4, T5, R>(Func<T1, T2, T3, T4, T5, R> func, T1 firstParam)
        {
            return (t2, t3, t4, t5) => func(firstParam, t2, t3, t4, t5);
        }

        public static Func<T, Task<R>> ToFunc<T, R>(Func<T, Task<R>> func) { return func; }
    }

    public static class ResultExtensions1
    {
        public static Func<Task<Result<T>>> TryCatch<T>(this Func<Task<T>> func)
        {
            return async () =>
            {
                try
                {
                    return await func();
                }
                catch (Exception ex)
                {
                    return ex;
                }
            };
        }

        public static Func<Result<Unit>> TryCatch(this Action action)
        {
            return () =>
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                try
                {
                    action();
                }
                catch (Exception ex)
                {
                    sw.Stop();
                    return Result<Unit>.FromException(ex, sw.Elapsed);
                }

                return Result<Unit>.Success(Unit.Default);
            };
        }

        public static Func<T, Task<Result<R>>> TryCatch<T, R>(this Func<T, Task<R>> func)
        {
            return async x =>
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                try
                {
                    return await func(x);
                }
                catch (Exception ex)
                {
                    sw.Stop();
                    return Result<R>.FromException(ex, sw.Elapsed);
                }
            };
        }

        public static Func<T, Result<R>> TryCatch<T, R>(this Func<T, R> func)
        {
            return x =>
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                try
                {
                    return func(x);
                }
                catch (Exception ex)
                {
                    sw.Stop();
                    return Result<R>.FromException(ex, sw.Elapsed);
                }
            };
        }

        public static Func<Result<T>, Task<R>> AcceptResult<T, R>(this Func<T, Task<R>> func)
        {
            return result =>
            {
                return func(result.Value);
            };
        }

        public static async Task<Result<R>> OnSuccess<T, R>(this Task<Result<T>> resultTask, Func<T, Task<R>> func)
        {
            Result<T> result = await resultTask.ConfigureAwait(false);

            if (result.IsFailed) { return Result<R>.FromException(result.Exception); }

            return await func(result.Value).ConfigureAwait(false);
        }

        public static async Task<Result<T>> OnSuccess<T>(this Task<Result<T>> resultTask, Func<T, Task> func)
        {
            Result<T> result = await resultTask.ConfigureAwait(false);

            if (result.IsFailed) { return Result<T>.FromException(result.Exception); }

            await func(result.Value).ConfigureAwait(false);

            return result;
        }

        public static async Task<Result<T>> OnSuccess<T>(this Task<Result<T>> resultTask, Action<T> action)
        {
            Result<T> result = await resultTask.ConfigureAwait(false);

            if (result.IsFailed) { return Result<T>.FromException(result.Exception); }

            action(result.Value);

            return result;
        }

        public static Func<Result<T>> OnFailure<T>(this Func<Result<T>> resultFunc, Action<Result<T>> failureAction)
        {
            return () =>
            {
                var result = resultFunc();

                if (result.IsFailed)
                {
                    failureAction(result);
                }

                return result;
            };
        }

        public static async Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Func<Task> func)
        {
            Result<T> result = await resultTask.ConfigureAwait(false);

            if (result.IsFailed)
                await func().ConfigureAwait(false);
            return result;
        }

        public static async Task<Result<T>> OnFailure<T>(this Task<Result<T>> resultTask, Action<Exception> action)
        {
            Result<T> result = await resultTask.ConfigureAwait(false);

            if (result.IsFailed)
            {
                action(result.Exception);
            }

            return result;
        }

        public static Func<T, Task<Result<R>>> OnFailure<T, R>(this Func<T, Task<Result<R>>> func, Action<T, Result<R>> failureAction)
        {
            return async x =>
            {
                Result<R> result = await func(x);

                if (result.IsFailed)
                {
                    failureAction(x, result);
                }

                return result;
            };
        }

        public static Func<Task<Result<R>>> OnFailure<R>(this Func<Task<Result<R>>> func, Action<Result<R>> failureAction)
        {
            return async () =>
            {
                Result<R> result = await func();

                if (result.IsFailed)
                {
                    failureAction(result);
                }

                return result;
            };
        }

        public static Func<T, Task<Result<R>>> OnSuccess<T, R>(this Func<T, Task<Result<R>>> func, Action<T, Result<R>> successAction)
        {
            return async x =>
            {
                Result<R> result = await func(x);

                if (result.IsOk)
                {
                    successAction(x, result);
                }

                return result;
            };
        }

        public static Func<T, Task<Result<R2>>> BindAsync<T, R1, R2>(this Func<T, Task<Result<R1>>> func, Func<R1, R2> project)
        {
            return async x => {
                Result<R1> result = await func(x);

                return result.IsOk ?
                    project(result.Value) :
                    Result<R2>.FromException(result.Exception);
            };
        }

        public static Func<T, Task<Result<R2>>> BindAsync<T, R1, R2>(this Func<T, Task<Result<R1>>> func, Func<T, R1, R2> project)
        {
            return async x => {
                Result<R1> result = await func(x);

                return result.IsOk ?
                    project(x, result.Value) :
                    Result<R2>.FromException(result.Exception);
            };
        }

        public static Func<T, Task<Result<R>>> TapAsync<T, R>(this Func<T, Task<Result<R>>> func, Action<R> action)
        {
            return async x => {
                Result<R> result = await func(x);

                if (result.IsOk)
                {
                    action(result.Value);
                }

                return result;
            };
        }

        public static Func<T, Task<Result<R>>> TapAsync<T, R>(this Func<T, Task<Result<R>>> func, Action<T, R> action)
        {
            return async x => {
                Result<R> result = await func(x);

                if (result.IsOk)
                {
                    action(x, result.Value);
                }

                return result;
            };
        }

        public static Func<T, Task<R>> OnSuccessUnsafe<T, R>(this Func<T, Task<R>> func, Action<T, R> successAction)
        {
            return async x =>
            {
                R result = await func(x);

                successAction(x, result);

                return result;
            };
        }

        public static Func<T, Task<R>> OnFailureWithRethrow<T, R>(this Func<T, Task<R>> func, Action<T, Result<R>> failureAction)
        {
            return async x =>
            {
                Stopwatch sw = new Stopwatch();
                sw.Start();
                try
                {
                    R result = await func(x);

                    return result;
                }
                catch (Exception e)
                {
                    sw.Stop();
                    failureAction(x, Result<R>.FromException(e, sw.Elapsed));
                    throw;
                }
            };
        }
    }
}