package org.telscenter.pas.util;
   
   import java.io.File;
   import java.io.FileOutputStream;
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.List;
   import java.util.Map;
   import java.util.Set;
  import java.util.Map.Entry;
  import java.util.logging.Logger;
  
  import net.sf.sail.core.beans.Pod;
  import net.sf.sail.core.beans.assembly.Assignment;
  import net.sf.sail.core.beans.assembly.IndexedPropertyRef;
  import net.sf.sail.core.beans.assembly.PodRegistry;
  import net.sf.sail.core.beans.assembly.PodVarDelegate;
  import net.sf.sail.core.beans.assembly.PropertyRef;
  import net.sf.sail.core.beans.assembly.SimpleContainer;
  import net.sf.sail.core.util.BinaryUtils;
  import net.sf.sail.core.util.PodUtils;
  import net.sf.sail.core.util.SailBeanUtils;
  import net.sf.sail.core.uuid.CurnitUuid;
  
  import org.apache.commons.lang.math.RandomUtils;
  import org.telscenter.pas.beans.PasActivity;
  import org.telscenter.pas.beans.PasProject;
  import org.telscenter.pas.beans.PasStep;
  
  public class PasCurnitUtils {
  
  	/***
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger.getLogger(PasCurnitUtils.class
  			.getName());
  
  	/***
  	 * @param activityPod
  	 * @return
  	 */
  	public static PasActivity activityFromPod(Pod activityPod) {
  		PasActivity activity = SailBeanUtils.firstChildOfType(activityPod,
  				PasActivity.class);
  		assert activity != null;
  		return activity;
  	}
  
  	/***
  	 * Adds the activity bean into the project bean at the specified index.
  	 * 
  	 * If the two beans are in the same pod, they will remain in the same pod.
  	 * 
  	 * If they are in separate pods, a hierarchical relationship will be made
  	 * between them and inter-pod links to reference the beans across the pod
  	 * boundaries.
  	 * 
  	 * Assumes that projectPod has one PasProject bean and activityPod has one
  	 * PasActivity bean. Also that each bean has an enclosing pod.
  	 */
  	public static void addActivity(PasProject project, int activityIndex,
  			PasActivity activity) {
  		Pod projectPod = PodUtils.resolvePod(project);
  		Pod activityPod = PodUtils.resolvePod(activity);
  		if (projectPod == activityPod)
  			addActivitySharePod(project, activityIndex, activity);
  		else
  			addActivityOwnPod(projectPod, project, activityIndex, activityPod,
  					activity);
  	}
  
  	/***
  	 * To the project pod and its project bean, adds the activity pod and its
  	 * activity bean at the specified index.
  	 * 
  	 * Assumes that projectPod has one PasProject bean and activityPod has one
  	 * PasActivity bean.
  	 */
  	@Deprecated
  	public static void addActivity(Pod projectPod, int index, Pod activityPod) {
  		PasProject project = projectFromPod(projectPod);
  		PasActivity activity = activityFromPod(activityPod);
  		addActivityOwnPod(projectPod, project, index, activityPod, activity);
  	}
  
  	/***
  	 * Makes activityPod a child of projectPod and adds an assembly assignment
  	 * of the activity bean into the specified index of the project bean's
  	 * activities property
  	 * 
  	 * @param projectPod
  	 * @param project
  	 * @param activityIndex
  	 * @param activityPod
  	 * @param activity
  	 */
  	static void addActivityOwnPod(Pod projectPod, PasProject project,
  			int activityIndex, Pod activityPod, PasActivity activity) {
  
 		insertActivityInProjectBean(project, activityIndex, activity);
 
 		// set up pod relationship
 		projectPod.add(activityPod);
 		projectPod.touch(); // mark as having been modified
 		activityPod.add(activity);
 		activityPod.touch(); // mark as having been modified
 
 		// give the varname a random component so it doesn't conflict with a
 		// future import
 		String leftName = "importActivity-" + RandomUtils.nextInt();
 		PropertyRef pr = new IndexedPropertyRef(project, "activities",
 				activityIndex);
 		projectPod.importProperty(pr, leftName);
 		PodVarDelegate podIn = new PodVarDelegate(projectPod.getPodId(),
 				leftName);
 		String rightName = "activity";
 		PodVarDelegate podOut = new PodVarDelegate(activityPod.getPodId(),
 				rightName);
 		SimpleContainer sc = new SimpleContainer();
 		sc.setValue(activity);
 		activityPod.add(sc);
 		activityPod.exportProperty(sc.getPropertyRef(), rightName);
 		Assignment assignment = new Assignment(podIn, podOut);
 		projectPod.getAssemblyCalls().add(assignment);
 	}
 
 	/***
 	 * 
 	 */
 	static void addActivitySharePod(PasProject project, int activityIndex,
 			PasActivity activity) {
 		Pod projectPod = PodUtils.resolvePod(project);
 		Pod activityPod = PodUtils.resolvePod(activity);
 		if (projectPod != activityPod)
 			throw new IllegalArgumentException(
 					"project and activity arguments must belong to same pod");
 
 		insertActivityInProjectBean(project, activityIndex, activity);
 		projectPod.touch();
 	}
 
 	/***
 	 * Adds the step bean into the activity bean at the specified index.
 	 * 
 	 * If the two beans are in the same pod, they will remain in the same pod.
 	 * 
 	 * If they are in separate pods, a hierarchical relationship will be made
 	 * between them and inter-pod links to reference the beans across the pod
 	 * boundaries.
 	 * 
 	 * Assumes that activityPod has one PasActivity bean and stepPod has one
 	 * PasStep bean. Also that each bean has an enclosing pod.
 	 */
 	public static void addStep(PasActivity activity, int stepIndex, PasStep step) {
 		Pod activityPod = PodUtils.resolvePod(activity);
 		Pod stepPod = PodUtils.resolvePod(step);
 		if (activityPod == stepPod)
 			addStepSharePod(activity, stepIndex, step);
 		else
 			addStepOwnPod(activityPod, activity, stepIndex, stepPod, step);
 	}
 	
 	/***
 	 * To the activity pod and its activity bean, adds the step pod and its step
 	 * bean at the specified index.
 	 * 
 	 * Assumes that activityPod has one PasActivity bean and stepPod has one
 	 * PasStep bean.
 	 */
 	@Deprecated
 	public static void addStep(Pod activityPod, int stepIndex, Pod stepPod) {
 		PasActivity activity = activityFromPod(activityPod);
 		PasStep step = stepFromPod(stepPod);
 		addStepOwnPod(activityPod, activity, stepIndex, stepPod, step);
 	}
 
 	/***
 	 * Adds the step bean in the list of the activity bean's steps at the index;
 	 * makes step pod a child of activity pod and adds an assembly assignment of
 	 * the step bean into the specified index of the activity bean's steps
 	 * property.
 	 * 
 	 * @param activityPod
 	 * @param activity
 	 * @param stepIndex
 	 * @param stepPod
 	 * @param step
 	 */
 	static void addStepOwnPod(Pod activityPod, PasActivity activity,
 			int stepIndex, Pod stepPod, PasStep step) {
 		insertStepInActivityBean(activity, stepIndex, step);
 
 		// set up pod relationship
 		activityPod.add(stepPod);
 		activityPod.touch(); // mark as having been modified
 		stepPod.add(step);
 		stepPod.touch(); // mark as having been modified
 
 		// set up import of value between pods
 		String leftName = "importStep-" + RandomUtils.nextInt();
 		PropertyRef pr = new IndexedPropertyRef(activity, "steps", stepIndex);
 		activityPod.importProperty(pr, leftName);
 		PodVarDelegate podIn = new PodVarDelegate(activityPod.getPodId(),
 				leftName);
 		String rightName = "step";
 		PodVarDelegate podOut = new PodVarDelegate(stepPod.getPodId(),
 				rightName);
 		SimpleContainer sc = new SimpleContainer();
 		sc.setValue(step);
 		stepPod.add(sc);
 		stepPod.exportProperty(sc.getPropertyRef(), rightName);
 		Assignment assignment = new Assignment(podIn, podOut);
 		activityPod.getAssemblyCalls().add(assignment);
 	}
 
 	/***
 	 * 
 	 */
 	static void addStepSharePod(PasActivity activity, int stepIndex,
 			PasStep step) {
 		Pod activityPod = PodUtils.resolvePod(activity);
 		Pod stepPod = PodUtils.resolvePod(step);
 		if (activityPod != stepPod)
 			throw new IllegalArgumentException(
 					"activity and step arguments must belong to same pod");
 
 		insertStepInActivityBean(activity, stepIndex, step);
 		activityPod.touch();
 	}
 
 	public static PasProject findPasProject(Pod pod) {
 		for (Object element : pod) {
 			if (element instanceof PasProject)
 				return (PasProject) element;
 		}// if
 		return null;
 	}// findPasProject
 
 	/***
 	 * @param project
 	 * @param activityIndex
 	 * @param activity
 	 */
 	public static void insertActivityInProjectBean(PasProject project,
 			int activityIndex, PasActivity activity) {
 		// update activity list of project bean
 		final PasActivity[] oldActivities = project.getActivities();
 		final PasActivity[] newActivities = new PasActivity[oldActivities.length + 1];
 		System.arraycopy(oldActivities, 0, newActivities, 0, activityIndex);
 		newActivities[activityIndex] = activity;
 		System.arraycopy(oldActivities, activityIndex, newActivities,
 				activityIndex + 1, oldActivities.length - activityIndex);
 
 		// must set the property for the project to know
 		project.setActivities(newActivities);
 	}
 
 	/***
 	 * @param activity
 	 * @param stepIndex
 	 * @param step
 	 */
 	public static void insertStepInActivityBean(PasActivity activity,
 			int stepIndex, PasStep step) {
 		// update steps list of activity bean
 		final PasStep[] oldSteps = activity.getSteps();
 		final PasStep[] newSteps = new PasStep[oldSteps.length + 1];
 		System.arraycopy(oldSteps, 0, newSteps, 0, stepIndex);
 		newSteps[stepIndex] = step;
 		System.arraycopy(oldSteps, stepIndex, newSteps, stepIndex + 1,
 				oldSteps.length - stepIndex);
 
 		// must set the property for the activity to know
 		activity.setSteps(newSteps);
 	}
 
 	/***
 	 * move step to a different activity
 	 * 
 	 * 
 	 * @param activityDes
 	 * @param activitySource
 	 * @param movedStep
 	 * @param newIndex
 	 */
 	public static void moveTo(PasActivity activityDes,
 			PasActivity activitySource, PasStep movedStep, int newIndex) {
 		// TODO operate more efficiently/simply when step is in same pod as
 		// activities
 
 		List<PasStep> newDesStepList = new ArrayList<PasStep>(Arrays
 				.asList(activityDes.getSteps()));
 		List<PasStep> newSourceStepList = new ArrayList<PasStep>(Arrays
 				.asList(activitySource.getSteps()));
 		if (!newSourceStepList.contains(movedStep)) {
 			throw new RuntimeException("step not in activity on reorder");
 		}// if
 
 		// first remove it from the source
 		newSourceStepList.remove(movedStep);
 
 		// removeStep(activitySource, movedStep);
 		// insert and shifts to right to the des list
 		newDesStepList.add(newIndex, movedStep);
 
 		for (PasStep step : newSourceStepList) {
 			addStep(activitySource, newSourceStepList.indexOf(step), step);
 		}// for
 
 		for (PasStep step : newDesStepList) {
 			addStep(activityDes, newDesStepList.indexOf(step), step);
 		}// for
 
 		removeStep(activitySource, movedStep);
 	}
 
 	/***
 	 * moves a step to a new position in the same activity
 	 * 
 	 * @param activity
 	 * @param movedStep
 	 * @param newIndex
 	 */
 	public static void moveTo(PasActivity activity, PasStep movedStep,
 			int newIndex) {
 		// TODO operate more efficiently/simply when step is in same pod as
 		// activity
 
 		List<PasStep> newStepList = new ArrayList<PasStep>(Arrays
 				.asList(activity.getSteps())); //
 		if (!newStepList.contains(movedStep)) {
 			throw new RuntimeException("step not in activity on reorder");
 		}// if
 
 		// first remove it
 		newStepList.remove(movedStep);
 
 		// insert and shifts to right
 		newStepList.add(newIndex, movedStep);
 
 		//first remove it
 		removeStepFromActivityBean(activity, movedStep);
 		
 		//insert it again
 		insertStepInActivityBean(activity, newIndex, movedStep);
 //		activity.setSteps(beans)
 //		for (PasStep step : newStepList) {
 //			addStep(activity, newStepList.indexOf(step), step);
 //		}
 
 	}
 
 	/***
 	 * reorder the activities
 	 * 
 	 * @param pasProject -
 	 *            the pasProject
 	 * @param movedActivity -
 	 *            the activity to move somewhere
 	 * @param newIndex -
 	 *            its new position
 	 */
 	public static void moveTo(PasProject pasProject, PasActivity movedActivity,
 			int newIndex) {
 		// TODO operate more efficiently/simply when activity is in same pod as
 		// project
 
 		// does this activity exist in the project?
 		PasActivity[] activities = pasProject.getActivities();
 		List<PasActivity> newActivityList = new ArrayList<PasActivity>(Arrays
 				.asList(activities));
 		if (!newActivityList.contains(movedActivity)) {
 			throw new RuntimeException("Activity not in project on reorder");
 		}// if
 
 		// remove the old one
 		newActivityList.remove(movedActivity);
 		// add new one
 		newActivityList.add(newIndex, movedActivity);
 
 //		for (PasActivity pasActivity : newActivityList) {
 //			addActivity(pasProject, newActivityList.indexOf(pasActivity),
 //					pasActivity);
 //		}
 		
 		//move the new activity list to the activities array
 		newActivityList.toArray(activities);
 		
 		//set the activities in the project to the updated activities
 		pasProject.setActivities(activities);
 	}
 
 	/***
 	 * @param projectPod
 	 * @return
 	 */
 	public static PasProject projectFromPod(Pod projectPod) {
 		PasProject project = SailBeanUtils.firstChildOfType(projectPod,
 				PasProject.class);
 		assert project != null;
 		return project;
 	}
 
 	/***
 	 * Removes the step bean and its enclosing pod from the project bean and its
 	 * enclosing pod.
 	 * 
 	 * @param project
 	 * @param activity
 	 */
 	public static void removeActivity(PasProject project, PasActivity activity) {
 		Pod projectPod = PodUtils.resolvePod(project);
 		Pod activityPod = PodUtils.resolvePod(activity);
 		if (projectPod == activityPod)
 			removeActivitySharePod(project, activity);
 		else
 			removeActivityOwnPod(project, activity);
 	}
 
 	/***
 	 * @param project
 	 * @param activity
 	 * @return index of activity that was removed
 	 */
 	public static int removeActivityFromProjectBean(PasProject project,
 			PasActivity activity) {
 		int index;
 		PasActivity[] oldActivities = project.getActivities();
 
 		for (index = 0; index < oldActivities.length; index++) {
 			if (activity == oldActivities[index])
 				break; // found
 		}
 
 		// in case we passed through the end of the list
 		if (index == oldActivities.length)
 			throw new RuntimeException(
 					"activity not in project's activity list");
 
 		// create new activity array from the old minus the removed activity
 		PasActivity[] newActivities = new PasActivity[oldActivities.length - 1];
 		System.arraycopy(oldActivities, 0, newActivities, 0, index);
 		// skip the index which has the removed activity
 		System.arraycopy(oldActivities, index + 1, newActivities, index,
 				newActivities.length - index);
 
 		// set new shorter activity list
 		project.setActivities(newActivities);
 		return index;
 	}
 
 	/***
 	 * Removes the activity bean and its enclosing pod from the project bean and
 	 * its enclosing pod.
 	 * 
 	 * @param project
 	 * @param activity
 	 */
 	static void removeActivityOwnPod(PasProject project, PasActivity activity) {
 		int index = removeActivityFromProjectBean(project, activity);
 
 		// find the pods of the beans
 		Pod projectPod = PodUtils.resolvePod(project);
 		Pod activityPod = PodUtils.resolvePod(activity);
 
 		// mark the project pod as having been modified and do it before the
 		// following code pulls up its pod id
 		projectPod.touch();
 
 		// remove the activity pod from the project pod
 		projectPod.remove(activityPod);
 
 		// remove from the imports and note which ref was the import
 		PropertyRef acRef = null;
 		Set<PropertyRef> transientRefs = projectPod.getTransientRefs();
 		for (PropertyRef importRef : transientRefs) {
 			if (activity == importRef.getTarget()) {
 				acRef = importRef;
 				transientRefs.remove(acRef);
 				break;
 			}
 		}
 
 		// now remove from the project pod the assembly calls importing the
 		// activity from its pod (using the acRef)
 		// FIXME can't assume the default registry
 		PodRegistry registry = PodRegistry.getDefaultRegistry();
 		List<Assignment> assemblyCalls = projectPod.getAssemblyCalls();
 		for (Assignment assignment : assemblyCalls) {
 			if (acRef == assignment.getLeft().getRef(registry)) {
 				assemblyCalls.remove(assignment);
 				break;
 			}
 		}
 
 		// must reassign rest of imports to target the correct index in the new
 		// activities array
 		Map<String, PropertyRef> vars = projectPod.getVars();
 		Set<Entry<String, PropertyRef>> entrySet = vars.entrySet();
 
 		// iterate over copy to avoid ConcurrentModificationException
 		List<Entry<String, PropertyRef>> entries = new ArrayList<Entry<String, PropertyRef>>(
 				entrySet);
 		for (Map.Entry<String, PropertyRef> e : entries) {
 
 			String bindingKey = e.getKey();
 			PropertyRef entryValue = e.getValue();
 
 			// System.out.println("VAR ENTRY " + bindingKey + " = " +
 			// entryValue);
 
 			if (entryValue instanceof IndexedPropertyRef) {
 				IndexedPropertyRef ipRef = (IndexedPropertyRef) entryValue;
 				// System.out.println("Binding name:" + bindingKey);
 				// System.out.println("property name:" +
 				// ipRef.getPropertyName());
 				// System.out.println("index name:" + ipRef.getIndex());
 				// System.out.println("TARGET: " + ipRef.getTarget());
 				if (ipRef.getPropertyName().equals("activities")) {
 					// ... it's an IndexedPropertyRef referrencing an index of
 					// an "activities" property
 
 					if (ipRef.getTarget() != project)
 						throw new IllegalStateException(
 								"\"activities\" property not on project bean");
 
 					int refIndex = ipRef.getIndex();
 
 					if (refIndex == index) {
 						// then that's the import we need to remove
 						activityPod.getVars().remove(bindingKey);
 					} else if (refIndex >= index) {
 						// then we need to shift it down one
 						PropertyRef newRef = new IndexedPropertyRef(project,
 								"activities", refIndex - 1);
 
 						// remove the current one
 						projectPod.getVars().remove(bindingKey);
 
 						// now rebind
 						projectPod.importProperty(newRef, bindingKey);
 						logger.info("rebound " + ipRef + " with " + newRef);
 					}
 				}
 			}
 		}
 
 	}
 
 	/***
 	 * Removes the activity bean and its enclosing pod from the project bean and
 	 * its enclosing pod.
 	 * 
 	 * @param project
 	 * @param activity
 	 */
 	static void removeActivitySharePod(PasProject project, PasActivity activity) {
 		removeActivityFromProjectBean(project, activity);
 		Pod projectPod = PodUtils.resolvePod(project);
 		projectPod.touch();
 	}
 
 	/***
 	 * Removes the step bean and its enclosing pod from the project bean and its
 	 * enclosing pod.
 	 * 
 	 * @param project
 	 * @param activity
 	 */
 	public static void removeStep(PasActivity activity, PasStep step) {
 		Pod activityPod = PodUtils.resolvePod(activity);
 		Pod stepPod = PodUtils.resolvePod(step);
 		if (activityPod == stepPod)
 			removeStepSharePod(activity, step);
 		else
 			removeStepOwnPod(activity, step);
 	}
 
 	/***
 	 * @param activity
 	 * @param step
 	 * @return index of step that was removed
 	 */
 	public static int removeStepFromActivityBean(PasActivity activity,
 			PasStep step) {
 		int index;
 		PasStep[] oldSteps = activity.getSteps();
 
 		for (index = 0; index < oldSteps.length; index++) {
 			if (step == oldSteps[index])
 				break; // found
 		}
 
 		// in case we passed through the end of the list
 		if (index == oldSteps.length)
 			throw new RuntimeException("step not in activity's step list");
 
 		// create new activity array from the old minus the removed activity
 		PasStep[] newSteps = new PasStep[oldSteps.length - 1];
 		System.arraycopy(oldSteps, 0, newSteps, 0, index);
 		// skip the index which has the removed activity
 		System.arraycopy(oldSteps, index + 1, newSteps, index, newSteps.length
 				- index);
 
 		// set new shorter activity list
 		activity.setSteps(newSteps);
 		return index;
 	}
 
 	/***
 	 * Removes the step bean and its enclosing pod from the project bean and its
 	 * enclosing pod.
 	 * 
 	 * @param project
 	 * @param activity
 	 */
 	static void removeStepOwnPod(PasActivity activity, PasStep step) {
 		int index = removeStepFromActivityBean(activity, step);
 
 		// find the pods of the beans
 		Pod activityPod = PodUtils.resolvePod(activity);
 		Pod stepPod = PodUtils.resolvePod(step);
 
 		// mark the project pod as having been modified and do it before the
 		// following code pulls up its pod id
 		activityPod.touch();
 
 		// remove the activity pod from the project pod
 		activityPod.remove(stepPod);
 
 		// remove from the imports and note which ref was the import
 		PropertyRef acRef = null;
 		Set<PropertyRef> transientRefs = activityPod.getTransientRefs();
 		for (PropertyRef importRef : transientRefs) {
 			if (step == importRef.getTarget()) {
 				acRef = importRef;
 				transientRefs.remove(acRef);
 				break;
 			}
 		}
 
 		// now remove from the project pod the assembly calls importing the
 		// activity from its pod (using the acRef)
 		// FIXME can't assume the default registry
 		PodRegistry registry = PodRegistry.getDefaultRegistry();
 		List<Assignment> assemblyCalls = activityPod.getAssemblyCalls();
 		for (Assignment assignment : assemblyCalls) {
 			if (acRef == assignment.getLeft().getRef(registry)) {
 				assemblyCalls.remove(assignment);
 				break;
 			}
 		}
 
 		// must reassign rest of imports to target the correct index in the new
 		// activities array
 		Map<String, PropertyRef> vars = activityPod.getVars();
 		Set<Entry<String, PropertyRef>> entrySet = vars.entrySet();
 
 		// iterate over copy to avoid ConcurrentModificationException
 		List<Entry<String, PropertyRef>> entries = new ArrayList<Entry<String, PropertyRef>>(
 				entrySet);
 		for (Map.Entry<String, PropertyRef> e : entries) {
 
 			String bindingKey = e.getKey();
 			PropertyRef entryValue = e.getValue();
 
 			if (entryValue instanceof IndexedPropertyRef) {
 				IndexedPropertyRef ipRef = (IndexedPropertyRef) entryValue;
 				if (ipRef.getPropertyName().equals("steps")) {
 					// ... it's an IndexedPropertyRef referrencing an index of
 					// an "activities" property
 
 					if (ipRef.getTarget() != activity)
 						throw new IllegalStateException(
 								"\"steps\" property not on activity bean");
 
 					int refIndex = ipRef.getIndex();
 
 					if (refIndex == index) {
 						// then that's the import we need to remove
 						activityPod.getVars().remove(bindingKey);
 					} else if (refIndex >= index) {
 						// then we need to shift it down one
 						PropertyRef newRef = new IndexedPropertyRef(activity,
 								"steps", refIndex - 1);
 
 						// remove the current one
 						activityPod.getVars().remove(bindingKey);
 
 						// now rebind
 						activityPod.importProperty(newRef, bindingKey);
 						logger.info("rebound " + ipRef + " with " + newRef);
 					}
 				}
 			}
 		}
 
 	}
 
 	/***
 	 * Removes the step from the activity and its enclosing pod.
 	 * 
 	 * @param activity
 	 * @param step
 	 */
 	private static void removeStepSharePod(PasActivity activity, PasStep step) {
 		removeStepFromActivityBean(activity, step);
 		Pod activityPod = PodUtils.resolvePod(activity);
 		activityPod.remove(step);
 	}
 
 	/***
 	 * @param stepPod
 	 * @return
 	 */
 	public static PasStep stepFromPod(Pod stepPod) {
 		PasStep step = SailBeanUtils.firstChildOfType(stepPod, PasStep.class);
 		assert step != null;
 		return step;
 	}
 
 	/***
 	 * writes the curnit to a file
 	 * 
 	 * @param curnitTitle
 	 * @param curnitId
 	 * @param rootPod
 	 * @return
 	 * @throws Exception
 	 */
 	public static File writeCurnit(String path, String curnitTitle,
 			CurnitUuid curnitId, Pod rootPod) throws Exception {
 		File outputFile = new File(path + curnitTitle + ".jar");
 		FileOutputStream output = new FileOutputStream(outputFile);
 		BinaryUtils.writeCurnit(curnitId, curnitTitle, rootPod, output);
 		return outputFile;
 	}
 
 }