public PageRecord processPageRequestAndReturnNewPageRecordAccordingToHistory(int i, PageRecord pageRecord)
        {
            if (pageRecord != null)
            {
                // csak a elgelső iterációban lehet üres, amikor még a History is üres
                if (pageRecord.Pages.Count == 0)
                {
                    // ha tényleg nincs benne semmi, vissza kell adni legalább az igény és annak behozatalából összeállított rekordot
                    PageRecord clone = MyCloner.DeepClone<PageRecord>(pageRecord.CreateNewPageByPageNumberAndShiftTheOtherPages(i));
                    clone.setTimestampOnPage(i, simulatorModel.StepCounter);
                    return clone;
                }

                // ha már tartalmazza a kívánt lapot, akkor nem kell kivinni senkit
                if (pageRecord.containsPage(i))
                {
                    PageRecord clone = MyCloner.DeepClone<PageRecord>(pageRecord);
                    clone.setReferenceAndPageFault(i, false);
                    clone.setTimestampOnPage(i, simulatorModel.StepCounter);
                    return clone;
                }

                // ha nem tartalmazza a kívánt lapot az új lapot be kell vinni

                // ha van elég hely a tárban, a lapot beszúrjuk az első helyre
                if (pageRecord.hasMoreSpaceForNewPage())
                {
                    pageRecord.Pages.Insert(0, new Page(i));
                    pageRecord.setReferenceAndPageFault(i, true);
                    pageRecord.setTimestampOnPage(i, simulatorModel.StepCounter);
                    return pageRecord;
                }

                // ha nincs elég hely a tárban, áldozatot kell kiválasztani
                Page actualPage = null;
                foreach (Page page in pageRecord.Pages)
                {
                    if (actualPage == null)
                    {
                        actualPage = page;
                        continue;
                    }
                    if (actualPage.LastUsedTimestamp > page.LastUsedTimestamp)
                    {
                        actualPage = page;
                    }
                }

                // az áldozat helyére
                if (actualPage != null)
                {
                    pageRecord.ReplaceExistingPageWithNewPage(actualPage, i);
                    pageRecord.setTimestampOnPage(i, simulatorModel.StepCounter);
                    return pageRecord;
                }
                
            }
            return null;
        }
        public PageRecord processPageRequestAndReturnNewPageRecordAccordingToHistory(int i, PageRecord pageRecord)
        {
            if (pageRecord != null)
            {
                // csak a elgelső iterációban lehet üres, amikor még a History is üres
                if (pageRecord.Pages.Count == 0)
                {
                    // ha tényleg nincs benne semmi, vissza kell adni legalább az igényt és annak behozatalából összeállított rekordot
                    PageRecord clone = MyCloner.DeepClone<PageRecord>(pageRecord.CreateNewPageByPageNumberAndShiftTheOtherPages(i));
                    clone.setTimestampOnPage(i, simulatorModel.StepCounter);
                    return clone;
                }

                // ha már legalább egy lap van a tárban
                // megnézni, hogy a lap a tárban van-e
                bool wasPageInMemory = false;
                foreach (Page page in pageRecord.Pages)
                {
                    if (page.PageNumber == i)
                    {
                        // a keresett lapot nem kell behozni 
                        wasPageInMemory = true;
                        break;
                    }
                }

                // ha a lap nem volt a tárban
                if (!wasPageInMemory)
                {
                    if (pageRecord.hasMoreSpaceForNewPage())
                    {
                        pageRecord.Pages.Insert(0, new Page(i));
                        pageRecord.setTimestampOnPage(i, simulatorModel.StepCounter);
                        pageRecord.setReferenceAndPageFault(i, true);
                        return pageRecord;
                    }

                    ObservableCollection<Page> pagesToAddToList = new ObservableCollection<Page>();
                    Page victim = null;

                    // áldozat kiválasztása ha van, egyben a 
                    foreach (Page page in pageRecord.Pages.Reverse())
                    {
                        if (page.Rbit == true)
                        {
                            page.Rbit = false;
                            pagesToAddToList.Add(page);
                        }
                        else
                        {
                            victim = page;
                            break;
                        }
                    }

                    // csak akkor lehet ha minden lap a laptáblán R-bites volt és victim nem került kiválasztásra
                    if (pagesToAddToList.Count == pageRecord.Pages.Count && victim == null)
                    {
                        pageRecord.Pages.Remove(pageRecord.Pages.Last());
                        pageRecord.Pages.Insert(0, new Page(i));
                        pageRecord.setReferenceAndPageFault(i, true);
                        pageRecord.setTimestampOnPage(i, simulatorModel.StepCounter);
                        return MyCloner.DeepClone<PageRecord>(pageRecord); 
                    }

                    // ha a laptáblán kevesebb lap került kiválasztásra mint amennyi benne volt akkor volt benne áldozat is
                    // ezért minden lapot előre beszúrni
                    if (pagesToAddToList != null)  
                    {
                        foreach (Page page in pagesToAddToList)
                        {
                            pageRecord.Pages.Remove(page);
                            pageRecord.Pages.Insert(0, page);
                        }
                    }
                    // majd az áldozatot eltakarítani, helyébe a kért lapot behozni
                    if (pageRecord.containsPage(victim.PageNumber))
                    {
                        pageRecord.Pages.Remove(victim);
                        pageRecord.Pages.Insert(0, new Page(i));
                    }

                    pageRecord.setTimestampOnPage(i, simulatorModel.StepCounter);
                    pageRecord.setReferenceAndPageFault(i, true);
                    return MyCloner.DeepClone<PageRecord>( pageRecord);

                }
                else
                {
                    // különben meg nem volt laphiba
                    PageRecord clone = MyCloner.DeepClone<PageRecord>(pageRecord);
                    clone.setReferenceAndPageFault(i, false);
                    clone.setTimestampOnPage(i, simulatorModel.StepCounter);
                    return clone;
                }
            }
            return null;
        }
        public PageRecord processPageRequestAndReturnNewPageRecordAccordingToHistory(int i, PageRecord pageRecord)
        {
            if (pageRecord != null)
            {
                // csak a legelső iterációban lehet üres, amikor még a History is üres
                if (pageRecord.Pages.Count == 0)
                {
                    PageRecord clone = MyCloner.DeepClone<PageRecord>(pageRecord.CreateNewPageByPageNumberAndShiftTheOtherPages(i));
                    clone.setTimestampOnPage(i, simulatorModel.StepCounter);
                    return clone;
                }

                // ha már tartalmazza a kívánt lapot, akkor nem kell kivinni senkit
                if (pageRecord.containsPage(i))
                {
                    PageRecord clone = MyCloner.DeepClone<PageRecord>(pageRecord);
                    clone.setReferenceAndPageFault(i, false);
                    clone.setTimestampOnPage(i, simulatorModel.StepCounter);
                    return clone;
                }


                // minden lapra a laptáblában meg kell nézni, mikor lesz a következő akció, amiben szerepel
                int notNeedMaxTime = 0;
                Page pageTmp = null;

                foreach (Page page in pageRecord.Pages)
                {
                    bool pageWasInRequestList = false;

                    foreach (PageActionBase action in simulatorModel.PageActionSequence)
                    {
                        // ha a lap benne van a listában, ideiglenesen eltesszük
                        if (action.Page == page.PageNumber)
                        {
                            pageWasInRequestList = true;

                            int notNeedTimeTmp = simulatorModel.PageActionSequence.IndexOf(action);

                            if (notNeedTimeTmp > notNeedMaxTime)
                            {
                                notNeedMaxTime = notNeedTimeTmp;
                                pageTmp = page;
                            }
                            break;
                        }
                    }

                    // ha a lap nem volt a várakozási listában, ki lehet vinni, többé nincs rá szükség
                    if (pageWasInRequestList == false) 
                    {
                        pageTmp = page;
                        break;
                    }
                }

                // Mostanra már biztosan talált egy kivihető lapot
                if (pageTmp != null)
                {
                    int index = pageRecord.Pages.IndexOf(pageTmp);
                    PageRecord clone = MyCloner.DeepClone<PageRecord>(pageRecord);
                    clone.ReplaceExistingPageWithNewPage(pageTmp, i);
                    clone.setTimestampOnPage(i, simulatorModel.StepCounter);
                    return clone;
                }
                // elvileg ide nem juthat az algoritmus
                throw new NotImplementedException();
                


            }
            return null;
        }