import java.io.*;
import java.util.Vector;


//Currently The VM Monitor, Pipe Manager, Process Manager, and Stream Manager  are all in this single class
//Will later separate and create a SYSAPI class that exposes certain methods to VMs.

class StreamManager
{
    public StreamManager()
    {
    }
    
    public Handle OpenFile(String filename)
    {
        
        try
        {
            RandomAccessFile rafile;
            File thefile = new File(filename);
            
            thefile.createNewFile();
            rafile = new RandomAccessFile(thefile,"rw");
            
            Handle filehandle = new Handle(rafile,3,"file - " + rafile.hashCode());
            
            return filehandle;
        }
        catch(IOException ex)
        {
            System.out.println(ex);
            return null;
        }
    }
    
    public String ReadFile(RandomAccessFile rafile, int readcount)
    {
        try
        {
            
            Long readlength;
            String strdata = "";
            byte[] filedata = new byte[0];
            
            if(readcount <= 0)
            {// Two versions shown here for this case
                // Reads from current file pointer to end of file
                //readlength = new Long(rafile.length() - rafile.getFilePointer());
                //filedata = new byte[readlength.intValue()];
                //rafile.read(filedata,0,readlength.intValue());
                
                //Reads a Line from the file
                strdata = rafile.readLine();
            }
            else
            {
                filedata = new byte[readcount];
                
                //Gets available bytes
                readlength = new Long(rafile.length() - rafile.getFilePointer());
                
                if(readcount <= readlength.intValue())
                {
                    filedata = new byte[readcount];
                    rafile.read(filedata,0,readcount);
                }
                else
                {
                    filedata = new byte[readlength.intValue()];
                    rafile.read(filedata,0,readlength.intValue());
                }
            }
            
            if(strdata.compareTo("")==0)
            {
                strdata = new String(filedata);
            }
            
            return strdata;
        }
        catch(Exception ex)
        {
            System.out.println(ex);
            return null;
        }
    }
    
    public synchronized void WriteFile(RandomAccessFile rafile, String strdata, int writecount)
    {
        // Will write min(strdata.length,writecount) number of bytes from strdata after the position of the
        // filepointer
        try
        {
            
            byte[] filedata;
            
            if(writecount < strdata.length() || writecount == 0)
            {
                filedata = new byte[strdata.length()];
            }
            else
            {
                filedata = new byte[writecount];
            }
            
            filedata = strdata.getBytes();
            rafile.write(filedata,0,filedata.length);
            
            try
            {
                notifyAll();
            }
            catch(Exception ex)
            {
                System.out.println(ex);
            }
            
        }
        catch(Exception ex)
        {
            System.out.println(ex);
        }
    }
    
}

class PipeManager
{
    public PipeManager()
    {
    }
    
    public Handle CreatePipe()
    {
        Pipe newpipe = new Pipe();
        
        Handle newhandle = new Handle(newpipe,3,"pipe - " + newpipe.hashCode());
        
        return newhandle;
    }
}

class Pipe
{
    private PipedOutputStream outpipe;
    private PipedInputStream inpipe;
    
    public Pipe()
    {
        try
        {
            outpipe = new PipedOutputStream();
            inpipe = new PipedInputStream(outpipe);
        }
        catch(IOException ex)
        {
            System.out.println("Error while creating pipe.");
        }
    }
    
    public synchronized void WritePipe(String strdata, int writecount)
    {
        try
        {
            byte[] pipedata;
            
            if(writecount < strdata.length() || writecount == 0)
            {
                pipedata = new byte[strdata.length()];
            }
            else
            {
                pipedata = new byte[writecount];
            }
            
            pipedata = strdata.getBytes();
            outpipe.write(pipedata,0,pipedata.length);
            outpipe.flush();
            try
            {
                notifyAll();
            }
            catch(Exception ex)
            {
                System.out.println(ex);
            }
            
        }
        catch(Exception ex)
        {
            System.out.println(ex);
        }
    }
    
