using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Threading;

using System.Threading.Tasks;

using System.Linq;

public class Program

{

    public async static void Main()

    {

        // Don't do anything.

        var threads = 4;

        if (threads < 1)

            return;

​

        //int exceptionBatchSize = Math.Max(0, SystemSettings.GetExceptionBatchSize());

        TimeSpan exceptionBatchTimeBudget = TimeSpan.FromSeconds(10);

        //string exclude = GetExceptionLogIDExcludes(EVENT_EXCEPTION.VR_REGROUPING);

​

        /*

        var quString = new Dictionary<string, string> {

            { "batchSize", exceptionBatchSize.ToString() } ,

            { "exclude", exclude }

        };

        var response = await InternalApiHelper.ExecuteServiceCall<List<int>>(

            "ExceptionLogService/GetExceptionLogIDsForVRMergeException", HttpMethod.Post, token, quString, timeOutMinutes: 5);

        */

​

        var response = new List<int>();

        for (var i = 0; i < 100; i++)

        {

            response.Add(i);

        }

        // Expect 100 items.

        Console.WriteLine("Responses: {0}", response.Count);

        //No work to do.  Return false;

        if (response == null || response.Count == 0)

            return;

​

        var exceptionLogIDsToProcess = response;

​

        int totalLogsProcessed = 0;

​

        var throttler = new SemaphoreSlim(initialCount: threads);

        var timer = Stopwatch.StartNew();

        Console.WriteLine("Started at {0}", DateTime.Now);

        var tasks = exceptionLogIDsToProcess.Select(async exceptionLogId =>

                                                    {

                                                        await throttler.WaitAsync();

                                                        try

                                                        {

                                                            var queryString = new Dictionary<string, string> { { "exceptionLogID", exceptionLogId.ToString() } };

                                                            /*

                                                            var serviceResponse = await InternalApiHelper.ExecuteServiceCall<bool>(

                                                                "ExceptionLogService/ResolveVRMergeExceptions", HttpMethod.Post, token, queryString);

                                                            */

                                                            await Task.Delay(1);

                                                            // Fail 100% of the time.

                                                            var serviceResponse = false; //new Random(System.Guid.NewGuid().GetHashCode()).Next(0, 100) > 25;

​

                                                            if (serviceResponse)

                                                                totalLogsProcessed++;

                                                            else

                                                                AddExceptionLogIDExcludes(exceptionLogId, "VR_REGROUPING");

                                                        }

                                                        finally

                                                        {

                                                            throttler.Release();

                                                        }

                                                        return true;

                                                    });

        Console.WriteLine("Tasks: {0}", tasks.Count());

        await Task.WhenAll(tasks);

        /*

        while (true)

        {

            if (Task.WhenAll(tasks).Wait(1000))

                break;

​

            if (timer.Elapsed > exceptionBatchTimeBudget)

                break;

        }

        */

        Console.WriteLine("Ended at {0}", DateTime.Now);

        // Expect 100 fails.

        Console.WriteLine("Fails: {0}", exceptionLogIDExcludes.Count);

​

        //Didn't actually process anything.

        if (totalLogsProcessed == 0)

            return;

        /*

        RhapsodyLogger.LogInformation<BackgroundTaskManager>(

            "Successfully processed {0}/{1} for VR_REGROUPING exception", totalLogsProcessed, response.Count);

        */

        return;

    }

    private static List<exceptionLogIDExclude> exceptionLogIDExcludes = new List<exceptionLogIDExclude>();

    private class exceptionLogIDExclude

    {

        public int Id;

        public DateTime DatetimeUTC;

        public int Count;

        public string EventException;

    }

    private static void AddExceptionLogIDExcludes(int exceptionLogID, string eventException)

    {

        if (exceptionLogIDExcludes != null)

        {

            var index = exceptionLogIDExcludes.FindIndex(i => i.Id == exceptionLogID);

            if (index >= 0)

            {

                exceptionLogIDExcludes.ElementAt(index).Count++;

                return;

            }

        }

        exceptionLogIDExcludes.Add(new exceptionLogIDExclude

                                   {

                                       Id = exceptionLogID,

                                       EventException= eventException,

                                       DatetimeUTC = DateTime.UtcNow,

                                       Count = 1

                                   });

    }

}