/*
    * Trip Tracker, a real-time position tracking system for the Internet.
    * Copyright (C) 2006  Team Trip Tracker
    *
    * This program is free software; you can redistribute it and/or modify it
    * under the terms of the GNU General Public License as published by the
    * Free Software Foundation; either version 2 of the License, or (at your
    * option) any later version.
    *
   * This program is distributed in the hope that it will be useful, but
   * WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   * General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License along
   * with this program; if not, write to the Free Software Foundation, Inc.,
   * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
   */
  
  package triptracker.client.net;
  
  import static triptracker.core.ConnectionState.*;
  import static triptracker.core.Protocol.*;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.OutputStream;
  import java.io.PrintStream;
  import java.net.InetSocketAddress;
  import java.net.Socket;
  import java.util.Set;
  import java.util.concurrent.CopyOnWriteArraySet;
  
  import triptracker.core.ConnectionState;
  import triptracker.core.Protocol;
  import triptracker.core.Route;
  
  /***
   * Connects to the server through a socket.
   */
  public abstract class SocketConnection<E extends SocketListener> {
  	private Socket socket = null;
  	protected InputStream inStream = null;
  	protected OutputStream outStream = null; 
  	protected BufferedReader in = null;
  	protected PrintStream out = null;
  	
  	private String username;
  	private String host = HOST;
  	private int port = PORTNR;
  	
  	protected boolean loggedIn = false;
  	
  	/*** Listener set for Model View Controller (MVC) separation. */
  	protected Set<E> listeners = new CopyOnWriteArraySet<E>();
  	
  	/***
  	 * Connects to the hostname and port number set by {@link #setHost(String)}
  	 * and {@link #setPort(int)}.
  	 * 
  	 * @throws IOException on connection failure
  	 * @see #connect(String, int)
  	 */
  	public void connect() throws IOException {
  		connect(host, port);
  	}
  	
  	/***
  	 * Connect to server on specified port.
  	 * 
  	 * @param host server hostname
  	 * @param port destination port
  	 * @throws IOException on connection failure
  	 * @see #connect(String)
  	 */
  	public void connect(String host, int port) throws IOException {
  		// Disconnect existing connection.
  		if (!isClosed()) {
  			disconnect();
  		}
  		
  		// Connect to server.
  		socket = new Socket();
  		
  		try {
  			socket.connect(new InetSocketAddress(host, port));
  		} catch (IOException e) {
  			socket = null;
  			throw e;
  		}
  
  		// Setup streams.
  		inStream = socket.getInputStream();
  		outStream = socket.getOutputStream();
  		in = new BufferedReader(new InputStreamReader(inStream));
  		out = new PrintStream(outStream, true);
  
 		connectionUpdate(CONNECTED);
 
 		// Start socket data reader thread.
 		Thread t = new DataReaderThread();
 		// Demonize so that it doesn't prevent the program from closing.
 		t.setDaemon(true); 
 		t.start();
 
 	}
 	
 	/***
 	 * Logon a user.
 	 * 
 	 * @param type type of user
 	 * @param user username
 	 * @param pass password
 	 * @throws IOException on connection failure
 	 */
 	protected void logon(int type, String user, String pass)
 			throws IOException {
 		// Tries to authenticate with the server
 		if (!isConnected()) {
 			connect();
 		}
 		
 		this.username = user;
 		
 		// Sends message to server, loggin in.
 		sendMessage(type, user, pass);
 	}
 	
 	/***
 	 * Sets route to track
 	 */
 	public void setRoute(Route route){
 		sendMessage(SET_ROUTE, route.getRouteId());
 	}
 	
 	/***
 	 * Request a list of routes for a given user. When the requested list
 	 * is received from the server.
 	 */
 	public void getRoutes(String username){
 		sendMessage(VIEW_ROUTES, username);
 		//TODO make it work with zip
 	}
 	
 	/***
 	 * Sends a message to the server
 	 * 
 	 * @param message
 	 */
 	protected void sendMessage(Object... message) {
 		if (!isConnected()){
 			// TODO It might be enough to check isClosed() because it might
 			// work to send a message while the socket is still connecting.
 			// Then it might send it right after successfully connecting.
 			// This needs to be tested.
 			System.out.println("socket not connected");
 			// No use announcing disconnected state when already disconnected.
 			// This must be detected somewhere else.
 //			connectionUpdate(DISCONNECTED);
 			return;
 		}
 
 		try {
 			send(outStream, message);
 		} catch (IOException e) {
 			socketErrorEvent(e);
 		}
 		
 		// TODO for testing purposes only
 //		System.out.println("%% sent to server: " + Arrays.toString(message));
 	}
 
 	/*** 
 	 * Checks if the client is connected to the server.
 	 * 
 	 * @return true if connected, false if disconnected
 	 */
 	public boolean isConnected() {
 		if (socket == null) {
 			return false;
 		} else {
 			return socket.isConnected();
 		}
 	}
 
 	/*** 
 	 * Checks if the client connection is closed.
 	 * 
 	 * @return true if connected, false if disconnected
 	 */
 	public boolean isClosed() {
 		if (socket == null) {
 			return true;
 		} else {
 			return socket.isClosed();
 		}
 	}
 
 	/***
 	 * Checks if the client is logged in.
 	 * 
 	 * @return true if logged in, false if not logged in
 	 */
 	public boolean isLoggedIn(){
 		return loggedIn;
 	}
 	
 	/***
 	 * Checks for messages recieved from the server, and pass them to the
 	 * message handler for further processing. Subclasses can override this
 	 * method to provide their own message loop if message processing needs to
 	 * be more fine grained than simple line based delimiting.
 	 */
 	protected void messageLoop() throws IOException {
 		String message;
 		
 		while (true) {
 			message = in.readLine();
 			if (message == null) {
 				break;
 			// Delegate message handling.
 			} else if (!messageHandler(message)) {
 				break;
 			}
 		}
 	}
 	
 	/***
 	 * Message handler for data received on socket. Subclasses must implement
 	 * this method to provide handing of recieved messages. 
 	 * 
 	 * @param message received message from server
 	 * @return true if more messages can be processed, false to end the message
 	 * 		loop, stop message handling and close the socket connection
 	 */
 	protected abstract boolean messageHandler(String message);
 
 	/***
 	 * Disconnect from the socket.
 	 * 
 	 * @throws IOException on socket error
 	 */
 	public void disconnect() throws IOException {
 		if (loggedIn) {
 			sendMessage(QUIT);
 			loggedIn = false;
 		}
 		
 		if (isClosed()) {
 			return;
 		}
 
 		// TODO Server closes socket on QUIT, but should have timeout on
 		// closing to ensure disconnection.
 		socket.close();
 		socket = null;
 		
 		 // XXX Hoping for close() to kill the data reader thread.
 		connectionUpdate(DISCONNECTED);
 	}
 	
 	/***
 	 * Register a listener for server events.
 	 * 
 	 * @param listener event receiver to register
 	 */
 	public void addListener(E listener) {
 		listeners.add(listener);
 	}
 	
 	/***
 	 * Remove listener from listener queue.
 	 * 
 	 * @param listener event receiver to remove
 	 */
 	public void removeListener(E listener) {
 		listeners.remove(listener);
 	}
 	
 	/***
 	 * Reports a broken listener, removes it from the listener queue and logs
 	 * the error.
 	 * 
 	 * @param listener broken listener
 	 * @param exception exception thrown by listener
 	 */
 	protected void brokenListener(SocketListener listener,
 			RuntimeException exception) {
 		System.err.println("Unexpected exception in listener");
 		exception.printStackTrace(); // XXX Temp error logging. Add log to file?
 		
 		// Remove listener from queue.
 		listeners.remove(listener);
 	}
 	
 	/***
 	 * Publish a socket error event to all listeners. This generally means that
 	 * the client socket connection has been closed. 
 	 * 
 	 * @param exception socket exception thrown
 	 */
 	protected void socketErrorEvent(IOException exception) {
 		for (SocketListener listener : listeners) {
 			try {
 				listener.socketError(exception);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 
 	/***
 	 * Publish an invalid message event to all listeners. This signals an
 	 * unsupported or malformed message recieved from the server. 
 	 * 
 	 * @param message full message
 	 */
 	protected void invalidMessage(String message) {
 //		System.out.println("invalidMessage: " + message); // XXX Temporary
 
 		for (SocketListener listener : listeners) {
 			try {
 				listener.invalidMessage(message);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 	
 	/***
 	 * Publish a connection state change event to all listeners. This notifies
 	 * the clients that the connection state of the underlying socket has
 	 * changed.
 	 * 
 	 * @param state new connection state
 	 */
 	protected void connectionUpdate(ConnectionState state) {
 //		System.out.println("connectionUpdate: " + state); // XXX Temporary
 
 		// Update logged in status.
 		loggedIn = (state == AUTH_SUCCESS);
 		
 		for (SocketListener listener : listeners) {
 			try {
 				listener.connectionUpdate(state);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 	
 	/***
 	 * Inner class to receive incomming messages.
 	 */
 	private class DataReaderThread extends Thread {
 		/***
 		 * Start the message loop that recieves messages from the socket.
 		 */
 		@Override
 		public void run() {
 			try {
 				// Start message loop
 				messageLoop();
 			}  catch (IOException e) {
 				socketErrorEvent(e);
 				//e.printStackTrace();
 			}  catch (RuntimeException e) {
 				e.printStackTrace();
 			} finally {
 				// Gracefully exit.
 				try {
 					in.close();
 					out.close();
 					socket.close();
 				} catch (IOException e) {
 					//socketErrorEvent(e);
 				} finally {
 					connectionUpdate(DISCONNECTED);
 				}
 			}
 		}
 	}
 
 	/***
 	 * Returns the current hostname. By default the hostname is set to
 	 * {@link Protocol#HOST}.
 	 * 
 	 * @return hostname
 	 */
 	public String getHost() {
 		return host;
 	}
 
 	/***
 	 * Set hostname to connect to. By default the hostname is set to
 	 * {@link Protocol#HOST}.
 	 * 
 	 * @param host host to set
 	 */
 	public void setHost(String host) {
 		this.host = host;
 	}
 
 	/***
 	 * Returns the current port. By default the port number is set to
 	 * {@link Protocol#PORTNR}.
 	 * 
 	 * @return port number
 	 */
 	public int getPort() {
 		return port;
 	}
 
 	/***
 	 * Set port to connect to. By default the port number is set to
 	 * {@link Protocol#PORTNR}.
 	 * 
 	 * @param port The port to set.
 	 */
 	public void setPort(int port) {
 		this.port = port;
 	}
 	
 	/***
 	 * Returns the name of the active user. This is set during login when
 	 * connecting to the server.
 	 * 
 	 * @return active user name
 	 */
 	public String getUsername() {
 		return username;
 	}
 }