    public String ReadPipe(int readcount) throws IOException
    {
        // Reads readcount bytes from inpipe
        // Reads all available if readcount == 0
        try
        {
            byte[] pipedata;
            int count = 0;
            
            if(readcount <= 0)
            {
                //Reads all available bytes
                //pipedata = new byte[inpipe.available()];
                //inpipe.read(pipedata,0,inpipe.available());
                
                //Reads bytes until newline or End of available Bytes found
                int recieved;
                String datastr;
                byte[] buffer = new byte[10000];
                byte[] data = new byte[1];
                
                do
                {
                    
                    recieved = inpipe.read();
                    data[0] = (byte) recieved;
                    buffer[count] = data[0];
                    datastr = new String(data);
                    count++;
                    //System.out.println(datastr);
                }while(inpipe.available() > 0 && datastr.compareTo("\n")!=0);
                System.out.println("TEST2");
                //discards last byte
                pipedata = new byte[count];
                for(int i=0;i<count;i++)
                {
                    pipedata[i] = buffer[i];
                }
            }
            else
            {
                pipedata = new byte[readcount];
                
                synchronized(this)
                {
                    while(inpipe.available() < readcount)
                    {//waits until readcount bytes available.
                        wait(3000);
                    }
                }
                
                inpipe.read(pipedata,0,readcount);
            }
            return new String(pipedata);
        }
        catch(Exception ex)
        {
            System.out.println(ex);
            throw(new IOException("Error While Reading Pipe."));
        }
        
        
    }
}

public class Sysapi
{
    private StreamManager streammanager = new StreamManager();
    private PipeManager pipemanager = new PipeManager();
    private VMMonitor vmmonitor = new VMMonitor(this);
    
    // This array contains the active consoles for each user
    private Vector ConsoleArray = new Vector(5,1);
    // This array congtains each active User
    private Vector UserArray = new Vector(5,1);
    
    public Sysapi()
    {
    }
    public void OsvmMain()
    {// Inital Creation of Login done here
        VMachine vm1 = null;
        FileClassLoader fileclass = null;
        fileclass = new FileClassLoader();
        fileclass.bindir = "C:\\java\\OSVM\\bin\\";
        Class newclass = null;
        
        Handle dh1 = OpenDevice("keyboard",null);
        Handle dh2 = OpenDevice("display",null);
        
        try
        {
            String[] args= new String[1];
            args[0] = "";
            newclass = fileclass.loadCmd("login");
            
            Handle vmh1 = CreateVM(dh1,dh2,newclass,"",args,null,null,0);
            
            //This is the only case where a VMachine gets started outside of Compute(Handle)
            ((VMachine)vmh1.getType()).start();
            
        } catch(Exception ex)
        {
            System.out.println(ex);
        }
        
    }
    
    public Handle OpenDevice(String device,String currentUser)
    {// Used by Virtual Machines to get the handle of the keyboard or display owned by the specified user.
        // Only One Handle for both devices since it is the same Object Handling it
        
        ConsoleWindow console;
        String ThreadID;
        int i;
        
        //This case is used for initial console-user creation
        if(currentUser == null)
        {// No initial User or Console
            
            if(device == "keyboard")
            {
                
                if(ConsoleArray.size() == 0)
                {
                    console = new ConsoleWindow("OSVM");
                    ConsoleArray.add(console);
                }
                else
                {
                    console = ((ConsoleWindow)ConsoleArray.get(0));
                }
                
                ThreadID = console.getClass().getName() + "-" + console.hashCode();
                Handle chandle = new Handle(console,1,ThreadID);//Create method for unique IDs
                return chandle;
            }
            if(device == "display")
            {
                if(ConsoleArray.size() == 0)
                {
                    console = new ConsoleWindow("OSVM");
                    ConsoleArray.add(console);
                }
                else
                {
                    console = ((ConsoleWindow)ConsoleArray.get(0));
                }
                
                ThreadID = console.getClass().getName() + "-" + console.hashCode();
                Handle chandle = new Handle(console,2,ThreadID);//Create method for unique IDs
                return chandle;
            }
            
        }
        //This case is used for all other device requests
        if(device == "keyboard")
        {
            for(i=0;i < UserArray.size() && getUser(i).getName() != currentUser;i++);
            
            if(i >= UserArray.size() || i >= ConsoleArray.size())
            {
                console = new ConsoleWindow("OSVM - " + currentUser);
                ConsoleArray.add(console);
            }
            else
            {
                console = ((ConsoleWindow)ConsoleArray.get(i));
            }
            
            ThreadID = console.getClass().getName() + "-" + console.hashCode();
            Handle chandle = new Handle(console,1,ThreadID);//Create method for unique IDs
            return chandle;
            
        }
        if(device == "display")
        {
            for(i=0;i < UserArray.size() && getUser(i).getName() != currentUser;i++);
            
            if(i >= UserArray.size() || i >= ConsoleArray.size())
            {
                console = new ConsoleWindow("OSVM - " + currentUser);
                ConsoleArray.add(console);
            }
            else
            {
                console = ((ConsoleWindow)ConsoleArray.get(i));
            }
            
            ThreadID = console.getClass().getName() + "-" + console.hashCode();
            Handle chandle = new Handle(console,2,ThreadID);//Create method for unique IDs
            return chandle;
        }
        else
        {
            return new Handle(null,0,"");
        }
    }
    
