/*
    * 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.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 java.util.logging.Level;
  import java.util.logging.Logger;
  
  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.AnnotationService;
  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;
  
  /**
   * Provides services to beans within the pod. Allows beans and pods to listen for session events. a life cycle manager for sail. The parent
   * bean for all javabeans.
   * 
   * @author turadg
   * AUDIT07-
   */
  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;
  		AnnotationService annotationService = null;
  		
  		void register(BeanContextServices bcs) {
  			bcs.addService(SessionService.class, serviceProvider);
  			bcs.addService(AgentService.class, serviceProvider);
  			bcs.addService(AnnotationService.class, serviceProvider);
  		}
  
  		/**
  		 * This will be called if a pod is added to more than one SessionContext.
  		 * The pod can only associated with a single session context at time.
  		 */
  		public void releaseService(BeanContextServices bcs, Object requestor,
  				Object service) {
  			// because we are not keeping track of the requestor and the services
  			// are not tracking the requestor either we don't need to do anything
  			// here. 
  			return;
  		}
  
  		@SuppressWarnings("unchecked")
  		public Iterator getCurrentServiceSelectors(BeanContextServices bcs,
  				Class serviceClass) {
  			throw new UnsupportedOperationException();
 		}
 
 		@SuppressWarnings("unchecked")
 		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 if (serviceClass == AnnotationService.class) {
 				return annotationService;
 			} else {
 				return null;
 			}
 		}
 	}
 
 	private final ServiceProvider serviceProvider = new ServiceProvider();
 
 	SessionUuid sessionId;
 
 	SessionDataService sessionDataService;
 
 	Offering offering;
 
 	protected Date startTime;
 
 	protected Date stopTime;
 	
 	// FIXME TODO get rid of this hack
 	public static boolean exitOnClose = true;
 
 	public Offering getOffering() {
 		return offering;
 	}
 
 	public void setOffering(Offering offering) {
 		this.offering = offering;
 	}
 
 	List<SessionEventListener> sessionEventListeners = new ArrayList<SessionEventListener>();
 
 	private boolean initiated;
 
 	private boolean terminationInProgress = false;
 
 	// timeDrift is the approximate difference in the SDS's clock and the local clock
 	private long timeDrift;
 
 	public void addSessionEventListener(SessionEventListener sel) {
 		sessionEventListeners.add(sel);
 	}
 
 	protected void fireSessionEvent(SessionEvent se) {
 		for (Object element : sessionEventListeners) {
 			SessionEventListener listener = (SessionEventListener) element;
 			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()");
 		if (startTime == null) {
 			initStartTime();
 		}
 		fireSessionEvent(new SessionEvent(this, SessionEvent.START));
 		logger.info("Session started at " + startTime); //$NON-NLS-1$
 	}
 
 	public void tryToTerminate() {
 		logger.info("trying to terminate"); //$NON-NLS-1$
 		if (terminationInProgress) {
 			logger.severe("already trying to terminate. ignoring.");
 			return;
 		}
 		terminationInProgress = true;
 		stopTime = new Date();
 		fireSessionEvent(new SessionEvent(this, SessionEvent.END));
 		logger.info("Session ended at " + stopTime); //$NON-NLS-1$
 		// dumpPersistance() should be called in a new thread for the progress bar to work correctly
 		Thread t = new Thread() {
 			public void run() {
 				dumpPersistance();
 				if (exitOnClose) System.exit(0);
 				terminationInProgress = false;
 			}
 		};
 		t.start();
 	}
 
 	public Date getStartTime() {
 		return startTime;
 	}
 	
 	public void initStartTime() {
 		if (startTime == null) {
 			String strTime = ((DefaultSessionService)(serviceProvider.sessionService)).getProperty("sds_time", "0");
 			long sdsTime = Long.parseLong(strTime); 
 			if (sdsTime == 0) {
 				startTime = new Date();
 				timeDrift = 0;
 			} else {
 				startTime = new Date(sdsTime);
 				timeDrift = java.lang.System.currentTimeMillis() - startTime.getTime();
 			}
 		}
 	}
 	
 	public long getTimeDifference() {
 		return timeDrift;
 	}
 
 	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);
 		serviceProvider.annotationService = 
 			sessionDataService.getAnnotationService();
 	}
 
 	/**
 	 * This is a hack until all this service mess is cleaned up
 	 * @param key
 	 * @param value
 	 */
 	public void setProperty(String key, String value)
 	{
 		((DefaultSessionService)(serviceProvider.sessionService)).setProperty(key, value);
 	}
 	
 	/**
 	 * Again this is a something that seems hacky.  Hopefully it can be clarified when
 	 * the service mess is cleaned up or clarified.
 	 * 
 	 */
 	public SessionService getSessionService()
 	{
 		return serviceProvider.sessionService;
 	}
 	
 	/**
 	 * @return milliseconds since the session started
 	 */
 	public long getOffsetMilliseconds() {
 		return java.lang.System.currentTimeMillis() - startTime.getTime() - timeDrift;
 	}
 
 	/**
 	 * 
 	 */
 	protected 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.log(Level.SEVERE, "FAILED to dump persistance data", e); //$NON-NLS-1$
 		}
 	}
 
 	@Override
 	public String toString() {
 		return ReflectionToStringBuilder.toString(this);
 	}
 }