/*

  * @author Robert Koenighofer, member of the ISAC-team, 

  * Copyright (c) 2006 by Robert Koenighofer

  * created Jul 11, 2006 10:09:13 AM

  * Institute for Softwaretechnology, Graz University of Technology, Austria.

  * 

  * Use is subject to PGPL license terms.

  */

 package isac.session;

 import isac.users.User;

 import isac.users.UserLogger;

 import isac.users.UserManager;

 import java.io.Serializable;

 import java.rmi.RemoteException;

 import java.rmi.server.UnicastRemoteObject;

 import java.util.HashMap;

 import org.apache.log4j.Logger;

 /**

  * This class administrates all sessions. It is implemented as Singleton (design

  * Pattern of Gamma et.al.), which means, that there can be only one instance of

  * this class. This instance can be accessed by the getInstance() method. The

  * class allows to generate new Sessions and to deliver session objects with a

  * specific session id. The session id is always unique.

  * 

  * @author Robert Koenighofer

  */

 public class SessionManager extends UnicastRemoteObject implements

         ISessionManager, Serializable {

     static final long serialVersionUID = 284066283;// FIXXME generate with

     // plugin

     private static final Logger logger = Logger.getLogger(SessionManager.class

             .getName());;

     private int next_id_;

     private static SessionManager instance_ = null;

     private HashMap<String, Session> sessionid_map_session_;

     private HashMap<String, String> sessionid_map_username_;

     public ICompod compod_;

     /**

      * The constructor is private, since this class is implemented as singleton.

      * Use the getInstance() method to get the one and only instance of this

      * class.

      * 

      * @throws RemoteException

      *             if remote object is not available

      */

     private SessionManager() throws RemoteException {

         sessionid_map_session_ = new HashMap<String, Session>();

         sessionid_map_username_ = new HashMap<String, String>();

         next_id_ = 0;

         compod_ = new CompodDummy();

         try {

             compod_.setLMSID("isac");

         } catch (Exception e) {

             e.printStackTrace();

         }

     }

     /**

      * This method creates a new session for the user with the name 'user_name'.

      * It returns the created session. One user can have more than one session

      * at a time.

      * 

      * @param user_name

      *            the name of the user of the new session

      * @return the created session

      * @throws RemoteException

      *             if remote object is not available

      */

     public Session addSession(User user) throws RemoteException {

         String new_id = String.valueOf(next_id_++);

         Session new_session = new Session(new_id, user, compod_);

         sessionid_map_session_.put(new_id, new_session);

         sessionid_map_username_.put(new_id, user.getUsername());

         if (logger.isDebugEnabled())

             logger.debug(" SM: new Session with ID: " + new_id + " created");

         return new_session;

     }

     /**

      * This method removes the session with the specified id from the maps. It

      * is called, whenever a logout is done (by closing the WindowApplication).

      * 

      * @param session_id

      *            the id of the session to remove

      * @throws RemoteException

      *             if remote object is not available any more

      */

     public void removeSession(String session_id) throws RemoteException {

         // WN0710 the similar UI_CLOSE_WORKSHEET is done in the gui;

         // analogously this could be done on closing the WindowApplication:

         UserLogger user_logger = getSessionByID(session_id).getUserLogger();

         user_logger.logStopSession();

         sessionid_map_session_.remove(session_id);

         sessionid_map_username_.remove(session_id);

     }

     /**

      * returns the session with the desired session_id. If the session does not

      * exist, null is returned.

      * 

      * @param session_id

      *            the unique id of the desired session

      * @return the desired session or null if it doesn't exist

      * @throws RemoteException

      *             if remote object is not available

      */

     public Session getSessionByID(String session_id) throws RemoteException {

         return sessionid_map_session_.get(session_id);

     }

     /**

      * returns the name of the user, which owns a specific session, as String.

      * If the session does not exist, null is returned.

      * 

      * @param session_id

      *            the unique id of the desired session

      * @return the desired user name or null if the session does not exist

      * @throws RemoteException

      *             if remote object is not available

      */

     public String getUserNameByID(String session_id) throws RemoteException {

         return sessionid_map_username_.get(session_id);

     }

     public HashMap getSessionMap() {

         return sessionid_map_session_;

     }

     /**

      * returns the instance of the singleton SessionManager. Since the

      * constructor is private, this is the only method to get a SessionManager.

      * It always returns one and the same instance of this class.

      * 

      * @return the one and only instance of this class.

      * @throws RemoteException

      *             if remote object is not available

      */

     public static SessionManager getInstance() throws RemoteException {

         if (instance_ == null) {

             try {

                 instance_ = new SessionManager();

             } catch (RemoteException e) {

                 e.printStackTrace();

             }

         }

         return instance_;

     }

 }