    public void setTitle(String username)
    {// Sets the title of the console owned by the specified user
        int i;
        
        for(i=0;i < UserArray.size() && getUser(i).getName() != username;i++);
        
        ((ConsoleWindow)ConsoleArray.get(i)).setTitle("OSVM - " + username);
    }
    
    // ---------- Public User Search Functions -------------------
    
    public User getUser(int index)
    {
        return ((User)UserArray.get(index));
    }
    
    public User findUser(String username)
    {
        int i;
        
        for(i=0;i<UserArray.size() && getUser(i).getName().compareTo(username) != 0;i++);
        
        if(i < UserArray.size())
        {
            return getUser(i);
        }
        else
        {
            return null;
        }
    }
    
    public int getUserCount()
    {
        return UserArray.size();
    }
    
    public void setUser(User newUser)
    {
        UserArray.add(newUser);
    }
    // --------------Public Console Search Functions-------------------
    public int findConsole(ConsoleWindow console)
    {
        int i = 0;
        for(i=0;i<ConsoleArray.size() && ! ((ConsoleWindow)ConsoleArray.get(i)).equals(console);i++);
        
        return i;
    }
    
    public ConsoleWindow getConsole(int index)
    {
        return ((ConsoleWindow)ConsoleArray.get(index));
    }
    
    // ----------------------------------------------------------------
    public void Exit(Handle vmh,String userVM)
    {// Called by Virtual Machines when they exit
        vmmonitor.Exit(vmh,userVM);
    }
    
    public Handle CreateVM(Handle IN,Handle OUT,Class VMClass,String owner,String[] args,VMachine Parent,Vector child,int undone)
    {// Normally used by a shell to create new instances of a Virtual Machine.
        return vmmonitor.CreateVM(IN,OUT,VMClass,owner,args,Parent,child,undone);
    }
    
    public void Write(Handle OUT, String output) throws IOException
    {// Writes the total size of the specified String to the particular handle of type (pipe,file,console)
        try
        {
            Write(OUT,output,0);
        }
        catch(IOException ex)
        {
            throw(ex);
        }
    }
    
    public void Write(Handle OUT, String output,int writecount) throws IOException
    {// Writes the specified number of bytes to the particular handle of type (pipe,file,console)
        
        try
        {
            if(OUT.getAccess() == 1)
            {
                throw(new IOException("No Write Priveleges."));
            }
            else
            {
                if(OUT.getID().startsWith("console"))
                {//case where handle is keyboard
                    ((ConsoleWindow)OUT.getType()).out.print(output);
                    ((ConsoleWindow)OUT.getType()).out.flush();
                }
                else if(OUT.getID().startsWith("pipe"))
                {
                    ((Pipe)OUT.getType()).WritePipe(output,writecount);
                }
                else if(OUT.getID().startsWith("file"))
                {
                    streammanager.WriteFile(((RandomAccessFile)OUT.getType()),output,writecount);
                }
            }
            
        }
        catch(Exception ex)
        {
            System.out.println(ex);
            throw(new IOException("Error while Writing."));
        }
        
    }
    
    
    public Handle OpenFile(String filename)
    {// Creates or Opens a File named filename and returns the handle to the file
        return streammanager.OpenFile(filename);
    }
    
    public Handle CreatePipe()
    {// Creates a Pipe and returns the handle to the pipe
        return pipemanager.CreatePipe();
    }
    
    
    public String Read(Handle IN) throws IOException
    {// This is called by virtual machines to Read from the handle provided
        // This implementation reads an entire line from a console, all available bytes in a pipe, or all the remaining bytes in the file after the file pointer
        try
        {
            return Read(IN,0);
        }
        catch(IOException ex)
        {
            throw(ex);
        }
    }
    
