/***
    * Created on Nov 17, 2005, Copyright UC Regents
    */
   package org.telscenter.pas.authortool.context;
   
   import java.io.IOException;
   import java.lang.reflect.Constructor;
   import java.lang.reflect.InvocationTargetException;
   import java.net.URL;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.Iterator;
  
  import javax.swing.Action;
  import javax.swing.JFrame;
  
  import net.sf.sail.common.apps.LaunchGenericSession;
  import net.sf.sail.common.apps.preview.PreviewSessionConfiguration;
  import net.sf.sail.core.beans.Pod;
  import net.sf.sail.core.beans.assembly.PodRegistry;
  import net.sf.sail.core.bundle.BundleManager;
  import net.sf.sail.core.curnit.Curnit;
  import net.sf.sail.core.service.ServiceContext;
  import net.sf.sail.core.service.SessionManager;
  import net.sf.sail.core.session.ICurnitProvider;
  import net.sf.sail.core.session.SessionConfiguration;
  import net.sf.sail.core.uuid.CurnitUuid;
  import net.sf.sail.core.uuid.PodUuid;
  
  import org.telscenter.pas.authortool.actions.HelpContextAction;
  import org.telscenter.pas.authortool.actions.PasCustomizerAction;
  import org.telscenter.pas.authortool.actions.PasLivePreviewCurnitAction;
  import org.telscenter.pas.authortool.actions.PreferenceAction;
  import org.telscenter.pas.authortool.actions.ReportIssueAction;
  import org.telscenter.pas.authortool.cards.CardProvider;
  import org.telscenter.pas.authortool.cards.customizer.pas.PasCustomizerCardX;
  import org.telscenter.pas.authortool.cards.help.HelpCard;
  import org.telscenter.pas.authortool.menu.EditMenu;
  import org.telscenter.pas.authortool.menu.FileMenu;
  import org.telscenter.pas.authortool.menu.HelpMenu;
  import org.telscenter.pas.authortool.menu.MenuProvider;
  import org.telscenter.pas.authortool.menu.ToolsMenu;
  import org.telscenter.pas.authortool.statusbar.StatusBarProvider;
  
  /***
   * @author turadg
   */
  public class CurnitAuthoringContext  {
  
  	private static final long serialVersionUID = 1L;
  
  	private Curnit workingCurnit;
  
  	private CardProvider cardProvider;
  
  	private Class[] cardClasses;
  
  	private IAuthoringSessionManager sessionManager;
  
  	private JFrame mainAuthoringFrame;
  
  	private MenuProvider menuProvider;
  
  	private Class[] menuClasses;
  	
  	private StatusBarProvider statusBarProvider;
  	
  	private HashMap<Class, Action> actions = new HashMap<Class, Action>();
  	
  	public Class[] getCardClasses() {
  		return cardClasses;
  	}	
  
  	public Class[] getMenuClasses(){
  		return menuClasses;
  	}
  	/***
  	 * @throws IOException
  	 */
  	public CurnitAuthoringContext(final IAuthoringSessionManager sessionManager)
  			throws IOException {
  		this.sessionManager = sessionManager;
  		this.assemble();
  		
  	}
  	
  	public void assemble() {
  		sessionManager.startAuthoringSession();
  		workingCurnit = sessionManager.getCurnit();
  		workingCurnit.assemble();
  
  		// FIXME read this from the sessionManager
  		cardClasses = new Class[] { PasCustomizerCardX.class, HelpCard.class };
  		menuClasses = new Class[] {FileMenu.class, EditMenu.class, ToolsMenu.class,HelpMenu.class};
  		
  		// Add the default actions
  		// This should be done from a config file.
  		addActionClass(PasLivePreviewCurnitAction.class);
 		addActionClass(PasCustomizerAction.class);
 		addActionClass(HelpContextAction.class);
 		//addActionClass(AboutAction.class);
 		addActionClass(PreferenceAction.class);
 		addActionClass(ReportIssueAction.class);
 	}
 
 	public Curnit getAssembledCurnit() {
 		return workingCurnit;
 	}
 
 	/***
 	 * Save the curnit to where it was last saved to (or loaded from)
 	 */
 	public void saveCurnit() {
 		try {
 			sessionManager.save(workingCurnit);
 		} catch (IOException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
 
 	/***
 	 * Return the first non Pod child of the root pod of
 	 * the curnit
 	 * 
 	 * @return
 	 */
 	public Object getFirstRootBean() {
 		PodUuid rootPodId = workingCurnit.getRootPodId();
 		Pod rootPod = PodRegistry.getRegistry().getPod(rootPodId);
 		Iterator children = rootPod.iterator();
 		while(children.hasNext()) {
 			Object child = children.next();
 			if(!(child instanceof Pod)) {
 				return child;
 			}
 		}
 		
 		return null;
 	}
 	
 	/***
 	 * Save the curnit to a new location
 	 */
 	public void saveCurnitAs() {
 		try {
 			sessionManager.saveAs(workingCurnit);
 		} catch (IOException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	}
 
 	public CardProvider getCardProvider() {
 		if (cardProvider == null)
 			cardProvider = new CardProvider(this);
 		return cardProvider;
 	}
 	
 	public void setCardProvider(CardProvider cardProvider) {
 		this.cardProvider = cardProvider;
 	}
 	public MenuProvider getMenuProvider() {
 		if( menuProvider == null ) {
 			menuProvider = new MenuProvider(this);
 		}// if
 		return menuProvider;
 	}
 
 	/***
 	 * Preview the whole curnit, as if the learner had begun it
 	 * @throws IOException
 	 */
 	public void previewCurnitOld() throws IOException {
 		SessionConfiguration sp = new PreviewSessionConfiguration(workingCurnit);
 		LaunchGenericSession.launchSession(sp);
 	}
 
 	/***
 	 * Preview the whole curnit, as if the learner had begun it, using 
 	 * the services architecture.
 	 * 
 	 * @throws IOException
 	 */
 	public void previewCurnit() throws IOException {
 		BundleManager bundleManager = new BundleManager();		
 		ServiceContext serviceContext = bundleManager.getServiceContext();
 		
 		
 		/***
 		 * Create the curnit provider for this curnit and add it to the 
 		 * service context
 		 */
 		ICurnitProvider provider = new ICurnitProvider(){
 
 			public Curnit getCurnit(CurnitUuid curnitId) {
 				return workingCurnit;
 			}
 
 			public Collection getRegisteredCurnitUuids() {
 				ArrayList curnits = new ArrayList();
 				curnits.add(workingCurnit.getCurnitId());
 				return curnits;
 			}			
 		};
 			
 		serviceContext.addService(ICurnitProvider.class, provider);
 
 		/***
 		 * Add the bundles configured in this xml file.  The format of the file is XMLEncoder
 		 */
 		URL bundlesXML = getClass().getResource("previewBundles.xml");		
 		bundleManager.addBundles(bundlesXML.openStream());
 
 		/***
 		 * Have all the bundles register their services, and then do any linking to other
 		 * registered services
 		 */
 		bundleManager.initializeBundles();
 		
 		/***
 		 * Start the session manager 
 		 */
 		SessionManager manager = (SessionManager)
 			serviceContext.getService(SessionManager.class);
 		manager.start(serviceContext);
 	}
 	
 	/***
 	 * @return the mainAuthoringFrame
 	 */
 	public JFrame getMainAuthoringFrame() {
 		return mainAuthoringFrame;
 	}
 
 	/***
 	 * @param mainAuthoringFrame the mainAuthoringFrame to set
 	 */
 	public void setMainAuthoringFrame(JFrame mainAuthoringFrame) {
 		this.mainAuthoringFrame = mainAuthoringFrame;
 	}
 
 	public Action getAction(Class actionClass){
 		return actions.get(actionClass);
 	}
 	
 	protected void addActionClass(Class actionClass){
 
 		try{
 			Class[] parameters = new Class[] { CurnitAuthoringContext.class };
 			Constructor constr = actionClass.getConstructor(parameters);
 			Object[] initargs = new Object[] { this };
 			Object instance = constr.newInstance(initargs);
 			actions.put(actionClass, (Action)instance);
 		} catch (SecurityException e) {
 			e.printStackTrace();
 		} catch (NoSuchMethodException e) {
 			e.printStackTrace();
 		} catch (IllegalArgumentException e) {
 			e.printStackTrace();
 		} catch (InstantiationException e) {
 			e.printStackTrace();
 		} catch (IllegalAccessException e) {
 			e.printStackTrace();
 		} catch (InvocationTargetException e) {
 			e.printStackTrace();
 		}
 	}
 
 	/***
 	 * @return the statusBarProvider
 	 */
 	public StatusBarProvider getStatusBarProvider() {
 		return statusBarProvider;
 	}
 
 	/***
 	 * @param statusBarProvider the statusBarProvider to set
 	 */
 	public void setStatusBarProvider(StatusBarProvider statusBarProvider) {
 		this.statusBarProvider = statusBarProvider;
 	}
 
 
 }