/*
    * Created on Apr 25, 2005, Copyright UC Regents
    */
   package org.telscenter.pas.beans;
   
   import java.awt.event.WindowAdapter;
   import java.awt.event.WindowEvent;
   import java.awt.event.WindowListener;
   import java.beans.PropertyChangeListener;
  import java.beans.PropertyVetoException;
  import java.beans.beancontext.BeanContext;
  import java.beans.beancontext.BeanContextChildSupport;
  import java.beans.beancontext.BeanContextServices;
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.lang.reflect.Method;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.TooManyListenersException;
  import java.util.logging.Logger;
  
  import javax.swing.ProgressMonitor;
  import javax.swing.WindowConstants;
  
  import net.sf.sail.common.beansupport.ITitleAware;
  import net.sf.sail.common.beansupport.SailBeanContextChildSupport;
  import net.sf.sail.core.beans.Pod;
  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.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 org.jdom.DefaultJDOMFactory;
  import org.jdom.Document;
  import org.jdom.Element;
  import org.jdom.output.XMLOutputter;
  import org.telscenter.pas.navigation.PasProjectNavigationTaskPanel;
  import org.telscenter.pas.navigation.events.NavigationListener;
  import org.telscenter.pas.service.PasProjectServiceProvider;
  import org.telscenter.pas.steps.Assessment;
  import org.telscenter.pas.ui.beans.issueReporter.IssueReporter;
  import org.telscenter.pas.ui.frames.PasFrame;
  import org.telscenter.pas.ui.pdf.actions.GeneratePDFAction;
  
  /***
   * Bean representing the Pas project.
   * 
   * @author turadg
   */
  public class PasProject extends SailBeanContextChildSupport implements
  		IAuthorNotation, ITitleAware {
  	/***
  	 * 
  	 */
  	public static final String ACTIVITIES = "activities";
  
  	/***
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger.getLogger(PasProject.class
  			.getName());
  
  	private static final long serialVersionUID = 1L;
  
  	List<PasActivity> activitiesList = new ArrayList<PasActivity>();
  
  	String authorNotes = new String();
  
  	String title;
  
  	private transient PasProjectServiceProvider pasServiceProvider;
  
  	private transient PasProjectNavigationTaskPanel pasProjectNavigationPanel;
  
  	private PasFrame projectFrame;
  
  	private String sessionTopic;
  
  	private AgentService agentService;
  	private SessionService sessionService;
  	private AnnotationService annotationService;
  
  	private Rim<String> navigationLogRim;
  	private Rim<String> sessionStateRim;
  	private Rim<String> curnitMapRim;
  	private ISock<String> navigationLogSock;
  	private ISock<String> sessionStateSock;
  	private ISock<String> curnitMapSock;
  	private Map<String, BeanContextChildSupport> itemParentMap = new HashMap<String, BeanContextChildSupport>();
 	private DefaultJDOMFactory domFactory = new DefaultJDOMFactory();
 	private XMLOutputter outputter = new XMLOutputter();
 	private Document document; // document that contains curnitmap
 
 	private boolean showFirstStepOnLoad = true;
 
 	private transient boolean exitOnClose = true;
 
 	private boolean autoNumbering = true;
 	
 	private boolean authoringMode = false;
 
 	private HashMap projectProperties;
 	// Check that we are on Mac OS X. This is crucial to loading and using the
 	// OSXAdapter class.
 	public static boolean MAC_OS_X = (System.getProperty("os.name")
 			.toLowerCase().startsWith("mac os x"));
 
 	public PasProject() {
 		initUI();
 		initServices();
 		initListeners();
 		
 	}
 
 	protected void initUI() {
 		projectFrame = new PasFrame();
 		
 		// display a welcome message at start up for users,
 		// eventually this can be a bean property
 		// WelcomeGlassPane.registerFrame(projectFrame);
 	}
 
 	protected void initServices() {
 		pasServiceProvider = new PasProjectServiceProvider(this);
 		projectFrame.setPasServiceProvider(pasServiceProvider);
 		pasProjectNavigationPanel = new PasProjectNavigationTaskPanel(
 				pasServiceProvider);
 		projectFrame.setPasProjectNavigationPanel(pasProjectNavigationPanel);
 	}
 
 	protected void initListeners() {
 		// TODO should PasProject be adding the listeners for its subparts?
 		addPropertyChangeListener(ACTIVITIES, pasProjectNavigationPanel); //$NON-NLS-1$
 		addPropertyChangeListener("title", pasProjectNavigationPanel); //$NON-NLS-1$
 		pasServiceProvider.getNavigationService().addNavigationListener(
 				new NavigationListener(projectFrame, pasServiceProvider));
 		addPropertyChangeListener("title", projectFrame); //$NON-NLS-1$
 		registerWithMacOSX();
 		// Application app = new Application();
 		// app.setEnabledAboutMenu(false);
 		// app.setEnabledPreferencesMenu(false);
 		// app.addApplicationListener(new ApplicationAdapter() {
 		//		   
 		// @Override
 		// public void handleQuit(ApplicationEvent arg0) {
 		// ExitSessionAction exit = new ExitSessionAction(PasProject.this);
 		// exit.actionPerformed(null);
 		// super.handleQuit(arg0);
 		// }
 		//		    
 		//		
 		// });
 	}
 
 	public PasProjectNavigationTaskPanel getPanel() {
 		return this.pasProjectNavigationPanel;
 	}
 
 	// General info dialog. The OSXAdapter calls this method when "About
 	// OSXAdapter"
 	// is selected from the application menu.
 	public void about() {
 		IssueReporter.showAboutDialog(projectFrame);
 	}
 
 	// General info dialog. The OSXAdapter calls this method when "Quit
 	// OSXAdapter"
 	// is selected from the application menu, Cmd-Q is pressed, or "Quit" is
 	// selected from the Dock.
 	public void quit() {
 		ExitSessionAction exit = new ExitSessionAction(PasProject.this);
 		exit.actionPerformed(null);
 	}
 
 	// General preferences dialog. The OSXAdapter calls this method when
 	// "Preferences..."
 	// is selected from the application menu.
 	public void preferences() {
 
 	}
 
 	// Generic registration with the Mac OS X application menu. Checks the
 	// platform, then attempts
 	// to register with the Apple EAWT.
 	// This method calls OSXAdapter.registerMacOSXApplication() and
 	// OSXAdapter.enablePrefs().
 	// See OSXAdapter.java for the signatures of these methods.
 	public void registerWithMacOSX() {
 		if (MAC_OS_X) {
 			try {
 				Class<?> osxAdapter = getClass().getClassLoader().loadClass(
 						"org.telscenter.pas.util.OSXAdapter");
 
 				Class<?>[] defArgs = { PasProject.class };
 				Method registerMethod = osxAdapter.getDeclaredMethod(
 						"registerMacOSXApplication", defArgs);
 				if (registerMethod != null) {
 					Object[] args = { this };
 					registerMethod.invoke(osxAdapter, args);
 				}
 				// This is slightly gross. to reflectively access methods with
 				// boolean args,
 				// use "boolean.class", then pass a Boolean object in as the
 				// arg, which apparently
 				// gets converted for you by the reflection system.
 				defArgs[0] = boolean.class;
 				Method prefsEnableMethod = osxAdapter.getDeclaredMethod(
 						"enablePrefs", defArgs);
 				if (prefsEnableMethod != null) {
 					Object args[] = { Boolean.FALSE };
 					prefsEnableMethod.invoke(osxAdapter, args);
 				}
 			} catch (NoClassDefFoundError e) {
 				// This will be thrown first if the OSXAdapter is loaded on a
 				// system without the EAWT
 				// because OSXAdapter extends ApplicationAdapter in its def
 				logger
 						.warning("This version of Mac OS X does not support the Apple EAWT.  Application Menu handling has been disabled ("
 								+ e + ")");
 			} catch (ClassNotFoundException e) {
 				// This shouldn't be reached; if there's a problem with the
 				// OSXAdapter we should get the
 				// above NoClassDefFoundError first.
 				logger
 						.warning("This version of Mac OS X does not support the Apple EAWT.  Application Menu handling has been disabled ("
 								+ e + ")");
 			} catch (Exception e) {
 				logger.severe("Exception while loading the OSXAdapter:");
 				e.printStackTrace();
 			}
 		}
 	}
 
 	public String getAuthorNotes() {
 		return authorNotes;
 	}
 
 	public String getTitle() {
 		return title;
 	}
 
 	/***
 	 * If this is set to false then the frame will only be hidden not disposed.
 	 * 
 	 * @param exitOnClose
 	 */
 	public void setExitOnClose(boolean exitOnClose) {
 		this.exitOnClose = exitOnClose;
 	}
 
 	public boolean getExitOnClose() {
 		return this.exitOnClose;
 	}
 
 	@Override
 	protected void registerDesiredServices(BeanContextServices bcs) {
 		pasServiceProvider.register(bcs);
 	}
 
 	WindowListener windowListener = new WindowAdapter() {
 		@Override
 		public void windowClosing(WindowEvent e) {
 			ExitSessionAction exit = new ExitSessionAction(PasProject.this);
 			exit.actionPerformed(null);
 		}
 	};
 
 	SessionEventListener sessionListener = new SessionEventListener() {
 
 		public void sessionInitiated(SessionEvent e) {
 
 			initiatePasProject();
 			sessionTopic = sessionService.getSessionId().toString();
 			assert sessionTopic != null;
 			// FIXME Mantaray is having trouble over JWS
 			// notifyOfThisSession();
 			// initiateNavigationPublisher();
 		}
 
 		public void sessionStarted(SessionEvent e) {
 			// save to PDF and exit if indicated on passed-in parameter
 			// generateReportOnly is true
 			String generateReportOnlyStr = sessionService.getProperty(
 					"generateReportOnly", null);
 			// generate xml representation of prompts of all questions that are gradeable
 			String generateCurnitMapOnlyStr = sessionService.getProperty(
 					"generateCurnitMapOnly", null);
 			if (generateReportOnlyStr != null) {
 				boolean generateReportOnly = Boolean.valueOf(
 						generateReportOnlyStr).booleanValue();
 				if (generateReportOnly) {
 					
 					//if there is an annotation service that means there are annotations or
 					//annotation potiental
 					boolean withAnnotations = false;
 					if( getAnnotationService() != null ) {
 						withAnnotations = true;
 					}
 					GeneratePDFAction action = new GeneratePDFAction(null,getTitle(),PasProject.this);
 					String filePath = System.getProperty("user.home")
 							+ System.getProperty("file.separator")
 							+ action.generateFileName() + ".pdf";
 					boolean pdfCreated = action.doPDF(filePath);
 					if (!pdfCreated) {
 						System.err.println("PDF was not created");
 						System.err.println("filepath: " + filePath);
 						System.exit(1);
 					}
 					System.out.println("student work saved successfuly to: "
 							+ filePath);
 					System.exit(0);
 				}
 			} else if (generateCurnitMapOnlyStr != null) {
 				boolean generateCurnitMapOnly = Boolean.valueOf(
 						generateCurnitMapOnlyStr).booleanValue();
 				if (generateCurnitMapOnly) {
 					String filePath;
 					// TODO Come up with a better naming scheme
 					try {
 						filePath = File.createTempFile("curnitmap", "xml", new File(System.getProperty("user.home"))).toString();
 					} catch (IOException ex) {
 						filePath = System.getProperty("user.home")
 							+ System.getProperty("file.separator")
 							+ "curnitmap" + ".xml";
 					}
 					boolean isCurnitMapCreated = createCurnitMap(filePath);
 					if (!isCurnitMapCreated) {
 						System.err.println("CurnitMap was not created");
 						System.err.println("filepath: " + filePath);
 						System.exit(1);
 					}					
 					System.out.println("CurnitMap saved successfuly to: "
 							+ filePath);
 					System.exit(0);					
 				}
 			}
 
 			projectFrame.showFrame();
 			
 			// Only make the curnit map if we are inside of a Pod
 			if(isInPod()){
 				createCurnitMap();
 			}
 			ISock<String> sock = getNavigationLogSock();
 			if (sock != null) {
 				sock.add(getItemLog("project_open", PasProject.this));
 			}
 			if (showFirstStepOnLoad())
 				projectFrame.showFirstStep();
 
 		}
 
 		public void sessionStopped(SessionEvent e) {
 			ISock<String> sock = getNavigationLogSock();
 			if (sock != null) {
 				sock.add(getItemLog("project_close", PasProject.this));
 			}
 		}
 
 	};
 
 	/***
 	 * @see java.beans.beancontext.BeanContextChildSupport#setBeanContext(java.beans.beancontext.BeanContext)
 	 */
 	@Override
 	public synchronized void setBeanContext(BeanContext bc)
 			throws PropertyVetoException {
 		// TODO Auto-generated method stub
 		super.setBeanContext(bc);
 		
 		// If we aren't in a Pod then our children's bean context won't be set so we need
 		// to set it ourselves.
 		if(!isInPod()){
 			for (PasActivity activity : activitiesList) {
 				bc.add(activity);
 			}
 		}
 	}
 	
 	/***
 	 * This method can be called more than once in the authoring runtime, when
 	 * the preview is shown more than once.
 	 * 
 	 * @param bcs
 	 * @param serviceClass
 	 * @param project
 	 */
 	@Override
 	@SuppressWarnings("unchecked")
 	protected void consumeService(BeanContextServices bcs, Class serviceClass) {
 		if (serviceClass == SessionService.class) {
 			try {
 				sessionService = (SessionService) bcs.getService(this, this,
 						SessionService.class, this, this);
 
 				projectFrame
 						.setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);
 				projectFrame.removeWindowListener(windowListener);
 				projectFrame.addWindowListener(windowListener);
 
 				sessionService.addSessionEventListener(sessionListener);
 				projectFrame.setSessionService(sessionService);
 				pasProjectNavigationPanel.setUserNames(projectFrame
 						.getUserDisplayNames());
 				pasProjectNavigationPanel.setProjectName(this.getTitle());
 			} catch (TooManyListenersException e1) {
 				// TODO Auto-generated catch block
 				logger
 						.severe("BeanContextServices, Class -  : exception: " + e1); //$NON-NLS-1$
 			}
 		}
 		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 == AnnotationService.class) {
 			try {
 				final AnnotationService aService = (AnnotationService) bcs
 						.getService(this, this, AnnotationService.class, this,
 								this);
 				annotationService = aService;
 			} catch (TooManyListenersException e) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	
 	/***
 	 * Updates steps with any properties as nessecary.
 	 * 
 	 */
 	protected void updateProjectProperties() {
 		
 		if( this.projectProperties == null )
 			return;
 		
 		//cycle through all activities and steps
 		for (PasActivity ac : activitiesList) {
 			PasStep[] steps = ac.getSteps();
 			for (int i = 0; i < steps.length; i++) {
 				PasStep step = steps[i];
 				
 				if( step instanceof Assessment) {
 					//for injecting starter prompts
 					Boolean value = (Boolean) this.getProjectProperties().get("org.telscenter.assmtpromptinject");
 					if( value != null)
 						((Assessment)step).setInjectPrompt(value.booleanValue());
 				}// if
 				
 			}// for
 		}// for
 		
 		
 	}
 	
 	
 	protected void initiatePasProject() {
 		
 		if( this.projectProperties != null)
 			this.updateProjectProperties();
 		
 		if (PasProject.this.isDesignTime())
 			throw new RuntimeException(
 					"initiatePasProject() should not be called in design-time, right?"); //$NON-NLS-1$
 
 		
 		// gather all steps
 		List<PasStep> allSteps = new ArrayList<PasStep>();
 		for (PasActivity ac : activitiesList) {
 			PasStep[] steps = ac.getSteps();
 			for (int i = 0; i < steps.length; i++) {
 				PasStep step = steps[i];
 				allSteps.add(step);
 			}
 		}
 
 		// create monitor
 		ProgressMonitor initiationMonitor = new ProgressMonitor(
 				null,
 				Messages.getString("PasProject.PROGRESS_MONITOR_TITLE"), Messages.getString("PasProject.Initiating"), 0, allSteps.size()); //$NON-NLS-1$ //$NON-NLS-2$
 		initiationMonitor.setMillisToDecideToPopup(0);
 
 		// notify each step
 		for (int i = 0; i < allSteps.size(); i++) {
 			PasStep step = allSteps.get(i);
 			long start = System.currentTimeMillis();
 			try {
 				step.beforeSessionStart();
 			} catch (RuntimeException e) {
 				logger.severe("exception: " + e); //$NON-NLS-1$
 				logger
 						.severe(this
 								+ Messages
 										.getString("PasProject.this_failed_to_initialize") + " -  : exception: " + e); //$NON-NLS-1$ //$NON-NLS-2$ 
 			}
 			long stop = System.currentTimeMillis();
 			logger
 					.info(Messages.getString("PasProject.initializing") + step + Messages.getString("PasProject.took") + (stop - start) + Messages.getString("PasProject.milliseconds")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$			
 			initiationMonitor.setProgress(i + 1);
 		}
 
 	}
 
 	public PasActivity[] getActivities() {
 		PasActivity[] beans = new PasActivity[activitiesList.size()];
 		return activitiesList.toArray(beans);
 	}
 
 	public void remove(PasActivity act) {
 		activitiesList.remove(act);
 	}
 
 	/***
 	 * @param i
 	 * @return
 	 */
 	public PasActivity getActivities(int i) {
 		return activitiesList.get(i);
 	}
 
 	public void setActivities(int index, PasActivity bean) {
 		if (bean == null)
 			throw new IllegalArgumentException(Messages
 					.getString("PasProject.NO_NULL")); //$NON-NLS-1$
 		
 		PasActivity old = (activitiesList.size() <= index) ? null : activitiesList.get(index);
 
 		// expand array as necessary
 		while (index >= activitiesList.size())
 			activitiesList.add(null);
 		activitiesList.set(index, bean);
 
 		pcSupport.fireIndexedPropertyChange(
 				ACTIVITIES, index, old, getActivities()); //$NON-NLS-1$
 	}
 
 	public void setActivities(PasActivity[] beans) {
 		PasActivity[] oldBeans = getActivities();
 		activitiesList = new ArrayList<PasActivity>(beans.length);
 		for (int i = 0; i < beans.length; i++) {
 			activitiesList.add(beans[i]);
 		}
 		firePropertyChange(ACTIVITIES, oldBeans, beans); //$NON-NLS-1$
 	}
 
 	public void setAuthorNotes(String authorNotes) {
 		Object old = this.authorNotes;
 		this.authorNotes = authorNotes;
 		firePropertyChange("authorNotes", old, authorNotes); //$NON-NLS-1$
 	}
 
 	public void setTitle(String title) {
 		Object old = this.title;
 		this.title = title;
 		pasProjectNavigationPanel.setProjectName(title);
 		firePropertyChange("title", old, title); //$NON-NLS-1$
 	}
 
 	public PasFrame getProjectFrame() {
 		return projectFrame;
 	}
 
 	public void setProjectFrame(PasFrame pasFrame) {
 		this.projectFrame = pasFrame;
 	}
 
 	// added so the bean editor can detect which properties are bound
 	public void addPropertyChangeListener(PropertyChangeListener listener) {
 		pcSupport.addPropertyChangeListener(listener);
 	}
 
 	// added so the bean editor can detect which properties are bound
 	public void removePropertyChangeListener(PropertyChangeListener listener) {
 		pcSupport.removePropertyChangeListener(listener);
 	}
 
 	/***
 	 * @return the sessionService
 	 */
 	public SessionService getSessionService() {
 		return sessionService;
 	}
 
 	/***
 	 * @param sessionService
 	 *            the sessionService to set
 	 */
 	public void setSessionService(SessionService sessionService) {
 		this.sessionService = sessionService;
 	}
 
 	/***
 	 * @param navigationLogRim
 	 *            the navigationLogRim to set
 	 */
 	public void setNavigationLogRim(Rim<String> navigationLogRim) {
 		this.navigationLogRim = navigationLogRim;
 	}
 
 	/***
 	 * @return the navigationLogRim
 	 */
 	public Rim<String> getNavigationLogRim() {
 		return navigationLogRim;
 	}
 
 	/***
 	 * @param sessionStateRim
 	 *            the sessionStateRim to set
 	 */
 	public void setSessionStateRim(Rim<String> sessionStateRim) {
 		this.sessionStateRim = sessionStateRim;
 	}
 
 	/***
 	 * @return the sessionStateRim
 	 */
 	public Rim<String> getSessionStateRim() {
 		return sessionStateRim;
 	}
 
 	/***
 	 * @param curnitMapRim
 	 *            the curnitMapRim to set
 	 */
 	public void setCurnitMapRim(Rim<String> curnitMapRim) {
 		this.curnitMapRim = curnitMapRim;
 	}
 
 	/***
 	 * @return the curnitMapRim
 	 */
 	public Rim<String> getCurnitMapRim() {
 		return curnitMapRim;
 	}
 
 	protected ISock<String> getRimSock(Rim<String> rim) {
 		ISock<String> sock = null;
 		if (rim != null) {
 			try {
 				IAgent agent = agentService.getAgentsInRole(Role.RUN_WORKGROUP)
 						.getSingle();
 				sock = agentService.getSock(rim, agent);
 			} catch (MismatchedAgentSetSizeException e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			} catch (UnsupportedRimShapeException e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 		}
 		return sock;
 	}
 
 	/***
 	 * @return
 	 */
 	public ISock<String> getNavigationLogSock() {
 		if (navigationLogSock == null) {
 			navigationLogSock = getRimSock(navigationLogRim);
 		}
 		return navigationLogSock;
 	}
 
 	/***
 	 * @return
 	 */
 	public ISock<String> getSessionStateSock() {
 		if (sessionStateSock == null) {
 			sessionStateSock = getRimSock(sessionStateRim);
 		}
 		return sessionStateSock;
 	}
 
 	/***
 	 * @return
 	 */
 	public ISock<String> getCurnitMapSock() {
 		if (curnitMapSock == null) {
 			curnitMapSock = getRimSock(curnitMapRim);
 		}
 		return curnitMapSock;
 	}
 
 	public String getItemUUID(BeanContextChildSupport item) {
 		if (item != null) {
 			Object beanContext = item.getBeanContext();
 			if (beanContext instanceof Pod) {
 				Pod pod = (Pod) beanContext;
 				return pod.getPodId().toString();
 			}
 		}
 		return null;
 	}
 
 	/***
 	 * @param step
 	 * @return
 	 */
 	public String getItemLog(String name, BeanContextChildSupport item) {
 		Element itemLog = domFactory.element(name);
 		Document document = domFactory.document(itemLog);
 		String id = getItemUUID(item);
 		itemLog.setAttribute("podUUID", id == null ? "null" : id);
 		return outputter.outputString(document);
 	}
 	
 	protected void createStepMap(Element stepElement,
 			PasStep step) {
 		if (step instanceof IWorkReporter) {
 			Map<String, String> entityToPromptMap = ((IWorkReporter) step).getEntityToPromptMap();
 						
 			// add possibleScore...In the future, this should be set from the authoring tool
 			Integer possibleScore = ((IWorkReporter)step).getPossibleScore();
 			
 			if( possibleScore != null )
 				stepElement.setAttribute("possibleScore", possibleScore.toString());
 			if (possibleScore == null) {
 				possibleScore = 20;
 			}			
 			
 			((IWorkReporter)step).setPossibleScore(20);
 			
 			stepElement.setAttribute("possibleScore", possibleScore.toString());
 			
 			if( entityToPromptMap != null ) {
 				for (String entityName : entityToPromptMap.keySet()) {
 					String prompt = entityToPromptMap.get(entityName);
 					Element rimElement = domFactory.element("rim");
 					rimElement.setAttribute("rimname", entityName);
 					rimElement.setAttribute("prompt", prompt);
 					stepElement.addContent(rimElement);
 				}
 			}
 		} else {
 			// do nothing for now...non-gradable steps's rim names are not
 			// needed for grading
 		}
 	}
 
 	protected void createActivityMap(Element activityElement,
 			PasActivity activity) {
 		PasStep[] steps = activity.getSteps();
 		for (int i = 0; i < steps.length; i++) {
 			PasStep step = steps[i];
 			String id = getItemUUID(step);
 			itemParentMap.put(id, activity);
 			Element stepElement = domFactory.element("step");
 			stepElement.setAttribute("podUUID", id);
 			stepElement.setAttribute("title", step.getTitle());
 			stepElement.setAttribute("number", "" + i);
 			stepElement.setAttribute("type", step.getType());
 			stepElement.setAttribute("classname", step.getClass().getName());
 			activityElement.addContent(stepElement);
 			createStepMap(stepElement, step);
 		}
 	}
 
 	protected void createProjectMap(Element projectElement, PasProject project) {
 		PasActivity[] activities = getActivities();
 		for (int i = 0; i < activities.length; i++) {
 			PasActivity activity = activities[i];
 			String id = getItemUUID(activity);
 			itemParentMap.put(id, project);
 			Element activityElement = domFactory.element("activity");
 			activityElement.setAttribute("podUUID", id);
 			activityElement.setAttribute("title", activity.getTitle());
 			activityElement.setAttribute("number", "" + i);
 			projectElement.addContent(activityElement);
 			createActivityMap(activityElement, activity);
 		}
 	}
 
 	public void createCurnitMap() {
 		if (document != null) {
 			return;
 		}
 		String id = getItemUUID(this);
 		Element root = domFactory.element("pas_curnit_map");
 		document = domFactory.document(root);
 		Element projectElement = domFactory.element("project");
 		projectElement.setAttribute("podUUID", id);
 		projectElement.setAttribute("title", getTitle());
 		root.addContent(projectElement);
 		createProjectMap(projectElement, this);
 		ISock<String> sock = getCurnitMapSock();
 		if (sock != null) {
 			sock.add(outputter.outputString(document));
 		}
 	}
 	
 	/***
 	 * Overloaded createCurnitMap method that output the curnitmap to provided filepath
 	 * 
 	 * @param filepath path to output the curnitmap
 	 * @return true iff the curnitmap was successfully outputted
 	 */
 	public boolean createCurnitMap(String filepath) {
 		createCurnitMap();
 		try {
 			File file = new File(filepath);
 			FileOutputStream fos = new FileOutputStream(file);
 			outputter.output(document, fos);
 		} catch (IOException e) {
 			return false;
 		}
 		return true;
 	}
 
 	public BeanContextChildSupport getItemParent(BeanContextChildSupport item) {
 		return itemParentMap.get(getItemUUID(item));
 	}
 
 	/***
 	 * @return the showFirstStepOnLoad
 	 */
 	public boolean showFirstStepOnLoad() {
 		return showFirstStepOnLoad;
 	}
 
 	/***
 	 * @param showFirstStepOnLoad
 	 *            the showFirstStepOnLoad to set
 	 */
 	public void setShowFirstStepOnLoad(boolean showFirstStepOnLoad) {
 		this.showFirstStepOnLoad = showFirstStepOnLoad;
 	}
 
 	/***
 	 * @return the autoNumbering
 	 */
 	public boolean isAutoNumbering() {
 		return autoNumbering;
 	}
 
 	/***
 	 * @param autoNumbering
 	 *            the autoNumbering to set
 	 */
 	public void setAutoNumbering(boolean autoNumbering) {
 		Object old = this.autoNumbering;
 		this.autoNumbering = autoNumbering;
 		firePropertyChange("autoNumbering", old, autoNumbering); //$NON-NLS-1$
 	}
 
 	/***
 	 * @return the annotationService
 	 */
 	public AnnotationService getAnnotationService() {
 		return annotationService;
 	}
 
 	/***
 	 * @param annotationService
 	 *            the annotationService to set
 	 */
 	public void setAnnotationService(AnnotationService annotationService) {
 		this.annotationService = annotationService;
 	}
 
 	public HashMap getProjectProperties() {
 		return projectProperties;
 	}
 
 	public void setProjectProperties(HashMap projectProperties) {
 		this.projectProperties = projectProperties;
 	}
 
 	/***
 	 * @param authoringMode the authoringMode to set
 	 */
 	public void setAuthoringMode(boolean authoringMode) {
 		this.authoringMode = authoringMode;
 	}
 
 	/***
 	 * @return the authoringMode
 	 */
 	public boolean isAuthoringMode() {
 		return authoringMode;
 	}
 }