    public String Read(Handle IN,int bytestoread) throws IOException
    {// This is called by virtual machines to Read from the handle provided
        // This implementation reads the specified number of bytes from a file or pipe, always reads a line from a console
        try
        {
            if(IN.getAccess() == 2)
            {
                throw(new IOException("No Read Priveleges."));
            }
            else
            {
                if(IN.getID().startsWith("console"))
                {//case where handle is display
                    return ((ConsoleWindow)IN.getType()).in.readLine();
                }
                else if(IN.getID().startsWith("pipe"))
                {
                    return ((Pipe)IN.getType()).ReadPipe(bytestoread);
                }
                else if(IN.getID().startsWith("file"))
                {
                    return streammanager.ReadFile(((RandomAccessFile)IN.getType()),bytestoread);
                }
            }
            return null;
            
        }
        catch(Exception ex)
        {
            throw(new IOException("Error while Reading."));
        }
        
        
    }
    
    public void Compute(Handle vmh)
    {// This is called by a VMachine to process its children
        vmmonitor.Compute(vmh);
    }
    
    public void removeUser(int index)
    {// This is normally only called by the Exit Method if no user shells are left
        ConsoleArray.remove(index);
        UserArray.remove(index);
    }
}

//----------------------------------------------------------------------------------

class VMMonitor
{
    private Sysapi sysapi;
    
    public VMMonitor(Sysapi api)
    {
        sysapi = api;
    }
    
    
    
    public Handle CreateVM(Handle IN,Handle OUT,Class VMClass,String owner,String[] args,VMachine Parent,Vector child,int undone)
    {
        try
        {
            
            VMachine vm1 = (VMachine) VMClass.newInstance();
            
            String ThreadID = VMClass.getName() + "-" + vm1.hashCode();
            
            ((Thread)vm1).setName(ThreadID);
            
            Handle vmh1 = new Handle(vm1,3,ThreadID);
            
            ((VMachine)vm1).prepareVM(IN,OUT,vmh1,owner,args,Parent,child,undone,sysapi);
            
            if(Parent != null)
            {
                Parent.child.add(vm1);
                Parent.undone++;
            }
            
            return vmh1;
        }
        catch(Exception ex)
        {
            System.out.println("Exception while Creating Virtual Machine");
            return null;
        }
        
        
    }
    
    private synchronized void DeleteVM(Handle vmh,String userVM)
    {
        int i = 0;
        
        if(((VMachine)vmh.getType()).Parent != null)
        {
            ((VMachine)vmh.getType()).Parent.undone--;
        }
        
        for(i=0;sysapi.getUser(i).getName() != userVM;i++);
        
        sysapi.getUser(i).removeHandle(vmh);
        
        try
        {
            if(((VMachine)vmh.getType()).Parent != null)
            {
                for(i=0;!vmh.getType().equals(((VMachine)vmh.getType()).Parent.child.get(i));i++);
                //Delete child from Parent of this VM
                ((VMachine)vmh.getType()).Parent.child.remove(i);
            }
            else
            {
                if(sysapi.getUser(i).getCount()==0)
                {//Removes user and closes ConsoleWindow
                    sysapi.getConsole(i).dispose();
                    //sysapi.removeUser deletes user and linked ConsoleWindow
                    sysapi.removeUser(i);
                    
                    if(sysapi.getUserCount()==0)
                    {//No users left so exit OSVM
                        System.exit(0);
                    }
                }
            }
        }
        catch(Exception ex)
        {
            System.out.println(ex);
        }
    }
    
    
    public synchronized void Exit(Handle vmh,String userVM)
    {// This method called to do any finalizing of Closing Virtual Machines
        
        DeleteVM(vmh,userVM);
        
        try
        {//Wakes up thread inside Compute of Parent VM so that it may check if undone == 0
            notifyAll();
        }
        catch(Exception ex)
        {
            System.out.println(ex);
        }
        
        
    }
    
    public void Compute(Handle vmh)
    {
        int i = 0;
        
        int childsize = ((VMachine)vmh.getType()).child.size();
        
        try
        {
            for(i=0;i<childsize;i++)
            {
                ((VMachine)((VMachine)vmh.getType()).child.get(i)).start();
            }
        }
        catch(ArrayIndexOutOfBoundsException ex)
        {
            System.out.println(ex);
        }
        
        try
        {
            synchronized(this)
            {
                while (((VMachine)vmh.getType()).undone>0)
                {// Parent VM waits until its children are finished
                    wait();
                }
            }
        }
        catch(InterruptedException ex)
        {
            System.out.println("Exception while stopping parent VM");
        }
    }
    
    
}