/*
    * 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.server;
  
  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.Socket;
  import java.util.List;
  
  import triptracker.core.Route;
  import triptracker.core.User;
  import triptracker.server.persistence.MySqlDB;
  import triptracker.server.persistence.PersistenceAdapter;
  
  /***
   * Message handler for connected clients.
   */
  public abstract class ClientHandler {
  	protected PersistenceAdapter db = new MySqlDB(); 
  	protected Server server;
  	protected User user;
  	protected Route route;
  	
  	private final Socket socket;
  	protected final InputStream inStream;
  	protected final OutputStream outStream;
  	protected final BufferedReader in;
  	protected final PrintStream out;
  
  	private DataReaderThread readerThread;
  	
  	/***
  	 * Sets up socket streams for client communication and creates the message
  	 * reader thread for message processing. 
  	 * 
  	 * @param server main server instance
  	 * @param socket client communication socket
  	 * @param user client user data
  	 * @throws IOException on connection failure
  	 */
  	protected ClientHandler(Server server, Socket socket, User user) throws IOException {
  		this.server = server;
  		this.socket = socket;
  		this.user = user;
  		db.setUserId(user.getUserId());
  		
  		// Setup streams.
  		inStream = socket.getInputStream();
  		outStream = socket.getOutputStream();
  		in = new BufferedReader(new InputStreamReader(inStream));
  		out = new PrintStream(outStream, true);
  		
  		readerThread = new DataReaderThread();
  	}
  	
  	/***
  	 * Invoked when the client has disconnected. Sub-classes can override this
  	 * method to implement their own clean up procedure when a connection is
  	 * closed down in order to release resources and object references.
  	 */
  	protected void stopHandler() { }
  
  	/***
  	 * Start the socket data reader thread.
  	 */
  	protected void startHandler() {
  		readerThread.start();
  	}
  	
  	/***
  	 * 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();
 			log("Message: " + message);
 
 			if (message == null) {
 				break;
 			} else if (!messageHandler(message)) {
 				break;
 			}
 		}
 	}
 	
 	/***
 	 * Invoked when a new message has been recieved. Sub-classes must implement
 	 * this method to provide handing of recieved messages.
 	 * 
 	 * @param message received message from client
 	 */
 	protected abstract boolean messageHandler(String message);
 	
 	/***
 	 * Get all routes from a specific user send them to the reciever.
 	 * @param username username to get routes from
 	 */
 	protected void viewRoutes(String username) {
 		List<Route> routes = db.getRoutes(username);
 
 		if (routes.size() == 0) {
 			sendMessage(VIEW_ROUTES);
 			return;
 		}
 		
 		// Build output route string.
 		StringBuilder routeString = new StringBuilder();
 		for (Route route : routes) {
 			makeMsg(DELIMITER, routeString, route.getRouteId(),
 					route.getUserId(), route.getDescription(), route.isActive(),
 					route.getLastUpdateString(), route.getVisible());
 		}
 //		GZIPOutputStream zipOutStream = new GZIPOutputStream(output);
 //		zipOutStream.write(routeString.toString().getBytes());
 		sendMessage(VIEW_ROUTES, routeString);
 		
 		log("Routes for user " + username + " has been sent");
 	}
 	
 	/***
 	 * Uses method in protocol to send message to client.
 	 * 
 	 * @param out output stream
 	 * @param message fields
 	 */
 	protected void sendMessage(OutputStream out, Object... message) {
 		try {
 			send(out, message);
 		} catch (IOException e) {
 			log("Problem sending message to client: " + e);
 			e.printStackTrace();
 		}
 	}
 
 	/***
 	 * Sends a message to the client.
 	 * 
 	 * @param message message to send
 	 */
 	protected void sendMessage(Object... message) {
 		sendMessage(out, message);
 	}
 
 	/***
 	 * Sends compressed data to client.
 	 * 
 	 * @param out output stream
 	 * @param message fields
 	 */
 	protected void sendZipMessage(OutputStream out,	Object... message) {
 		// TODO Implement ZIP compression method
 	}
 	
 	/***
 	 * This method is used for logging messages on the server.
 	 * 
 	 * @param message log message
 	 */
 	protected void log(String message) {
 		server.log(user.getUsername(), message);
 	}
 	
 	/***
 	 * Returns the currently active route for this client handler.
 	 * 
 	 * @return currently active route
 	 */
 	protected Route getActiveRoute() {
 		return route;
 	}
 	
 	/***
 	 * Inner class to receive incomming messages.
 	 */
 	private class DataReaderThread extends Thread {
 		/***
 		 * Start the message loop that receives messages from the socket.
 		 */
 		@Override
 		public void run() {
 			try {
 				// Start message loop.
 				messageLoop();
 			} catch (IOException e) {
 				log("Client terminated with IOException: " + e);
 			} catch (RuntimeException e) {
 				log("Client terminated with RuntimeException: " + e);
 				e.printStackTrace();
 			} finally {
 				// Gracefully exit.
 				// XXX Before or after socket.close()?
 //				server.connectionUpdate(DISCONNECTED);
 
 				try {
 					socket.close();
 				} catch (IOException e) {
 					// Broadcast error to clients.
 //					server.socketErrorEvent(this, e);  // TODO Fix MVC.
 					log("Error closing client socket: " + e);
 					e.printStackTrace();
 				}
 				
 				stopHandler();
 				log("Client disconnected");
 			}
 		}
 	}
 }