/*

Communication Interface for Virtual Classroom Components.
Complied in JDK 1.4.2

Usage:

    Step1: Create your component which implemnts Interface 
           ComponentBase.
           
    Step2: Replace the ComponentMy with your class name in 
           InterfaceServer::main().
            
    Step3: start up Interface Server by
             java InterfaceServer
             
    Step4: Use Virtual remote which is also provided on the 
           web to send message and get the feedback message.

Enjoyed by flying, Jan 28, 2004.
Any comments, please Email:
      flying@cs.pitt.edu

*/ 


import java.io.*;
import java.net.*;
import java.util.*;

/* 
  Class KeyValueList:
    List of (Key, Value) pair--the basic format of message
    keys: MsgID and Description are required for any messages
    MsgID 0-999 is reserved for system use.
    You MsgID could start from 1000. 
*/
  
class KeyValueList
{
	private Vector keys;
	private Vector values;
   
	/* Constructor */
	public KeyValueList()
	{
		keys = new Vector();
		values = new Vector();
	}
   
	/* Look up the value given key, used in getValue() */
   
	public int lookupKey(String strKey)
	{
		for(int i=0; i < keys.size(); i++)
		{
			String k = (String) keys.elementAt(i);
			if (strKey.equals(k)) 
				return i;
		} 
		return -1;
	}
   
	/* add new (key,value) pair to list */
   
	public boolean addPair(String strKey,String strValue)
	{
		return (keys.add(strKey) && values.add(strValue));
	}
   
	/* get the value given key */
   
	public String getValue(String strKey)
	{
		int index=lookupKey(strKey);
		if (index==-1) 
			return null;
		return (String) values.elementAt(index);
	} 
	
	public void setValue(int index, String val)
	{
		if(index >= 0 && index < size())
			values.set(index, val);
	}

	/* Show whole list */
	public String toString()
	{
		String result = new String();
		for(int i=0; i<keys.size(); i++)
		{
       		result+=(String) keys.elementAt(i)+":"+(String) values.elementAt(i)+"\n";
		} 
		return result;
	}
   
	public int size()
	{ 
		return keys.size(); 
	}
   
	/* get Key or Value by index */
	public String keyAt(int index){ return (String) keys.elementAt(index);}
	public String valueAt(int index){ return (String) values.elementAt(index);}
}

/*
  Class MsgEncoder:
      Serialize the KeyValue List and Send it out to a Stream.
*/
class MsgEncoder
{
	private PrintStream printOut;
	/* Default of delimiter in system is $$$ */
	private final String delimiter = "$$$";
   
	public MsgEncoder(){}
   
	/* Encode the Key Value List into a string and Send it out */
   
	public void sendMsg(KeyValueList kvList, OutputStream out) throws IOException
	{
		PrintStream printOut= new PrintStream(out);
		if (kvList == null) 
			return;
		String outMsg= new String();
		for(int i=0; i<kvList.size(); i++)
		{
     		if (outMsg.equals(""))
     			outMsg = kvList.keyAt(i) + delimiter + kvList.valueAt(i);
     		else
     			outMsg += delimiter + kvList.keyAt(i) + delimiter + kvList.valueAt(i);
		}
		//System.out.println(outMsg);
		printOut.println(outMsg);
	}
}

/*
  Class MsgDecoder:
     Get String from input Stream and reconstruct it to 
     a Key Value List.
*/

class MsgDecoder 
{
	private BufferedReader bufferIn;
	private final String delimiter = "$$$";
   
	public MsgDecoder(InputStream in)
	{
		bufferIn  = new BufferedReader(new InputStreamReader(in));	
	}
   
	/*
     get String and output KeyValueList
	*/
   
	public KeyValueList getMsg() throws IOException
	{
		String strMsg= bufferIn.readLine();
       
		if (strMsg==null) 
			return null;
       
		KeyValueList kvList = new KeyValueList();	
		StringTokenizer st = new StringTokenizer(strMsg, delimiter);
		while (st.hasMoreTokens()) 
		{
			kvList.addPair(st.nextToken(), st.nextToken());
		}
		return kvList;
	}
   
}

/* 
   interface ComponentBase:
      The interface you have to implement in your component
*/
interface ComponentBase
{
    public void processMsg(KeyValueList kvList) throws Exception;
	public void set(Socket s);
}

/*
    Class InterfaceServer    
        Set up a socket server waiting for the remote to connect.
*/

public class InterfaceServer
{	
	private static final int port = 7999;
	private static String vcAddress;
	private static Socket client;
	private static Socket component = null;
	private static ComponentBase compMy;
	
	public static void main(String[] args) throws Exception 
	{
		if (args.length < 1)
        {
            System.out.println("Too few arguments.");
            System.out.println("Run it like this: java InterfaceServer VC_IP");
            System.exit(0);
        }

		vcAddress = args[0];

		final ServerSocket server = new ServerSocket(port);

		Thread t = new Thread( new Runnable()
			{
				public void run()
				{
					try
					{
						client = server.accept();
						new ClientSession();

						while(true)
						{
							component = server.accept();
							new ComponentSession();
						}
					}
					catch ( IOException ioe )
					{ System.out.println("Server Exception!"); }
				}
			});
		t.setDaemon( true );
		t.start();
		
		System.out.println( "Hit Enter to stop.\n" );
		try { System.in.read(); } catch( Throwable thr ) {};

	}

	private static class ClientSession implements Runnable
	{
		public ClientSession()
		{
			compMy = new componentMy(vcAddress, component, client);

			Thread t = new Thread( this );
			t.setDaemon( true );
			t.start();
		}

		public void run()
		{
			try
			{
				MsgDecoder mDecoder= new MsgDecoder(client.getInputStream());
				MsgEncoder mEncoder= new MsgEncoder();
				KeyValueList kvInput, kvOutput;
				do
				{
					kvInput = mDecoder.getMsg();
					if (kvInput != null) 
						compMy.processMsg(kvInput);
				}
				while (kvInput != null);
			}
			catch (SocketException se)
			{
				 System.out.println("Connection was Closed by Client");
			}	
			catch ( IOException ioe )
			{
				System.out.println("SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
			}
			catch (Exception ex)
			{
				System.out.println("Exception");
			}
		}
	}

	private static class ComponentSession implements Runnable
	{
		public ComponentSession()
		{
			compMy.set(component);

			Thread t = new Thread( this );
			t.setDaemon( true );
			t.start();
		}

		public void run()
		{
			try
			{
				MsgDecoder mDecoder= new MsgDecoder(component.getInputStream());
				MsgEncoder mEncoder= new MsgEncoder();
				KeyValueList kvInput, kvOutput;
				do
				{
					kvInput = mDecoder.getMsg();
					if (kvInput != null) 
					{
						int msgID = Integer.parseInt(kvInput.getValue("MsgID"));
						if(msgID >= 0 && msgID <= 10)
							compMy.processMsg(kvInput);
						else
							mEncoder.sendMsg(kvInput, client.getOutputStream());
					}
				}
				while (kvInput != null);
			}
			catch (SocketException se)
			{
				 System.out.println("Connection was Closed by Client");
			}	
			catch ( IOException ioe )
			{
				System.out.println("SERVER INTERNAL ERROR: IOException: " + ioe.getMessage());
			}
			catch (Exception ex)
			{
				System.out.println("Exception");
			}
		}
	}

}