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

namespace consoleKNIR
{
    class TaskManagement
    {
        int tasksLeft = 0;
        int numberOfTasks;
        int workUnitNumber;
        double time = 0;
        int numberOfUsers;
        int numberOfChecks;

        // массив заданий, инициализируется нулями в конструкторе, по мере выполнения заданий заполняется единицами
        public int[][] tasks;

        // массив, в котором хранится время выполнения каждого задания
        public double[] tasksTime;

        // массив, в котором хранится выполнение каждого work-unit'а (успешное или нет)
        //первоначально забит нулями
        public int[][] successCheck;

        // массив проваленных заданий 
        public int[] failedTasks;

        int failure;
        double workUnitTime;

        // конструктор принимает число заданий, число work-unit'ов на которые делятся задания, количество пользователей
        // которым выдается задания и шанс на отказ в процентах
        public TaskManagement(int numberOfTasks, int workUnitNumber, int numberOfUsers, int numberOfChecks, int failure, double EV, double sigma)
        {
            this.numberOfTasks = numberOfTasks;
            this.workUnitNumber = workUnitNumber;
            this.numberOfChecks = numberOfChecks;
            this.numberOfUsers = numberOfUsers;
            this.tasks = new int[numberOfTasks][];
            this.tasksTime = new double[numberOfTasks];
            for (int i = 0; i < tasks.Length; i++)
            {
                tasks[i] = new int[workUnitNumber];
                for (int j = 0; j < tasks[i].Length; j++)
                {
                    tasks[i][j] = numberOfChecks+1;
                }
                tasksTime[i] = 0;
            }
            this.failure = failure;
            this.workUnitTime = this.NormalDistribution(EV, sigma);

            this.successCheck = new int[numberOfTasks][];
            for (int i = 0; i < successCheck.Length; i++)
            {

                successCheck[i] = new int[workUnitNumber];
                for (int j = 0; j < successCheck[i].Length; j++)
                {
                    successCheck[i][j] = 0;
                    
                }
            }
            this.failedTasks = new int[numberOfTasks];
            for (int i = 0; i < failedTasks.Length; i++)
            {
                failedTasks[i] = 0;
            }
            
            
        }

        // Проверяем успешность подсчета work-unit'a
        Random random = new Random();
        public bool CheckFailure()
        {
            
            int check = random.Next(1, 101);
            if (check > failure)
                return true;
            else
                return false;
        }
        // Вычисляем время вычисления с помощью нормального распределения(ЦПТ)
        // параметрами является математичесок ожидание и отклонение
        public double NormalDistribution(double mo, double sigma)
        {
            double Sum = 0;
            double ndValue = 0;
            //Random rand = new Random();
            for (int i = 0; i <= 12; i++)
            {
                double R = random.NextDouble();
                Sum = Sum + R;
            }
            ndValue = Math.Round((mo + sigma * (Sum - 6)), 3);
            return ndValue;
        }

        //функция генерирует одну итерацию (раздачу пользователям заданий)
        //public int[] GenerateIteration()
        //{

        //    Random rand = new Random();

        //    int[] users = new int[numberOfUsers];
        //    for (int i = 0; i < users.Length; i++)
        //    {
        //        users[i] = -1;
        //    }
        //    for (int i = 0; i < users.Length; i++)
        //    {
        //        int randomtask = rand.Next(0, numberOfTasks);
        //        // если задания розданы не полностью (у последнего work-unit'а задания индекс не равен 1)
        //        if (tasks[randomtask][workUnitNumber - 1] != 1)
        //        {
        //            while (users.Contains(randomtask) || tasks[randomtask][workUnitNumber - 1] == 1 || failedTasks[randomtask] != 0)
        //            {
        //                randomtask = rand.Next(0, numberOfTasks);
        //            }
        //            users[i] = randomtask;
        //        }
        //        else
        //        {

        //            while ((users.Contains(randomtask)) || (tasks[randomtask][workUnitNumber - 1] == 1) || failedTasks[randomtask] != 0)
        //            {
        //                randomtask = rand.Next(0, numberOfTasks);
        //                //rand.Next(
        //            }
        //            users[i] = randomtask;
        //        }
        //    }

