/*
    * 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.Date;
  import java.util.List;
  
  import triptracker.core.Coordinate;
  import triptracker.core.Route;
  import triptracker.core.Utils;
  
  public class GPSSocket extends SocketConnection<GPSSocketListener> {
  	/***
  	 * Logon a user of the type {@link triptracker.core.Protocol#SENDCLIENT}.
  	 * 
  	 * @param user username
  	 * @param pass password
  	 * @throws IOException on connection failure
  	 */
  	public void logon(String user, String pass) throws IOException {
  		logon(SENDCLIENT, user, pass);
  	}
  
  	/***
  	 * Sends coordinates to server.
  	 * 
  	 * @param coord coordinate to send to server
  	 */
  	public void sendCoord(Coordinate coord){
  		sendMessage(COORD_ADD, coord.getY(), coord.getX(),
  				coord.getDateString());
  	}
     
     /***
      * Sends buffered coordinates to server.
      * 
      * @param coordBuffer string buffer of all coordinates
      * @return true if send successful, false if send failed
      */
     public boolean sendTmpCoords(StringBuilder coordBuffer){
  		// 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.
  	   	// Same this as with sendMessage(...) except that this method uses
  	    // sendMessage so it might not be needed here.
  		if(isConnected()) {
  //			GZIPOutputStream zipOutStream;
  			int size = coordBuffer.toString().getBytes().length;
  			sendMessage(COORD_BUFFER_ADD, size);
  //			try {
  //			System.out.println("Sending zipped coordBuffer: "
  //					+ coordBuffer.toString());
  			sendMessage(coordBuffer);
  				
  //		        FileOutputStream fout = new FileOutputStream("test.gz");
  //		        GZIPOutputStream out = new GZIPOutputStream(fout);
  	
  //				ZipOutputStream zipOutStream = new ZipOutputStream(outStream);
  //				DeflaterOutputStream zipOutStream =
  //						new DeflaterOutputStream(outStream); 
  //				GZIPOutputStream zipOutStream =
  //						new GZIPOutputStream(outStream, size);
  
  //				.toString().getBytes(),0,size);
  //				send(zipOutStream, true, coordBuffer,0,size);
  				
  //				send(zipOutStream, true, coordBuffer);
  //				zipOutStream.write(coordBuffer.toString().getBytes(),0,size);
  //				zipOutStream.write(coordBuffer.toString().getBytes());
  				
  /*				byte[] x = new byte[2];
  				x[0] = 1;
  				x[1] = 2;
  */
  //				zipOutStream.write(x);//coordBuffer.toString().getBytes());
  
 //				zipOutStream.flush();
 //				zipOutStream.finish();
 //				zipOutStream = null;				
 			
 /*			} catch (IOException e) {
 				System.out.println("Problem sending buffered coords: " + e);
 				e.printStackTrace();
 				return false;
 			}
 */	//		System.out.println("Zipped buffer is sent");
 			return true;
 		}
 //		System.out.println("Zipping gjekk gale!");
 		return false;
    }
    
    /***
     * Generates new route
     * @param description
     */
    public void makeRoute(String description){
 	   sendMessage(MAKE_ROUTE, description);
    }
    
    /*** For locking route when it is finnished. */
    public void lockRoute(int route){
 	   sendMessage(ROUTE_LOCK, route);
    }
    
    protected void routesReceived(List<Route> routes) {
 	   for (GPSSocketListener listener : listeners) {
 		   try {
 			   listener.routeList(routes);
 		   } catch (RuntimeException e) {
 			   brokenListener(listener, e);
 		   }
 	   }
    }
    
 	/***
 	 * {@inheritDoc}
 	 */
 	@Override
 	public void addListener(GPSSocketListener listener) {
 		listeners.add(listener);
 	}
 	
    	/***
 	 * {@inheritDoc}
 	 */
 	@Override
 	public void removeListener(GPSSocketListener listener) {
 		listeners.remove(listener);
 	}
 	
    	/***
 	 * {@inheritDoc}
 	 */
 	@Override
 	protected boolean messageHandler(String message){
 		String[] 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 VIEW_ROUTES:
 				List<Route> routes = new ArrayList<Route>();
 
 				for (int i = 1; i < msg.length; i += 6) {
 					int 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);
 				}
 				routesReceived(routes);
 				break;
 			case MAKE_ROUTE:
 				routeCreated(Integer.parseInt(msg[1]));
 				break;
 			default:
 				invalidMessage(message);
 				break;
 			}
 		} catch (NumberFormatException num) {
 			System.out.println("NumberFormatException: " + num);
 			num.printStackTrace();
 			invalidMessage(message);
 		}
 		
 		return true;
 	}
 
 	/***
 	 * Publish a route created message event to all listeners. This signals that
 	 * a previous request to create a route has been accepted.
 	 * 
 	 * @param routeId route ID of the new route
 	 */
 	protected void routeCreated(int routeId) {
 	   for (GPSSocketListener listener : listeners) {
 		   try {
 			   listener.routeCreated(routeId);
 		   } catch (RuntimeException e) {
 			   brokenListener(listener, e);
 		   }
 	   }
 	}
 }