/*
    * Copyright (c) 2005 Regents of the University of California (Regents). Created
    * by TELS, Graduate School of Education, University of California at Berkeley.
    *
    * This software is distributed under the GNU Lesser General Public License, v2.
    *
    * Permission is hereby granted, without written agreement and without license
    * or royalty fees, to use, copy, modify, and distribute this software and its
    * documentation for any purpose, provided that the above copyright notice and
   * the following two paragraphs appear in all copies of this software.
   *
   * REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
   * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE. THE SOFTWAREAND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
   * HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
   * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
   *
   * IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
   * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
   * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
   * REGENTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package net.sf.sail.core.beans;
  
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import java.beans.beancontext.BeanContextServiceProvider;
  import java.beans.beancontext.BeanContextServices;
  import java.beans.beancontext.BeanContextServicesSupport;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.PrintStream;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.List;
  
  import net.sf.sail.core.beans.event.SessionEvent;
  import net.sf.sail.core.beans.event.SessionEventListener;
  import net.sf.sail.core.beans.service.AgentService;
  import net.sf.sail.core.beans.service.SessionService;
  import net.sf.sail.core.entity.Offering;
  import net.sf.sail.core.entity.User;
  import net.sf.sail.core.session.DefaultSessionService;
  import net.sf.sail.core.session.SessionDataService;
  import net.sf.sail.core.uuid.SessionUuid;
  
  import org.apache.commons.lang.builder.ReflectionToStringBuilder;
  
  /***
   * @author turadg
   */
  public class SessionContext extends BeanContextServicesSupport {
  	/***
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger.getLogger(SessionContext.class
  			.getName());
  
  	private static final long serialVersionUID = 1L;
  
  	/***
  	 * @author turadg
  	 */
  	class ServiceProvider implements BeanContextServiceProvider {
  
  		SessionService sessionService = new DefaultSessionService(
  				SessionContext.this);
  
  		AgentService agentService = null;
  
  		void register(BeanContextServices bcs) {
  			bcs.addService(SessionService.class, serviceProvider);
  			bcs.addService(AgentService.class, serviceProvider);
  		}
  
  		public void releaseService(BeanContextServices bcs, Object requestor,
  				Object service) {
  			throw new UnsupportedOperationException();
  		}
  
  		public Iterator getCurrentServiceSelectors(BeanContextServices bcs,
  				Class serviceClass) {
  			throw new UnsupportedOperationException();
  		}
  
  		public Object getService(BeanContextServices bcs, Object requestor,
  				Class serviceClass, Object serviceSelector) {
  			if (serviceClass == SessionService.class) {
  				return sessionService;
  			} else if (serviceClass == AgentService.class) {
  				return agentService;
  			} else
  				return null;
  		}
  	}
  
  	private final ServiceProvider serviceProvider = new ServiceProvider();
 
 	SessionUuid sessionId;
 
 	SessionDataService sessionDataService;
 
 	Offering offering;
 
 	Date startTime;
 
 	Date stopTime;
 
 	public Offering getOffering() {
 		return offering;
 	}
 
 	public void setOffering(Offering offering) {
 		this.offering = offering;
 	}
 
 	List<SessionEventListener> sessionEventListeners = new ArrayList<SessionEventListener>();
 
 	private boolean initiated;
 
 	public void addSessionEventListener(SessionEventListener sel) {
 		sessionEventListeners.add(sel);
 	}
 
 	protected void fireSessionEvent(SessionEvent se) {
 		for (Iterator iter = sessionEventListeners.iterator(); iter.hasNext();) {
 			SessionEventListener listener = (SessionEventListener) iter.next();
 			switch (se.getID()) {
 			case SessionEvent.INITIATE:
 				listener.sessionInitiated(se);
 				break;
 			case SessionEvent.START:
 				listener.sessionStarted(se);
 				break;
 			case SessionEvent.END:
 				listener.sessionStopped(se);
 				break;
 			}
 		}
 	}
 
 	public void addUser(User user) {
 		serviceProvider.sessionService.addUser(user);
 	}
 
 	public void initiate() {
 		if (sessionDataService == null)
 			throw new IllegalStateException(
 					"initiate() called before sessionDataService property set");
 		BeanContextServices bcs = getBeanContextServicesPeer();
 		serviceProvider.register(bcs);
 		fireSessionEvent(new SessionEvent(this, SessionEvent.INITIATE));
 		initiated = true;
 	}
 
 	public void start() {
 		if (!initiated)
 			throw new IllegalStateException("start() called before initiate()");
 		startTime = new Date();
 		fireSessionEvent(new SessionEvent(this, SessionEvent.START));
 		logger.info("Session started at " + startTime); //$NON-NLS-1$
 	}
 
 	public void tryToTerminate() {
 		logger.severe("trying to terminate -  : exception: " + null); //$NON-NLS-1$
 		stopTime = new Date();
 		fireSessionEvent(new SessionEvent(this, SessionEvent.END));
 		logger.info("Session ended at " + stopTime); //$NON-NLS-1$
 		dumpPersistance();
 		System.exit(0);
 	}
 
 	public Date getStartTime() {
 		return startTime;
 	}
 
 	public Date getStopTime() {
 		return stopTime;
 	}
 
 	public SessionUuid getSessionId() {
 		return sessionId;
 	}
 
 	public void setSessionId(SessionUuid sessionId) {
 		this.sessionId = sessionId;
 	}
 
 	public SessionDataService getSessionDataService() {
 		return sessionDataService;
 	}
 
 	public void setSessionDataService(SessionDataService sessionDataService) {
 		this.sessionDataService = sessionDataService;
 		serviceProvider.agentService = sessionDataService
 				.getPersistenceService(this);
 	}
 
 	/***
 	 * @return milliseconds since the session started
 	 */
 	public long getOffsetMilliseconds() {
 		return java.lang.System.currentTimeMillis() - startTime.getTime();
 	}
 
 	/***
 	 * 
 	 */
 	private void dumpPersistance() {
 		try {
 			File file = File.createTempFile("saildump", ".xml");
 			logger.info("dumping persistance data to " + file); //$NON-NLS-1$
 			PrintStream ps = new PrintStream(new FileOutputStream(file));
 			serviceProvider.agentService.dump(this, ps);
 			if (logger.isLoggable(Level.CONFIG)) {
 				logger.info("done."); //$NON-NLS-1$
 			}
 		} catch (Exception e) {
 			logger
 					.severe("FAILED to dump persistance data -  : exception: " + e); //$NON-NLS-1$
 			logger.severe("exception: " + e); //$NON-NLS-1$
 		}
 	}
 
 	@Override
 	public String toString() {
 		return ReflectionToStringBuilder.toString(this);
 	}
 }