OS.java

import java.util.ArrayList;
import java.util.Optional;

public class OS {
    
    private static Kernel kernel;               // A reference to the Kernel.
    public static CallType currentCall;         // The current call to the Kernel.
    public static ArrayList<Object> parameters; // The Parameters for the Kernel Call.
    public static Object retval;                // The return value from the Kernel.

    public enum CallType{
        ALLOCATE, CLOSE, CREATE, FREE, SEARCHPID, GETPID, GET_MAPPING, OPEN, READ, SEEK, SEND_MESSAGE, SLEEP, SWITCH, WAIT_MESSAGE, WRITE
    }

    public enum Priority{
        REALTIME, INTERACTIVE, BACKGROUND
    }

    // Init Methods:

    /**
     * Starts the initial process of the OS.
     * 
     * @param init The first process to run.
     */
    public static void startUp(UserLandProcess init){
        
        dbMes("OS: StartUp");

        kernel = new Kernel();
        parameters = new ArrayList<Object>();
        retval = new Object();

        createProcess(init);
        createProcess(new IdleProcess(), Priority.BACKGROUND);
    }

    // Kernel Calls:

    /**
     * Adds a process to the scheduler.
     * 
     * @param up The process to be added.
     * @return The PID of the new process.
     */
    public static Optional<Integer> createProcess(UserLandProcess up) {

        dbMes("OS: Creating new Process: " + up.getClass());

        // Reset the parameters
        parameters.clear();
        parameters.add(up);
        parameters.add(Priority.INTERACTIVE);

        // Set currentCall
        currentCall = CallType.CREATE;

        // Switch to Kernal
        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                return (Optional<Integer>) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } catch(Exception ex){}
            }
        }
    }

    /**
     * Adds a process to the scheduler.
     * 
     * @param up The process to be added.
     * @param priority The priority of the new process.
     * @return The PID of the new Process.
     */
    public static Optional<Integer> createProcess(UserLandProcess up, Priority priority){

        dbMes("OS: Creating new Process: " + up.getClass() + " Priority: " + priority.toString());

        parameters.clear();
        parameters.add(up);
        parameters.add(priority);

        currentCall = CallType.CREATE;

        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                return (Optional<Integer>) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } catch(Exception ex){}
            }
        }
    }

    /**
     * Switches to the next process in the queue.
     */
    public static void switchProcess(){
        dbMes("OS: Switching process");

        retval = null;
        parameters.clear();

        currentCall = CallType.SWITCH;

        switchToKernel();
    }

    /**
     * Pauses the currentlyRunning process and doesn't put it back in the queue unitl after the specified time has elapsed.
     * 
     * @param milliseconds The amount of time that the process wants to sleep for.
     */
    public static void sleep(int milliseconds){

        dbMes("OS: Sleep");

        retval = null;
        parameters.clear();

        parameters.add(milliseconds);
        
        currentCall = CallType.SLEEP;

        switchToKernel();
    }

    /**
     * Opens the desired device and returns the File IDentification number (FID) of the device.
     * 
     * @param device
     * @return The FID of the opened device, or -1 if it fails.
     */
    public static Optional<Integer> open(String device){

        OS.dbMes("OS: Opening " + device);

        parameters.clear();
        parameters.add(device);

        currentCall = CallType.OPEN;

        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                return (Optional<Integer>) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } catch(Exception ex){}
            }
        }
    }

    /**
     * Reads data from the specifed device.
     * 
     * @param FID The File ID of the device to be read from.
     * @param size The amount of data in bytes to be read.
     * @return
     */
    public static Optional<byte[]> read(int FID, int size){
        OS.dbMes("OS: Reading " + FID + " Size: " + size);

        parameters.clear();
        parameters.add(FID);
        parameters.add(size);

        currentCall = CallType.READ;

        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                return (Optional<byte[]>) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } catch(Exception ex){}
            }
        }
    }

    /**
     * Moves the curser within the specified device.
     * 
     * @param FID The File ID of the device to be seeked.
     * @param size The distance to be seeked
     */
    public static void seek(int FID, int size){
        OS.dbMes("OS: Seeking FID: " + FID + " Size: " + size);

        parameters.clear();
        parameters.add(FID);
        parameters.add(size);

        currentCall = CallType.SEEK;

        switchToKernel();
    }

    /**
     * Writes information to the specifed device.
     * 
     * @param FID The File ID of the device being writen to.
     * @param data The data passed to the device.
     * @return The amount of data written to the device.
     */
    public static Optional<Integer> write(int FID, byte[] data){
        OS.dbMes("OS: Writing to " + FID + " Data: " + data);

        parameters.clear();
        parameters.add(FID);
        parameters.add(data);

        currentCall = CallType.WRITE;

        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                return (Optional<Integer>) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } catch(Exception ex){}
            }
        }
    }

    /**
     * Closes the device specified by the FID.
     * 
     * @param FID The File ID of the device to be closed.
     */
    public static void close(int FID){
        OS.dbMes("OS: Closing " + FID);

        parameters.clear();
        parameters.add(FID);

        currentCall = CallType.CLOSE;

        switchToKernel();
    }

    /**
     * Gets the current process's PID.
     * 
     * @return The PID of the process.
     */
    public static int getPID(){
        OS.dbMes("OS: Get PID");

        parameters.clear();
        
        currentCall = CallType.GETPID;

        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                return (int) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } 
                catch(InterruptedException ex){}
            }
        }
    }

    /**
     * Gets the PID of the named process.
     * 
     * @param name The name of the desired process.
     * @return The PID of the named process, or -1 on failure.
     */
    public static Optional<Integer> searchPID(String name){
        OS.dbMes("OS: Get PID of \"" + name + "\"");

        parameters.clear();
        parameters.add(name);

        currentCall = CallType.SEARCHPID;

        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                return (Optional<Integer>) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } 
                catch(Exception ex){

                }
            }
        }
    }

    /**
     * Sends a message to the desired process.
     * 
     * @param message The message to be sent.
     */
    public static void sendMessage(Message message){
        dbMes("OS: Send message: " + new String(message.getData()));

        parameters.clear();
        parameters.add(message);

        currentCall = CallType.SEND_MESSAGE;

        switchToKernel();
    }

    /**
     * Pauses the process until it recives a message.
     * 
     * @return The most recent messge sent to the process.
     */
    public static Message waitForMessage(){
        dbMes("OS: Wait Message");

        parameters.clear();

        currentCall = CallType.WAIT_MESSAGE;

        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                if(retval != null)
                    return (Message) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } 
                catch(Exception ex){

                }
            }
        }
    }

    /**
     * Gets the mapping for the provided virutal page number, and stores it into the tlp.
     * 
     * @param virtualPageNum The virtual page number of the desired memory or -1 on failure.
     */
    public static void getMapping(int virtualPageNum){
        dbMes("OS: Get Mapping");

        parameters.clear();
        parameters.add(virtualPageNum);
        currentCall = CallType.GET_MAPPING;

        switchToKernel();
    }

    /**
     * Allocates memory.
     * 
     * @param size The amount of bytes in memory to be allocated.
     * @return The first pointer in the allocated memory.
     */
    public static Optional<Integer> allocateMemory(int size){
        dbMes("OS: Allocate Memory");

        if(size % UserLandProcess.PAGE_SIZE != 0){
            dbMes("OS: Size " + size + " is not a multiple of " + UserLandProcess.PAGE_SIZE + ".");
            return Optional.empty();
        }

        // Change to number of pages added because we don't support removing anything smaller anyway.
        size = size / UserLandProcess.PAGE_SIZE;

        parameters.clear();
        
        parameters.add(size);

        currentCall = CallType.ALLOCATE;

        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                if(retval != null)
                    return (Optional<Integer>) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } 
                catch(Exception ex){

                }
            }
        }
    }

    /**
     * Frees the specified page in memory.
     * 
     * @param pointer The start of the addresses in memory to be freed.
     * @param size The amound of memory in bytes to be freed in memory.
     * 
     * @return True if the freeing was successfull. False otherwize.
     */
    public static boolean freeMemory(int pointer, int size){
        dbMes("OS: Allocate Memory");

        if(pointer % UserLandProcess.PAGE_SIZE !=0){
            dbMes("OS: Size " + pointer + " is not a multiple of " + UserLandProcess.PAGE_SIZE + ".");
            return false;
        }

        if(size % UserLandProcess.PAGE_SIZE !=0){
            dbMes("OS: Size " + size + " is not a multiple of " + UserLandProcess.PAGE_SIZE + ".");
            return false;
        }

        // Change to page number because we don't support removeing anything smaller than a page.
        pointer = pointer / UserLandProcess.PAGE_SIZE;

        // Change to number of pages added because we don't support removing anything smaller anyway.
        size = size / UserLandProcess.PAGE_SIZE;

        parameters.clear();

        parameters.add(pointer);
        parameters.add(size);

        currentCall = CallType.FREE;

        switchToKernel();

        while(true){    // The processes are async, so this will sometimes run before Kernel can update it.
            try{
                if(retval != null)
                    return (boolean) retval;
            } catch (Exception e){
                try{
                    Thread.sleep(5);
                } 
                catch(Exception ex){

                }
            }
        }
    
    }

    // Helper Methods:

    /**
     * Starts the Kernel and stops the current process.
     */
    private static void switchToKernel(){
        dbMes("OS: Switching to kernel");

        // Store the process here in case the kernel thread changes currentlyRunning before we can call stop.
        PCB stopMe = kernel.getCurrentlyRunning();  

        kernel.start();

        if(stopMe != null)
            stopMe.stop();

        //kernel.stopCurrentProcesss();
    }
    
    // Debugging Help:

    /**
     * EXTRA METHOD!!! Prints a message to the terminal to help bebugging.
     * 
     * @param message The message printed to the terminal.
     */
    public static void dbMes(String message){
        System.err.println("    ||"+message);
    }
}