        //    return users;
        //}
        public int[] GenerateIteration()
        {

            int[] users = new int[numberOfUsers];
            for (int i = 0; i < users.Length; i++)
            {
                users[i] = -1;
            }

            int randomtask = 0;
            int counter = 0;
            while (((tasks[randomtask][workUnitNumber - 1] == 1) || failedTasks[randomtask] != 0))
            {
                randomtask++;
            }
            users[counter] = randomtask;
            while (users[counter] != numberOfTasks && counter != numberOfUsers-1)
            {
                users[counter+1] = users[counter] + 1;
                counter++;
            }
            return users;
        }
        // функция считает количество выполненных заданий
        public int ShowFailedTasks()
        {
            int failedTasks = 0;
            for (int i = 0; i < this.failedTasks.Length; i++)
            {
                if (this.failedTasks[i] != 0)
                    failedTasks++;
            }
            return failedTasks;
        }

        //функция проверяет выполнены ли все задания
        bool CompletionCheck()
        {
            int counter = 0;
            for (int i = 0; i < numberOfTasks; i++)
            {
                if (tasks[i][workUnitNumber - 1] == 1 || failedTasks[i] != 0)
                    counter++;
            }
            if (counter == numberOfTasks)
                return true;
            else
            {
                tasksLeft = numberOfTasks - counter;
                if (tasksLeft < numberOfUsers)
                    numberOfUsers = tasksLeft;

                return false;
            }
            
            
                
            
        }

        //функция считает время которое необходимо на просчет всех заданий
        //а также вносит в массив в какой момент времени каждое задание было завершено

        //public double CalcTime()
        //{

        //    while (!this.CompletionCheck())
        //    {
        //        int[] iteration = this.GenerateIteration();
        //        Array.Sort(iteration);

        //        for (int i = 0; i < iteration.Length; i++)
        //        {
        //            if (this.CheckFailure()) //&& iteration[i] != -1)
        //            {
        //                int progress = 0;
        //                for (int j = 0; j < workUnitNumber; j++)
        //                {
        //                    if (tasks[iteration[i]][j] == 1)
        //                        progress++;
        //                }
        //                if (progress != workUnitNumber)
        //                {
        //                    tasks[iteration[i]][progress] = tasks[iteration[i]][progress] - 1;
        //                    if (progress == workUnitNumber - 1)
        //                    {

        //                        tasksTime[iteration[i]] = time + workUnitTime;
        //                    }
        //                }
        //            }
        //        }
        //        time = time + workUnitTime;
        //    }

