/*
    *  XNap
    *
    *  A pure java file sharing client.
    *
    *  See AUTHORS for copyright information.
    *
    *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *
   */
  package org.xnap.plugin.joscar;
  
  import java.io.IOException;
  import java.util.Hashtable;
  import java.util.Observable;
  import java.util.Observer;
  
  import org.apache.log4j.Logger;
  import org.xnap.event.StateListener;
  import org.xnap.event.StateSupport;
  import org.xnap.plugin.joscar.msg.JOscarMessageQueue;
  import org.xnap.plugin.joscar.msg.JOscarMessageSender;
  import org.xnap.util.FiniteStateMachine;
  import org.xnap.util.State;
  import org.xnap.XNap;
  
  import JOscarLib.Core.OscarConnection;
  import JOscarLib.Integration.Event.MessagingListener;
  import JOscarLib.Integration.Event.StatusListener;
  import JOscarLib.Setting.Enum.StatusModeEnum;
  import JOscarLib.Tool.OscarInterface;
  
  public class JOscarConnection implements Observer
  {
  	//--- Constant(s) ---
  	
  	//--- Data field(s) ---
  
  	/***
  	 * The connection to the oscar server.
  	 */
      private OscarConnection connection = null;
  	/***
  	 * Provides listener support for state listeners.
  	 */
  	private StateSupport listeners = new StateSupport(this);
  	
  	private StateMachine sm = new StateMachine();
  	/***
  	 * Queue for messages to be sent out. This is necessary since the joscar
  	 * library doesn't use a thread itself for sending out messages, so we
  	 * have to do this in order to prevent the GUI from blocking.
  	 */
  	private JOscarMessageQueue queue = new JOscarMessageQueue();
  	/***
  	 * Sends out the messages in the queue.
  	 */
  	private JOscarMessageSender sender = new JOscarMessageSender(queue);
  
  	private static Logger logger = Logger.getLogger(JOscarConnection.class);
  
  	private static JOscarPreferences prefs = JOscarPreferences.getInstance();
  
  	private static final Hashtable TRANSITION_TABLE;
  	static {
  		State[][] table = new State[][] {
  			{ State.DISCONNECTED, State.CONNECTING, },
  			{ State.CONNECTING, State.CONNECTED, State.DISCONNECTED },
  			{ State.CONNECTED, State.DISCONNECTING, State.DISCONNECTED },
  			{ State.DISCONNECTING, State.DISCONNECTED }
  		};
  		TRANSITION_TABLE = FiniteStateMachine.createStateTable(table);
  	}
  	
  	//--- Constructor(s) ---
  
      public JOscarConnection()
  	{
  		
  	}
  
      //--- Method(s) ---
  
  	public void addMessagingListener(MessagingListener l)
  	{
  		if (connection != null) {
  			connection.addMessagingListener(l);
 		}
 	}
 
 	public void addStatusListener(StatusListener l)
 	{
 		if (connection != null) {
 			connection.addStatusListener(l);
 		}
 	}
 
 	/***
 	 * Adds message to its internal message queue {@link JOscarMessageQueue}
 	 * which is emptied by the {@link JOscarMessageSender}.
 	 */
 	public void sendMessage(String uin, String message)
 	{
 		queue.addMessage(uin, message);
 	}
 
 	/***
 	 * Adds SMS message to its internal message queue {@link
 	 * JOscarMessageQueue} which is emptied by the {@link
 	 * JOscarMessageSender}.
 	 */
 	public void sendSMS(String uin, String message)
 	{
 		queue.addSMS(uin, message);
 	}
 
 	public void addUser(String uin)
 	{
 		queue.addUser(uin);
 	}
 
 	public void connect()
 	{
 		setState(State.CONNECTING);
 	}
 
 	public void disconnect()
 	{
 		setState(State.DISCONNECTING);
 	}
 
 	public State getState()
 	{
 		return sm.getState();
 	}
 
 	private void setState(State newState)
 	{
 		sm.setState(newState);
 		listeners.fireStateChanged();
 	}
 
 	private void setState(State newState, String message)
 	{
 		sm.setState(newState, message);
 		listeners.fireStateChanged();
 	}
 
 	public void addStateListener(StateListener listener) 
     {
         listeners.addStateListener(listener);
     }
 
     public void removeStateListener(StateListener listener) 
     {
         listeners.removeStateListener(listener);
     }
 
 	/***
 	 * Implements the {@link Observer} interface.
 	 *
 	 * The <code>connection</code> notifies us when it's connected.
 	 */
 	public void update(Observable obs, Object obj) 
 	{
 		if (connection.isLogged()) {
 			OscarInterface.changeStatus
 				(connection,new StatusModeEnum(StatusModeEnum.ONLINE));
 			setState(State.CONNECTED);
 		}
 		else {
 			// this is never the case yet
 			setState(State.DISCONNECTED);
 		}
 	}		
 
 
 	private class StateMachine extends FiniteStateMachine
 	{
 		public StateMachine()
 		{
 			super(State.DISCONNECTED, TRANSITION_TABLE);
 		}
 
 		protected synchronized void stateChanged(State oldState,
 												 State newState)
 		{
 			if (newState == State.CONNECTING) {
 				createConnection();
 			}
 			else if (newState == State.CONNECTED) {
 				sender.setConnection(connection);
 				sender.start();
 			}
 			else if (newState == State.DISCONNECTING) {
 				closeConnection();
 			}
 			else if (newState == State.DISCONNECTED) {
 				sender.stop();
 				queue.clear();
 			}
 		}
 
 		/***
 		 * Connect to the oscar server.
 		 */
 		private void createConnection()
 		{
 			connection = new OscarConnection(prefs.getServerHost(), 
 											 prefs.getServerPort(),
 											 prefs.getUsername(),
 											 prefs.getPassword());
 			if (XNap.isRunFromCvs()) {
 				connection.getPacketAnalyser().setDebug(true);
 			}
 			connection.addObserver(JOscarConnection.this);
 		}
 		
 		/***
 		 * Closes the connection.
 		 */
 		private void closeConnection()
 		{
 			try {
 				connection.getClient().disconnect();
 			}
 			catch (IOException ie) {
 				logger.debug("Error stopping connection", ie);
 			}
 			connection = null;
 			JOscarConnection.this.setState(State.DISCONNECTED);
 		}
 	}
 	
 }