import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.logging.Level;
import java.util.logging.Logger;



public class PagedMemory {
     private static String listFile = "/Users/pcase/Desktop/test.txt";
     private static BufferedReader fileReader = null;
     private static ArrayList<Job> jobQueue = null;
     public static boolean[] busyTracker = new boolean[10];
     public static ArrayList<Job> completedTasks = new ArrayList<Job>();
     private static String line = "";

    public static void main(String[] args) throws InterruptedException, NumberFormatException, IOException {

        HashMap<Integer, Boolean> PageMemoryTable = new HashMap<>();

        PageMemoryTable.put(1, true);
        PageMemoryTable.put(2, true);
        PageMemoryTable.put(3, true);
        PageMemoryTable.put(4, true);
        PageMemoryTable.put(5, true);
        PageMemoryTable.put(6, true);
        PageMemoryTable.put(7, true);
        PageMemoryTable.put(8, true);
        PageMemoryTable.put(9, true);
        PageMemoryTable.put(10, true);


        jobQueue = new ArrayList<Job>();
        jobQueue.ensureCapacity(5);
        fileReader = new BufferedReader(new FileReader(listFile));
        while ((line = fileReader.readLine()) != null)
        {
            String[] entry = line.split(",", 3);
            jobQueue.add(new Job(entry[0], Double.parseDouble(entry[1]), Double.parseDouble(entry[2])));
        }

        for (int i = 0; i < jobQueue.size(); i++) {

            i = i + 2;
        }
        System.out.println("Job List:" + jobQueue);

        //Remove jobs that are too large
        for(int i = 0; i < jobQueue.size(); i++){
            if(jobQueue.get(i).getSize() > 1000){
                    System.out.println("Size " + jobQueue.get(i).getSize() + " is too large! It will be removed from the table!");
                    jobQueue.remove(i);
                }
        }
        System.out.println("Job List:" + jobQueue + "/n");


        ArrayList<PMTInfo> PMT = new ArrayList<>();


        while (jobQueue.size() > 0) {

            //Checks if jobs are done
            for(int i = 0; i < jobQueue.size(); i++){

                if((jobQueue.get(i).getStartTime() + jobQueue.get(i).getExecutionTime()) <= System.currentTimeMillis()){
                    resetPMT(jobQueue.get(i), PageMemoryTable);
                    System.out.println("Job ID " + jobQueue.get(i).getID() + " finished");
                    jobQueue.remove(i);
                }
            }

            for(int i = 0; i < jobQueue.size(); i++){
                PMT.clear();
                int freeMemory = checkMemoryAvailable(PageMemoryTable);
                double currentJobSize = jobQueue.get(i).getSize();
                double numberOfPages = 0;
                if(currentJobSize <= freeMemory){


                   if(currentJobSize % 100 != 0){
                       numberOfPages = (currentJobSize / 100) + 1;
                   }else{
                       numberOfPages = currentJobSize / 100;
                   }

                   for(int b = 0; b < numberOfPages; b++){
                       int pageFrame = findFreePageFrame(PageMemoryTable);
                       if(pageFrame != -1){
                           PMT.add(new PMTInfo(b,pageFrame));
                       }else{
                           System.out.println("ERROR: There are no free page frames.");
                       }

                   }
                   jobQueue.get(i).setPMT(PMT);
                   System.out.println("- JOB " + " " + i + " - \n" + jobQueue.get(i));
                   System.out.println("- PMT - \n" + jobQueue.get(i).displayPMT());
                   jobQueue.get(i).setStartTime(System.currentTimeMillis());
                   Thread.sleep(1000);
                }else{
                    System.out.println(" - There is not enough free memory at the moment for - JOB " + jobQueue.get(i) + " -. Continuing to next Job.\n");
                }
            }
        }

        System.out.println("Processing COMPLETE. Program Ended");

    }

    public static int checkMemoryAvailable(HashMap<Integer, Boolean> mMT){
        int freeMemory = 0;
        for(int i = 0; i < mMT.size(); i++){
            if(mMT.get(i) == true){
                freeMemory += 100;
            }
        }

        return freeMemory;
    }

    public static int findFreePageFrame(HashMap<Integer, Boolean> mMT){
        int toReturn =-1;
        for(int i = 0; i < mMT.size(); i++){
            if(mMT.get(i)){
                mMT.replace(i, false);
                toReturn = i;
                break;
            }
        }

        return toReturn;
    }

     public static void resetPMT(Job job, HashMap<Integer, Boolean> mMT){
        for(int i = 0; i < job.getPMT().size(); i++){
            int index = job.getPMT().get(i).getPageFrameNumber();
            mMT.put(index, true);
        }
    }

}