using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;

namespace Sony.Filtr.Utility.HttpHandlers
{
    public class ThreadRateLimitHttpHandler : DelegatingHandler
    {
        private readonly int Capacity;

        private ActionBlock<TaskInput<HttpRequestMessage, HttpResponseMessage>> ProcessBlock;

        public ThreadRateLimitHttpHandler(int capacity)
        {
            this.Capacity = capacity;

            this.ProcessBlock = new ActionBlock<TaskInput<HttpRequestMessage, HttpResponseMessage>>(async input => {
                try
                {
                    //Console.WriteLine($"LIMIT + {input.Input.RequestUri}");
                    var response = await base.SendAsync(input.Input, input.Token);
                    //Console.WriteLine($"LIMIT - {response.StatusCode} {input.Input.RequestUri}");

                    input.TaskCompletionsSource.SetResult(response);
                }
                catch (Exception ex)
                {
                    //Console.ForegroundColor = ConsoleColor.Green;
                    //Console.WriteLine($"LIMIT !!!!!!!!!!!!! {input.Input.RequestUri} {ex.Message}");
                    //Console.ResetColor();
                    input.TaskCompletionsSource.SetException(ex);
                }

            }, new ExecutionDataflowBlockOptions { EnsureOrdered = false, MaxDegreeOfParallelism = capacity });
        }
        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            var taskInput = TaskInput<HttpRequestMessage, HttpResponseMessage>.Create(request, cancellationToken);

            //Console.WriteLine($"LIMIT +++ {request.RequestUri}");

            this.ProcessBlock.SendAsync(taskInput);

            //Console.WriteLine($"LIMIT --- {request.RequestUri} {this.ProcessBlock.Completion.Status} {this.ProcessBlock.Completion.Exception}");

            return taskInput.TaskCompletionsSource.Task;
        }

        private class TaskInput<TInput, TResponse>
        {
            public readonly TInput Input;
            public readonly TaskCompletionSource<TResponse> TaskCompletionsSource;
            public CancellationToken Token;

            private TaskInput(TaskCompletionSource<TResponse> tcs, TInput input, CancellationToken token)
            {
                this.Input = input;
                this.TaskCompletionsSource = tcs;
                this.Token = token;
            }

            public static TaskInput<TInput, TResponse> Create(TInput input, CancellationToken token)
            {
                return new TaskInput<TInput, TResponse>(new TaskCompletionSource<TResponse>(TaskCreationOptions.RunContinuationsAsynchronously), input, token);
            }
        }
    }
}