package com.sri.emo.wizard.creation;
   
   import java.io.*;
   import java.util.*;
   
   import com.jcorporate.expresso.core.controller.*;
   import com.jcorporate.expresso.core.dataobjects.*;
   import com.jcorporate.expresso.core.db.*;
   import com.jcorporate.expresso.core.db.exception.*;
  import com.jcorporate.expresso.core.registry.*;
  import com.sri.common.util.*;
  import com.sri.emo.dbobj.*;
  import com.sri.emo.wizard.*;
  import com.sri.emo.wizard.defaults.*;
  import com.sri.emo.wizard.creation.model.*;
  
  /***
   * A creation wizard, as originally copied from Completion wizard with
   * some modifications done to allow for the initialization page to be inserted
   * For the completion wizard pages, ids are java.lang.Integer types with values
   * <= 0 are special pages.  Any values >0 represent a corresponding Part.
   * Developers should use isPartsPage() for interpretation of this, however.
   *
   * @author Michael Rimov
   *
   */
  public class EmoCreationWizardOld extends SequentialWizard {
  
      /***
       * Constant for the title page id.
       */
      public static final String TITLE_PAGE_ID = "-2";
  
      /***
       * Constant for the initialization page id
       */
      public static final String INITIALIZATION_PAGE_ID = "-3";
  
      /***
       * Constant for the last page (where 'finish' appears) id.
       */
      public static final String FINAL_PAGE_ID = "-1";
  
  
      /***
       * Underlying completion data bean. This object is not serialized due
       * to space considerations since it is stateless for the given wizard.
       * However, for saving state and reconsistuting it via the <tt>Memento</tt>
       * pattern, then it is set/reset during that phase.
       */
      private transient CreationBean completionBean;
  
  
      /***
       * Constructs an emo completion wizard.
       *
       * @param wizMonitor WizardMonitor
       * @param steps      WizardPage[]
       */
      public EmoCreationWizardOld(final WizardMonitor wizMonitor, final WizardPage[] steps) {
          super(wizMonitor, steps);
      }
  
  
      /***
       * Override of Sequential's onNextPage to allow for validation of values
       * as they're entered.
       *
       * @param previousPage     WizardPage
       * @param nextPage         The next page that will be invoked.  A 'lookahead' so
       *                         to speak.
       * @param previousPageData Serializable
       * @return boolean true if the wizard can proceed, false if the previous
       *         page needs to be displayed with validation errors.
       * @throws WizardException upon error.
       * @throws AssertionError  if the previouspage id is the final page.
       */
      protected boolean onNextPage(final WizardPage previousPage, final WizardPage nextPage,
                                   final Serializable previousPageData) throws WizardException, AssertionError {
  
          Integer previousPageId = (Integer) previousPage.getId();
          assert previousPageId != null;
          if(isInitializationPage(previousPageId)){
              return validateInitializationPageData(previousPage, previousPageData);
          }
          //If we have a part page
          else if (isPartsPage(previousPageId)) {
              //validate part entry.
              return validatePartPageData(previousPage, previousPageData);
              //Or if we have a title page.
          } else if (TITLE_PAGE_ID.equals(previousPageId.toString())) {
              //Then return true/
              return true;
  
              //Or if we have the final page.
          } else if (FINAL_PAGE_ID.equals(previousPageId.toString())) {
              assert false:"Final page should not have gotten 'onNext' event";
              throw new WizardException("Internal Error: received 'next' where the previous page "
                      + "was the final page.  Wizard is incorrectly constructed.");
         } else {
 
             //Consider if the next page is a multi attribute page, then the current
             //date must be the number of steps.
             if (nextPage.getMetadata() instanceof MultiEntryMetadata) {
                 boolean returnValue = validatePreMultiAttributesPage(previousPage, nextPage, previousPageData);
                 returnValue &= super.onNextPage(previousPage, nextPage, previousPageData);
                 return returnValue;
 //                if (returnValue && ((MultiEntryWizardPage)nextPage).getNumEntries() == 0) {
 //                    return returnValue
 //                }
             }
 
             //
             //We don't have to do anything to make everything work.
             //
         }
 
         //
         //Super class will return false if the page itself has errors.
         //
         return super.onNextPage(previousPage, nextPage, previousPageData);
     }
 
     /***
      * validateInitializationPageData
      *
      * @param previousPage WizardPage
      * @param previousPageData Serializable
      * @return boolean
      */
     private boolean validateInitializationPageData(WizardPage src,
             Serializable previousPageData) {
         List list = (List)previousPageData;
         String title  = (String) list.get(0);
         if(title == null || title.length() == 0){
             src.addError("Please enter a title.");
             return false;
         }
             try {
                 Node testNode = new Node(RequestRegistry.getUser());
                 testNode.setNodeTitle(title);
                 System.out.println("node type = " + testNode.getNodeType());
                 if (testNode.find()) {
                     src.addError(
                             "Title is already in use; please choose another.");
                     return false;
                 }
             } catch (DBException ex1) {
                 src.addError(ex1.getMessage());
                 return false;
             }
         try {
             completionBean.getCurrentNode().set(Node.NODE_TITLE, title);
         } catch (DataException ex) {
             src.addError(ex.getMessage());
             return false;
         }
         return true;
     }
 
     /***
      * isInitializationPage
      *
      * @param previousPageId Integer
      * @return boolean
      */
     private boolean isInitializationPage(Integer previousPageId) {
 
         Integer i = new Integer(INITIALIZATION_PAGE_ID);
         return i.equals(previousPageId);
     }
 
 
     private boolean validatePreMultiAttributesPage(final WizardPage previousPage, final WizardPage nextPage,
                                                    final Serializable previousPageData) {
 //        if (previousPageData == null) {
 //            previousPage.addError("You must enter a value for this page");
 //            return false;
 //        }
 
         MultiEntryWizardPage multiNextPage = (MultiEntryWizardPage) nextPage;
         MultiEntryMetadata nextPageMetadata = (MultiEntryMetadata) nextPage.getMetadata();
 
         int numEntries = 0;
         try {
 
             if (previousPageData == null || ((String) previousPageData).trim().length() == 0) {
                 numEntries = 0;
             } else {
                 numEntries = Integer.parseInt((String) previousPageData);
             }
         } catch (NumberFormatException ex) {
             previousPage.addError("You must enter a valid number for this page");
             return false;
         }
 
         boolean hadError = false;
 //        if (nextPageMetadata.getMinEntries() != null
 //                && numEntries < nextPageMetadata.getMinEntries().intValue()) {
 //            previousPage.addError(
 //                "Too few. You must enter a value greater than or equal to the minimum number of entries: "
 //                + nextPageMetadata.getMinEntries());
 //            hadError = true;
 //        }
 
         if (nextPageMetadata.getMaxEntries() != null
                 && numEntries > nextPageMetadata.getMaxEntries().intValue()) {
             previousPage.addError(
                     "Too many. You must enter a value less than or equal to the maximum number of entries: "
                             + nextPageMetadata.getMaxEntries());
             hadError = true;
         }
 
         if (hadError) {
             return false;
         }
 
         multiNextPage.setNumEntries(numEntries);
         return true;
     }
 
     /***
      * Constant for the minimum possible part number.  Anything else is a
      * 'special page' of some sort.
      */
     private static final int MIN_PARTS_NUMBER = 0;
 
     /***
      * Overridden target node id.  This must be explicitly set by the
      * wizard controller. Otherwise we use the completion bean.
      */
 //    private String targetNodeId;
 
     /***
      * Checks if the given page Id indicates it is a
      * 'Parts' page.
      *
      * @param pageId Integer
      * @return boolean
      */
     protected boolean isPartsPage(final Integer pageId) {
         assert pageId != null;
 
         return pageId.intValue() >= MIN_PARTS_NUMBER;
     }
 
     /***
      * @param src         WizardPage
      * @param enteredData Serializable
      * @return boolean true if the data was validated.
      * @throws WizardException upon error.
      */
     private boolean validatePartPageData(final WizardPage src, final Serializable enteredData) throws WizardException {
         int partId = ((Integer) src.getId()).intValue();
 
         try {
             Part onePart = new Part();
             onePart.setPartId(partId);
             onePart.retrieve();
             //If single valued, then validate it.
 //            * @todo Finish here when Part has custom handler.
             if (onePart.isSingleValued()) {
                 if (enteredData == null) {
                     src.addError("Please enter a value for this page.");
                     return false;
                 }
             }
         } catch (DBRecordNotFoundException ex) {
             throw new WizardException("Could not find part of id: " + partId
                     + " perhaps it was deleted by someone else?", ex);
         } catch (Throwable ex) {
             throw new WizardException("Error processing page for part id: " + partId, ex);
         }
 
         return true;
     }
 
 
     /***
      * This version returns a <tt>Node<tt> instance if one has
      * been successfully created.
      * <p>{@inheritDoc}</p>
      *
      * @param src             WizardPage the source of the event.
      * @param data            This class expects a string for the data.
      * @param additonalParams anything that the underlying wizard needs. The
      *                        values are set by the Application Controller.
      * @return An instance of a {@link com.sri.emo.dbobj.Node} object
      *         that represents the node the Decision Matrix returned or null if
      *         there was no equivilant data found.
      * @throws WizardException upon error.
      */
     public Object processFinish(final WizardPage src, final Serializable data,
                                 final Map additonalParams) throws WizardException {
         super.processFinish(src, data, additonalParams);
 
         assert src != null;
 
         Node node = getCompletionBean().getCurrentNode();
         System.out.println("processFinish : " + node.toDebugString());
         try {
             if(!verifyRequiredAttributes(src)){
                 return null;
             }
             copyReqDataIntoTargetNode(node);
             node.add();
             copyDataIntoTargetNode(node);
         } catch (DBException ex) {
             src.addError(ex.getMessage());
             throw new WizardException(ex);
         } catch (Exception e) {
             src.addError(e.getMessage());
 
             if (e instanceof RuntimeException) {
                 throw (RuntimeException) e;
             } else {
                 throw new WizardException(e);
             }
         }
         // only save data if we have 'dynamic target', i.e., specified by param at beginning of
         // web call, as opposed to 'model' target ID, which was used to design this wizard
 //        if (this.isDynamicTarget()) {
 //            try {
 //                node = new Node();
 //                node.setNodeId(getTargetNodeId());
 //                node.retrieve();
 //
 //                copyDataIntoTargetNode(node);
 //
 //            } catch (DBRecordNotFoundException ex) {
 //                String message = "Could not find node of id: " + getTargetNodeId();
 //                src.addError(message + " with error: " + ex.getMessage());
 //                throw new WizardException(message, ex);
 //            } catch (Exception e) {
 //                src.addError(e.getMessage());
 //
 //                if (e instanceof RuntimeException) {
 //                    throw (RuntimeException) e;
 //                } else {
 //                    throw new WizardException(e);
 //                }
 //            }
 //        } else {
 //            src.addError("Cannot save to source of wizard design; expected a different (cloned?) destination");
 //        }
 
         return node;
     }
 
     /***
      * verifyRequiredAttributes
      */
     private boolean verifyRequiredAttributes(WizardPage src) throws DBException,
             NumberFormatException, WizardException {
         CreationBean completionBean = this.getCompletionBean();
 
         boolean requiredFilled = true;
 
         for (Iterator partsIterator = completionBean.getCompletionParts().iterator(); partsIterator.hasNext();) {
             CreationPartsBean onePartBean = (CreationPartsBean) partsIterator.next();
             //Skip parts beans that have no data.
             if (onePartBean.getFieldCompletion() == FieldCompletion.NOT_INCLUDED) {
                 continue;
             }
 
             Part currentPart = onePartBean.getPart();
 //            System.out.println("working on part type " + currentPart.getPartType());
 
             //Retrieves the data value for that part.
             Object wizardData = this.getAllData().get(new Integer(currentPart.getId()));
             if(onePartBean.isRequired()){
                 System.out.println(currentPart.getPartType() + " is required");
                 System.out.println("data = '" + wizardData + "' class:"+wizardData.getClass());
                 if(wizardData == null){
                     src.addError(currentPart.getPartLabel() + " was marked as a required field, but has not been set, please fix.");
                     requiredFilled = false;
                 }
                 else if(wizardData instanceof Collection &&
                    ((Collection)wizardData).size() == 0){
                     src.addError(currentPart.getPartLabel() + " was marked as a required field, but has not been set, please fix.");
                     requiredFilled = false;
                 }
             }
         }
         return requiredFilled;
     }
 
     /***
      * copyReqDataIntoTargetNode
      *
      * @param node Node
      */
     private void copyReqDataIntoTargetNode(Node node) throws DataException {
         Map allData = this.getAllData();
         System.out.println("All Data = " +
                            StringUtil.toString(allData.keySet().iterator()));
 //        System.out.println("init page class = " + allData.get(new Integer(EmoTemplateWizard.
 //                INITIALIZATION_PAGE_ID)).getClass());
         List list = (List)allData.get(new Integer(EmoCreationWizardOld.
                 INITIALIZATION_PAGE_ID));
         String title  = (String) list.get(0);
         String summary = (String) list.get(1);
         String comment = (String) list.get(2);
         System.out.println("found title as '" + title + "'");
         node.set(Node.NODE_TITLE, title);
         node.set(Node.NODE_ANNOTATION, summary);
         node.set(Node.NODE_COMMENT, comment);
     }
 
 
     /***
      * Returns true if the dynamic target has been specified.
      *
      * @return boolean
      */
     protected boolean isDynamicTarget() {
         //changed by rich
         //always dynamic target?
         return true;
 //        if (this.getCompletionBean().getTargetId().intValue() == Integer.parseInt(this.getTargetNodeId())) {
 //            return false;
 //        } else {
 //            return true;
 //        }
     }
 
     /***
      * Copies the wizard data into the given node.
      *
      * @param target Node The node that is set to receive all the data.
      * @throws Exception upon consturction error, and database errors.
      */
     private void copyDataIntoTargetNode(final Node target) throws Exception {
         CreationBean completionBean = this.getCompletionBean();
 
 
 
         for (Iterator partsIterator = completionBean.getCompletionParts().iterator(); partsIterator.hasNext();) {
             CreationPartsBean onePartBean = (CreationPartsBean) partsIterator.next();
             //Skip parts beans that have no data.
             if (onePartBean.getFieldCompletion() == FieldCompletion.NOT_INCLUDED) {
                 continue;
             }
 
             Part currentPart = onePartBean.getPart();
             System.out.println("working on part type " + currentPart.getPartType());
 
             //Retrieves the data value for that part.
             Object wizardData = this.getAllData().get(new Integer(currentPart.getId()));
 
             if (currentPart.isHaveCustomHandler()) {
 
                 CustomPartHandlerMetadata meta = (CustomPartHandlerMetadata) getCurrentPage().getMetadata();
                 IPartHandler handler = meta.getCustomHandler();
                 List inputs = meta.getInputList();
 
                 for (Iterator iterator = inputs.iterator(); iterator.hasNext();) {
                     Input input = (Input) iterator.next();
                     handler.saveInput(input);
                 }
 
             } else if (currentPart.isOwnedAttribute()) {
                 //TODO Transaction Me
                 if (currentPart.isMultipleAllowed()) {
                     List valueList = (List) wizardData;
 //                    assert valueList != null:"Got null values from wizard page: " + onePartBean.toString();
                     if (valueList == null) {
                         valueList = new ArrayList(0);
                     }
 
                     Attribute[] attributes = target.getAttributes(currentPart.getPartType());
                     //Don't worry about existing attributes since the wizard ones replace
                     //whatever is there, so we go from there.
                     for (int attributeIndex = 0; attributeIndex < attributes.length; attributeIndex++) {
                         attributes[attributeIndex].delete(true);
                     }
 
                     for (Iterator pageValuesIterator = valueList.iterator(); pageValuesIterator.hasNext();) {
                         String onePageValue = (String) pageValuesIterator.next();
                         System.out.println("adding attribute " + currentPart.getPartType() + " as " + onePageValue);
                         target.addAttribute(currentPart.getPartType(), onePageValue, "");
                     }
 
                 } else {
 //                    System.out.println("
                     Attribute[] attributes = target.getAttributes(currentPart.getPartType());
                     System.out.println("attribute.length = " + attributes.length);
                     for (int i = 0; i < attributes.length; i++) {
                         System.out.println(attributes[i].getAttribValue());
                     }
 //                    System.out.println(StringUtil.toString(attributes));
                     assert attributes.length == 0 || attributes.length == 1:
                             "Expected only zero or one attributes returned for single attribute";
 
                     if (attributes.length == 0) {
                         if (wizardData != null) {
                             target.addAttribute(currentPart.getPartType(), wizardData.toString(), "");
                         }
                     } else {
                         if (wizardData == null) {
                             target.removeAttribute(attributes[0].getAttribId());
                         } else {
                             target.updateAttribute(attributes[0].getAttribId(), wizardData.toString(), "");
                         }
                     }
                 }
 
             } else if (currentPart.isSharedNodeAttrib()) {
                 //TODO Transaction Me
                 assert wizardData instanceof Set;
 
                 Set allRelationsParameterMap = (Set) wizardData;
                 if (allRelationsParameterMap == null) {
                     allRelationsParameterMap = new HashSet(0);
                 }
                 String[] allRelationIds = (String[]) allRelationsParameterMap.toArray(
                         new String[allRelationsParameterMap.size()]);
 
                 target.updateNodeRelations(currentPart.getPartType(), currentPart.getNodeRelation(), allRelationIds);
             }
 
         }
     }
 
 // commented out by rich, we use the node within the templatebean instead
 //of a target node within the DB
 //    public String getTargetNodeId() {
 //        assert completionBean != null;
 //
 //        if (targetNodeId == null) {
 //            return this.completionBean.getTargetId().toString();
 //        } else {
 //            return targetNodeId;
 //        }
 //    }
 
 //    public Node getTargetNode() throws WizardException {
 //        try {
 //            Node n = new Node();
 //            n.setNodeId(this.getTargetNodeId());
 //            n.retrieve();
 //            return n;
 //        } catch (DBRecordNotFoundException ex) {
 //            throw new WizardException("Could no longer find template of id: " + getTargetNodeId()
 //                    + " perhaps someone else deleted it?");
 //        } catch (DBException ex) {
 //            throw new WizardException("Error querying database", ex);
 //        }
 //    }
 
     /***
      * Sets the underlying completion bean.
      *
      * @param completionBean CompletionBean
      */
     public void setCompletionBean(final CreationBean completionBean) {
         this.completionBean = completionBean;
     }
 
 //    public void setTargetNodeId(final String targetNodeId) {
 //        this.targetNodeId = targetNodeId;
 //    }
 
     public CreationBean getCompletionBean() {
         return completionBean;
     }
 
 
 }