/* ===================================================================
    * Copyright 2002-04 SRI International.
    * Released under the MOZILLA PUBLIC LICENSE Version 1.1
    * which can be obtained at http://www.mozilla.org/MPL/MPL-1.1.html
    * This software is distributed on an "AS IS"
    * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.
    * See the License for the specific language governing rights and
    * limitations under the License.
    * =================================================================== */
  package com.sri.emo.wizard.expressoimpl;
  
  import com.jcorporate.expresso.core.controller.*;
  import com.jcorporate.expresso.core.dbobj.DBObject;
  import com.sri.common.controller.AbstractComponentController;
  import com.sri.emo.EmoSchema;
  import com.sri.emo.wizard.*;
  import com.sri.emo.wizard.defaults.SequentialWizard;
  
  import java.io.Serializable;
  import java.util.*;
  
  
  /***
   * Wizard Controller is basically a thin wrapper over the Wizard domain
   * model which does the actual thinking.  The WizardController may
   * be overridden in the case of custom onFinish() behavior.
   *
   * @author Michael Rimov
   */
  public class WizardController extends AbstractComponentController {
  
      /***
  	 * 
  	 */
  	private static final long serialVersionUID = 1L;
  
  	/***
       * Start state constant.
       */
      public static final String STATE_BEGIN = "Begin";
  
      /***
       * Next State constant.
       */
      public static final String NEXT_STATE = "Next";
  
      /***
       * Finish State.
       */
      public static final String FINISH_STATE = "Finish";
  
      /***
       * Cancel State.
       */
      public static final String CANCEL_STATE = "Cancel";
  
      /***
       * Display Page State.
       */
      public static final String DISPLAY_STATE = "Display";
  
      /***
       * Previous State.
       */
      public static final String PREVIOUS_STATE = "Previous";
  
      /***
       * State name to allow jumping backwards.
       */
      public static final String STATE_JUMP_BACKWARDS = "JumpBackwards";
  
  
      /***
       * Key for session state for the Wizard.  [More than one wizard
       * is possible in a session since they are keyed by wizard id.
       */
      protected static final String SESSION_STATE_KEY_PREFIX = WizardController.class.getName();
  
      /***
       * Key for the current wizard in the request.
       */
      public static final String REQUEST_ID = "Wizard";
  
      /***
       * Constant for the id of the EMO  Wizard that is being executed. Used
       * in transitions inside the wizard.
       */
      public static final String WIZ_PARAMETER_ID = "Emo.WizardId";
  
      /***
       * Constant for what data is sent us.
       */
      public static final String WIZ_DATA_ID = "Emo.DataParameter";
  
      /***
       * Where the wizard is stored in the request context when finish() is
       * called.
       */
      public static final String WIZ_RESULT_ID = "WizResult";
 
 
     /***
      * Parameter for Wizard's finish to get the ExpressoRequest object.
      */
     public static final String FINISH_REQUEST = "Request";
 
     /***
      * Parameter for the Wizard's finish method to get the
      * ExpressoResponse object.
      */
     public static final String FINISH_RESPONSE = "Response";
 
     /***
      * Current Page ID Parameter name.
      */
     public static final String WIZ_PAGE_PARAMETER = "Emo.CurrentPage";
 
     /***
      * Current page number constant.
      */
     public static final String CURRENT_PAGE_NUM = "current";
 
     /***
      * Total Pages constant.
      */
     public static final String TOTAL_PAGES = "total";
 
 
     /***
      * Generic wizard controller.
      */
     public WizardController() {
         super(com.sri.emo.EmoSchema.class);
 
         State s = new State("Begin", "Begin a Wizard");
         s.addParameter(WIZ_PARAMETER_ID, DBObject.INT_MASK);
         addState(s);
 
         s = new State("Next", "Next Page in the Wizard");
         s.addParameter(WIZ_PARAMETER_ID, DBObject.INT_MASK);
         addState(s);
 
         s = new State("Finish", "Finish the Wizard");
         s.addParameter(WIZ_PARAMETER_ID, DBObject.INT_MASK);
         addState(s);
 
         s = new State("Cancel", "Cancel the Wizard");
         s.addParameter(WIZ_PARAMETER_ID, DBObject.INT_MASK);
 //        s.addRequiredParameter(WIZ_CANCEL_PARAMETER);
         addState(s);
 
         s = new State("Display", "Display a wizard page");
         s.addParameter(WIZ_PARAMETER_ID, true, DBObject.INT_MASK);
         s.addParameter(WIZ_PAGE_PARAMETER, true, DBObject.INT_MASK);
         addState(s);
 
         s = new State("Previous", "Previous page in the Wizard");
         s.addParameter(WIZ_PARAMETER_ID, DBObject.INT_MASK);
         addState(s);
 
         s = new State(STATE_JUMP_BACKWARDS, "Jump Backwards In the Wizard");
         addState(s);
 
         setSchema(com.sri.emo.EmoSchema.class);
         setInitialState("Begin");
     }
 
     /***
      * Return the title of this Controller.
      *
      * @return java.lang.String The Title of the controller
      */
     public String getTitle() {
         return "WizardController";
     }
 
     /* getTitle() */
 
     /***
      * Location for transition on cancel instances.  Override in custom
      * controllers to have your own capabilities.
      *
      * @return Transition instance.
      */
     protected Transition getCancelTransition() {
         Transition t = new Transition();
         t.setName("Cancel");
         t.setLabel("Cancel");
         t.setControllerObject(WizardController.class);
         t.setState(DISPLAY_STATE);
 
         return t;
     }
 
     /***
      * Retrieve where a particular wizard is stored in the session.
      *
      * @param wizardId    the current id of the wizard.
      * @param dataContext the datacontext for the wizard.
      * @return String in the session of the Wizard.
      */
     protected String getSessionKey(final String dataContext, final Serializable wizardId) {
         assert wizardId != null : " wizardId Parameter Cannot be null";
         assert dataContext != null: " parameter datacontext cannot be null";
 
         return SESSION_STATE_KEY_PREFIX + "." + dataContext + "." + wizardId.toString();
     }
 
     /***
      * Retrieves the current wizard from session.
      *
      * @param request the current controller request.
      * @return Wizard Instance
      * @throws ControllerException if unable to query the session.
      */
     public Wizard getCurrentWizard(final ExpressoRequest request) throws ControllerException {
         Integer id = new Integer(request.getParameter(WIZ_PARAMETER_ID));
 
         //Get the session key.
         String sessionKey = getSessionKey(request.getDataContext(), id);
 
         WizardMementoConverter converter = getMementoConverter();
 
         //Retrieve the item from the store.
         Serializable toRetrieve = (Serializable) request.getSession().getPersistentAttribute(sessionKey);
         if (toRetrieve == null) {
             return null;
         }
 
         //Convert to usable type if necessary.
         if (converter != null) {
             try {
                 toRetrieve = converter.fromMemento(toRetrieve);
             } catch (WizardException ex) {
                 throw new ControllerException("Error converting wizard to be able to store it in session.", ex);
             }
         }
 
         return (Wizard) toRetrieve;
     }
 
     /***
      * Retrieves the current page as set in the displayed page.
      *
      * @param request       ExpressoRequest the controller request object.
      * @param currentWizard Wizard the current wizard.
      * @return WizardPage the current wizard page as defined by the hidden
      *         parameters on the form.
      * @throws ControllerException upon error.
      */
     public WizardPage getCurrentPage(final ExpressoRequest request,
                                      final Wizard currentWizard) throws ControllerException {
         String currentPageString = request.getParameter(WizardController.WIZ_PAGE_PARAMETER);
         if (currentPageString == null || currentPageString.length() == 0) {
             return currentWizard.getCurrentPage();
         } else {
             Integer i = null;
             try {
                 i = new Integer(currentPageString);
             } catch (NumberFormatException ex) {
                 throw new ControllerException("Illegal argument value " + "for parameter '" + WIZ_PAGE_PARAMETER + "'");
             }
             return currentWizard.getPageById(i);
         }
     }
 
     /***
      * Stores a new wizard to session.
      *
      * @param request the <code>ExpressoRequest</code> object
      * @param toStore the wizard to store.
      * @param wizId   the integer id of the wizard.
      * @throws ControllerException upon session related error.
      */
     protected void storeWizInSession(final ExpressoRequest request, final Wizard toStore,
                                      final Integer wizId) throws ControllerException {
 
         String sessionId = getSessionKey(request.getDataContext(), wizId);
 
         WizardMementoConverter converter = getMementoConverter();
         Serializable objectToStore = toStore;
         if (converter != null) {
             try {
                 objectToStore = converter.toMemento(toStore);
             } catch (WizardException ex) {
                 throw new ControllerException("Error converting wizard to be able to store it in session.", ex);
             }
         }
         request.getSession().setPersistentAttribute(sessionId, objectToStore);
     }
 
 
     /***
      * <tt>Template Method</tt>.  Retrieves/Constructs the WizardMementoConverter
      * appropriate for the current run.
      *
      * @return WizardMementoConverter or null if none is defined.
      */
     protected WizardMementoConverter getMementoConverter() {
         return null;
     }
 
     /***
      * Create a new wizard and store it to session.
      *
      * @param request the <code>ExpressoRequest</code> object
      * @return Wizard instance
      * @throws WizardException     upon wizard error
      * @throws ControllerException upon expresso controller related
      *                             error.
      */
     protected Wizard newWizard(final ExpressoRequest request) throws WizardException, ControllerException {
         Integer id = new Integer(request.getParameter(WIZ_PARAMETER_ID));
         WizardRepository repository = ((EmoSchema) getSchemaInstance()).getWizardRepository(request.getDataContext());
 
         Wizard returnValue = repository.find(id);
         storeWizInSession(request, returnValue, id);
 
         return returnValue;
     }
 
     /***
      * Runs the begin state.
      *
      * @param request  the <code>ExpressoRequest</code> object
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException    upon error
      * @throws NonHandleableException upon fatal error
      */
     protected void runBeginState(final ExpressoRequest request,
                                  final ExpressoResponse response) throws ControllerException, NonHandleableException {
         try {
             Wizard wiz = newWizard(request);
             wiz.begin();
             request.setParameter(WIZ_PAGE_PARAMETER, wiz.getCurrentPage().getId().toString());
             transition(DISPLAY_STATE, request, response);
         } catch (WizardException ex) {
             throw new ControllerException("Error starting wizard", ex);
         }
     }
 
     /***
      * Runs the cancel state.
      *
      * @param request  the <code>ExpressoRequest</code> object
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException    upon error
      * @throws NonHandleableException upon fatal error
      */
     protected void runCancelState(final ExpressoRequest request,
                                   final ExpressoResponse response) throws ControllerException, NonHandleableException {
         Wizard wiz = getCurrentWizard(request);
         if (wiz != null) {
             request.getSession().removePersistentAttribute(this.getSessionKey(request.getDataContext(),
                     request.getParameter(WIZ_PARAMETER_ID)));
         }
         getCancelTransition().executeTransition(request, response);
     }
 
     /***
      * Displays the result of the wizard.  This particular implementation
      * puts the wizard in the request context under the parameter
      * name of {@link #REQUEST_ID}.  and if the wizard metadata is using
      * expresso links, then it dumps the resulting Transitions into the
      * ExpressoResponse object. [Although JSTL can certainly
      * get the links directly from the {@link #REQUEST_ID} object's metadata:
      * so choose your style.
      *
      * @param request  the <code>ExpressoRequest</code> object
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException    upon error
      * @throws NonHandleableException upon fatal error
      */
     protected void runDisplayState(final ExpressoRequest request,
                                    final ExpressoResponse response) throws ControllerException, NonHandleableException {
 
         //Add the cancel button.
         response.add(getCancelTransition());
 
         Wizard requestedWizard = getCurrentWizard(request);
         if (requestedWizard == null) {
             return;
         }
 
         //Save the current wizard in the request stack.
         request.getSession().setAttribute(REQUEST_ID, requestedWizard);
 
         PageMetadata pageMetadata = requestedWizard.getCurrentPage().getMetadata();
 
         //
         //Add next/finish/back links.
         //
         Link l = pageMetadata.getNext();
         if ((l != null) && (l instanceof ExpressoLink)) {
             response.add(((ExpressoLink) l).getTransition());
         }
 
         l = pageMetadata.getFinish();
         if ((l != null) && (l instanceof ExpressoLink)) {
             response.add(((ExpressoLink) l).getTransition());
         }
 
         l = pageMetadata.getPrevious();
         if ((l != null) && (l instanceof ExpressoLink)) {
             Transition previous = ((ExpressoLink) l).getTransition();
             previous.addParam(WizardController.WIZ_DATA_ID, request.getParameter(WizardController.WIZ_DATA_ID));
             response.add(previous);
         }
 
         //Add the wizard input
         addWizardInput(response, requestedWizard, pageMetadata);
 
         //Set the custom view if needed.
         if (pageMetadata.getViewId() != null) {
             response.setStyle(pageMetadata.getViewId());
         }
 
         //Add Page Numbers if available.
         addPageNumberForSequentialWizards(requestedWizard, response);
 
         // this is an interesting hack -- adding an output with a morebot-recognized
         // error message on it, just in case the JSP is not found, and this message
         // goes throught the expresso 'default' renderer, which puts Output content on screen
         response.add(new Output("morebot protection internal output", "Sorry, an error has occured  "
                 + "Expresso Default Page Has Been Displayed. Check struts configurations."));
     }
 
 
     /***
      * Run the finish state.
      *
      * @param request  the <code>ExpressoRequest</code> object
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException    upon error
      * @throws NonHandleableException upon fatal error
      */
     protected void runFinishState(final ExpressoRequest request,
                                   final ExpressoResponse response) throws ControllerException, NonHandleableException {
 
         try {
             Wizard wiz = getCurrentWizard(request);
             if (wiz == null) {
                 response.addError("We're sorry, but your session has expired.  Please re-run the wizard");
                 Transition cancel = getCancelTransition();
                 cancel.executeTransition(request, response);
                 return;
 
             }
 
             String data = request.getParameter(WIZ_DATA_ID);
 
             if (this.hasNoDataEntryAndShould(data, wiz.getCurrentPage())) {
                 this.handleNoEntryErrorInPage(request, response);
                 return;
             }
 
             WizardPage currentPage = wiz.getCurrentPage();
             Map finishParameters = new HashMap();
             this.addOnFinishWizardParameters(request, response, finishParameters);
             Object result = wiz.processFinish(currentPage, data, finishParameters);
             if (currentPage.getPageErrors() == null || currentPage.getPageErrors().isEmpty()) {
                 request.getSession().setAttribute(WIZ_RESULT_ID, result);
                 releaseWizard(request, wiz);
                 afterFinishState(request, response);
             } else {
                 //Don't release the page if there were errors.
                 transferPageErrorsToRequest(currentPage, response);
                 transition(DISPLAY_STATE, request, response);
             }
         } catch (WizardException ex) {
             throw new ControllerException("Error going to previous page", ex);
         }
     }
 
     protected void addOnFinishWizardParameters(final ExpressoRequest request,
                                                final ExpressoResponse response,
                                                final Map parameterMap) {
 
     }
 
     /***
      * Template method.  Once the wizard is released and processing is finished
      * what do we do?
      *
      * @param request  ExpressoRequest Expresso Request object
      * @param response ExpressoResponse ExpressoResponse object
      * @throws ControllerException upon errors.
      */
     protected void afterFinishState(final ExpressoRequest request, final ExpressoResponse response) throws
             ControllerException {
         transition(DISPLAY_STATE, request, response);
     }
 
     /***
      * Removes the wizard resources from the session.
      *
      * @param request ExpressoRequest the ExpressoRequest object.
      * @param wiz     Wizard the Wizard to release.
      * @throws ControllerException upon session removal error.
      * @throws WizardException     upon wizard destruction error.
      */
     protected void releaseWizard(final ExpressoRequest request, final Wizard wiz) throws ControllerException,
             WizardException {
         wiz.destroy();
 
         //Remove the wizard from session and put it
         //in the request so the JSP pages can get the data from the
         //wizard, and then we're done with it.
         request.getSession().removePersistentAttribute(this.getSessionKey(request.getDataContext(),
                 wiz.getId().toString()));
 
         request.getSession().setAttribute(
                 getSessionKey(request.getDataContext(), wiz.getId().toString()),
                 wiz);
     }
 
     /***
      * Runs the next state.  This fucntion checks for input and transitions
      * to the display state after invoking the wizard's 'next' function if there
      * were not errors.
      *
      * @param request  the <code>ExpressoRequest</code> object
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException    upon error
      * @throws NonHandleableException upon fatal error
      */
     protected void runNextState(final ExpressoRequest request,
                                 final ExpressoResponse response) throws ControllerException, NonHandleableException {
         try {
             Wizard wiz = getCurrentWizard(request);
             if (wiz == null) {
                 response.addError("We're sorry, but your session has expired.  Please re-run the wizard");
                 Transition cancel = getCancelTransition();
                 cancel.executeTransition(request, response);
                 return;
             }
 
             //Verify that data has been entered.
             WizardPage currentPage = getCurrentPage(request, wiz);
 
             //At the time of the writing of this comment, data can be
             //either a list or Strings -- of course, other possibilities
             //exist.
             Serializable data = extractPostedWizardData(request);
 
             boolean errorInPage = false;
             errorInPage = hasNoDataEntryAndShould(data, currentPage);
 
             if (errorInPage) {
                 handleNoEntryErrorInPage(request, response);
                 return;
             }
 
             wiz.next(currentPage, data);
 
             //Check for errors on the page.
             transferPageErrorsToRequest(currentPage, response);
             transition(DISPLAY_STATE, request, response);
         } catch (WizardException ex) {
             throw new ControllerException("Error going to previous page", ex);
         }
     }
 
     private void transferPageErrorsToRequest(WizardPage currentPage, final ExpressoResponse response) throws
             ControllerException {
         ErrorCollection ec = currentPage.getPageErrors();
         if (ec != null && ec.size() > 0) {
             response.saveErrors(ec);
             //Clear errors associated with the page
             //since we've handled them now.
             currentPage.removeErrors();
         }
     }
 
     /***
      * Template Method, override in your derived classes if desired.  No matter
      * what, it tries to extract WIZ_DATA_ID.  Then It appends _1, _2, _3, etc
      * until it doesn't find any new parameters.  If it finds more than one
      * value it returns a Collection, if not, it will return a string.  Derived
      * classes, of course, may return other collections depending on the
      * wizard.
      *
      * @param request ExpressoRequest
      * @return Serializable may be null if the data is not found or incomplete.
      */
     protected Serializable extractPostedWizardData(final ExpressoRequest request) {
         String data = request.getParameter(WIZ_DATA_ID);
 
         //If we found at least the one data, then check for more.
         if (data != null) {
 
             //Return value-- lazily constructed.
             ArrayList returnCollection = null;
 
             //Current parameter counter.
             int paramCounter = 1;
 
             //The result of the last extract.
             String extractedData = null;
 
             //
             //Keep going for WIZ_DATA_ID + "_1", WIZ_DATA)DI+ "_2"
             //until we don't hit anything.
             //
             do {
                 extractedData = request.getParameter(WIZ_DATA_ID + "_" + paramCounter);
                 if (extractedData != null) {
                     if (returnCollection == null) {
                         returnCollection = new ArrayList();
                         returnCollection.add(data);
                     }
 
                     returnCollection.add(extractedData);
                 }
                 paramCounter++;
             } while (extractedData != null);
 
             //If we ended up building an arraylist, then return the list.
             if (returnCollection != null) {
                 return returnCollection;
             } else {
                 //Otherwise, return the original single data point we extracted.
                 return data;
             }
         }
         return data;
     }
 
     /***
      * Method that handles no-data entry if pages that should have occurred.
      *
      * @param request  ExpressoRequest
      * @param response ExpressoResponse
      * @throws NonHandleableException upon transition error.
      * @throws ControllerException    upon error in substate (Usually Display)
      */
     protected void handleNoEntryErrorInPage(final ExpressoRequest request, final ExpressoResponse response) throws
             NonHandleableException,
             ControllerException {
         ErrorCollection ec = request.getErrorCollection();
         if (ec == null) {
             ec = new ErrorCollection();
         }
 
         ec.addError("Please enter a value for this step.");
         response.saveErrors(ec);
         transition(DISPLAY_STATE, request, response);
     }
 
     /***
      * Function that allows for consistent checking for whether data was
      * entered.  In this case it checks for null values, zero length strings,
      * or zero size collections.
      *
      * @param data        String
      * @param currentPage WizardPage
      * @return boolean
      */
     protected boolean hasNoDataEntryAndShould(final Object data, final WizardPage currentPage) {
         boolean errorInPage = false;
 
         if (currentPage.getMetadata().isHasEntry() && currentPage.getMetadata().isEntryRequired()) {
             if (data == null) {
                 errorInPage = true;
             } else if ((data instanceof String) && ((String) data).trim().length() == 0) {
                 errorInPage = true;
             } else if ((data instanceof Collection) && ((Collection) data).size() == 0) {
                 errorInPage = true;
             }
         }
         return errorInPage;
     }
 
     /***
      * Runs the begin state.
      *
      * @param request  the <code>ExpressoRequest</code> object
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException    upon error
      * @throws NonHandleableException upon fatal error
      */
     protected void runPreviousState(final ExpressoRequest request, final ExpressoResponse response) throws
             ControllerException, WizardException {
         Wizard wiz = getCurrentWizard(request);
 
         if (checkSessionExpired(request, response, wiz)) {
             return;
         }
 
         wiz.previous();
         transition(DISPLAY_STATE, request, response);
     }
 
     private boolean checkSessionExpired(ExpressoRequest request, ExpressoResponse response,
                                         Wizard wiz) throws NonHandleableException, ControllerException {
         if (wiz == null) {
             response.addError("We're sorry, but your session has expired.  Please re-run the wizard");
             Transition cancel = getCancelTransition();
             cancel.executeTransition(request, response);
             return true;
         } else {
             return false;
         }
     }
 
 
     /***
      * Runs the state that jumps the wizard backwards to some sort of previous page.
      *
      * @param request  the <code>ExpressoRequest</code> object
      * @param response the <code>ExpressoResponse</code> object.
      * @throws ControllerException upon error
      */
     protected void runJumpBackwardsState(final ExpressoRequest request, final ExpressoResponse response) throws
             ControllerException {
         Wizard wiz = getCurrentWizard(request);
 
         if (checkSessionExpired(request, response, wiz)) {
             return;
         }
 
 
         String pageId = request.getParameter(WIZ_PAGE_PARAMETER);
         if (pageId == null || pageId.length() == 0) {
             throw new ControllerException(
                     "Parameter " + WIZ_PAGE_PARAMETER + " is required to jump backwards in the wizard.");
         }
 
         wiz.backupToPage(pageId);
         transition(DISPLAY_STATE, request, response);
     }
 
 
     /***
      * Adds the wizard page input.  Template method to allow overriding based
      * on
      *
      * @param response ExpressoResponse
      * @param wiz      Wizard
      * @param wp       PageMetadata
      * @throws ControllerException
      */
     protected void addWizardInput(final ExpressoResponse response, final Wizard wiz,
                                   final PageMetadata wp) throws ControllerException {
         if (wp.isHasEntry()) {
             Input i = new Input();
             i.setName(WIZ_DATA_ID);
             i.setLabel(wp.getDirective());
 
             // @todo why not set Input type? -- A: Type of input varies too much
             //between pages to really tell.  We'd have to modify the API to tie
             //it to a widget of some sort.  Direct JSP manipulation seems
             //to be easier af the moment.  (IMO of course! )  -MR
 
             // if we have data, display it
             if (wiz.getCurrentPage().getMenu() != null && wiz.getCurrentPage().getMenu().length > 0) {
 
                 List v = Arrays.asList(wiz.getCurrentPage().getMenu());
                 i.setValidValues(v);
                 String curVal = (String) wiz.getCurrentPage().getData();
                 if (curVal != null && curVal.length() > 0) {
                     i.setDefaultValue(curVal);
                 }
             }
 
 
             if (wiz.getCurrentPage().getData() instanceof List) {
                 List inputs = (List) wiz.getCurrentPage().getData();
                 int counter = 0;
                 for (Iterator iterator = inputs.iterator(); iterator.hasNext();) {
                     if (counter == 0) {
                         i.setDefaultValue((String) iterator.next());
                         response.add(i);
                     } else {
                         Input nextInput = new Input();
                         nextInput.setName(WIZ_DATA_ID + "_" + counter);
                         nextInput.setDefaultValue((String) iterator.next());
                         response.add(nextInput);
                     }
 
                     counter++;
                 }
             } else {
                 if (wiz.getCurrentPage().getData() != null) {
                     i.setDefaultValue(wiz.getCurrentPage().getData().toString());
                 }
                 response.add(i);
             }
         }
     }
 
     protected void addPageNumberForSequentialWizards(final Wizard wiz, final ExpressoResponse response) throws
             ControllerException {
         //If we have a sequential wizard where we know the exact number
         //of steps that will be taken then we can
         //output the page sequences.
         if (wiz instanceof SequentialWizard) {
             SequentialWizard sequence = (SequentialWizard) wiz;
             response.add(new Output(CURRENT_PAGE_NUM, "" + sequence.getCurrentPageIndex()));
             response.add(new Output(TOTAL_PAGES, "" + sequence.getTotalPages()));
         }
     }
 }