/***
    * 
    */
   package org.telscenter.pas.steps;
   
   import java.awt.Component;
   import java.beans.beancontext.BeanContextServices;
   import java.io.File;
   import java.io.FileWriter;
  import java.io.UnsupportedEncodingException;
  import java.lang.reflect.Method;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.net.URLEncoder;
  import java.util.HashMap;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  import java.util.TooManyListenersException;
  import java.util.Map.Entry;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import javax.swing.JOptionPane;
  
  import net.sf.sail.core.beans.service.SessionService;
  
  import org.telscenter.pas.ui.browser.BrowserEvent;
  import org.telscenter.pas.ui.browser.IBrowser;
  import org.telscenter.pas.ui.browser.IBrowserListener;
  
  /***
   * Pas step type that adapts a legacy WISE-2 module, conformant to the <a
   * href="http://www.telscenter.org/confluence/display/WPS/Module+API">WISE v2
   * Module API</a> specification.
   * 
   * This is the API used by the <i>WISE Original Browser-based Learning
   * Environment</i> aka the <b>WOBBLE</b>.
   * 
   * @author turadg
   * 
   */
  
  // FIXME inheriting from BrowseWeb right now but should be refactored since
  // WobbleModule doesn't have a simple URL property
  public class WobbleModule extends BrowseWeb {
  
  	private static final long serialVersionUID = 1L;
  
  	/***
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger.getLogger(WobbleModule.class
  			.getName());
  
  	/***
  	 * We have to use a static variable for this because sail doesn't provide a
  	 * session service for our data as far as I know.
  	 */
  	protected static boolean isWiseSessionSetup = false;
  
  	SessionService sessionService;
  
  	String moduleOtherData = "";
  
  	int moduleOtherNumber = 0;
  
  	String wiseStepUrl;
  
  	/***
  	 * 
  	 */
  	public WobbleModule() {
  		setMockSettings();
  	}
  
  	// TODO should we make this part of abstract PasStep?
  	// TODO should we rename PasStep to AbstractPasStep?
  	public void setMockSettings() {
  		// set up parameters to match step 190176
  		/*
  		 * <title>Self Test 1</title>
  		 * <url>/modules/selftest/studentSelfTest.php</url> <assessmentURL />
  		 * <authoringURL>/modules/selftest/authorSelfTest.php</authoringURL>
  		 * <otherData /> <otherNumber>451</otherNumber> <dataToSend>full</dataToSend>
  		 * <iconURL>/student/images/icon1/test2.gif</iconURL> <frameName>main</frameName>
  		 * <moduleDataID>216673</moduleDataID> <iteration>1</iteration>
  		 * <duplicationURL>/modules/selftest/duplicateSelfTest.php</duplicationURL>
  		 * <assessmentExtURL /> <isHingeSelectionStep /> <isHintsStep />
  		 * <isEvSelectionStep /> <isAllWorkStep /> <isSubsidiary>0</isSubsidiary>
  		 * <bigAuthoringWindow>0</bigAuthoringWindow> <isComplete>1</isComplete>
  		 * <hingeID>0</hingeID> <isReflected>0</isReflected> <knownModuleID>24</knownModuleID>
  		 * 
  		 */
  		try {
  			// for "Self Test 1" step in 11752
  			// setTitle("Self Test 1");
  			// setModuleOtherNumber(451);
  			// String studentUrlStr =
 			// "http://wise.berkeley.edu/modules/selftest/studentSelfTest.php";
 
 			// for "Discussion 1" step in 11752
 			setTitle("Discussion 1");
 			setModuleOtherNumber(1006);
 			String studentUrlStr = "http://wise.berkeley.edu/modules/forum/studentDiscussion.php";
 
 			URL studentUrl = new URL(studentUrlStr);
 			setUrl(studentUrl);
 		} catch (MalformedURLException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see org.telscenter.pas.steps.BrowseWeb#getComponent()
 	 */
 	public Component getComponent() {
 		Component component = super.getComponent();
 		if (!isWiseSessionSetup) {
 			// look for the wise.sessionId in the sail session object
 			// pass that id to the wise server so the login cookie is
 			// setup correct in the browser
 			String sessionId = sessionService.getProperty("wise.sessionId",
 					null);
 			String wiseServer = sessionService.getProperty("wise.wiseServer",
 					null);
 			if (sessionId != null && wiseServer != null) {
 				String urlStr = "http://" + wiseServer
 						+ "/SAIL/setSessionCookie.php?WISESESSIONID="
 						+ sessionId;
 				logger.info("setupcookie url: " + urlStr);
 
 				try {
 					browser.addBrowserListener(new IBrowserListener() {
 						public void downloadCompleted(BrowserEvent event) {
 							// this can be dangerous, se we'll need to make sure
 							// our
 							// browser implementations handle this correctly
 							browser.removeBrowserListener(this);
 
 							// seems like this short circuits the setting of the
 							// cookie in the browser. Sleeping for a bit here
 							// until the browser updates seems like it works
 							// but this is pretty hacky
 							// 500 ms worked for some, but 1000 seems more safe
 							(new Thread() {
 								public void run() {
 									try {
 										Thread.sleep(1000);
 									} catch (InterruptedException e) {
 										// TODO Auto-generated catch block
 										e.printStackTrace();
 									}
 									isWiseSessionSetup = true;
 									setBrowserUrl();
 								}
 							}).start();
 						}
 
 						public void documentCompleted(BrowserEvent event) {
 						}
 
 						public void downloadProgress(BrowserEvent event) {
 						}
 					});
 
 					// The browser might never report that the download is
 					// complete
 					// in this case we need to simply set the browser url. and
 					// if it
 					// wasn't successful they will have to log in.
 					(new Thread() {
 						public void run() {
 							try {
 								Thread.sleep(1500);
 								if (!isWiseSessionSetup) {
 									isWiseSessionSetup = true;
 									setBrowserUrl();
 								}
 							} catch (InterruptedException e) {
 								e.printStackTrace();
 							}
 						}
 					}).start();
 
 					browser.setUrl(new URL(urlStr));
 
 					// We are all done for now the real url will be set
 					// after this one has loaded.
 					return component;
 				} catch (MalformedURLException e) {
 					logger.log(Level.INFO, "can't setup cookie in wise", e);
 				}
 			} else {
 				logger.info("no wise sessionId, user will have to login in");
 			}
 		}
 
 		setBrowserUrl();
 		return component;
 	}
 
 	protected void setBrowserUrl() {
 		// POST before returning
 		Map<String, String> studentModeParameters = getStudentModeParameters(
 				moduleOtherData, moduleOtherNumber);
 		String postData = encodeParameterMap(studentModeParameters);
 
 		String stepUrlStr = getWiseStepUrl();
 
 		// Check to see if this is a curnit that was created with an old
 		// converter. In that case getWiseStepUrl will return null.
 		// and instead getUrl will contain the url.
 		if (stepUrlStr == null) {
 			URL origUrl = getUrl();
 			String path = origUrl.getPath();
 			String query = origUrl.getQuery();
 			stepUrlStr = "";
 			if (path != null) {
 				stepUrlStr += path;
 			}
 			if (query != null) {
 				stepUrlStr += query;
 			}
 		}
 
 		String wiseServer = sessionService.getProperty("wise.wiseServer",
 				"wise.berkeley.edu");
 		URL browserUrl;
 		try {
 			URL wiseUrl = new URL("http://" + wiseServer);
 			browserUrl = new URL(wiseUrl, stepUrlStr);
 
 			// need to verify the jdic implementation on the mac returns safari
 			String browserType = browser.getBrowserType();
 			logger.info("browserType: " + browserType);
 			if (browserType == IBrowser.SAFARI) {
 				browserUrl = new URL(browserUrl.toExternalForm() + "?"
 						+ postData);
 				logger.info("legacy wise step url: " + browserUrl);
 				try {
 					openExternalBrowser(browserUrl);
 					// need to put some text in the browser lets put the wise
 					// site
 					File tmpFile = File.createTempFile("loading", ".html");
 					tmpFile.deleteOnExit();
 					FileWriter writer = new FileWriter(tmpFile);
 					writer
 							.append("A browser window should be opening with this step.");
 					writer.close();
 					browser.setUrl(tmpFile.toURL());
 				} catch (Exception exp) {
 					logger.log(Level.WARNING, "Can't open external browser.",
 							exp);
 					JOptionPane
 							.showMessageDialog(
 									null,
 									"Mac OSX currently requires and external "
 											+ "browser to display legacy WISE steps.  An external brower could not "
 											+ "be successfully opened.  Please check the logs for more info.  The "
 											+ "embedded jdic will be used but it is not stable.",
 									"No External Browser",
 									JOptionPane.WARNING_MESSAGE);
 					// it seems the postData is ignored on OSX right now
 					// which is why the external browser is needed.				
 					browser.setUrl(url, postData);
 				}
 
 			} else {
 				logger.info("legacy wise step url (not including post data): "
 						+ browserUrl);
 				browser.setUrl(browserUrl, postData);
 			}
 		} catch (MalformedURLException e) {
 			// FIXME should set the url to something for an error message
 			e.printStackTrace();
 		}
 	}
 
 	public void openExternalBrowser(URL url) throws Exception {
 		Class<?> serviceManager = Class.forName("javax.jnlp.ServiceManager");
 		Method lookupMethod = serviceManager.getMethod("lookup",
 				new Class[] { String.class });
 		Object basicService = lookupMethod.invoke(null,
 				new Object[] { "javax.jnlp.BasicService" });
 		Method showDocument = basicService.getClass().getMethod("showDocument",
 				new Class[] { URL.class });
 		showDocument.invoke(basicService, new Object[] { url });
 		return;
 	}
 
 	/***
 	 * @param studentModeParameters
 	 * @return
 	 */
 	private String encodeParameterMap(Map<String, String> studentModeParameters) {
 		StringBuffer sb = new StringBuffer();
 		Set<Entry<String, String>> entrySet = studentModeParameters.entrySet();
 		for (Entry<String, String> pair : entrySet) {
 			String name = pair.getKey();
 			String value = pair.getValue();
 			try {
 				sb.append(URLEncoder.encode(name, "UTF-8"));
 				sb.append("=");
 				sb.append(URLEncoder.encode(value, "UTF-8"));
 				sb.append("&");
 			} catch (UnsupportedEncodingException e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 		}
 		return sb.toString();
 	}
 
 	protected Map<String, String> getStudentModeParameters(String otherData,
 			int otherNumber) {
 		// comments from
 		// http://www.telscenter.org/confluence/display/WPS/Module+API
 		Map<String, String> p = new HashMap<String, String>();
 
 		// inWISE - always 1
 		p.put("inWISE", "1");
 
 		// mode - 1 for regular project mode, 0 for demo mode NOT YET
 		// IMPLEMENTED,
 		p.put("mode", "1");
 
 		// projectName - human name of the running project
 		addUrlParamFromSession(p, "projectName", "a project for testing");
 
 		// projectID - ID number of the running project
 		// FIXME this should be removed from the API as it's implied by groupID
 		addUrlParamFromSession(p, "projectID", "130670");
 
 		// groupID - ID number of the group of students calling the module
 		// default is Turadg in project 11752
 		addUrlParamFromSession(p, "groupID", "130670");
 
 		// wiseServer - the name of the WISE server that holds the currently
 		// running project NOTE: groupID does NOT constitute a unique index
 		// unless it is combined with wiseServer. For example, there could be
 		// group with ID number 702 on wise.berkeley.edu and a different group
 		// with ID 702 on wise.ils.uio.no. This is true also of projectID.
 		addUrlParamFromSession(p, "wiseServer", "wise.berkeley.edu");
 
 		// language - the two-letter language code of the currently running
 		// project
 		// TODO should this come from wise or from the java environment
 		addUrlParamFromSession(p, "language", Locale.getDefault().getLanguage());
 
 		// groupUsernames - a comma-separated list of the usernames of the
 		// students calling the module NOTE: usernames are also not
 		// necessarily unique unless combined with wiseServer
 		addUrlParamFromSession(p, "groupUsernames", "turadg");
 
 		// groupRealnames - a comma-separated list of the human names of the
 		// students calling the module
 		addUrlParamFromSession(p, "groupRealnames", "Turadg Aleahmad");
 
 		// isCurrent - 1 if the group has a current, up-to-date registration
 		// with WISE, 0 if their registration is not up-to-date (ie, from a
 		// previous term or year)
 		addUrlParamFromSession(p, "isCurrent", "1"); // I don't know anything
 														// that observes this
 
 		// teacher - human name of the current group's teacher
 		addUrlParamFromSession(p, "teacher", "FIXME teacher");
 
 		// period - period number of the current group
 		addUrlParamFromSession(p, "period", "1");
 
 		// otherData - module-defined field (see Authoring)
 		p.put("otherData", otherData);
 
 		// otherNumber - module-defined field (see Authoring)
 		p.put("otherNumber", otherNumber + "");
 
 		// hingeSelection - if the current project contains a hinge, the value
 		// of the current group's selection is passed here
 		addUrlParamFromSession(p, "hingeSelection", "FIXME hingeSelection");
 
 		// iteration - if the current step is a reflection step (set by "revisit
 		// a previous step" in the PM), then this field will contain the
 		// iteration number (see example under Other Notes)
 		addUrlParamFromSession(p, "iteration", "FIXME iteration");
 
 		// style - 1 for "Classic" interface style, 2 for "Expert"
 		p.put("style", "1"); // TODO stick with Classic for now
 
 		return p;
 	}
 
 	/***
 	 * This method uses the sessionService to lookup the key and if it isn't
 	 * there then it uses the default value.
 	 * 
 	 * @param p
 	 * @param key
 	 * @param defaultValue
 	 */
 	protected void addUrlParamFromSession(Map<String, String> p, String key,
 			String defaultValue) {
 		p.put(key, sessionService.getProperty("wise." + key, defaultValue));
 	}
 
 	/***
 	 * @return the apiOtherData
 	 */
 	public String getModuleOtherData() {
 		return moduleOtherData;
 	}
 
 	/***
 	 * @param apiOtherData
 	 *            the apiOtherData to set
 	 */
 	public void setModuleOtherData(String apiOtherData) {
 		this.moduleOtherData = apiOtherData;
 	}
 
 	/***
 	 * @return the apiOtherNumber
 	 */
 	public int getModuleOtherNumber() {
 		return moduleOtherNumber;
 	}
 
 	/***
 	 * @param apiOtherNumber
 	 *            the apiOtherNumber to set
 	 */
 	public void setModuleOtherNumber(int apiOtherNumber) {
 		this.moduleOtherNumber = apiOtherNumber;
 	}
 
 	protected void consumeService(BeanContextServices bcs, Class<?> serviceClass) {
 		super.consumeService(bcs, serviceClass);
 		if (serviceClass == SessionService.class) {
 			try {
 				sessionService = (SessionService) bcs.getService(this, this,
 						SessionService.class, this, this);
 			} catch (TooManyListenersException e1) {
 				logger
 						.severe("BeanContextServices, Class -  : exception: " + e1); //$NON-NLS-1$ 
 			}
 		}
 	}
 
 	public String getWiseStepUrl() {
 		return wiseStepUrl;
 	}
 
 	public void setWiseStepUrl(String wiseStepUrl) {
 		this.wiseStepUrl = wiseStepUrl;
 	}
 }