import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;

/**
 * Created by Erick on 4/8/2017.
 * Program implements a process table
 */
public class ProcessTable {
    public static void main(String[] args){
        ProcessTable pt = new ProcessTable();
        Scanner input = new Scanner(System.in);
        while(true){
            String str = input.next();
            switch (str){
                case("fork"):
                    pt.Fork();
                    break;
                case("kill"):
                    int temp = input.nextInt();
                    pt.Kill(temp);
                    break;
                case("execve"):
                    String newProgram = input.next();
                    String newUser = input.next();
                    pt.Exec(newUser,newProgram);
                    break;
                case("block"):
                    pt.Block();
                    break;
                case("yield"):
                    pt.Yield();
                    break;
                case("exit"):
                    pt.Exit();
                    break;
                case("print"):
                    pt.Print();
                    break;
                case("unblock"):
                    int tempPid = input.nextInt();
                    pt.Unblock(tempPid);
                    break;
            }
        }

    }
    /**
     * Process Table
     * Structure contains the Process Table of the CPU
     */
    private ArrayList<Process> table;
    /**
     * Contains the contents of the CPU
     */
    private int[] CPU  = new int[6];
    /**
     * Contains the process index that is running
     */
    private Process runningProcess;

    /**
     * Keeps the number of processes running
     */
    private int pid;

    public ProcessTable(){
        this.table = new ArrayList<>();
        int[] tempReg = new int[6];
        System.arraycopy(this.getRandomArray(),0,tempReg,0,6);
        pid = 0;
        Process temp = new Process(pid,"init","root",0,tempReg);
        table.add(temp);
        System.arraycopy(temp.getRegisters(),0,this.CPU,0,6);
        this.runningProcess = temp;
    }

    /**
     * This method makes a copy of the currently running process with a new status 1 (ready) and a
     * new unique pid. The program, user, and register content s are the same as the running process
     */
    public void Fork(){
        Process temp  = new Process(this.runningProcess);
        temp.setStatus(1);
        this.pid++;
        temp.setPid(this.pid);
        this.table.add(temp);
    }

    public void Block(){
        this.runningProcess.setStatus(2);
        this.runningProcess.setRegisters(this.CPU);
        this.runningProcess = this.getRandom();
        System.arraycopy(this.runningProcess.getRegisters(),0,this.CPU,0,6);
        this.runningProcess.setStatus(0);


    }
    public void Yield(){
        this.runningProcess.setRegisters(this.CPU);
        Process temp  = this.getRandom();
        this.runningProcess.setStatus(1);
        this.runningProcess = temp;
        System.arraycopy(this.runningProcess.getRegisters(),0,this.CPU,0,6);
        this.runningProcess.setStatus(0);
    }
    public void Exit(){
        table.remove(this.runningProcess);
        this.runningProcess = this.getRandom();
        System.arraycopy(this.runningProcess.getRegisters(),0,this.CPU,0,6);
        this.runningProcess.setStatus(0);
    }
    public void Print(){
        System.out.println(this.toString());
    }
    public void Exec(String newUser,String newProgram){
        if(this.runningProcess.getUser().equals("root") || this.runningProcess.getUser().equals(newUser)){
            this.runningProcess.setUser(newUser);
            this.runningProcess.setRegisters(this.getRandomArray());
            this.runningProcess.setProgram(newProgram);
            System.arraycopy(this.runningProcess.getRegisters(),0,this.CPU,0,6);
        }

    }

    /**
     * Changes the PID to (1) - Ready - from (2) - Blocked
     * In order to change the PID, the PID has to be found and the process is Blocked
     * @param pidToUnblock - the PID to unblock
     */
    public void Unblock(int pidToUnblock){
        int index = find(pidToUnblock);
        boolean allow = index >=0 && this.table.get(index).getStatus() == 2 ;
        if(allow)
            this.table.get(index).setStatus(1);
    }

    public int find (int pid){
        int i =0;
        boolean found= false;
        while(!found && i < table.size()){
            if(pid== table.get(i).getPid()) {
                found = true;
                i--;
            }
            i++;
        }
        if(i == table.size())
            return -1;
        else
            return i;
    }

    /**
     * getRandom()
     * Gets a random process from the process table with the ready status
     * TODO: When there's no processes with a ready status, it will return the process at the 0th index.
     *
     * @return a random process with a ready status of 1
     */
    public Process getRandom(){
        ArrayList<Process> temp = new ArrayList<>();
        for(int index =0;index< this.table.size();index++){
            if(this.table.get(index).getStatus() == 1)
                temp.add(table.get(index));
        }
        Random r = new Random();
        int i = r.nextInt(temp.size());
        return temp.get(i);

    }
    public int[] getRandomArray(){
        Random ran = new Random();
        int maximum = 911111111;
        int min = 879854396;
        int range = maximum - min + 1;
        int[] ar = new int[6];
        ar[0] = ran.nextInt(range) + min;
        ar[1] = ran.nextInt(range) + min;
        ar[2] = ran.nextInt(range) + min;
        ar[3] = ran.nextInt(range) + min;
        ar[4] = ran.nextInt(range) + min;
        ar[5] = ran.nextInt(range) + min;
        return ar;
    }

    /**
     * This method kills the process with the specified process id only if the currently running process
     * - has user set as "root" or
     * - has the same user set as the process being killed.
     * @param pidToKill - PID to kill from the table
     */
    public void Kill(int pidToKill){
        boolean allow = false;
        if(this.runningProcess.getUser().equals("root")){
            allow = true;
        }
        int index = this.find(pidToKill);

        boolean found=  index >= 0;
        if(found && table.get(index).getUser().equals(this.runningProcess.getUser()))
            allow = true;
        if(allow && found)
            table.remove(index);
    }

    /**
     * Finds the Process in the Process Table
     * @param temp the Process to find
     * @return the index of the process temp, or -1 if its not found inside the Process Table
     */
    public int  find(Process temp){

        boolean found = false;
        int i =0;
        while(!found && i < table.size()) {
            if(temp.equals(table.get(i)))
                found = true;
            else
                i ++;
        }
        if(found)
            return i;
        else
            return -1;
    }

    public String toString(){

        String str = String.format("CPU:\n PC = 0x%8s SP = 0x%8s\n R0 = 0x%8s R1 = 0x%8s\n R2 = 0x%8s R3 = 0x%8s\n",
                Integer.toHexString(this.CPU[0]),Integer.toHexString(this.CPU[1]),Integer.toHexString(this.CPU[2]),
                Integer.toHexString(this.CPU[3]),Integer.toHexString(this.CPU[4]),Integer.toHexString(this.CPU[5])) ;
        str = str + "\nProcess Table:\n" + (new Process()).header;
        for(int i =0; i<this.table.size();i++){
            str = str + table.get(i).toString() + "\n";
        }
        return str;
    }

}