/**
    * Copyright 2005-2014 The Kuali Foundation
    *
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    *
   * 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.
   */
  package org.kuali.rice.krad.uif.util;
  
  import org.apache.commons.lang.StringUtils;
  import org.kuali.rice.krad.datadictionary.state.StateMapping;
  import org.kuali.rice.krad.datadictionary.validation.constraint.BaseConstraint;
  import org.kuali.rice.krad.datadictionary.validation.constraint.CaseConstraint;
  import org.kuali.rice.krad.datadictionary.validation.constraint.Constraint;
  import org.kuali.rice.krad.datadictionary.validation.constraint.MustOccurConstraint;
  import org.kuali.rice.krad.datadictionary.validation.constraint.PrerequisiteConstraint;
  import org.kuali.rice.krad.datadictionary.validation.constraint.SimpleConstraint;
  import org.kuali.rice.krad.datadictionary.validation.constraint.ValidCharactersConstraint;
  import org.kuali.rice.krad.datadictionary.validation.constraint.WhenConstraint;
  import org.kuali.rice.krad.messages.MessageService;
  import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
  import org.kuali.rice.krad.uif.UifConstants;
  import org.kuali.rice.krad.uif.control.TextControl;
  import org.kuali.rice.krad.uif.field.InputField;
  import org.kuali.rice.krad.uif.view.FormView;
  import org.kuali.rice.krad.uif.view.View;
  
  import java.text.MessageFormat;
  import java.util.ArrayList;
  import java.util.EnumSet;
  import java.util.List;
  
  /**
   * Contains all the methods necessary for generating the js required to perform validation client side.
   * The processAndApplyConstraints(InputField field, View view) is the key method of this class used by
   * InputField to setup its client side validation mechanisms.
   *
   * Methods now take into account state based validation and states on constraints.
   *
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public class ClientValidationUtils {
      // used to give validation methods unique signatures
      private static int methodKey = 0;
  
      // list used to temporarily store mustOccurs field names for the error
      // message
      private static List<List<String>> mustOccursPathNames;
  
      public static final String LABEL_KEY_SPLIT_PATTERN = ",";
  
      public static final String PREREQ_MSG_KEY = "prerequisite";
      public static final String POSTREQ_MSG_KEY = "postrequisite";
      public static final String MUSTOCCURS_MSG_KEY = "mustOccurs";
      public static final String MUSTOCCURS_MSG_EQUAL_KEY = "mustOccursEqualMinMax";
      public static final String GENERIC_FIELD_MSG_KEY = "general.genericFieldName";
  
      public static final String ALL_MSG_KEY = "general.all";
      public static final String ATMOST_MSG_KEY = "general.atMost";
      public static final String AND_MSG_KEY = "general.and";
      public static final String OR_MSG_KEY = "general.or";
  
      // enum representing names of rules provided by the jQuery plugin
      public static enum ValidationMessageKeys {
          REQUIRED("required"),
          MIN_EXCLUSIVE("minExclusive"),
          MAX_INCLUSIVE("maxInclusive"),
          MIN_LENGTH("minLengthConditional"),
          MAX_LENGTH("maxLengthConditional");
  
          private ValidationMessageKeys(String name) {
              this.name = name;
          }
  
          private final String name;
  
          @Override
          public String toString() {
              return name;
          }
  
          public static boolean contains(String name) {
              for (ValidationMessageKeys element : EnumSet.allOf(ValidationMessageKeys.class)) {
                  if (element.toString().equalsIgnoreCase(name)) {
                      return true;
                  }
              }
              return false;
          }
      }
  
     /**
      * Returns formatted message text for the given message namespace, component, and key
      *
      * @param namespace - namespace code the message is associated with, if null the default namespace
      * will be used
      * @param componentCode - component code the message is associated with, if null default component
      * code is used
      * @param messageKey - key for the message to retrieve
      * @param params - list of parameters for the message text
      * @return String formatted message text
      */
     public static String generateMessageText(String namespace, String componentCode, String messageKey,
             List<String> params) {
         String message = "NO MESSAGE";
         if (StringUtils.isNotEmpty(messageKey)) {
             message = KRADServiceLocatorWeb.getMessageService().getMessageText(namespace, componentCode, messageKey);
             if (params != null && !params.isEmpty() && StringUtils.isNotEmpty(message)) {
                 message = MessageFormat.format(message, params.toArray());
                 message = MessageStructureUtils.translateStringMessage(message);
             }
         }
 
         if (StringUtils.isEmpty(message)) {
             message = messageKey;
         }
 
         //replace characters that might cause issues with their equivalent html codes
         if (message.contains("\"")) {
             message = message.replace("\"", "&quot;");
         }
         if (message.contains("'")) {
             message = message.replace("'", "&#39;");
         }
         if (message.contains("\\")) {
             message = message.replace("\\", "&#92;");
         }
 
         return message;
     }
 
     /**
      * Generates the js object used to override all default messages for validator jquery plugin with
      * custom messages retrieved from the message service
      *
      * @return String script for message override
      */
     public static String generateValidatorMessagesOption() {
         MessageService messageService = KRADServiceLocatorWeb.getMessageService();
 
         String mOption = "";
         String keyValuePairs = "";
         for (ValidationMessageKeys element : EnumSet.allOf(ValidationMessageKeys.class)) {
             String key = element.toString();
             String message = messageService.getMessageText(UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + key);
 
             if (StringUtils.isNotEmpty(message)) {
                 message = MessageStructureUtils.translateStringMessage(message);
                 keyValuePairs = keyValuePairs + "\n" + key + ": '" + message + "',";
             }
         }
 
         keyValuePairs = StringUtils.removeEnd(keyValuePairs, ",");
         if (StringUtils.isNotEmpty(keyValuePairs)) {
             mOption = "{" + keyValuePairs + "}";
         }
 
         return mOption;
     }
 
     /**
      * Returns the add method jquery validator call for the regular expression
      * stored in validCharactersConstraint.
      *
      * @param validCharactersConstraint
      * @return js validator.addMethod script
      */
     public static String getRegexMethod(InputField field, ValidCharactersConstraint validCharactersConstraint) {
         String message = generateMessageText(validCharactersConstraint.getMessageNamespaceCode(),
                 validCharactersConstraint.getMessageComponentCode(), validCharactersConstraint.getMessageKey(),
                 validCharactersConstraint.getValidationMessageParams());
         String key = "validChar-" + field.getBindingInfo().getBindingPath() + methodKey;
 
         // replace characters known to cause issues if not escaped
         String regex = validCharactersConstraint.getValue();
         if (regex.contains("\\\\")) {
             regex = regex.replaceAll("\\\\", "\\\\\\\\");
         }
         if (regex.contains("/")) {
             regex = regex.replace("/", "\\/");
         }
 
         return "\njQuery.validator.addMethod(\""
                 + ScriptUtils.escapeName(key)
                 + "\", function(value, element) {\n "
                 + "return this.optional(element) || /"
                 + regex
                 + "/.test(value);"
                 + "}, \""
                 + message
                 + "\");";
     }
 
     /**
      * Returns the add method jquery validator call for the regular expression
      * stored in validCharactersConstraint that explicitly checks a boolean.  Needed because one method
      * accepts params and the other doesn't.
      *
      * @param validCharactersConstraint
      * @return js validator.addMethod script
      */
     public static String getRegexMethodWithBooleanCheck(InputField field,
             ValidCharactersConstraint validCharactersConstraint) {
         String message = generateMessageText(validCharactersConstraint.getMessageNamespaceCode(),
                 validCharactersConstraint.getMessageComponentCode(), validCharactersConstraint.getMessageKey(),
                 validCharactersConstraint.getValidationMessageParams());
         String key = "validChar-" + field.getBindingInfo().getBindingPath() + methodKey;
 
         // replace characters known to cause issues if not escaped
         String regex = validCharactersConstraint.getValue();
         if (regex.contains("\\\\")) {
             regex = regex.replaceAll("\\\\", "\\\\\\\\");
         }
         if (regex.contains("/")) {
             regex = regex.replace("/", "\\/");
         }
 
         return "\njQuery.validator.addMethod(\""
                 + ScriptUtils.escapeName(key)
                 + "\", function(value, element, doCheck) {\n if(doCheck === false){return true;}else{"
                 + "return this.optional(element) || /"
                 + regex
                 + "/.test(value);}"
                 + "}, \""
                 + message
                 + "\");";
     }
 
     /**
      * This method processes a single CaseConstraint. Internally it makes calls
      * to processWhenConstraint for each WhenConstraint that exists in this
      * constraint. It adds a "dependsOn" css class to this field for the field
      * which the CaseConstraint references.
      *
      * @param view
      * @param andedCase the boolean logic to be anded when determining if this case is
      * satisfied (used for nested CaseConstraints)
      */
     public static void processCaseConstraint(InputField field, View view, CaseConstraint constraint, String andedCase,
             String validationState, StateMapping stateMapping) {
         if (constraint.getOperator() == null) {
             constraint.setOperator("equals");
         }
 
         String operator = "==";
         if (constraint.getOperator().equalsIgnoreCase("not_equals") || constraint.getOperator().equalsIgnoreCase(
                 "not_equal")) {
             operator = "!=";
         } else if (constraint.getOperator().equalsIgnoreCase("greater_than_equal")) {
             operator = ">=";
         } else if (constraint.getOperator().equalsIgnoreCase("less_than_equal")) {
             operator = "<=";
         } else if (constraint.getOperator().equalsIgnoreCase("greater_than")) {
             operator = ">";
         } else if (constraint.getOperator().equalsIgnoreCase("less_than")) {
             operator = "<";
         } else if (constraint.getOperator().equalsIgnoreCase("has_value")) {
             operator = "";
         }
         // add more operator types here if more are supported later
 
         field.getControl().addStyleClass("dependsOn-" + ScriptUtils.escapeName(constraint.getPropertyName()));
 
         if (constraint.getWhenConstraint() != null && !constraint.getWhenConstraint().isEmpty()) {
             //String fieldPath = field.getBindingInfo().getBindingObjectPath() + "." + constraint.getPropertyName();
             String fieldPath = constraint.getPropertyName();
             for (WhenConstraint wc : constraint.getWhenConstraint()) {
                 wc = ConstraintStateUtils.getApplicableConstraint(wc, validationState, stateMapping);
                 if (wc != null) {
                     processWhenConstraint(field, view, constraint, wc, ScriptUtils.escapeName(fieldPath), operator,
                             andedCase, validationState, stateMapping);
                 }
             }
         }
     }
 
     /**
      * This method processes the WhenConstraint passed in. The when constraint
      * is used to create a boolean statement to determine if the constraint will
      * be applied. The necessary rules/methods for applying this constraint are
      * created in the createRule call. Note the use of the use of coerceValue js
      * function call.
      *
      * @param view
      * @param wc
      * @param fieldPath
      * @param operator
      * @param andedCase
      */
     private static void processWhenConstraint(InputField field, View view, CaseConstraint caseConstraint,
             WhenConstraint wc, String fieldPath, String operator, String andedCase, String validationState,
             StateMapping stateMapping) {
         String ruleString = "";
         // prerequisite constraint
 
         String booleanStatement = "";
         if (wc.getValues() != null) {
 
             String caseStr = "";
             if (!caseConstraint.isCaseSensitive()) {
                 caseStr = ".toUpperCase()";
             }
             for (int i = 0; i < wc.getValues().size(); i++) {
                 if (operator.isEmpty()) {
                     // has_value case
                     if (wc.getValues().get(i) instanceof String && ((String) wc.getValues().get(i)).equalsIgnoreCase(
                             "false")) {
                         booleanStatement = booleanStatement + "(coerceValue('" + fieldPath + "') == '')";
                     } else {
                         booleanStatement = booleanStatement + "(coerceValue('" + fieldPath + "') != '')";
                     }
                 } else {
                     // everything else
                     booleanStatement = booleanStatement
                             + "(coerceValue('"
                             + fieldPath
                             + "')"
                             + caseStr
                             + " "
                             + operator
                             + " \""
                             + wc.getValues().get(i)
                             + "\""
                             + caseStr
                             + ")";
                 }
                 if ((i + 1) != wc.getValues().size()) {
                     booleanStatement = booleanStatement + " || ";
                 }
             }
 
         }
 
         if (andedCase != null) {
             booleanStatement = "(" + booleanStatement + ") && (" + andedCase + ")";
         }
 
         if (wc.getConstraint() != null && StringUtils.isNotEmpty(booleanStatement)) {
             Constraint constraint = ConstraintStateUtils.getApplicableConstraint(wc.getConstraint(), validationState,
                     stateMapping);
             if (constraint != null) {
                 ruleString = createRule(field, constraint, booleanStatement, view, validationState, stateMapping);
             }
         }
 
         if (StringUtils.isNotEmpty(ruleString)) {
             addScriptToPage(view, field, ruleString);
         }
     }
 
     /**
      * Adds the script to the view to execute on a jQuery document ready event.
      *
      * @param view
      * @param script
      */
     public static void addScriptToPage(View view, InputField field, String script) {
         String prefixScript = "";
 
         if (field.getOnDocumentReadyScript() != null) {
             prefixScript = field.getOnDocumentReadyScript();
         }
         field.setOnDocumentReadyScript(prefixScript + "\n" + "runValidationScript(function(){" + script + "});");
     }
 
     /**
      * Determines which fields are being evaluated in a boolean statement, so handlers can be
      * attached to them if needed, returns these names in a list.
      *
      * @param statement
      * @return
      */
     private static List<String> parseOutFields(String statement) {
         List<String> fieldNames = new ArrayList<String>();
         String[] splits = StringUtils.splitByWholeSeparator(statement, "coerceValue(");
         for (String s : splits) {
             //must be a coerceValue param and not preceding content from the split, always starts with "'"
             if(!s.startsWith("'")){
                 continue;
             }
 
             s = s.substring(1);
             String fieldName = StringUtils.substringBefore(s, "'");
             //Only add field name once for this condition check
             if(fieldNames.contains(fieldName)){
                 fieldNames.add(fieldName);
             }
 
         }
         return fieldNames;
     }
 
     /**
      * This method takes in a constraint to apply only when the passed in
      * booleanStatement is valid. The method will create the necessary addMethod
      * and addRule jquery validator calls for the rule to be applied to the
      * field when the statement passed in evaluates to true during runtime and
      * this field is being validated. Note the use of custom methods for min/max
      * length/value.
      *
      * @param field the field to apply the generated methods and rules to
      * @param constraint the constraint to be applied when the booleanStatement
      * evaluates to true during validation
      * @param booleanStatement the booleanstatement in js - should return true when the
      * validation rule should be applied
      * @param view
      * @return
      */
     @SuppressWarnings("boxing")
     private static String createRule(InputField field, Constraint constraint, String booleanStatement, View view,
             String validationState, StateMapping stateMapping) {
         String rule = "";
         int constraintCount = 0;
         if (constraint instanceof BaseConstraint && ((BaseConstraint) constraint).getApplyClientSide()) {
             if (constraint instanceof SimpleConstraint) {
                 if (((SimpleConstraint) constraint).getRequired() != null && ((SimpleConstraint) constraint)
                         .getRequired()) {
                     rule = rule + "required: function(element){\nreturn (" + booleanStatement + ");}";
                     //special requiredness indicator handling
                     String showIndicatorScript = "";
                     for (String checkedField : parseOutFields(booleanStatement)) {
                         showIndicatorScript = showIndicatorScript +
                                 "setupShowReqIndicatorCheck('" + checkedField + "', '" + field.getBindingInfo()
                                 .getBindingPath() + "', " + "function(){\nreturn (" + booleanStatement + ");});\n";
                     }
                     addScriptToPage(view, field, showIndicatorScript);
 
                     constraintCount++;
                 }
 
                 if (((SimpleConstraint) constraint).getMinLength() != null) {
                     if (constraintCount > 0) {
                         rule = rule + ",\n";
                     }
                     rule = rule
                             + "minLengthConditional: ["
                             + ((SimpleConstraint) constraint).getMinLength()
                             + ", function(){return "
                             + booleanStatement
                             + ";}]";
                     constraintCount++;
                 }
 
                 if (((SimpleConstraint) constraint).getMaxLength() != null) {
                     if (constraintCount > 0) {
                         rule = rule + ",\n";
                     }
                     rule = rule
                             + "maxLengthConditional: ["
                             + ((SimpleConstraint) constraint).getMaxLength()
                             + ", function(){return "
                             + booleanStatement
                             + ";}]";
                     constraintCount++;
                 }
 
                 if (((SimpleConstraint) constraint).getExclusiveMin() != null) {
                     if (constraintCount > 0) {
                         rule = rule + ",\n";
                     }
                     rule = rule
                             + "minExclusive: ["
                             + ((SimpleConstraint) constraint).getExclusiveMin()
                             + ", function(){return "
                             + booleanStatement
                             + ";}]";
                     constraintCount++;
                 }
 
                 if (((SimpleConstraint) constraint).getInclusiveMax() != null) {
                     if (constraintCount > 0) {
                         rule = rule + ",\n";
                     }
                     rule = rule
                             + "maxInclusive: ["
                             + ((SimpleConstraint) constraint).getInclusiveMax()
                             + ", function(){return "
                             + booleanStatement
                             + ";}]";
                     constraintCount++;
                 }
 
                 rule = "jQuery('[name=\""
                         + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                         + "\"]').rules(\"add\", {"
                         + rule
                         + "\n});";
             } else if (constraint instanceof ValidCharactersConstraint) {
                 String regexMethod = "";
                 String methodName = "";
                 if (StringUtils.isNotEmpty(((ValidCharactersConstraint) constraint).getValue())) {
                     regexMethod = ClientValidationUtils.getRegexMethodWithBooleanCheck(field,
                             (ValidCharactersConstraint) constraint) + "\n";
                     methodName = "validChar-" + field.getBindingInfo().getBindingPath() + methodKey;
                     methodKey++;
                 } else {
                     if (StringUtils.isNotEmpty(((ValidCharactersConstraint) constraint).getMessageKey())) {
                         methodName = ((ValidCharactersConstraint) constraint).getMessageKey();
                     }
                 }
 
                 if (StringUtils.isNotEmpty(methodName)) {
                     rule = regexMethod
                             + "jQuery('[name=\""
                             + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                             + "\"]').rules(\"add\", {\n\""
                             + methodName
                             + "\" : function(element){return ("
                             + booleanStatement
                             + ");}\n});";
                 }
             } else if (constraint instanceof PrerequisiteConstraint) {
                 processPrerequisiteConstraint(field, (PrerequisiteConstraint) constraint, view, booleanStatement);
             } else if (constraint instanceof CaseConstraint) {
                 processCaseConstraint(field, view, (CaseConstraint) constraint, booleanStatement, validationState,
                         stateMapping);
             } else if (constraint instanceof MustOccurConstraint) {
                 processMustOccurConstraint(field, view, (MustOccurConstraint) constraint, booleanStatement);
             }
         }
 
         return rule;
     }
 
     /**
      * Simpler version of processPrerequisiteConstraint
      *
      * @param constraint
      * @param view
      * @see ClientValidationUtils#processPrerequisiteConstraint(org.kuali.rice.krad.uif.field.InputField,
      *      PrerequisiteConstraint, View, String)
      */
     public static void processPrerequisiteConstraint(InputField field, PrerequisiteConstraint constraint, View view) {
         processPrerequisiteConstraint(field, constraint, view, "true");
     }
 
     /**
      * Processes a Prerequisite constraint that should be applied
      * when the booleanStatement passed in evaluates to true.
      *
      * @param constraint prerequisiteConstraint
      * @param view
      * @param booleanStatement the booleanstatement in js - should return true when the
      * validation rule should be applied
      */
     public static void processPrerequisiteConstraint(InputField field, PrerequisiteConstraint constraint, View view,
             String booleanStatement) {
         if (constraint != null && constraint.getApplyClientSide().booleanValue()) {
             String dependsClass = "dependsOn-" + ScriptUtils.escapeName(constraint.getPropertyName());
             String addClass = "jQuery('[name=\""
                     + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                     + "\"]').addClass('"
                     + dependsClass
                     + "');"
                     +
                     "jQuery('[name=\""
                     + ScriptUtils.escapeName(constraint.getPropertyName())
                     + "\"]').addClass('"
                     + "dependsOn-"
                     + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                     + "');";
 
             addScriptToPage(view, field, addClass
                     + getPrerequisiteStatement(field, view, constraint, booleanStatement)
                     + getPostrequisiteStatement(field, constraint, booleanStatement));
 
             //special requiredness indicator handling
             String showIndicatorScript = "setupShowReqIndicatorCheck('" + ScriptUtils.escapeName(
                     field.getBindingInfo().getBindingPath()) + "', '" + ScriptUtils.escapeName(
                     constraint.getPropertyName()) + "', " + "function(){\nreturn (coerceValue('" + ScriptUtils
                     .escapeName(field.getBindingInfo().getBindingPath()) + "') && " + booleanStatement + ");});\n";
 
             addScriptToPage(view, field, showIndicatorScript);
         }
     }
 
     /**
      * Creates the script necessary for executing a prerequisite
      * rule in which this field occurs after the field specified in the
      * prerequisite rule - since it requires a specific set of UI logic. Builds
      * an if statement containing an addMethod jquery validator call. Adds a
      * "dependsOn" css class to this field for the field specified.
      *
      * @param constraint prerequisiteConstraint
      * @param booleanStatement the booleanstatement in js - should return true when the
      * validation rule should be applied
      * @return
      */
     private static String getPrerequisiteStatement(InputField field, View view, PrerequisiteConstraint constraint,
             String booleanStatement) {
         methodKey++;
 
         MessageService messageService = KRADServiceLocatorWeb.getMessageService();
 
         String message = "";
         if (StringUtils.isEmpty(constraint.getMessageKey())) {
             message = messageService.getMessageText(UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "prerequisite");
             message = MessageStructureUtils.translateStringMessage(message);
         } else {
             message = generateMessageText(constraint.getMessageNamespaceCode(),
                     constraint.getMessageComponentCode(), constraint.getMessageKey(),
                     constraint.getValidationMessageParams());
         }
 
         if (StringUtils.isEmpty(message)) {
             message = "prerequisite - No message";
         } else {
             InputField requiredField = (InputField) view.getViewIndex().getDataFieldByPath(
                     constraint.getPropertyName());
             if (requiredField != null && StringUtils.isNotEmpty(requiredField.getLabel())) {
                 message = MessageFormat.format(message, requiredField.getLabel());
             } else {
                 String genericFieldLabel = messageService.getMessageText(GENERIC_FIELD_MSG_KEY);
                 message = MessageFormat.format(message, genericFieldLabel);
             }
         }
 
         // field occurs before case
         String methodName = "prConstraint-"
                 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                 + methodKey;
 
         String addClass = "jQuery('[name=\""
                 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                 + "\"]').addClass('"
                 + methodName
                 + "');\n";
 
         String method = "\njQuery.validator.addMethod(\"" + methodName + "\", function(value, element) {\n" +
                 " if(" + booleanStatement + "){ return (this.optional(element) || (coerceValue('" + ScriptUtils
                 .escapeName(constraint.getPropertyName()) + "')));}else{return true;} " +
                 "}, \"" + message + "\");";
 
         String ifStatement = "if(occursBefore('"
                 + ScriptUtils.escapeName(constraint.getPropertyName())
                 + "','"
                 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                 +
                 "')){"
                 + addClass
                 + method
                 + "}";
 
         return ifStatement;
     }
 
     /**
      * This method creates the script necessary for executing a prerequisite
      * rule in which this field occurs before the field specified in the
      * prerequisite rule - since it requires a specific set of UI logic. Builds
      * an if statement containing an addMethod jquery validator call.
      *
      * @param constraint prerequisiteConstraint
      * @param booleanStatement the booleanstatement in js - should return true when the
      * validation rule should be applied
      * @return
      */
     private static String getPostrequisiteStatement(InputField field, PrerequisiteConstraint constraint,
             String booleanStatement) {
         MessageService messageService = KRADServiceLocatorWeb.getMessageService();
 
         // field occurs after case
         String message = "";
         if (StringUtils.isEmpty(constraint.getMessageKey())) {
             message = messageService.getMessageText(UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + "postrequisite");
             message = MessageStructureUtils.translateStringMessage(message);
         } else {
             message = generateMessageText(constraint.getMessageNamespaceCode(), constraint.getMessageComponentCode(),
                     constraint.getMessageKey(), constraint.getValidationMessageParams());
         }
 
         if (StringUtils.isEmpty(constraint.getMessageKey())) {
             if (StringUtils.isNotEmpty(field.getLabel())) {
                 message = MessageFormat.format(message, field.getLabel());
             } else {
                 String genericFieldLabel = messageService.getMessageText(GENERIC_FIELD_MSG_KEY);
                 message = MessageFormat.format(message, genericFieldLabel);
             }
         }
 
         String function = "function(element){\n" +
                 "return (coerceValue('"
                 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                 + "') && "
                 + booleanStatement
                 + ");}";
         String postStatement = "\nelse if(occursBefore('"
                 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                 + "','"
                 + ScriptUtils.escapeName(constraint.getPropertyName())
                 +
                 "')){\njQuery('[name=\""
                 + ScriptUtils.escapeName(constraint.getPropertyName())
                 +
                 "\"]').rules(\"add\", { required: \n"
                 + function
                 + ", \nmessages: {\nrequired: \""
                 + message
                 + "\"}});}\n";
 
         return postStatement;
 
     }
 
     /**
      * This method processes the MustOccurConstraint. The constraint is only
      * applied when the booleanStatement evaluates to true during validation.
      * This method creates the addMethod and add rule calls for the jquery
      * validation plugin necessary for applying this constraint to this field.
      *
      * @param view
      * @param mc
      * @param booleanStatement the booleanstatement in js - should return true when the
      * validation rule should be applied
      */
     public static void processMustOccurConstraint(InputField field, View view, MustOccurConstraint mc,
             String booleanStatement) {
         methodKey++;
         mustOccursPathNames = new ArrayList<List<String>>();
         // TODO make this show the fields its requiring
         String methodName = "moConstraint-"
                 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                 + methodKey;
         String method = "\njQuery.validator.addMethod(\"" + methodName + "\", function(value, element) {\n" +
                 " if("
                 + booleanStatement
                 + "){return (this.optional(element) || ("
                 + getMustOccurStatement(field, mc)
                 + "));}else{return true;}"
                 +
                 "}, \""
                 + getMustOccursMessage(view, mc)
                 + "\");";
         String rule = method
                 + "jQuery('[name=\""
                 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                 + "\"]').rules(\"add\", {\n\""
                 + methodName
                 + "\": function(element){return ("
                 + booleanStatement
                 + ");}\n});";
         addScriptToPage(view, field, rule);
     }
 
     /**
      * This method takes in a MustOccurConstraint and returns the statement used
      * in determining if the must occurs constraint has been satisfied when this
      * field is validated. Note the use of the mustOccurCheck method. Nested
      * mustOccurConstraints are ored against the result of the mustOccurCheck by
      * calling this method recursively.
      *
      * @param constraint
      * @return
      */
     @SuppressWarnings("boxing")
     private static String getMustOccurStatement(InputField field, MustOccurConstraint constraint) {
         String statement = "";
         List<String> attributePaths = new ArrayList<String>();
         if (constraint != null && constraint.getApplyClientSide()) {
             String array = "[";
             if (constraint.getPrerequisiteConstraints() != null) {
                 for (int i = 0; i < constraint.getPrerequisiteConstraints().size(); i++) {
                     field.getControl().addStyleClass("dependsOn-" + constraint.getPrerequisiteConstraints().get(i)
                             .getPropertyName());
                     array = array + "'" + ScriptUtils.escapeName(constraint.getPrerequisiteConstraints().get(i)
                             .getPropertyName()) + "'";
                     attributePaths.add(constraint.getPrerequisiteConstraints().get(i).getPropertyName());
                     if (i + 1 != constraint.getPrerequisiteConstraints().size()) {
                         array = array + ",";
                     }
 
                 }
             }
             array = array + "]";
             statement = "mustOccurTotal(" + array + ", " + constraint.getMin() + ", " + constraint.getMax() + ")";
             //add min to string list
             if (constraint.getMin() != null) {
                 attributePaths.add(constraint.getMin().toString());
             } else {
                 attributePaths.add(null);
             }
             //add max to string list
             if (constraint.getMax() != null) {
                 attributePaths.add(constraint.getMax().toString());
             } else {
                 attributePaths.add(null);
             }
 
             mustOccursPathNames.add(attributePaths);
             if (StringUtils.isEmpty(statement)) {
                 statement = "0";
             }
             if (constraint.getMustOccurConstraints() != null) {
                 for (MustOccurConstraint mc : constraint.getMustOccurConstraints()) {
                     statement = "mustOccurCheck(" + statement + " + " + getMustOccurStatement(field, mc) +
                             ", " + constraint.getMin() + ", " + constraint.getMax() + ")";
                 }
             } else {
                 statement = "mustOccurCheck(" + statement +
                         ", " + constraint.getMin() + ", " + constraint.getMax() + ")";
             }
         }
         return statement;
     }
 
     /**
      * Generates a message for the must occur constraint (if no label key is specified).
      * This message is most accurate when must occurs is a single
      * or double level constraint.  Beyond that, the message will still be accurate but may be confusing for
      * the user - this auto-generated message however will work in MOST use cases.
      *
      * @param view
      * @return
      */
     private static String getMustOccursMessage(View view, MustOccurConstraint constraint) {
         MessageService messageService = KRADServiceLocatorWeb.getMessageService();
 
         String message = "";
         if (StringUtils.isNotEmpty(constraint.getMessageKey())) {
             message = generateMessageText(constraint.getMessageNamespaceCode(), constraint.getMessageComponentCode(),
                     constraint.getMessageKey(), constraint.getValidationMessageParams());
         } else {
             String and = messageService.getMessageText(AND_MSG_KEY);
             String or = messageService.getMessageText(OR_MSG_KEY);
             String all = messageService.getMessageText(ALL_MSG_KEY);
             String mustOccursMsgEqualMinMax = messageService.getMessageText(
                     UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + MUSTOCCURS_MSG_EQUAL_KEY);
             String atMost = messageService.getMessageText(ATMOST_MSG_KEY);
             String genericLabel = messageService.getMessageText(GENERIC_FIELD_MSG_KEY);
             String mustOccursMsg = messageService.getMessageText(
                     UifConstants.Messages.VALIDATION_MSG_KEY_PREFIX + MUSTOCCURS_MSG_KEY);
 
             String statement = "";
             for (int i = 0; i < mustOccursPathNames.size(); i++) {
                 String andedString = "";
 
                 List<String> paths = mustOccursPathNames.get(i);
                 if (!paths.isEmpty()) {
                     //note that the last 2 strings are min and max and rest are attribute paths
                     String min = paths.get(paths.size() - 2);
                     String max = paths.get(paths.size() - 1);
                     for (int j = 0; j < paths.size() - 2; j++) {
                         InputField field = (InputField) view.getViewIndex().getDataFieldByPath(paths.get(j).trim());
                         String label = genericLabel;
                         if (field != null && StringUtils.isNotEmpty(field.getLabel())) {
                             label = field.getLabel();
                         }
                         if (min.equals(max)) {
                             if (j == 0) {
                                 andedString = label;
                             } else if (j == paths.size() - 3) {
                                 andedString = andedString + " " + and + " " + label;
                             } else {
                                 andedString = andedString + ", " + label;
                             }
                         } else {
                             andedString = andedString + "(" + label + ")";
                         }
                     }
                     if (min.equals(max)) {
                         andedString = "(" + andedString + ")";
                     }
 
                     if (StringUtils.isNotBlank(andedString) && !andedString.equals("()")) {
                         if (StringUtils.isNotEmpty(min) && StringUtils.isNotEmpty(max) && !min.equals(max)) {
                             andedString = MessageFormat.format(mustOccursMsg, min + "-" + max) + " " + andedString;
                         } else if (StringUtils.isNotEmpty(min)
                                 && StringUtils.isNotEmpty(max)
                                 && min.equals(max)
                                 && i == 0) {
                             andedString = mustOccursMsgEqualMinMax + " " + andedString;
                         } else if (StringUtils.isNotEmpty(min)
                                 && StringUtils.isNotEmpty(max)
                                 && min.equals(max)
                                 && i != 0) {
                             //leave andedString as is
                         } else if (StringUtils.isNotEmpty(min)) {
                             andedString = MessageFormat.format(mustOccursMsg, min) + " " + andedString;
                         } else if (StringUtils.isNotEmpty(max)) {
                             andedString = MessageFormat.format(mustOccursMsg, atMost + " " + max) + " " + andedString;
                         }
                     }
                 }
                 if (StringUtils.isNotEmpty(andedString)) {
                     if (StringUtils.isNotBlank(statement)) {
                         statement = statement + " " + or.toUpperCase() + " " + andedString;
                     } else {
                         statement = andedString;
                     }
                 }
             }
             if (StringUtils.isNotEmpty(statement)) {
                 message = statement;
                 message = message.replace(")(", " " + or + " ");
             }
         }
 
         return message;
     }
 
     /**
      * This method processes all the constraints on the InputField passed in and adds all the necessary
      * jQuery and js required (validator's rules, methods, and messages) to the View's onDocumentReady call.
      * The result is js that will validate all the constraints contained on an InputField during user interaction
      * with the field using the jQuery validation plugin and custom code.
      *
      * @param field
      */
     @SuppressWarnings("boxing")
     public static void processAndApplyConstraints(InputField field, View view, Object model) {
         methodKey = 0;
         String validationState = ConstraintStateUtils.getClientViewValidationState(model, view);
         StateMapping stateMapping = view.getStateMapping();
 
         if (view instanceof FormView && ((FormView) view).isValidateClientSide()) {
             SimpleConstraint simpleConstraint = ConstraintStateUtils.getApplicableConstraint(
                     field.getSimpleConstraint(), validationState, stateMapping);
             if (simpleConstraint != null && simpleConstraint.getApplyClientSide()) {
 
                 if ((simpleConstraint.getRequired() != null) && (simpleConstraint.getRequired().booleanValue())) {
                     field.getControl().addStyleClass("required");
                 }
 
                 if (simpleConstraint.getExclusiveMin() != null) {
                     if (field.getControl() instanceof TextControl
                             && ((TextControl) field.getControl()).getDatePicker() != null) {
                         ((TextControl) field.getControl()).getDatePicker().getTemplateOptions().put("minDate",
                                 simpleConstraint.getExclusiveMin());
                     } else {
                         String rule = "jQuery('[name=\""
                                 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                                 + "\"]').rules(\"add\", {\n minExclusive: ["
                                 + simpleConstraint.getExclusiveMin()
                                 + "]});";
                         addScriptToPage(view, field, rule);
                     }
                 }
 
                 if (simpleConstraint.getInclusiveMax() != null) {
                     if (field.getControl() instanceof TextControl
                             && ((TextControl) field.getControl()).getDatePicker() != null) {
                         ((TextControl) field.getControl()).getDatePicker().getTemplateOptions().put("maxDate",
                                 simpleConstraint.getInclusiveMax());
                     } else {
                         String rule = "jQuery('[name=\""
                                 + ScriptUtils.escapeName(field.getBindingInfo().getBindingPath())
                                 + "\"]').rules(\"add\", {\n maxInclusive: ["
                                 + simpleConstraint.getInclusiveMax()
                                 + "]});";
                         addScriptToPage(view, field, rule);
                     }
                 }
             }
 
             ValidCharactersConstraint validCharactersConstraint = ConstraintStateUtils.getApplicableConstraint(
                     field.getValidCharactersConstraint(), validationState, stateMapping);
 
             if (validCharactersConstraint != null && validCharactersConstraint.getApplyClientSide()) {
                 if (StringUtils.isNotEmpty(validCharactersConstraint.getValue())) {
                     // set regex value takes precedence
                     addScriptToPage(view, field, ClientValidationUtils.getRegexMethod(field,
                             validCharactersConstraint));
                     field.getControl().addStyleClass(
                             "validChar-" + field.getBindingInfo().getBindingPath() + methodKey);
                     methodKey++;
                 } else {
                     //blindly assume that if there is no regex value defined that there must be a method by this name
                     if (StringUtils.isNotEmpty(validCharactersConstraint.getMessageKey())) {
                         field.getControl().addStyleClass(validCharactersConstraint.getMessageKey());
                     }
                 }
             }
 
             CaseConstraint caseConstraint = ConstraintStateUtils.getApplicableConstraint(field.getCaseConstraint(),
                     validationState, stateMapping);
             if (caseConstraint != null && caseConstraint.getApplyClientSide()) {
                 processCaseConstraint(field, view, caseConstraint, null, validationState, stateMapping);
             }
 
             if (field.getDependencyConstraints() != null) {
                 for (PrerequisiteConstraint prc : field.getDependencyConstraints()) {
                     prc = ConstraintStateUtils.getApplicableConstraint(prc, validationState, stateMapping);
                     if (prc != null) {
                         processPrerequisiteConstraint(field, prc, view);
                     }
                 }
             }
 
             if (field.getMustOccurConstraints() != null) {
                 for (MustOccurConstraint mc : field.getMustOccurConstraints()) {
                     mc = ConstraintStateUtils.getApplicableConstraint(mc, validationState, stateMapping);
                     if (mc != null) {
                         processMustOccurConstraint(field, view, mc, "true");
                     }
                 }
             }
 
         }
     }
 
 }