package com.sri.emo.wizard.branch;
   
   import com.sri.emo.wizard.AbstractWizard;
   import com.sri.emo.wizard.WizardMonitor;
   import com.sri.emo.wizard.WizardPage;
   import com.sri.emo.wizard.WizardException;
   import java.util.Map;
   import java.util.HashMap;
   import java.io.Serializable;
  import java.util.Stack;
  import java.util.Arrays;
  import java.util.List;
  import com.sri.emo.wizard.defaults.SequentialWizard;
  import java.util.Iterator;
  import com.sri.emo.wizard.creation.StringUtil;
  import java.util.ArrayList;
  
  /***
   * <p>Title: </p>
   *
   * <p>Description: </p>
   *
   * <p>Copyright: Copyright (c) 2003</p>
   *
   * <p>Company: </p>
   *
   * @author not attributable
   * @version 1.0
   */
  public class BranchingWizard extends AbstractWizard {
  
      /***
       * An array of steps.  Since it's sequential, wizSteps[0] == first
       * step, wizSteps[1] == second step and so on.
       */
      final private BranchNode[] wizSteps;
  //    final private BranchNode currentStep;
  //    final private WizardPage[] wizSteps;
  
      /***
       * Internal boolean flag -- if finished then page history's index will
       * include the last page.
       */
      boolean finished = false;
  
      /***
       * Constructor that takes a monitor and an array of steps.
       *
       * @param wizMonitor the monitor for events occuring in the wizard.
       * @param steps      the WizardPage array ordered by the order
       *                   they appear.  Index 0 == first page.
       */
      public BranchingWizard(final WizardMonitor wizMonitor, final BranchNode[] steps) {
          super(wizMonitor);
          wizSteps = steps;
  //        currentStep = steps;
      }
  
      /***
       * Retrieve the initial page for the wizard.
       *
       * @return WizardPage instance.
       */
      protected WizardPage getInitialPage() {
          return wizSteps[0].getPage();
      }
  
      /***
       * Retrieve the index of the current wizard.  First page is page 1,
       * Second Page is page 2, etc.
       *
       * @return int
       */
      public int getCurrentPageIndex() {
          return (findWizardPageIndex(getCurrentPage()) + 1);
      }
  
      /***
       * Retrieve the total number of pages in this sequential wizard.
       *
       * @return int the number of pages.
       */
  //    public int getTotalPages() {
  //        return wizSteps.length;
  //    }
  
      /***
       * {@inheritDoc}
       * <p>The SequentialWizard implementation allows for
       * the browser back button
       * to be pressed and still achieve status quo.  What happens is that
       * if we detect that the browser back button was ealier pressed
       * (we can tell because the src page parameter is already on
       * the backtrace stack), then we rollback to the page previous to the
       * src page and re-execute.</p>
       *
       * @param src     the wizard page source
       * @param newData the data for the previous page.
       * @return the next wizard page
      * @throws WizardException                upon error
      * @throws ArrayIndexOutOfBoundsException if next was clicked and
      *                                        there should be no next button (ie last page)
      */
     public WizardPage next(WizardPage src, Serializable newData,
             Serializable allData) throws WizardException {
         finished = false;
         System.out.println("BranchingWizard.next("+newData+")");
 
         getMonitor().onForward(src);
         src.setData(newData);
 
         int val = findWizardPageIndex(src);
         if (isNeedingRollback(src)) {
             rollbackBacktrace(src);
         }
 
         //Checks against illegal forward jumps.
         checkAgainstIllegalJump(val);
 
         //
         //Allow for the page to validate itself first.  If there's problems there
         //don't even try continuing.
         //
         if (src.getPageErrors() != null && src.getPageErrors().size() > 0) {
             return wizSteps[val].getPage();
         }
 
         //Call template method and see if we can continue.
         BranchNode nextNode = getTransition(wizSteps[val], allData);
 
 //        if (!onNextPage(wizSteps[val], wizSteps[val + 1], newData)) {
         if (!onNextPage(wizSteps[val].getPage(), nextNode.getPage(), newData)) {
             //Rollback
             return wizSteps[val].getPage();
         } else {
             super.getBackTrace().push(src);
 //            val++;
 //            getMonitor().onEnterPage(wizSteps[val].getPage());
 //            setCurrentPage(wizSteps[val].getPage());
 //
 //            return wizSteps[val].getPage();
             getMonitor().onEnterPage(nextNode.getPage());
             setCurrentPage(nextNode.getPage());
 
             return nextNode.getPage();
 
         }
     }
 
 
     /***
      * {@inheritDoc}
      * <p>The SequentialWizard implementation allows for
      * the browser back button
      * to be pressed and still achieve status quo.  What happens is that
      * if we detect that the browser back button was ealier pressed
      * (we can tell because the src page parameter is already on
      * the backtrace stack), then we rollback to the page previous to the
      * src page and re-execute.</p>
      *
      * @param src     the wizard page source
      * @param newData the data for the previous page.
      * @return the next wizard page
      * @throws WizardException                upon error
      * @throws ArrayIndexOutOfBoundsException if next was clicked and
      *                                        there should be no next button (ie last page)
      */
     public WizardPage next(WizardPage src, Serializable newData) throws WizardException {
         return next(src, newData, null);
     }
 
     /***
      * getTransition
      *
      * @param branchNode BranchNode
      * @param newData Serializable
      * @return BranchNode
      */
     private BranchNode getTransition(BranchNode branchNode,
                                      Serializable newData) {
         System.out.println("BranchingWizard.getTransition()");
         if(newData == null){
             System.out.println("data is null so returning default page");
             return branchNode.getDefault();
         }
         if(newData instanceof String){
             System.out.println("data is a string so returning default page");
             return branchNode.getDefault();
         }
         if(newData instanceof List){
             System.out.println("getTransition() LIST: " + StringUtil.toString((List)newData));
             return branchNode.getDefault();
         }
         System.out.println("newData is of type " + newData.getClass());
         Map map = (Map) newData;
         String key = branchNode.getTransitionKey();
         System.out.println("BranchingWizard.getTransition(), map = " + map);
         System.out.println("transition key = " + key);
         System.out.println("transition to = " + (String) map.get(key));
         System.out.println("next node = " + branchNode.getNext((String) map.get(key)));
         return branchNode.getNext((String) map.get(key));
 
     }
 
     /***
      * Forgivingly converts page id to an internal integer.  Allowed parameters
      * can be either Strings with integers or java.lang.Integer object.
      *
      * @param pageId Serializable the requested page id.
      * @return int the converted value.
      */
     protected Integer convertKeyToPageId(Serializable pageId) {
         assert pageId != null;
 
         if (pageId instanceof String) {
             return new Integer((String) pageId);
         } else if (pageId instanceof Integer) {
             return ((Integer) pageId);
         } else {
             throw new IllegalArgumentException(
                     "Page id must be some sort of integer, either in java.lang.Integer or java.lang.String form");
         }
     }
 
     /***
      * Allows programmatic rewinding to a previous page.
      *
      * @param pageId Serializable the page key.
      * @return WizardPage the resulting page.
      */
     public WizardPage backupToPage(Serializable pageKey) throws ArrayIndexOutOfBoundsException,
             IllegalArgumentException {
         assert pageKey != null;
         System.out.println("BranchingWizard.backupToPage("+pageKey+")");
         Integer pageId = convertKeyToPageId(pageKey);
 //        assert pageId.intValue() > 0;
 
         WizardPage requestedPage = null;
         for (int i = 0; i < wizSteps.length; i++) {
             if (wizSteps[i].getPage().getId().equals(pageId)) {
                 requestedPage = wizSteps[i].getPage();
                 break;
             }
         }
 
         if (requestedPage == null) {
             throw new IllegalArgumentException("Could not find page with id: " + pageKey.toString());
         }
 
         rollbackBacktrace(requestedPage);
         setCurrentPage(requestedPage);
         getMonitor().onBack(requestedPage);
 
         getMonitor().onEnterPage(requestedPage);
         return requestedPage;
     }
 
 
     /***
      * Template method that gets called after the next page has been determined
      * in the sequence.
      *
      * @param previousPage     The previousPage that was displayted
      * @param nextPage         WizardPage the next page that is about to be displayed.
      * @param previousPageData Serializable the previously entered data from the
      *                         last page where the user clicked 'next'.
      * @return boolean true if you wish for the user to continue.  False if
      *         the page data needs to be vetoed.
      * @throws WizardException upon error.
      */
     protected boolean onNextPage(final WizardPage previousPage,
                                  final WizardPage nextPage,
                                  final Serializable previousPageData) throws WizardException {
 
         return (previousPage.getPageErrors() == null);
     }
 
     /***
      * Checks that there were no illegally jumping forward moves
      * caused by parameter manipulation.
      *
      * @param src WizardPage the wizard page we're checking against.
      * @throws IllegalStateException if the check fails.
      */
     protected void checkAgainstIllegalJump(int pageIndex) {
         Stack backtrace = getBackTrace();
         if (backtrace.size() == 0) {
             if (pageIndex == 0) {
                 return;
             } else {
 //                throw new IllegalStateException("Illegal Page Order");
             }
         } else {
             WizardPage previous = (WizardPage) backtrace.peek();
             int previousIndex = findWizardPageIndex(previous);
             int current = pageIndex;
 //            System.out.println("checkAgainstIllegalJump("+pageIndex+")");
 //            System.out.println("previous index = " + previousIndex);
 //            System.out.println("current = " + current);
 //            System.out.println("PREVIOUS: " + wizSteps[previousIndex]);
 //            System.out.println("CURRENT: " + wizSteps[current]);
 
             if (!wizSteps[previousIndex].containsTransitionTo(wizSteps[current])) {
 //                throw new IllegalStateException("Illegal Page Order");
             }
         }
     }
 
     /***
      * {@inheritDoc}
      *
      * @param s Serializable
      * @return WizardPage
      */
     public WizardPage getPageById(Serializable s) {
         for (int i = 0; i < wizSteps.length; i++) {
             WizardPage onePage = wizSteps[i].getPage();
 //            System.out.println("checking " + s + " against " + onePage.getId());
             if (onePage.getId().equals(s)) {
                 return onePage;
             }
         }
 
         throw new IllegalArgumentException("Key: " + s.toString()
                 + " does not exist for this wizard");
     }
 
     /***
      * Retrieve all the steps for the wizard.
      *
      * @return WizardPage[]
      */
     protected BranchNode[] getAllSteps() {
         return wizSteps;
     }
 
     /***
      * Checks the backtrace for presence of the given wizard page.
      *
      * @param src WizardPage the source wizard page.
      * @return boolean true.
      */
     protected boolean isNeedingRollback(WizardPage src) {
         Stack backtrace = getBackTrace();
         boolean foundInStack = false;
         for (int i = 0; i < backtrace.size(); i++) {
             WizardPage onePage = (WizardPage) backtrace.get(i);
             if (src.equals(onePage)) {
                 foundInStack = true;
                 break;
             }
         }
 
         return foundInStack;
     }
 
 
     /***
      * Rolls back the backtrace stack if the src page is already
      * on the stack, indicating that the browser pushed the back button.
      *
      * @param src WizardPage the source of the 'next' event, so we rollback
      *            so that it is no longer on the backtrace.
      */
     protected void rollbackBacktrace(final WizardPage src) {
         Stack backtrace = getBackTrace();
 
         while (!backtrace.empty()) {
             WizardPage onePage = (WizardPage) backtrace.pop();
             if (src.equals(onePage)) {
                 break;
             }
         }
     }
 
 
     /***
      * Find the wizard page index so we can define what the next page is.
      *
      * @param toFind the wizard page to find.
      * @return integer, the index inside wizSteps
      * @throws IllegalStateException if we're unable to find the page.
      */
     protected int findWizardPageIndex(final WizardPage toFind) {
 
         for (int i = 0; i < wizSteps.length; i++) {
             if (wizSteps[i].getPage() == toFind) {
                 return i;
             }
         }
         throw new IllegalStateException("Unable to find Wizard Page");
     }
 
 
     /***
      * Retrieve all the data for the wizard keyed by page id.
      *
      * @return Map of WizardPage objects keyed by id.
      * @throws WizardException upon error
      */
     public Map getAllData() throws WizardException {
         Map returnValue = new HashMap(wizSteps.length);
 
         for (int i = 0; i < wizSteps.length; i++) {
             WizardPage oneStep = wizSteps[i].getPage();
             returnValue.put(oneStep.getId(), oneStep.getData());
         }
 
         return returnValue;
     }
 
     /***
      * {@inheritDoc}
      *
      * @return List
      * @throws WizardException upon retrieval order.
      */
     public List getStepHistory() throws WizardException {
         //Typically
         int currentIndex = getCurrentPageIndex() - 1;
 
         //If we are finished
         if (finished) {
             //Include the last page that was not normally
             //processed by next.
             currentIndex++;
         }
 
         //Create a new array and copy the appropriate elements
         //Return the array as a list.
         WizardPage history[] = new WizardPage[currentIndex];
         for (int i = 0; i < currentIndex; i++) {
             history[i] = wizSteps[i].getPage();
         }
         return Arrays.asList(history);
     }
 
     /***
      * Will return a history of steps without accounting for any of the branching
      * @return List
      * @throws WizardException
      */
     public List getMainStepHistory() throws WizardException {
         //Typically
         int currentIndex = getCurrentPageIndex() - 1;
 
         //If we are finished
         if (finished) {
             //Include the last page that was not normally
             //processed by next.
             currentIndex++;
         }
 
         //Create a new array and copy the appropriate elements
         //Return the array as a list.
 //    WizardPage history[] = new WizardPage[currentIndex];
         ArrayList list = new ArrayList(currentIndex);
         for (int i = 0; i < currentIndex; i++) {
             if (includeInMainStep(wizSteps[i])) {
                 list.add(wizSteps[i].getPage());
             }
         }
         return list;
     }
 
     protected boolean includeInMainStep(BranchNode node){
         return true;
     }
 
 
     /***
      * Override of Object.equals to check field by field.
      * {@inheritDoc}
      *
      * @param parm1 the object SequentialWizard
      * @return true if the fields are equal.
      */
     public boolean equals(final Object parm1) {
         if (super.equals(parm1)) {
             BranchingWizard other = (BranchingWizard) parm1;
             boolean returnValue = true;
             returnValue &= (wizSteps.length == other.wizSteps.length);
             if (returnValue) {
                 for (int i = 0; i < wizSteps.length; i++) {
                     returnValue &= wizSteps[i].equals(other.wizSteps[i]);
                 }
             }
             return returnValue;
         } else {
             return false;
         }
     }
 
     /***
      * Returns a hash code value for the object.
      *
      * @return a hash code value for this object.
      */
     public int hashCode() {
         return super.hashCode();
     }
 
     /***
      * Processes the final finish and returns some sort of data that can be
      * whatever is desired.
      *
      * @param src             WizardPage the source of the event.
      * @param data            Serializable the data given during wht wizard post.
      * @param additonalParams anything that the underlying wizard needs. The
      *                        values are set by the Application Controller.
      * @return Object: whatever object the wizard returns after processing.
      * @throws WizardException upon error.
      */
     public Object processFinish(WizardPage src, Serializable data, Map additonalParams) throws WizardException {
         finished = true;
         return super.processFinish(src, data, additonalParams);
     }
 
     /***
      * {@inheritDoc}
      *
      * @return WizardPage instance.
      * @throws WizardException upon error.
      */
     public WizardPage previous() throws WizardException {
         finished = false;
         return super.previous();
     }
 
     /***
      * Override of toString().
      *
      * @return Wizard Title
      */
     public String toString() {
         return getTitle() + " Branching Wizard";
     }
 
 }