/*
    * 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.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Date;
  import java.util.List;
  
  import triptracker.core.Coordinate;
  import triptracker.core.Route;
  import triptracker.core.User;
  import triptracker.core.Utils;
  
  public class MapSocket extends SocketConnection<MapSocketListener> {
  	/***
  	 * Logon a user of the type {@link triptracker.core.Protocol#MAPCLIENT}.
  	 * 
  	 * @param user username
  	 * @param pass password
  	 * @throws IOException on connection failure
  	 */
  	public void logon(String user, String pass) throws IOException {
  		logon(MAPCLIENT, user, pass);
  	}
  
     	/***
  	 * {@inheritDoc}
  	 */
  	@Override
  	public void addListener(MapSocketListener listener) {
  		listeners.add(listener);
  	}
  	
     	/***
  	 * {@inheritDoc}
  	 */
  	@Override
  	public void removeListener(MapSocketListener listener) {
  		listeners.remove(listener);
  	}
  	
  	/***
  	 * Send a request for a list of users to the server.
  	 */
  	public void getUsers() {
  		sendMessage(USERS_GET);
  	}
  	
  	public void getUser(int userId) {
  		sendMessage(USER_GET, userId);
  	}
  	
  	/***
  	 * Gets complete route from server.
  	 */
  	public void getRoute(Route route) {
  		if (route == null){
  			routeList(null);
  			return;
  		}
  		sendMessage(ROUTE_GET, route.getRouteId());
  	}
  	
  	/***
  	 * Sets realtime route to track.
  	 * 
  	 * @param route
  	 */
  	public void setRealtimeRoute(Route route) {
  		sendMessage(SET_ROUTE, route.getRouteId(), "x");
  	}
  	
  	/***
  	 * Gets realtime plotting routes from server.
  	 */
  	public void getRealtimeRoutes() {
  		sendMessage(REALTIME);
 	}
 	
 	/***
 	 * Publish a connection state change event to all listeners. This notifies
 	 * the clients that the connection state of the underlying socket has
 	 * changed.
 	 * 
 	 * @param routeId route ID updated
 	 * @param coord new coordinate
 	 */
 	protected void coordReceived(int routeId, Coordinate coord) {
 		for (MapSocketListener listener : listeners) {
 			try {
 				listener.coordReceived(routeId, coord);
 			} 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 routeId route ID updated
 	 * @param coord new coordinate
 	 */
 	protected void coordsReceived(List<Coordinate> coords) {
 		for (MapSocketListener listener : listeners) {
 			try {
 				listener.coordsReceived(coords);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 	
 	/***
 	 * Publish an updated user list event to all listeners.
 	 * 
 	 * @param users
 	 */
 	protected void usersReceived(List<User> users) {
 		for (MapSocketListener listener : listeners) {
 			try {
 				listener.usersReceived(users);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 	
 	/***
 	 * Publish updated user to all listeners
 	 * @param users
 	 */
 	protected void userReceived(User user) {
 		for (MapSocketListener listener : listeners) {
 			try {
 				listener.userReceived(user);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 	
 	/***
 	 * Publish a route list update event to all listeners.
 	 * 
 	 * @param routeId route ID updated
 	 * @param coords list of coordinates
 	 */
 	protected void routeReceived(int routeId, List<Coordinate> coords) {
 		for (MapSocketListener listener : listeners) {
 			try {
 				listener.routeReceived(routeId, coords);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 	
 	/***
 	 * Publish a route list update event to all listeners. 
 	 * 
 	 * @param routes received list of routes
 	 */
 	protected void routeList(List<Route> routes) {
 		for (MapSocketListener listener : listeners) {
 			try {
 				listener.routeList(routes);
 			} catch (RuntimeException e) {
 				brokenListener(listener, e);
 			}
 		}
 	}
 
    	/***
 	 * {@inheritDoc}
 	 */
 	@Override
 	protected boolean messageHandler(String message) {
 		String[] msg;
 		int routeId;
 		double latitude;
 		double longitude;
 		String time;
 		Coordinate coord;
 		
 		msg = message.split(DELIMITER, -1);
 		System.out.println("Message: " + Arrays.toString(msg));
 
 		try {
 			// Handle message based on first field (msg[0]).
 			switch (Integer.parseInt(msg[0])) {
 			case AUTH_FAIL: //=-1
 				connectionUpdate(AUTH_FAILED);
 				break;
 			case AUTH_OK: //=0
 				connectionUpdate(AUTH_SUCCESS);
 				break;
 			case COORD_ADD: //=1
 //				 For plotting one spesific coordinate
 				routeId = Integer.parseInt(msg[1]);
 				latitude = Double.parseDouble(msg[2]);
 				longitude = Double.parseDouble(msg[3]);
 				time = msg[4];
 				coord = new Coordinate(latitude, longitude,
 						Utils.parseDate(time));
 
 //				System.out.println("Recieved: RouteId: "  + routeId
 //						+ " latitude: " + latitude + ", longitude "
 //						+ longitude + ", tidspunkt: " + time);
 				coordReceived(routeId, coord);
 				break;
 			case COORD_BUFFER_ADD:
 				routeId = Integer.parseInt(msg[1]);
 				List<Coordinate> coords = new ArrayList<Coordinate>();
 				
 				for (int i = 2; i < msg.length; i += 3) {
 					latitude = Double.parseDouble(msg[i]);
 					longitude = Double.parseDouble(msg[i + 1]);
 					time = msg[i + 2];
 					coords.add(new Coordinate(latitude, longitude,
 							Utils.parseDate(time)));
 				}
 				
 				coordsReceived(coords);
 				break;
 			case USERS_GET:
 				List<User> users = new ArrayList<User>();
 				for (int i = 1; i<msg.length ; i += 2){
 					int userId = Integer.parseInt(msg[i]);
 					String username = msg[i+1];
 					users.add(new User(userId, username, null));
 				}
 				usersReceived(users);
 				break;
 			case USER_GET:
 				User user = new User(Integer.parseInt(msg[1]), msg[2]);
 				userReceived(user);
 				break;
 			case ROUTE_GET:
 				//Recieves full route previously asked for
 				List<Coordinate> coordList = new ArrayList<Coordinate>();
 				
 				routeId = Integer.parseInt(msg[1]);
 				
 //				if (msg.length == 3) { 
 //					routeReceived(routeId,coordList);
 //					break;
 //				}
 //				System.out.println(routeId);
 //				System.out.println(inStream);
 //				
 //				byte[] buffer = new byte[2];
 //				GZIPInputStream zipin = new GZIPInputStream(inStream);
 //				zipin.read(buffer);//,0,size);
 //				System.out.println("Array: " + buffer[0] + " " + buffer[1]);
 //				String coordBuffer = new String(buffer);
 //				System.out.println(coordBuffer);
 				
 				for (int i = 2; i < msg.length; i += 3) {
 					latitude = Double.parseDouble(msg[i]);
 					longitude = Double.parseDouble(msg[i + 1]);
 					time = msg[i + 2];
 					
 					Coordinate coordi = new Coordinate(latitude, longitude,
 							Utils.parseDate(time));
 //					System.out.println("Got coordinate: " + ((i + 1) / 3)
 //							+ " - " + coordi.getX() + ", " + coordi.getY()
 //							+ ", " + coordi.getDateString());
 					coordList.add(coordi);
 				}
 				routeReceived(routeId, coordList);
 				break;
 			case VIEW_ROUTES:
 				List<Route> routes = new ArrayList<Route>();
 
 				if (msg.length == 1) { 
 					routeList(routes);
 					break;
 				}
 				if (msg.length == 2) { //FIXME Make server not send empty space
 					routeList(routes);
 					break;
 				}
 				
 //				System.out.println("msg[1] " + msg[1]);
 				for (int i = 1; i < msg.length; i += 6) {
 					routeId = Integer.parseInt(msg[i]);
 					int userId = Integer.parseInt(msg[i + 1]);
 					String description = msg[i + 2];
 					boolean active = Utils.strToBool(msg[i + 3]);
 					Date date = Utils.parseDate(msg[i + 4]);
 					boolean visible = Utils.strToBool(msg[i + 5]);
 					Route route = new Route(routeId, userId, description,
 							active, visible, date);
 					routes.add(route);
 				}
 				routeList(routes);
 				break;
 			case SET_ROUTE:
 				// TODO Implement: Route not beeing tracked...
 				break;
 			case REALTIME:
 				// TODO implement: Tracker has stopped logging route.
 				// XXX Same states as SUBSCRIBED and UNSUBSCRIBED?
 				if (Utils.strToBool(msg[1])) {
 					connectionUpdate(TRACKING);
 				} else {
 					connectionUpdate(WATCHING);
 				}
 				break;
 			default:
 				System.out.print("Message: " + msg[1]);
 				break;
 			}
 		} catch (NumberFormatException num) {
 			System.out.println("NumberFormatException: " + num);
 			num.printStackTrace();
 		} 
 		return true;
 	}	
 }