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

namespace Pithos.Core
{
    public static class TaskExtensions
    {
        public static Task<T2> Then<T1, T2>(this Task<T1> first, Func<T1, Task<T2>> next)
        {
            if (first == null)
                throw new ArgumentNullException("first");
            if (next == null)
                throw new ArgumentNullException("next");
            Contract.EndContractBlock();
            return Then(first, next, CancellationToken.None);
        }

        public static Task Then<T1>(this Task<T1> first, Func<T1, Task> next)
        {
            if (first == null)
                throw new ArgumentNullException("first");
            if (next == null)
                throw new ArgumentNullException("next");
            Contract.EndContractBlock();
            return Then(first, next, CancellationToken.None);
        }

        public static Task<T2> Then<T1, T2>(this Task<T1> first, Func<T1, Task<T2>> next, CancellationToken cancellationToken)
        {
            if (first == null) 
                throw new ArgumentNullException("first");
            if (next == null) 
                throw new ArgumentNullException("next");
            Contract.EndContractBlock();
            Contract.Assume(TaskScheduler.Current!=null);

            var tcs = new TaskCompletionSource<T2>();
            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); }
                }
            }, cancellationToken, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Current);
            return tcs.Task;
        }

        public static Task Then<T1>(this Task<T1> first, Func<T1, Task> next, CancellationToken cancellationToken)
        {
            if (first == null)
                throw new ArgumentNullException("first");
            if (next == null)
                throw new ArgumentNullException("next");
            Contract.EndContractBlock();
            Contract.Assume(TaskScheduler.Current != null);

            var tcs = new TaskCompletionSource<object>();
            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(null);
                        }, TaskContinuationOptions.ExecuteSynchronously);
                    }
                    catch (Exception exc) { tcs.TrySetException(exc); }
                }
            }, cancellationToken, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Current);
            return tcs.Task;
        }



        public static void ReportExceptions(this Task task,Action<AggregateException> OnError,Action OnSuccess )
        {
            if (!task.IsCompleted) throw new InvalidOperationException("The task has not completed.");
            if (task.IsFaulted)             
                task.Exception.Handle(exc=>
                                          {
                                              OnError(task.Exception);
                                              return true;
                                          }); 
            else
            {
                OnSuccess();
            }
        }

        public static bool TryRemove<T>(this ObservableConcurrentCollection<T> collection,T item) where T:class
        {
            IProducerConsumerCollection<T> items= collection;
            for (var i = 0; i < items.Count; i++)
            {
                T tempItem;
                if (!items.TryTake(out tempItem)) 
                    return false;
                if (tempItem == item) 
                    return true;
                items.TryAdd(item);
            }
            return false;
        }

    }
}