package com.explosion.expfmodules.wizard.standard;
   
   /* =============================================================================
    *       
    *     Copyright 2004 Stephen Cowx
    *
    *     Licensed under the Apache License, Version 2.0 (the "License");
    *     you may not use this file except in compliance with the License.
    *     You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   *     Unless required by applicable law or agreed to in writing, software
   *     distributed under the License is distributed on an "AS IS" BASIS,
   *     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *     See the License for the specific language governing permissions and
   *     limitations under the License.
   * 
   * =============================================================================
   */
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import com.explosion.expfmodules.wizard.Step;
  import com.explosion.expfmodules.wizard.Wizard;
  import com.explosion.utilities.exception.ExceptionManagerFactory;
  
  /***
   * @author Stephen Cowx
   * This is a standard and basic implementation of the Wizard interface intended for use with simple wizards
   * Created on 02-Dec-2004
   */
  public class StandardWizard implements Wizard
  {
      private static org.apache.log4j.Logger log = org.apache.log4j.LogManager.getLogger(StandardWizard.class);
      private String name;
      private String version;
      
      private Map stepDefinitions;
      private Step firstStep;
      
      private Step currentStep;
      private List previousSteps = new ArrayList();
      private List previousDataValues = new ArrayList();
      private Map currentDataValues = new HashMap(); 
       
      /***
       * Advances to the next step by checking all of the conditions of the outbound routes
       * the first outbound step with no condition or with a condition thatmatches will be chosen
       * 
       * It also copies all of the data items from this step into the data items set for the wizard.
       * If the step is reversed (using back) the dataitems are also reversed.  The step dataitems are remembered
       * usign shallow copies so any changes to the actual data items may not be rolled back
       * @see com.explosion.expfmodules.wizard.Wizard#next()
       *
       */
      public void next()
      {
          try
          {
              log.debug("Called next");
              boolean found = false;
              if (currentStep != null)
              {
                /* Make the decision about what the next step should be */  
                List outboundRoutes = currentStep.getOutboundSteps();
                for (Iterator it = outboundRoutes.iterator(); it.hasNext();)
                {
                    Step step = (Step) it.next();
                    if (step.getCondition() == null || step.getCondition().conditionMet(this))
                    {
                        /* Add the old step to the history */
                        previousSteps.add(currentStep);
                        
                        /* Move the datavalues from the last step into the wizard data values map */
                        promoteDataValues();
                        
                        /* Execute the action for the last step*/
                        if (currentStep.getStepDefinition().getAction() != null)
  	          		  {
  	          			 boolean advance = currentStep.getStepDefinition().getAction().execute(this);
  	          			 if (!advance)
  	          			 {
  	          			 	//reverse any progress we have made and go back to the current step
  	          			 	undoPromote();
  	          	            break;
  	          			 }
  	          		  }
                        
                        /* Set the current step to the new value */
                        currentStep = step;
                        found = true;
                        
                        break;
                    }
               }
               if (!found)
                   log.error("No suitable outbound routes found for step " + currentStep.getStepDefinition().getName() + " (ID: )" + currentStep.getStepDefinition().getId());
             }
         }
         catch (Exception e)
         {
             ExceptionManagerFactory.getExceptionManager().manageException(e,"Exception caught while advancing wizard to the next step.");
         }
     }
     
     /***
 	 * This method moves the data values from the current step into the data values for the wizard.
 	 * It also saves the previous data values hash map and makes a new one
 	 */
 	private void promoteDataValues() {
 		/* Advance the data values in the wizard */
 		  previousDataValues.add(currentDataValues);
 		  Map newDataValues = new HashMap();
 		  for (Iterator valKeys = currentDataValues.keySet().iterator(); valKeys.hasNext();)
 		  {
 		  	 Object key = valKeys.next();
 		  	 newDataValues.put(key, currentDataValues.get(key));
 		  }
 		  
 		  if (currentStep.getStepDefinition().getDataItems() != null)
 		  {
 			  /* Add the data values from this step */
 			  for (Iterator newKeys = currentStep.getStepDefinition().getDataItems().keySet().iterator(); newKeys.hasNext();)
 			  {
 			  	 Object key = newKeys.next();
 			  	 newDataValues.put(key, currentStep.getStepDefinition().getDataItems().get(key));
 			  }
 		  }
 		  /* Set the currentDataValues to the newDataValues so that the current Data values 
 		   * has all of the data values collected so far*/
 		  currentDataValues = newDataValues;
 	}
 
 	/***
      * This method must be called for the wizard to be initialised and ready for processing.
      * It initialises the currentStep with the step set as the firstStep and clears the previousSteps array.
      * @see com.explosion.expfmodules.wizard.Wizard#start()
      *
      */
     public void start()
     {
         log.debug("Called start");
         if (firstStep != null)
         {
             previousSteps = new ArrayList();
             currentStep = firstStep;
             
             previousDataValues = new ArrayList();
             currentDataValues = (Map) new HashMap();
         }
     }
     
     /***
      * This method moves the currentStep to the previous step,
      * essentially just moving the wizard back one step.
      * @see com.explosion.expfmodules.wizard.Wizard#back()
      */
     public void back()
     {
         log.debug("Called back");
         if (previousSteps.size() > 0)
         {
             currentStep = (Step) previousSteps.get(previousSteps.size()-1);
             undoPromote();
         }
          
     }
     
     /***
      * This is a helper method for code shared in several places in this class.It rolls back changes made 
      * to the data items and steps
      */
     private void undoPromote()
     {
         previousSteps.remove(previousSteps.size()-1);
         currentDataValues = (Map) previousDataValues.get(previousDataValues.size()-1);
         previousDataValues.remove(previousDataValues.size()-1);
     }
     
     /***
      * This method cancels the wizard.
      * It may perform some logic here perhaps instantiate a class of type Cencel and invoke the Cancel method.
      * Currently it is not implemented.
      * @see com.explosion.expfmodules.wizard.Wizard#cancel()
      *
      */
     public void cancel()
     {
         log.debug("Called cancel");
     }
     
     /***
      * This method completes the wizard.
      * It may perform some logic here perhaps instantiate a class of type Completion and invoke the complete method.
      * Currently it is not implemented.
      * @see com.explosion.expfmodules.wizard.Wizard#finish()
      *
      */
     public void finish()
     {
         try {
 			log.debug("Called finish");
 			
 			/* Add the old step to the history */
             previousSteps.add(currentStep);
             
 			/* Move the datavalues from the last step into the wizard data values map */
             promoteDataValues();
 			
             /* Execute the action for the last step*/
             if (currentStep.getStepDefinition().getAction() != null)
 			{
             	boolean advance = currentStep.getStepDefinition().getAction().execute(this);
      			 if (!advance)
      			 {
      			 	//reverse any progress we have made and go back to the current step
      			 	undoPromote();
      			 	return;
      			 }
 			}
             
             currentStep = null;
             
 		} catch (Exception e) {
 			ExceptionManagerFactory.getExceptionManager().manageException(e,"Exception caught while finshing wizard");
 		}
     }
     
     /***
      * 
      * @see com.explosion.expfmodules.wizard.Wizard#getName()
      * @return
      */
     public String getName()
     {
         log.debug("Called getName");
         return name;
     }
     
     /***
      * Sets the name for this wizard
      * @param name
      */
     public void setName(String name)
     {
         this.name = name;
     }
      
     
     /***
      * 
      * @see com.explosion.expfmodules.wizard.Wizard#getFirstStep()
      * @return
      */
     public Step getFirstStep()
     {
         log.debug("Called getStepsDefinitions");
         return firstStep;
     }
     
     /***
      * Sets the first step for this wizard
      * @param steps
      */
     public void setFirstStep(Step firstStep)
     {
         this.firstStep = firstStep;
         this.currentStep = firstStep;
     }  
       
     
     /***
      * @return Returns the stepDefinitions.
      */
     public Map getStepDefinitions()
     {
         return stepDefinitions;
     }
     
     /***
      * @param stepDefinitions The stepDefinitions to set.
      */
     public void setStepDefinitions(Map stepDefinitions)
     {
         this.stepDefinitions = stepDefinitions;
     }
     
     /***
      * This method returns the current step which the wizard is on.
      * @return
      */
     public Step getCurrentStep()
     {
         return currentStep;
     }
     
     /***
      * REeturns the version of this Wizard
      * @return
      */
     public String getVersion()
     {
         return version;
     }
     
     /***
      * Sets the version of this wizard
      * @param version
      */
     public void setVersion(String version)
     {
         this.version = version;
     }
     
     /***
      * These values will be populated by each step in the wizard as it progresses so that at the end of the wizard
      * the values collected can be used by the action performed
      * @return
      */
     public Map getWizardDataValues()
     {
     	return this.currentDataValues;
     }
     
     /***
      * Returns true if this wizard is finshed
      * @return
      */
     public boolean isFinished()
     {
     	if (this.currentStep == null)
     		return true;
     	else
     		return false;
     }
 }