/*
    * Created on Apr 27, 2005, Copyright UC Regents
    */
   package org.telscenter.pas.pedagogica;
   
   import java.awt.BorderLayout;
   import java.awt.Component;
   import java.awt.Dimension;
   import java.awt.FlowLayout;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.beans.beancontext.BeanContextServices;
  import java.io.File;
  import java.io.IOException;
  import java.io.InputStream;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.TooManyListenersException;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.JButton;
  import javax.swing.JLabel;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  
  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.IAgent;
  import net.sf.sail.core.entity.ISock;
  import net.sf.sail.core.entity.MismatchedAgentSetSizeException;
  import net.sf.sail.core.entity.Rim;
  import net.sf.sail.core.entity.Role;
  import net.sf.sail.core.entity.UnsupportedRimShapeException;
  import net.sf.sail.core.util.BinaryUtils;
  
  import org.concord.pedagogica.engine.Activity;
  import org.concord.pedagogica.ui.ActivityFrame;
  import org.concord.pedagogica.ui.RunActivity;
  import org.telscenter.pas.steps.AbstractUrlStep;
  import org.telscenter.pas.steps.IntroductionHtmlAware;
  import org.xhtmlrenderer.extend.NamespaceHandler;
  import org.xhtmlrenderer.simple.FSScrollPane;
  import org.xhtmlrenderer.simple.XHTMLPanel;
  import org.xhtmlrenderer.simple.extend.XhtmlNamespaceHandler;
  
  /***
   * Implementation of the PAS step type, <i>Pedagogica</i>.
   * 
   * @author turadg
   */
  public class PedagogicaStep extends AbstractUrlStep implements
  		IntroductionHtmlAware, SessionEventListener
  {
  	/***
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger.getLogger(PedagogicaStep.class
  			.getName());
  	
  	private AgentService agentService;
  	private SessionService sessionService;
  
  	private Map rimMap;
  
  	private Map sockMap = new HashMap();
  
  	private RunActivity runActivity;
  
  	private String activityPath;
  
  	private Activity activity;
  	private ActivityFrame frame;
  
  	private Boolean authoring;
  
  	private static final long serialVersionUID = 1L;
  
  	private Content content;
  
  	private String codeBasePath;
  
  	private boolean initialized;
  	private int enterCount = 0;
  
  	private String introductionHtml;
  
  	public PedagogicaStep()
  	{
  	}
  
  	public Component getComponent()
  	{
  		if (!initialized)
 			beforeSessionStart();
 		return content;
 	}
 
 	public String getCodeBase()
 	{
 		return codeBasePath;
 	}
 
 	public void setCodeBase(String path)
 	{
 		Object old = this.codeBasePath;
 		this.codeBasePath = path;
 		firePropertyChange("codeBase", old, codeBasePath); //$NON-NLS-1$
 	}
 	
 	public String getType()
 	{
 		return "Interactive Model";
 	}
 
 	// this gets called before the project UI shows up so users don't
 	// have to wait for it when they click this step -turadg
 	public void beforeSessionStart()
 	{
 		initialize();
 	}
 
 	protected void initialize()
 	{
 		if (initialized)
 			return;
 		/*
 		 * if (codeBasePath == null) throw new InvalidPropertyException(this,
 		 * "codeBasePath"); //$NON-NLS-1$
 		 */
 		URL stepUrl = getUrl();
 		content = new Content();
 		String htmlText = getIntroductionHtml();
 		content.setHtmlText(htmlText);
 		if (stepUrl != null)
 		{
 			try
 			{
 				File tempFile = BinaryUtils.tempFileForUrl(getUrl());
 				activityPath = tempFile.toString();
 			}
 			catch (IOException e)
 			{
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 			if (logger.isLoggable(Level.CONFIG))
 			{
 				logger.config("activityPath = " + activityPath); //$NON-NLS-1$
 			}
 
 			runActivity = new RunActivity();
 
 			if (activityPath != null)
 			{
 				runActivity.setActivityPath(activityPath);
 			}
 			if (authoring != null)
 			{
 				runActivity.setAuthoringMode(authoring.booleanValue());
 			}
 			runActivity.setErrorSilent(true);
 			initialized = true;
 		}
 		else
 		{
 
 		}
 	}
 
 	public class Content extends JPanel implements ActionListener
 	{
 		protected JLabel noContentLabel = new JLabel("No Pedagogica Content Specified");
 		protected JPanel activityPanel = new JPanel();
 		protected XHTMLPanel htmlDisplay = new XHTMLPanel();
 		protected JScrollPane scroll = new FSScrollPane(htmlDisplay);
 		protected JPanel buttonPanel = new JPanel(new FlowLayout());
 		protected JButton showButton = new JButton("Launch");
 		protected ActionListener showListener = new ActionListener()
 		{
 			public void actionPerformed(ActionEvent event)
 			{
 				if (frame == null)
 				{
 					frame = (ActivityFrame) runActivity.getFrame();
 					if (frame != null)
 						frame.setExitOnClose(false);
 				}
 				if (frame != null)
 				{
 					frame.setVisibleEnabled(true);
 					frame.setVisible(true);
 				}
 			}
 		};
 		private NamespaceHandler nameSpaceHandler = new XhtmlNamespaceHandler();
 
 		public Content()
 		{
 			setPreferredSize(new Dimension(800, 600));
 			setLayout(new BorderLayout());
 			add(scroll, "Center");
 			add(buttonPanel, "South");
 			buttonPanel.add(showButton);
 			showButton.addActionListener(showListener);
 		}
 		
 		public void setHtmlText(String text)
 		{
 			htmlDisplay.setDocumentFromString(text, "http://wise.berkeley.edu", nameSpaceHandler );
 		}
 		
 		public JPanel getActivityPanel()
 		{
 			return activityPanel;
 		}
 
 		public void addNotify()
 		{
 			super.addNotify();
 		}
 
 		public void actionPerformed(ActionEvent event)
 		{
 		}
 	}
 
 	public String getIntroductionHtml()
 	{
 		return introductionHtml;
 	}
 
 	public void setIntroductionHtml(String introductionHtml)
 	{
 		Object old = this.introductionHtml;
 		this.introductionHtml = introductionHtml;
 		firePropertyChange("introductionHtml", old, this.introductionHtml); //$NON-NLS-1$
 	}
 
 	protected InputStream getURLStream(URL url)
 	{
 		try
 		{
 			return url.openStream();
 		}
 		catch (IOException e)
 		{
 			logger.severe("URL -  : exception: " + e); //$NON-NLS-1$
 		}
 		return null;
 	}
 
 	protected InputStream getURLStream(String urlString)
 	{
 		try
 		{
 			URL url = new URL(urlString);
 			return getURLStream(url);
 		}
 		catch (MalformedURLException e)
 		{
 			logger.severe("String -  : exception: " + e); //$NON-NLS-1$
 		}
 		return null;
 	}
 	
 	public Map getRimMap()
 	{
 		if (rimMap == null)
 			rimMap = new HashMap();
 		return rimMap;
 	}
 	
 	public void setRimMap(Map map)
 	{
 		rimMap = map;
 	}
 
 	public Rim getRim(String name)
 	{
 		return (Rim) getRimMap().get(name);
 	}
 
 	public void setRim(String name, Rim rim)
 	{
 		getRimMap().put(name, rim);
 	}
 	
 	protected void createSocks()
 	{
 		
 		Iterator entries = getRimMap().entrySet().iterator();
 		try {
 			IAgent agent = agentService.getAgentsInRole(Role.RUN_WORKGROUP).getSingle();
 			while (entries.hasNext())
 			{
 				Map.Entry entry = (Map.Entry) entries.next();
 				String key = (String) entry.getKey();
 				Rim rim = (Rim) rimMap.get(key);
 				ISock sock = agentService.getSock(rim, agent);
 				sockMap.put(key, sock);
 			}
 		} catch (MismatchedAgentSetSizeException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		} catch (UnsupportedRimShapeException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
 
 	public void restoreSockData()
 	{
 		Iterator rimNames = getRimMap().keySet().iterator();
 		createSocks();
 		while (rimNames.hasNext())
 		{
 			String rimName = (String) rimNames.next();
 			ISock sock = (ISock) sockMap.get(rimName);
 			if (sock == null)
 			{
 				logger.warning("No sock found for rim: " + rimName);
 			}
 			else
 			{
 				if (! sock.isEmpty())
 				{
 					byte [] data = null;
 					Object sockData = sock.peek();
 					if (sockData.getClass() == String.class)
 						data = ((String) sockData).getBytes();
 					else
 						data = (byte []) sockData;
 					runActivity.setSavedState(rimName, data);
 				}
 			}
 		}
 	}
 
 	public void saveSockData()
 	{
 		Iterator rimNames = getRimMap().keySet().iterator();
 		createSocks();
 		while (rimNames.hasNext())
 		{
 			String rimName = (String) rimNames.next();
 			Rim rim = (Rim) rimMap.get(rimName);
 			ISock sock = (ISock) sockMap.get(rimName);
 			if (sock == null)
 			{
 				logger.warning("No sock found for rim: " + rimName);
 			}
 			else
 			{
 				byte[] data = runActivity.getSavedState(rimName);
 				if (data != null)
 				{
 					Object sockData = data;
 					// Special case String because the original data
 					// will be a byte array.
 					if (rim.getShape() == String.class)
 						sockData = new String(data);
 					sock.add(sockData);
 				}
 			}
 		}
 	}
 
 	protected void consumeService(BeanContextServices bcs, Class serviceClass)
 	{
 		if (serviceClass == AgentService.class)
 		{
 			try
 			{
 				final AgentService p = (AgentService) bcs.getService(this,
 						this, AgentService.class, this, this);
 				agentService = p;
 			}
 			catch (TooManyListenersException e)
 			{
 				e.printStackTrace();
 			}
 		}
 		if (serviceClass == SessionService.class) {
 			try {
 				sessionService = (SessionService) bcs.getService(this, this,
 						SessionService.class, this, this);
 				sessionService.addSessionEventListener(this);
 			} catch (TooManyListenersException e1) {
 				// TODO Auto-generated catch block
 				logger.severe("BeanContextServices, Class -  : exception: " + e1); //$NON-NLS-1$
 			}
 		}
 	}
 	
 	public void stepEnter()
 	{
 		if (initialized && enterCount == 0)
 		{
 			restoreSockData();
 			runActivity.start(false);
 			activity = runActivity.getActivity();
 		}
 		enterCount++;
 	}
 	
 	public void stepExit()
 	{
 		// If frame == null then the model was never displayed
 		// so there should be nothing to save
 		if (frame != null && activity != null)
 		{
 			frame.setVisible(false);
 			activity.save();
 			saveSockData();
 		}
 	}
 
 	public void sessionInitiated(SessionEvent arg0) {
 		// TODO Auto-generated method stub
 		
 	}
 
 	public void sessionStarted(SessionEvent arg0) {
 		// TODO Auto-generated method stub
 		
 	}
 
 	public void sessionStopped(SessionEvent arg0) {
 		stepExit();
 	}
 }