/*
* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/


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

public class EchoServer extends Thread{

	// Constants
	
	// Commands available
	private final String		iCommandShutdown = "Shutdown.";
	private final String		iCommandShutdownNow = "ShutdownNow.";
	private final String		iCommandStopReturning = "StopReturning.";
	private final String		iCommandStartReturning = "StartReturning.";
	private final String		iCommandSleep = "sleep=";
	private final String		iCommandSendBufferSize = "sendbufsize=";
	private final String		iCommandReceiveBufferSize = "recvbufsize=";

	private final int			iBufferSize = 256;

	// Static variables
	private static final int	sDefaultTcpPort = 10007;
	private static int			sPort;
	
	// Member variables
	private Socket				iClientSocket;
	private boolean				iUdpSocket;
	private int					iUdpPort;
	
	private String				iClientHost;
	private int					iClientPort;
	
	private int					iSendBufferLength = 0;
	private int					iReceiveBufferLength = 0;
	
	private boolean				iEchoData = true;
	private boolean				iPortSet = false;

	public static void main(String[] aArgs) throws IOException{
	
		ServerSocket lServerSocket = null;
		sPort = sDefaultTcpPort;
		boolean lUdpSocket = false;
		if (aArgs.length > 0){
			try{
				sPort = Integer.parseInt(aArgs[0]);
			}
    		catch(NumberFormatException nfe){
 				System.out.println("Usage:\n\tjava EchoServer [port [protocol]]\n\tIf port is not specified, port: " + sDefaultTcpPort + " will be used\n\tProtocol is TCP or UDP if not specified or incorrect TCP is default");		
 				System.exit(1);
    		}
    		if (aArgs.length > 1){
    			if (aArgs[1].equalsIgnoreCase("UDP")){
					lUdpSocket = true;
				}
    		}
		}
		// UDP Version
		if (lUdpSocket){
			System.out.println("Connection Socket Created for UDP connection on port: " + sPort);
			while (true){
				try{
					java.lang.Thread.sleep(1000);
				}
				catch(java.lang.InterruptedException ie){
					System.err.println("Sleep inturrupted.");
				}
				System.out.println("Waiting for Connection");
				EchoServer lEchoServer = new EchoServer(sPort);
				lEchoServer.handleUDP();
			}
		}

		// TCP version
		else{
		
			try{
				lServerSocket = new ServerSocket(sPort);
				System.out.println("Connection Socket Created for TCP connection on port: " + sPort);

				try{
					while (true){
						System.out.println("Waiting for Connection");
						new EchoServer(lServerSocket.accept());
					}
				}
				catch(IOException e){
					System.err.println("Accept failed.");
					System.exit(1);
				}
			}
			catch(IOException e){
				System.err.println("Could not listen on port: " + sPort + ".");
				System.exit(1);
			}
			finally{
				try{
					lServerSocket.close();
				}
				catch(IOException e){
					System.err.println("Could not close port: " + sPort + ".");
					System.exit(1);
				}
			}
		}
	}

	private EchoServer(Socket aClientSoc){
	
		iClientSocket = aClientSoc;
		iUdpSocket = false;
		
		InetAddress lIpAddress = iClientSocket.getInetAddress();
		iClientHost = lIpAddress.getHostAddress();
		System.out.println("Accepted from IP Address: " + iClientHost);

		start();
	}
	
	private EchoServer(int aPort){
	
		iUdpSocket = true;
		iUdpPort = aPort;
	}
	
	// returns true if iClientPort successfully parsed
	private boolean parsePort(String aMessage){
	
		// If the text is formatted like this:  
		// [2024]
		// parse the client port so that connection back to this preference is possible
		int lFirstIndex = aMessage.indexOf('[');
		int lSecondIndex = aMessage.indexOf(']');
		
		if ( (lFirstIndex == 0) && (lSecondIndex > 1) ){
		
			String lPortString = aMessage.substring(1, lSecondIndex);
			int lPort = 0;
						
			try{
				lPort = Integer.parseInt(lPortString);
			}
    		catch(NumberFormatException nfe){
 				System.out.println("Failed to parse port to integer");
 				return false;
    		}
    		
    		iClientPort = lPort;
    		iPortSet = true;
    		return true;
		}
    	return false;
	}
	
	// returns true if integer successfully parsed
	private int parseIntCommand(String aMessage, String aCommandName){
	
		// If the text is formatted like this:  
		// command=x
		// parse the integer x
		int lResult = -1;
		
		if (aMessage.startsWith(aCommandName)){
		
			int lDotIndex = aMessage.indexOf('.');
			
			if (lDotIndex < 0){
				lDotIndex = aMessage.length();
			}
			
			String lResultString = aMessage.substring(aCommandName.length(), lDotIndex);
						
			try{
				lResult = Integer.parseInt(lResultString);
			}
    		catch(NumberFormatException nfe){
 				System.out.println("Failed to parse integer");
    		}
		}
		return lResult;
	}

	// TCP Handling	
	public void run(){
	
		System.out.println("New TCP Communication Thread Started");
		try{
		
			PrintWriter lOut = null;
			Socket lClientSocketConn = null;
			BufferedReader lIn = new BufferedReader(new InputStreamReader(iClientSocket.getInputStream()));
			String lInputLine;
			boolean lExit = false;
			int lTempResult = -1;

			while (lExit == false){
			
				char lDataReceived[] = new char[iBufferSize];
				
				int lLengthOfData = lIn.read(lDataReceived);

				if (lLengthOfData <= 0){
					lExit = true;
					continue;
				}
				
				lInputLine = new String(lDataReceived, 0, lLengthOfData);
				
				System.out.println("Server: " + lInputLine);

				lTempResult = parseIntCommand(lInputLine, iCommandReceiveBufferSize);
				if (lTempResult != -1){		// Message parsed
					if (lTempResult > 0){
						iReceiveBufferLength = lTempResult;
						iClientSocket.setReceiveBufferSize(iReceiveBufferLength);
						System.out.println("RECEIVE BUFFER LENGTH SET TO " + iClientSocket.getReceiveBufferSize());
					}
					else{
						System.out.println("INVALID RECEIVE BUFFER LENGTH: " + iReceiveBufferLength);
					}
				}
				
				lTempResult = parseIntCommand(lInputLine, iCommandSendBufferSize);
				if (lTempResult != -1){		// Message parsed
					if (lTempResult > 0){
						iSendBufferLength = lTempResult;
					}
					else{
						System.out.println("INVALID SEND BUFFER LENGTH: " + lTempResult);
					}
				}
				if (iSendBufferLength > 0){
					lClientSocketConn.setSendBufferSize(iSendBufferLength);
					System.out.println("SEND BUFFER LENGTH SET TO " + lClientSocketConn.getSendBufferSize());
				}
				
				if (parsePort(lInputLine)){
					try{
						lClientSocketConn = new Socket(iClientHost, iClientPort);
        				lOut = new PrintWriter(lClientSocketConn.getOutputStream(), true);
					}
					catch(UnknownHostException e){
						System.err.println("Don't know about host: " + iClientHost);
						lExit = true;
						continue;
					}
					catch(IOException e){
						System.err.println("Couldn't get I/O for the connection to: " + iClientHost);
						lExit = true;
						continue;
    				}
				}
				
				if (lInputLine.startsWith(iCommandStartReturning)){
					System.out.println("ECHOING ACTIVATED");
					iEchoData = true;
				}
								
				if (lInputLine.startsWith(iCommandShutdownNow)){
					System.out.println("SHUTTING DOWN");
					break;					
				}
				
				if ( (lOut != null) && iEchoData ){
					System.out.println("Echo to host: " + iClientHost + ":" + iClientPort);
					lOut.print(lInputLine);
					lOut.flush();
				}

				if (lInputLine.startsWith(iCommandShutdown)){
					System.out.println("SHUTTING DOWN");
					break;					
				}
				
				if (lInputLine.startsWith(iCommandStopReturning)){
					System.out.println("ECHOING DEACTIVATED");
					iEchoData = false;
				}
				
				int lSleepLength = parseIntCommand(lInputLine, iCommandSleep);
				if (lSleepLength != -1){		// Message parsed
					if (lSleepLength > 0){
						System.out.println("SLEEPING FOR " + lSleepLength + " MILLISECONDS");
						try{
							java.lang.Thread.sleep(lSleepLength);
						}
						catch(java.lang.InterruptedException ie){
							System.err.println("Sleep inturrupted.");
						}
					}
					else{
						System.out.println("INVALID SLEEP LENGTH: " + lSleepLength + " MILLISECONDS");
					}
				}
			}
			
			if (lOut != null){
				lOut.close();
				lClientSocketConn.close();
			}
			
			lIn.close();
			iClientSocket.close();
			System.out.println("Communication Thread Ended");	
		}
		catch(IOException e){
			System.err.println("Problem with Communication Server");
		}
	}
	
	// UDP Handling
	public void handleUDP(){
	
		DatagramSocket lSock;
		try{
			lSock = new DatagramSocket(iUdpPort);
		}
		catch(SocketException e){
			System.out.println(e);
			return;
		}
		int lTempResult = -1;
		// echo back everything to new socket
		while (true){
		
			try{
				DatagramPacket lPack = new DatagramPacket(new byte[iBufferSize], iBufferSize);

				lSock.receive(lPack);
				
				// Set IP address of remote socket
				InetAddress lIpAddress = lPack.getAddress();
				iClientHost = lIpAddress.getHostAddress();
				System.out.println("Received from IP Address: " + iClientHost);
				
				int lLengthOfData = lPack.getLength();

				if (lLengthOfData <= 0){
					continue;
				}
				
				byte[] lData = lPack.getData();
				String lMessage = new String(lData, 0, lLengthOfData);
				System.out.println("Server: " + lMessage);

				lTempResult = parseIntCommand(lMessage, iCommandReceiveBufferSize);
				if (lTempResult != -1){		// Message parsed
					if (lTempResult > 0){
						iReceiveBufferLength = lTempResult;
						lSock.setReceiveBufferSize(iReceiveBufferLength);
						System.out.println("RECEIVE BUFFER LENGTH SET TO " + lSock.getReceiveBufferSize());
					}
					else{
						System.out.println("INVALID RECEIVE BUFFER LENGTH: " + iReceiveBufferLength);
					}
				}
				
				lTempResult = parseIntCommand(lMessage, iCommandSendBufferSize);
				if (lTempResult != -1){		// Message parsed
					if (lTempResult > 0){
						iSendBufferLength = lTempResult;
					}
					else{
						System.out.println("INVALID SEND BUFFER LENGTH: " + lTempResult);
					}
				}
				
				parsePort(lMessage);
				
				if (lMessage.startsWith(iCommandStartReturning)){
					System.out.println("ECHOING ACTIVATED");
					iEchoData = true;
				}
				
				if (lMessage.startsWith(iCommandShutdownNow)){
					System.out.println("SHUTTING DOWN");
					lSock.close();
					return;					
				}			

				if (iPortSet && iEchoData){
					sendUDP(lMessage);					
				}
				
				if (lMessage.startsWith(iCommandShutdown)){
					System.out.println("SHUTTING DOWN");
					lSock.close();
					return;					
				}			

				if (lMessage.startsWith(iCommandStopReturning)){
					System.out.println("ECHOING DEACTIVATED");
					iEchoData = false;
				}
				
				int lSleepLength = parseIntCommand(lMessage, iCommandSleep);
				if (lSleepLength != -1){		// Message parsed
					if (lSleepLength > 0){
						System.out.println("SLEEPING FOR " + lSleepLength + " MILLISECONDS");
						try{
							java.lang.Thread.sleep(lSleepLength);
						}
						catch(java.lang.InterruptedException ie){
							System.err.println("Sleep inturrupted.");
						}
					}
					else{
						System.out.println("INVALID SLEEP LENGTH: " + lSleepLength + " MILLISECONDS");
					}
				}
			}
			catch(IOException ioe){
				System.out.println(ioe);
				try{
					lSock.close();
				}
				catch(Exception e){
					System.err.println(e);
				}
				return;
			}
		}
	}
	
	private void sendUDP(String aMessage){
	
		try{
			byte[] lMessage = aMessage.getBytes();
			System.out.println("Echo to host: " + iClientHost + ":" + iClientPort);

			InetAddress lAddress = InetAddress.getByName(iClientHost);
			// Initialize a datagram packet with data and address
			DatagramPacket lPacket = new DatagramPacket(lMessage, lMessage.length, lAddress, iClientPort);

			// Create a datagram socket, send the packet through it, close it.
			DatagramSocket lDSocket = new DatagramSocket();
			
			if (iSendBufferLength > 0){
				lDSocket.setSendBufferSize(iSendBufferLength);
				System.out.println("SEND BUFFER LENGTH SET TO " + lDSocket.getSendBufferSize());
			}

			lDSocket.send(lPacket);
			lDSocket.close();
		}
		catch(Exception e){
			System.err.println(e);
		}		
	}
}