        //    return time;
        //}
        public double CalcTime()
        {

            while (!this.CompletionCheck())
            {
                int[] iteration = this.GenerateIteration();
                //Array.Sort(iteration);

                //for (int i = 0; i < iteration.Length; i++)
                Parallel.For(0, iteration.Length, delegate(int i)
                {
                    //if (this.CheckFailure()) //&& iteration[i] != -1)
                    {
                        int progress = 0;
                        for (int j = 0; j < workUnitNumber; j++)
                        {
                            if (tasks[iteration[i]][j] == 1)
                            {

                                progress++;

                            }
                        }
                        if (progress != workUnitNumber)
                        {
                            tasks[iteration[i]][progress] = tasks[iteration[i]][progress] - 1;
                            if (this.CheckFailure())
                            {
                                //successCheck[iteration[i]]
                                successCheck[iteration[i]][progress]++;
                            }

                            if (successCheck[iteration[i]][progress] == 0 && tasks[iteration[i]][progress] == 1)
                            {
                                failedTasks[iteration[i]] = progress;
                                //goto Failed;
                            }

                            if (progress == workUnitNumber - 1 || failedTasks[iteration[i]] != 0)
                            {
                                //if (failedTasks[iteration[i]] != 1)
                                tasksTime[iteration[i]] = time + workUnitTime;

                            }
                        }
                    }
                });
                //Failed:
                time = time + workUnitTime;
            }

            return time;
        }
        public Dictionary<int,double> GetFailedInfo()
        {
            
            Dictionary<int,double> failed = new Dictionary<int, double>();
            for (int i = 0; i < tasks.Length; i++)
			{
			    if(failedTasks[i] != 0)
                    failed.Add(i, this.tasksTime[i]);
			}
            return failed;
        }
        public Dictionary<int, double> GetSuccessedInfo()
        {

            Dictionary<int, double> successed = new Dictionary<int, double>();
            for (int i = 0; i < tasks.Length; i++)
            {
                if (failedTasks[i] == 0)
                    successed.Add(i, this.tasksTime[i]);
            }
            return successed;
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            //количество заданий, количество work-unit'ов, количество участников, количество проверок, процент отказа, мат ожидание, отклонение
            //TaskManagement a = new TaskManagement(40000, 4, 100, 3, 33, 4, 0);
            
            //double time = a.CalcTime();
            //int failed = a.ShowFailedTasks();
            //double[] taskTime = a.tasksTime;

            //asteroids@home
            //double[, ,] asteroidsResults = new double[4, 10, 6];
            double[] asteroidsResults = new double[240];
            double[] asteroidsTime = new double[240];
            for (int i = 0; i < 240; i++)
            {
                asteroidsResults[i] = 0;
                asteroidsTime[i] = 0;
            }
            int counter = 0;
            StreamWriter stream = new StreamWriter("results/" + "asteroids" +  @".csv");
            for (int i = 2; i <= 5; i++)
            {
                for (int j = 1; j <= 10; j++)
                {
                    for (int k = 5; k <= 30; k = k + 5)
                    {
                        for (int z = 0; z < 100; z++)
                        {
                            TaskManagement atmp = new TaskManagement(77447, k, 2570, i, j, 2.95, 0.85);
                            asteroidsTime[counter] += atmp.CalcTime();
                            asteroidsResults[counter] += (77447 - atmp.ShowFailedTasks());
                            
                        }
                        asteroidsResults[counter] = asteroidsResults[counter] / 100;
                        asteroidsTime[counter] = asteroidsTime[counter] / 100;
                        stream.WriteLine("{0}; {1}; {2}; {3}; {4}", asteroidsResults[counter], asteroidsTime[counter], i, j, k);
                        
                        Console.WriteLine("{0} {1}",counter, DateTime.Now);
                        counter++;
                    }
                }
            }
            stream.Close();

            //sat@home
            double[] satResults = new double[240];
            double[] satTime = new double[240];
            for (int i = 0; i < 240; i++)
            {
                satResults[i] = 0;
                satTime[i] = 0;
            }
            int scounter = 0;
            StreamWriter sstream = new StreamWriter("results/" + "sat" + @".csv");
            for (int i = 2; i <= 5; i++)
            {
                for (int j = 1; j <= 10; j++)
                {
                    for (int k = 5; k <= 30; k = k + 5)
                    {
                        for (int z = 0; z < 100; z++)
                        {
                            TaskManagement atmp = new TaskManagement(37422, k, 1405, i, j, 1.865, 0.495);
                            satTime[scounter] += atmp.CalcTime();
                            satResults[scounter] += (37422 - atmp.ShowFailedTasks());
                            
                        }
                        satResults[scounter] = satResults[scounter] / 100;
                        satTime[scounter] = satTime[scounter] / 100;
                        sstream.WriteLine("{0}; {1}; {2}; {3}; {4}", satResults[scounter], satTime[scounter], i, j, k);
                        Console.WriteLine("{0} {1}", scounter, DateTime.Now);
                        //Console.WriteLine(scounter);
                        scounter++;
                    }
                }
            }
            sstream.Close();

            //LHC@gome
            double[] lhcResults = new double[240];
            double[] lhcTime = new double[240];
            for (int i = 0; i < 240; i++)
            {
                lhcResults[i] = 0;
                lhcTime[i] = 0;
            }
            int lcounter = 0;
            StreamWriter lstream = new StreamWriter("results/" + "lhc" + @".csv");
            for (int i = 2; i <= 5; i++)
            {
                for (int j = 1; j <= 10; j++)
                {
                    for (int k = 5; k <= 30; k = k + 5)
                    {
                        for (int z = 0; z < 100; z++)
                        //Parallel.For(0, 100, delegate(int z)
                        {
                            TaskManagement atmp = new TaskManagement(49876, k, 11988, i, j, 1.115, 1.085);
                            lhcTime[lcounter] += atmp.CalcTime();
                            lhcResults[lcounter] += (49876 - atmp.ShowFailedTasks());

                        }
                        lhcResults[lcounter] = lhcResults[lcounter] / 100;
                        lhcTime[lcounter] = lhcTime[lcounter] / 100;
                        lstream.WriteLine("{0}; {1}; {2}; {3}; {4}", lhcResults[lcounter], lhcTime[lcounter], i, j, k);
                        //Console.WriteLine(lcounter);
                        Console.WriteLine("{0} {1}", lcounter, DateTime.Now);
                        lcounter++;
                    }
                }
            }
            lstream.Close();

            //Dictionary<int, double> f = a.GetFailedInfo();
            //Dictionary<int, double> s = a.GetSuccessedInfo();

            //Console.WriteLine("{0:f3}", time);
            //Console.WriteLine("{0}", failed);
            //Console.ReadLine();
            
            
        }
    }
}