public SimulationResult Simulation(Queue<Process> queueProcesses, List<Process> listProcesses)
        {
            int peekProcessingTime = 0;
            _completeProcessList = new List<Process>();

            do
            {
                if (queueProcesses.Count != 0)
                {
                    if (peekProcessingTime == queueProcesses.Peek().CpuPhaseLength) // zdjęcie procesu z kolejki
                    {
                        _completeProcessList.Add(queueProcesses.Peek());
                        _processCounter++;
                        _waitingTimeResult += queueProcesses.Peek().WaitingTime;
                        queueProcesses.Dequeue();
                        peekProcessingTime = 0;
                    }

                    foreach (var process in queueProcesses) // zwiększenie czasu oczekiwania wszystkim oprócz Peeka
                    {
                        if (process == queueProcesses.Peek())
                            continue;

                        process.WaitingTime++;
                    }

                    if (peekProcessingTime == QuantumOfTime)   // przesunięcie procesu na koniec kolejki po upływie kwantu czasu     RRRRRRRRRRRRR
                    {
                        queueProcesses.Peek().CpuPhaseLength -= peekProcessingTime;
                        var tempProcess = queueProcesses.Dequeue();
                        queueProcesses.Enqueue(tempProcess);
                        peekProcessingTime = 0;
                    }
                }

                if (listProcesses.Count != 0 && listProcesses[0].EntryTime == _time) // dodanie do kolejki
                {
                    queueProcesses.Enqueue(listProcesses[0]);
                    listProcesses.Remove(listProcesses[0]);
                }
                _time++;
                peekProcessingTime++;

            } while (queueProcesses.Count != 0 || listProcesses.Count != 0);

            _averageWaitingTimeResult = _waitingTimeResult / _processCounter;

            var filePath = "C:\\aga\\06_Robocze\\SchedulingAccesToCpuRR.txt";
            var saveToTextFile = new TextFileSchedulingAccessToCPU();
            saveToTextFile.SaveFile(_completeProcessList, filePath);

            return new SimulationResult()
            {
                AverageWaitingTime = _averageWaitingTimeResult,
                CompleteProcessList = _completeProcessList
            };
        }
        public SimulationResult Simulation(Queue<Process> queueProcesses, List<Process> listProcesses)
        {
            int peekProcessingTime = 0;
               _completeProcessList = new List<Process>();
            queueProcesses = SchedulingAlgorithmHelper.SortQueue(queueProcesses);  // sortowanie kolejki początkowych procesów

            do
            {
                if (queueProcesses.Count != 0)
                {
                    if (peekProcessingTime == queueProcesses.Peek().CpuPhaseLength) // zdjęcie procesu z kolejki
                    {
                        _completeProcessList.Add(queueProcesses.Peek());
                        _processCounter++;
                        _waitingTimeResult += queueProcesses.Peek().WaitingTime;
                        queueProcesses.Dequeue();
                        peekProcessingTime = 0;
                    }

                    foreach (var process in queueProcesses) // zwiększenie czasu oczekiwania wszystkim oprócz Peeka
                    {
                        if (process == queueProcesses.Peek())
                            continue;
                        process.WaitingTime++;
                    }
                }

                if (listProcesses.Count != 0 && listProcesses[0].EntryTime == _time) // dodanie do kolejki
                {
                    queueProcesses.Enqueue(listProcesses[0]);
                    listProcesses.Remove(listProcesses[0]);
                    queueProcesses = SchedulingAlgorithmHelper.SortQueueWithoutPeek(queueProcesses);  // sortowanie kolejki po dodaniu nowego procesu
                }
                _time++;
                peekProcessingTime++;

            } while (queueProcesses.Count != 0 || listProcesses.Count != 0);

            _averageWaitingTimeResult = _waitingTimeResult / _processCounter;

            var filePath = "C:\\aga\\06_Robocze\\SchedulingAccesToCpuSJF.txt";
            var saveToTextFile = new TextFileSchedulingAccessToCPU();
            saveToTextFile.SaveFile(_completeProcessList, filePath);

            return new SimulationResult()
            {
                AverageWaitingTime = _averageWaitingTimeResult,
                CompleteProcessList = _completeProcessList
            };
        }
        public static SimulationData PrepareSimulationData()
        {
            ProcessList testData = new ProcessList();
            var listProcess = testData.CreateProcessList(40);

            Queue<Process> queueProcess = new Queue<Process>();

            for (int i = 0; i < listProcess.Count / 2; i++)
            {
                queueProcess.Enqueue(listProcess[i]);
            }
            listProcess = listProcess.GetRange(listProcess.Count / 2, listProcess.Count / 2);

            var time = 0;
            Random timeRandom = new Random();
            foreach (var process in listProcess)
            {
                process.EntryTime = timeRandom.Next(1, 10)+time;
                time = process.EntryTime;
            }

            var completeProcessList = queueProcess.ToList();
            completeProcessList.AddRange(listProcess);
            var filePath = "C:\\aga\\06_Robocze\\SchedulingAccesToCpuStartList.txt";
            var saveToTextFile = new TextFileSchedulingAccessToCPU();
            saveToTextFile.SaveFile(completeProcessList, filePath);

            return new SimulationData() { QueueProcess = queueProcess, ListProcess = listProcess };
        }
        public SimulationResult Simulation(Queue<Process> queueProcesses, List<Process> listProcesses)
        {
            int peekProcessingTime = 0;
            // SchedulingAlgorithmHelper.ShowQueue(queueProcesses); // !!!
            _completeProcessList = new List<Process>();

            queueProcesses = SchedulingAlgorithmHelper.SortQueue(queueProcesses);  // sortowanie kolejki początkowych procesów
            // SchedulingAlgorithmHelper.ShowQueue(queueProcesses); // !!!

            do
            {
                if (queueProcesses.Count != 0)
                {
                    if (peekProcessingTime == queueProcesses.Peek().CpuPhaseLength) // zdjęcie procesu z kolejki
                    {
                        _completeProcessList.Add(queueProcesses.Peek());
                        _processCounter++;
                        _waitingTimeResult += queueProcesses.Peek().WaitingTime;
                        queueProcesses.Dequeue();
                        peekProcessingTime = 0;
                    }

                    foreach (var process in queueProcesses) // zwiększenie czasu oczekiwania wszystkim oprócz Peeka
                    {
                        if (process == queueProcesses.Peek())
                            continue;

                        process.WaitingTime++;
                    }
                }

                if (listProcesses.Count != 0 && listProcesses[0].EntryTime == _time) // dodanie do kolejki
                {
                    queueProcesses.Enqueue(listProcesses[0]);

                    if (listProcesses[0].CpuPhaseLength >= (queueProcesses.Peek().CpuPhaseLength - peekProcessingTime))
                    {
                        queueProcesses = SchedulingAlgorithmHelper.SortQueueWithoutPeek(queueProcesses); // sortowanie kolejki po dodaniu nowego procesu
                    }
                    else
                    {
                       // SchedulingAlgorithmHelper.ShowQueue(_queueProcess); // !!!
                       // Console.WriteLine("Czas pozostały do wykonania procesu Peek: " + (_queueProcess.Peek().CpuPhaseLength - peekToGoTime));
                        queueProcesses = SchedulingAlgorithmHelper.SortQueueWithExpropriation(queueProcesses, peekProcessingTime); // sortowanie kolejki po dodaniu nowego procesu Z WYWLASZCZENIEM
                        peekProcessingTime = 0;
                        _expropriationCounter++;
                       // SchedulingAlgorithmHelper.ShowQueue(_queueProcess); // !!!
                    }
                    listProcesses.Remove(listProcesses[0]);
                }
                _time++;
                peekProcessingTime++;

            } while (queueProcesses.Count != 0 || listProcesses.Count != 0);

            _averageWaitingTimeResult = _waitingTimeResult / _processCounter;

            var filePath = "C:\\aga\\06_Robocze\\SchedulingAccesToCpuSRTF.txt";
            var saveToTextFile = new TextFileSchedulingAccessToCPU();
            saveToTextFile.SaveFile(_completeProcessList, filePath);

            Console.WriteLine("Ilość wywłaszczeń: " + _expropriationCounter);

            return new SimulationResult()
            {
                AverageWaitingTime = _averageWaitingTimeResult,
                CompleteProcessList = _completeProcessList
            };
        }