/*
    * Replica is published under the terms
    * of the Apache Software License.
    */
   package replica.textui;
   
   import java.io.BufferedReader;
   import java.io.BufferedWriter;
   import java.io.FileNotFoundException;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.OutputStreamWriter;
  import java.net.InetAddress;
  import java.net.Socket;
  import java.util.Hashtable;
  import java.util.StringTokenizer;
  
  import replica.utils.BeanUtils;
  
  /***
   * @author Pedro Costa
   * @author Helder Silva
   * @since 24/Jan/2004
   */
  public class SimpleInterface implements Runnable{
  	
  	final static String CONNECT = "connect";
  	final static String DISCONNECT = "disconnect";
  	final static String QUIT = "quit";
  	final static String RUN = "run";
  	
  	int port = 7654;
  	String address = "localhost";
  
  	Socket socket;
  	BufferedReader reader;
  	BufferedWriter writer;
  	
  	static Hashtable initialOptions;
  	static{
  		initialOptions = new Hashtable();
  		initialOptions.put("-p", "port");
  		initialOptions.put("-a", "address");
  	}
  	
  	public static void main(String[] args) {
  		
  		SimpleInterface si = new SimpleInterface();
  		
  		if( args != null ){
  			for (int i = 0; i < args.length; i=i+2) {
  				if( i < args.length - 1 )
  					BeanUtils.writeProperty(si, args[i], args[i+1]);
  				else{
  					System.out.println("Invalid program option. Usage" + usage());
  					System.exit(-1);
  				}
  			}
  		}
  		
  		new Thread(si).start();
  	}
  	
  	static String usage(){
  		return "java replica.textui.SimpleTextInterface <options>\n"+
  		       "\n"+
  		       " Where <options> can be any of the following:\n"+
  		       "    -p <portNumber> - changes the default port number to use.\n"+
  		       "    -a <host>       - changes the default host address.";
  			
  	}
  	
  	
  	public SimpleInterface (){
  		super();
  	}
  	
  	public void run(){
  		
  		BufferedReader userReader = null;
  		
  		try{
  			userReader = new BufferedReader( new InputStreamReader( System.in ) ); 
  	
  			System.out.print(helloMessage());
  			
  			System.out.print("  > ");
  					
  			String line = null;
  			StringBuffer command = new StringBuffer();
  			int lineNumber = 1;
  			while ( ( line = userReader.readLine() ) != null ){
  				command.append(line + "\n");
  				if( isApplicationCommand(line) || 
  						line.indexOf(';') >= 0 ||
  						line.trim().length() == 0){
  					String result = processLine(command.toString());
  					command = new StringBuffer();
 					lineNumber = 1;
 					if( result != null && result.length() > 0 )
 						System.out.print(result);
 					System.out.print("\n  > ");
 				}
 				else{
 					System.out.print("  " + (++lineNumber) + " ");
 				}
 			}
 		}
 		catch(IOException e){
 			System.out.println("Problem connecting to ["+getAddress()+":"+
 					getPort()+"].");
 			e.printStackTrace();
 		}
 		finally{
 			close();
 		}
 	}
 	
 	/***
 	 * Return true if the given line starts with 
 	 * an application command.
 	 * 
 	 * @param line the line to check
 	 * @return true or false
 	 */
 	boolean isApplicationCommand(String line){
 		line = line.trim();
 		
 		return line.startsWith(CONNECT) ||
 		    line.startsWith(DISCONNECT) ||
 		    line.startsWith(QUIT);
 	}
 	
 	String processLine(String line){
 		if(line == null)
 			return null;
 			
 		line = line.trim();
 		
 		if( line.length() == 0 )
 			return null;
 		
 		StringTokenizer tokenizer = new StringTokenizer( line);
 		
 		if( tokenizer.countTokens() == 0)
 			return null;
 		
 		String command = tokenizer.nextToken();
 			
 		if( tokenizer.countTokens() == 0)
 			return processCommand(command, null);
 			
 		String args = line.substring(command.length());
 		
 		return processCommand( command, args);
 	}
 	
 	String helloMessage(){
 		return "\n" +
 			   "     +----------------------------------------------+\n"+
 			   "     |  T H E  R E P L I C A  P R O J E C T         |\n"+
 			   "     |                                              |\n"+
 			   "     |              S i m p l e  I n t e r f a c e. |\n"+
 	     	   "     +----------------------------------------------+\n"+
 	     	   "\n"+
 	     	   "   by: Replica Inc.:)\n"+
 	     	   "\n"+
 	     	   "\n";
 	}
 	
 	String processCommand(String command, String args){
 		
 		if( command.equalsIgnoreCase(CONNECT) )
 			return connect(args);
 				
 		if( command.equalsIgnoreCase(DISCONNECT) )
 			return disconnect();
 				
 		if( command.equalsIgnoreCase(QUIT) ){
 			quit();
 			return "YOU WILL NEVER SEE THIS.";
 		}
 		
 		if( command.equalsIgnoreCase(RUN) )
 			return run(args);
 			
 		if( !isConnected() )
 			return "Not connected. You must connect first.";
 			
 		return sendToServer( command + 
 			(args==null?"":(" " + args)) );
 	}
 	
 	String run(String args){
 		
 		if( args == null || args.trim().length() == 0 )
 			return "Usage: run <filename>;";
 			
 		args = args.trim();
 		if(args.endsWith(";"))
 			args = args.substring(0, args.length()-1);
 			
 		BufferedReader reader = null;
 		int i = 0;
 		try{
 			reader = new BufferedReader( new FileReader(args));
 			
 			String line = null;
 			while( (line = reader.readLine() ) != null ){
 				processLine(line);i++;
 			}
 		}
 		catch(FileNotFoundException e){
 			return "File no found: [" + args + "].";
 		}
 		catch(IOException e){
 			e.printStackTrace();
 			return e.getMessage();
 		}
 		finally{
 			try{ reader.close(); }catch(Throwable t){}
 		}
 		
 		return "Processed " + i + " lines from file [" + args + "].";
 	}
 	
 	String connect(String args){
 		
 		Object[] conArgs = null;
 		try{
 			conArgs = getConnectArgs(args);
 		}
 		catch(IllegalArgumentException e){
 			return e.getMessage();
 		}
 		
 		try{
 			connect( conArgs[0].toString(), ((Integer)conArgs[1]).intValue(), conArgs[2].toString() );
 		}
 		catch(IOException e){
 			e.printStackTrace();
 			return "Unable to connect to [" + conArgs[0] + ":" + conArgs[1] 
 						+ "] as [" + conArgs[2] + "].";
 		}
 		
 		return null;
 	}
 	
 	/***
 	 * Parse a connect command string.
 	 * 
 	 * If the string to parse does not contain the host address and/or
 	 * the port number, a default value is used. 
 	 * 
 	 * @param args the connect string to parse.
 	 * @return a array where:
 	 * 		1: is a String with a address;
 	 * 		2: is a Integer with the port number;
 	 * 		3: is the user string.
 	 * @throws IllegalArgumentException if the string cannot be parsed.
 	 */
 	Object[] getConnectArgs(String args) throws IllegalArgumentException{
 		
 		if( args == null )
 			throw new IllegalArgumentException( 
 					"Error in connect command. Usage: " + connectUsage() );
 			
 		StringTokenizer tokenizer = new StringTokenizer(args, " ");
 
 		if( tokenizer.countTokens() < 1 )
 			throw new IllegalArgumentException( 
 					"Error in connect command. Usage: " + connectUsage() );
 		
 		String host = null;
 		int port = -1;
 		if( tokenizer.countTokens() > 1){	
 			String fullAddress = tokenizer.nextToken();
 			StringTokenizer tok2 = new StringTokenizer(fullAddress,":");
 			host = tok2.nextToken();
 			if( tok2.countTokens() > 0 ){
 				String portStr = tok2.nextToken();
 				try{
 					port = Integer.parseInt(portStr);
 				}
 				catch(NumberFormatException e){
 					throw new IllegalArgumentException( 
 							"Invalid port number [" + portStr + "]." );	
 				}
 			}
 		}
 			
 		String user = tokenizer.nextToken();
 		
 		if( host == null || host.length() == 0 )
 			host = getAddress();
 			
 		if( port < 0 )
 			port = getPort();
 			
 		return new Object[]{ host, new Integer(port), user}; 
 	}
 	
 	void connect(String address, int port, String serverArgs) throws IOException{
 		
 		if( address == null || address.length() == 0)
 			address = getAddress();
 			
 		if( port < 0 )
 			port = getPort();
 		
 		socket = new Socket(InetAddress.getByName(address), port);
 			
 		new Thread(new ReturnListener(new BufferedReader(
 						new InputStreamReader( socket.getInputStream() ) ) ) ).start();
 							
 		writer = new BufferedWriter( new OutputStreamWriter( socket.getOutputStream() ) );
 		
 		writer.write( "connect " + serverArgs + 
 						(serverArgs.trim().endsWith(";")?"\n":";\n") );
 		writer.flush();
 	}
 	
 	String sendToServer(String msg){
 		try{
 			writer.write(msg + "\n");
 			writer.flush();
 			return "Sent [" + msg + "].";
 		}
 		catch(IOException e){
 			e.printStackTrace();
 			return "Problem sending message to server.";
 		}
 	}
 	
 	String connectUsage(){
 		return "connect <host>:<port> <user>[/<password>][@<databasename>]";
 	}
 	
 	String disconnect(){
 		close();
 		return "Disconnected from remote.";
 	}
 	
 	void quit(){
 		close();
 		System.exit(0);
 	}
 	
 	public boolean isConnected(){
 		return socket != null && socket.isConnected();
 	}
 	
 	void close(){
 		if(reader != null){
 			try{ reader.close(); }catch(Throwable t){}
 		}
 		if(writer != null){
 			try{ writer.close(); }catch(Throwable t){}
 		}
 		if(socket != null){		
 			try{ socket.close(); }catch(Throwable t){}
 		}
 	}
 	
 	/***
 	 * @return
 	 */
 	public String getAddress() {
 		return address;
 	}
 
 	/***
 	 * @return
 	 */
 	public int getPort() {
 		return port;
 	}
 
 	/***
 	 * @param string
 	 */
 	public void setAddress(String string) {
 		address = string;
 	}
 
 	/***
 	 * @param i
 	 */
 	public void setPort(int i) {
 		port = i;
 	}
 
 	class ReturnListener implements Runnable{
 		
 		BufferedReader reader;
 		
 		ReturnListener( BufferedReader reader ){
 			super();
 			
 			this.reader = reader;
 		}
 		
     	/* (non-Javadoc)
 		 * @see java.lang.Runnable#run()
 		 */
 		public void run(){
 			
 //			System.out.println("Started return listener.");
 			
 			String line = null;
 			try{
 				boolean firstLine = true;
 				while( (line = reader.readLine() ) != null ){
 					if( firstLine ){
 						System.out.println();
 						firstLine = false;
 					}
 					System.out.println( "  < " + line );
 					if( !reader.ready() ){
 						System.out.println();
 						System.out.print( "  > " );
 						firstLine = true;
 					}
 				}
 			}
 			catch(IOException e){
 				throw new RuntimeException( e );
 			}
 			
 //			System.out.println("Stopped return listener.");
 		}
 
 	}
 }