/*
    * 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.File;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.net.ServerSocket;
  import java.net.Socket;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  import java.util.Set;
  import java.util.concurrent.CopyOnWriteArraySet;
  
  import triptracker.core.Route;
  import triptracker.core.Utils;
  
  /***
   * Main server class.
   */
  public class Server {
  	/*** Main listening server socket. */
  	private ServerSocket tripTrackerSocket;
  
  	/*** Connected clients sending coordinates. */
  	private List<GPSHandler> gpsHandlers = new ArrayList<GPSHandler>();
  
  	/*** Connected clients receiving coordinates. */
  	private List<MapHandler> mapHandlers = new ArrayList<MapHandler>();
  
  	/*** Listener set for Model View Controller (MVC) separation. */
  	private Set<ServerListener> listeners =
  			new CopyOnWriteArraySet<ServerListener>();
  
  	/*** Default server log file. */
  	private final String SERVER_LOG = "server.log";
  
  	/*** Server log. */
  	private final File logFile;
  	
  	/***
  	 * Default constructor.
  	 */
  	public Server() {
  		logFile = new File(SERVER_LOG); // TODO Move to properties file
  	}
  	
  	/***
  	 * Method being run when server is set for stopping.
  	 * 
  	 * @throws IOException server dies on <code>IOException</code>
  	 */
  	public final void stopServer() throws IOException {
  		log("Server", "Closing down server");
  		
  		tripTrackerSocket.close();
  	}
  
  	// TODO Remove method when ConsoleServer is complete.
  	/***
  	 * Main server entry point. 
  	 */
  	public static void main(final String[] args) {
  		try {
  			new Server().startServer(PORTNR); // TODO Move to properties file
  		} catch (IOException e) {
  			System.err.println("Server terminated by fatal IOException");
  			e.printStackTrace();
  		}
  	}
  	
  	/***
  	 * Main method will open the server socket, and go into a loop, where it
  	 * recieves clients and starts handlers.
  	 * 
  	 * @param port listening port
  	 * @throws IOException server dies on <code>IOException</code>
  	 */
 	public final void startServer(final int port) throws IOException {
 		Socket client;
 
 		log("Server", "Starting server.");
 
 		// Opening socket port
 		log("Server", "Opening port " + port); // TODO MVC listener call
 		tripTrackerSocket = new ServerSocket(port);
 
 		// TODO MVC listener call
 		log("Server", "Listening for connections...");
 		
 		// Process connection requests in an infinite loop.
 		while (true) {
 			client = tripTrackerSocket.accept();
 
 			log("Server", "Connection accepted from " + client.getInetAddress().
 					getHostAddress()); // TODO MVC listener call
 			new Thread(new CheckThread(this, client)).start();
 		}
 	}
 
 	/***
 	 * Returns a GPSHandler to listen to.
 	 * @Param route - Route to search for
 	 * @return GPS handler
 	 */
 	// TODO (jani) Add compareTo in GPSHandler to use binSearch or SortedSet 
 //	protected final GPSHandler getGPSHandler(final int routeId){
 	public GPSHandler getGPSHandler(final Route route) {
 		for(GPSHandler handler : gpsHandlers){
 			if (handler.getActiveRoute() != null
 					&& route.getRouteId() == handler.getActiveRoute()
 					.getRouteId()) {
 				return handler;
 			}
 		}
 		return null;
 	}
 	
 	/***
 	 * Adds a GPS client handler to the main server handler list.
 	 * 
 	 * @param handler handler
 	 */
 	protected final void addGPSHandler(final GPSHandler handler) {
 		log("Server", "Adding gpsHandler: " + handler);
 
 		clientListUpdate(handler, true);
 
 		gpsHandlers.add(handler);
 	}
 
 	/***
 	 * Removes a GPS client handler from the main server handler list.
 	 * 
 	 * @param handler handler
 	 */
 	protected final void removeGPSHandler(final GPSHandler handler) {
 		clientListUpdate(handler, false);
 		log("Server", "Removing gpsHandler: " + handler);
 		gpsHandlers.remove(handler);
 	}
 
 	/***
 	 * Checks if any mapHandlers are listening to the route gpsHandler will log
 	 * @param gpsHandler
 	 */
 	protected final void checkMapHandler(GPSHandler gpsHandler){
 		for(MapHandler mapHandler : mapHandlers){
 //			System.out.println("Maphandler route: "
 //					+ mapHandler.getActiveRoute());
 //			System.out.println("GpsHandler route: "
 //					+ gpsHandler.getActiveRoute());
 			if (mapHandler.getActiveRoute() != null && 
 					mapHandler.getActiveRoute().getRouteId() == gpsHandler
 							.getActiveRoute().getRouteId()) {
 				gpsHandler.addCoordListener(mapHandler);
 				mapHandler.startLogging(gpsHandler);
 				log("Server", "mapHandler will now start listening to route: "
 						+ gpsHandler.getActiveRoute().getRouteId());
 			}
 		}
 	}
 	
 	/***
 	 * Adds a map client handler from the main server handler list.
 	 * 
 	 * @param handler handler
 	 */
 	protected final void addMapHandler(final MapHandler handler) {
 		clientListUpdate(handler, true);
 		mapHandlers.add(handler);
 	}
 
 	/***
 	 * Removes a map client handler from the main server handler list.
 	 * 
 	 * @param handler handler
 	 */
 	protected final void removeMapHandler(final MapHandler handler) {
 		clientListUpdate(handler, false);
 		log("Server", "Removing mapHandler: " + handler);
 		mapHandlers.remove(handler);
 	}
 	
 	public List<GPSHandler> getGPSHandlers(){		
 		return gpsHandlers;
 	}
 	
 	/***
 	 * Register a listener for server events.
 	 * 
 	 * @param listener event receiver 
 	 */
 	public final void addListener(final ServerListener listener) {
 		listeners.add(listener);
 	}
 	
 	/***
 	 * Remove listener from listener queue.
 	 * 
 	 * @param listener event receiver 
 	 */
 	public final void removeListener(final ServerListener 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
 	 */
 	private void brokenListener(final ServerListener listener,
 			final RuntimeException exception) {
 		log("Server", "Unexpected exception in listener: "
 				+ exception.toString());
 		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 socket associated with <code>client</code> has been closed and
 	 * the client has been removed from any client list it might be a member of. 
 	 * 
 	 * @param client disconnected client
 	 * @param exception socket <code>IOException</code> thrown by client
 	 */
 	protected final void socketErrorEvent(final ClientHandler client,
 			final IOException exception) {
 		for (ServerListener listener : listeners) {
 			try {
 				listener.socketError(client, exception);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 
 	/***
 	 * Publish an "invalid message" event to all listeners. This signals an
 	 * unsupported or malformed message recieved from <code>client</code>.
 	 * Clients are usually not disconnected for sending invalid messages, unless
 	 * the amount of invalid messages is significant and the behaviour of the
 	 * client appears to be malicious.
 	 * 
 	 * @param client misbehaving client
 	 * @param message full message
 	 */
 	protected final void invalidMessage(final ClientHandler client,
 			final String message) {
 		for (ServerListener listener : listeners) {
 			try {
 				listener.invalidMessage(client, message);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 	
 	/***
 	 * Publish a "socket error" event to all listeners. This generally means
 	 * that the socket associated with <code>client</code> has been closed and
 	 * the client has been removed from any client list it might be a member of. 
 	 * 
 	 * @param client joined or disconnected client
 	 * @param joined true if joined, false if disconnected
 	 */
 	protected final void clientListUpdate(final ClientHandler client,
 			final boolean joined) {
 		for (ServerListener listener : listeners) {
 			try {
 				listener.clientListUpdate(client, joined);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 	
 	/***
 	 * Log a status message to the server log file. Each log entry is given
 	 * a timestamp and appended to the end of the file.
 	 * 
 	 * @param source in what context the log message was recorded
 	 * @param message status message
 	 */
 	protected final void log(final String source, final String message) {
 		System.out.println(source  + " [" + Thread.currentThread().getId() + "]"
 				+ ": " + message);
 		try {
 			if (!(logFile.exists())) {
 			   logFile.createNewFile();
 			}
 			
 			String date = Utils.dateToString(new Date());
 			
 			PrintWriter logOut = new PrintWriter(new FileWriter(logFile, true));
 			logOut.println("[" + date + "] " + source  + " ["
 					+ Thread.currentThread().getId() + "]" + ": " + message);
 			logOut.flush();
 		} catch (IOException e) {
 			System.out.println("With logging: " + e);
 			e.printStackTrace();
 		}
 	}
 }