/*

  * Created on Jun 24, 2003

  *

  * To change the template for this generated file go to

  * Window>Preferences>Java>Code Generation>Code and Comments

  */

 package isac.session;

 import isac.browserdialog.BDialog;

 import isac.browserdialog.BrowserDialog;

 import isac.gui.WindowApplication;

 import isac.wsdialog.DGuide;

 import java.io.Serializable;

 import java.rmi.RemoteException;

 import java.rmi.server.UnicastRemoteObject;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.Vector;

 import org.apache.log4j.Logger;

 import org.apache.xmlrpc.WebServer;

 /**

  * @author Andreas Griesmayer

  */

 public class SessionDialog extends UnicastRemoteObject implements SDialog,

     Serializable {

 	static Logger logger_ = Logger.getLogger(SessionDialog.class.getName());

 	//private Map dguide_map_ = new HashMap();//WN0503 unused

   private int counter_;

   private static UMHandler um_handler_ = new UMHandler();

   private static WSDHandler dg_handler_ = new WSDHandler();

   private Map sessionmap_ = new HashMap();

   private Map bdialogmap_ = new HashMap();

   private static SessionDialog instance_;

   private SessionDialog() throws RemoteException {

     init();

     System.out.println("SessionDialog constructor");

   }

   /**

    * returns the instance of the singleton SessionDialog. The SessionDialog is

    * responsible for maintaining all session-relevant informations like Browser-

    * and WorksheetDialog and UserModel it provides its functions using RMI and

    * XML-RPC

    * 

    * @return

    */

   public static SessionDialog getInstance() {

     if (instance_ == null) {

       try {

         instance_ = new SessionDialog();

       } catch (RemoteException e) {

         e.printStackTrace();

       }

     }

     return instance_;

   }

   // LK 04.09.02: user control with the UserManager

   /**

    * @param username

    *          name of the user

    * @param pass

    *          password

    * @return vector with the sessionid as first and only element on success or

    *         empty vector on failure

    */

   public Vector login(String username, String pass) {

     Vector return_val = new Vector();

     User user = UserManager.getUser(username, pass);

     String sessionid = null;

     if (user != null) {

       //WN050222 String sessionid;

       if ((sessionid = (String) sessionmap_.get(username)) == null) {

         sessionmap_.put(username, (sessionid = username + counter_++));

         um_handler_.newUserModel(username, sessionid);

       }

       return_val.add(sessionid);

     }

     logger_.fatal("WA<-SH: login <- sessionid=" + sessionid);

     return return_val;

   }

   /**

    * @param sessionId

    * @return the user for the session id

    */

   public User getUser(String sessionId) {

     //TODO: get user

     return null;

   }

   /**

    * returns the name of the user which owns the given session.

    * 

    * @param session

    *          ID of the session for which the owner is requested

    * @return the name of the owner of the session

    * TODO.WN050311 encapsulate User#getName !!!

    */

   public String getUsername(String session) {

     Iterator keys = sessionmap_.keySet().iterator();

     String username;

     while (keys.hasNext()) {

       if (session.equals(sessionmap_.get((username = (String) keys.next())))) {

         return username;

       }

     }

     return "";

   }

   /**

    * create a new WSDialog and assign it to session <code>session</code>

    */

   public String openDGuide(String session) {

     return dg_handler_.newDGuide(this, session);

   }

   public DGuide getDGuide(String dg_id) {

     return (DGuide) dg_handler_.getDGuide(dg_id);

   }

   /**

    * used if the SessionDialog is used in standalone mode for testing-purposes.

    * Registers its XML-RPC services on port 1050 of the local machine

    * 

    * @param args

    *          not used

    */

   public static void main(String[] args) {

     init();

   }

   private static void init() {

     try {

       // Invoke me as <http://localhost:8080/RPC2>.

       System.out.println("SessionDialog main");

       WebServer server = new WebServer(1050);//WN0503 fixed port !

       server.setParanoid(false);

       //			server.addHandler("sample", new JavaServer());

       server.addHandler("SDialog", getInstance());

       server.addHandler(" WSDialog", dg_handler_);

       // LK 04.09.02: new temorary user management

       //server.addHandler("UserModel", um_handler_);

     } catch (Exception exception) {

       System.err.println("SessionDialog: " + exception.toString());

     }

   }

   public void finalize() {

     System.out.println("SessionDialog finalize!");

   }

   /**

    * returns the BrowserDialog identified by <code>bdialog_id</code> or

    * creates a new one.

    * 

    * @param bdialog_id

    *          ID of the BrowserDialog to open.

    * @return RMI-Object of the requested BrowserDialog

    */

   public BDialog getBDialog(String bdialog_id) {

     BDialog browser_dialog = (BDialog) bdialogmap_.get(bdialog_id);

     if (browser_dialog == null) {

       try {

         bdialogmap_.put(bdialog_id, (browser_dialog = new BrowserDialog(

             bdialog_id)));

       } catch (RemoteException e) {

         System.err.println("unable to create new BrowserDialog for session "

             + bdialog_id);

         e.printStackTrace();

       }

     }

     return browser_dialog;

   }

 }