using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;

namespace Model
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }

        private void button1_Click(object sender, EventArgs e)
        {
            TaskManagement a = new TaskManagement(int.Parse(textBox1.Text), int.Parse(textBox2.Text), int.Parse(textBox3.Text),
                int.Parse(textBox4.Text), int.Parse(textBox5.Text), int.Parse(textBox6.Text), int.Parse(textBox7.Text));
            double time = a.CalcTime();
            int failed = a.ShowFailedTasks();
            double[] taskTime = a.tasksTime;
            Dictionary<int, double> f = a.GetFailedInfo();
            Dictionary<int, double> s = a.GetSuccessedInfo();

            string sfile = int.Parse(textBox1.Text) + "-" + int.Parse(textBox2.Text) + "-" + int.Parse(textBox3.Text) + "-" +
                int.Parse(textBox4.Text) + "-" + int.Parse(textBox5.Text) + "-" + int.Parse(textBox6.Text) + "-" + int.Parse(textBox7.Text);
            //string date = DateTime.Now.ToString();

            StreamWriter stream = new StreamWriter("results/success-" + sfile + "-" + failed + @".txt");
            foreach (var item in s)
	        {
                stream.WriteLine("{0} --- {1:0.00}", item.Key, item.Value); 
	        }
            stream.Close();


            StreamWriter fstream = new StreamWriter("results/failed-" + sfile + "-" + failed + @".txt");
            foreach (var item in f)
            {
                fstream.WriteLine("{0} --- {1:0.00} --- {2}", item.Key, item.Value, a.failedTasks[item.Key]);
            }
            fstream.Close();

            textBox8.Text = time.ToString("0.00");
            textBox9.Text = failed.ToString();
        }
    }
    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
        public bool CheckFailure()
        {
            Random random = new Random();
            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 = rand.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 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++)
                {
                    //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+1;
                                //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;
        }

    }

}