/**

  * Copyright 2005-2011 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.container;

 import org.apache.commons.collections.ListUtils;

 import org.apache.commons.lang.StringUtils;

 import org.kuali.rice.core.api.mo.common.active.Inactivatable;

 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;

 import org.kuali.rice.krad.uif.UifConstants;

 import org.kuali.rice.krad.uif.UifParameters;

 import org.kuali.rice.krad.uif.UifPropertyPaths;

 import org.kuali.rice.krad.uif.control.Control;

 import org.kuali.rice.krad.uif.component.DataBinding;

 import org.kuali.rice.krad.uif.field.ActionField;

 import org.kuali.rice.krad.uif.field.InputField;

 import org.kuali.rice.krad.uif.field.Field;

 import org.kuali.rice.krad.uif.field.FieldGroup;

 import org.kuali.rice.krad.uif.layout.CollectionLayoutManager;

 import org.kuali.rice.krad.uif.service.ExpressionEvaluatorService;

 import org.kuali.rice.krad.uif.util.ComponentUtils;

 import org.kuali.rice.krad.uif.util.ObjectPropertyUtils;

 import org.kuali.rice.krad.uif.view.View;

 import org.kuali.rice.krad.util.KRADUtils;

 import org.kuali.rice.krad.util.ObjectUtils;

 import org.kuali.rice.krad.web.form.UifFormBase;

 import java.io.Serializable;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 /**

  * Builds out the <code>Field</code> instances for a collection group with a

  * series of steps that interact with the configured

  * <code>CollectionLayoutManager</code> to assemble the fields as necessary for

  * the layout

  * 

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class CollectionGroupBuilder implements Serializable {

         private static final long serialVersionUID = -4762031957079895244L;

         /**

          * Creates the <code>Field</code> instances that make up the table

          * 

          * <p>

          * The corresponding collection is retrieved from the model and iterated

          * over to create the necessary fields. The binding path for fields that

          * implement <code>DataBinding</code> is adjusted to point to the collection

          * line it is apart of. For example, field 'number' of collection 'accounts'

          * for line 1 will be set to 'accounts[0].number', and for line 2

          * 'accounts[1].number'. Finally parameters are set on the line's action

          * fields to indicate what collection and line they apply to.

          * </p>

          * 

          * @param view

          *            - View instance the collection belongs to

          * @param model

          *            - Top level object containing the data

          * @param collectionGroup

          *            - CollectionGroup component for the collection

          */

     public void build(View view, Object model, CollectionGroup collectionGroup) {

         // create add line

         if (collectionGroup.isRenderAddLine() && !collectionGroup.isReadOnly()) {

             buildAddLine(view, model, collectionGroup);

         }

         // get the collection for this group from the model

         List<Object> modelCollection = ObjectPropertyUtils.getPropertyValue(model, ((DataBinding) collectionGroup)

                 .getBindingInfo().getBindingPath());

         if (modelCollection != null) {

             // filter inactive model

             List<Integer> showIndexes = performCollectionFiltering(view, model, collectionGroup, modelCollection);

             // for each collection row build the line fields

             for (int index = 0; index < modelCollection.size(); index++) {

                 // display only records that passed filtering

                 if (showIndexes.contains(index)) {

                     String bindingPathPrefix = collectionGroup.getBindingInfo().getBindingName() + "[" + index + "]";

                     if (StringUtils.isNotBlank(collectionGroup.getBindingInfo().getBindByNamePrefix())) {

                         bindingPathPrefix =

                                 collectionGroup.getBindingInfo().getBindByNamePrefix() + "." + bindingPathPrefix;

                     }

                     Object currentLine = modelCollection.get(index);

                     List<ActionField> actions = getLineActions(view, model, collectionGroup, currentLine, index);

                     buildLine(view, model, collectionGroup, bindingPathPrefix, actions, false, currentLine, index);

                 }

             }

         }

     }

     /**

      * Performs any filtering necessary on the collection before building the collection fields

      *

      * <p>

      * If showInactive is set to false and the collection line type implements <code>Inactivatable</code>,

      * invokes the active collection filter. Then any {@link CollectionFilter} instances configured for the collection

      * group are invoked to filter the collection. Collections lines must pass all filters in order to be

      * displayed

      * </p>

      *

      * @param view - view instance that contains the collection

      * @param model - object containing the views data

      * @param collectionGroup - collection group component instance that will display the collection

      * @param collection - collection instance that will be filtered

      */

     protected List<Integer> performCollectionFiltering(View view, Object model, CollectionGroup collectionGroup,

             Collection<?> collection) {

         List<Integer> filteredIndexes = new ArrayList<Integer>();

         for (int i = 0; i < collection.size(); i++) {

             filteredIndexes.add(new Integer(i));

         }

         if (Inactivatable.class.isAssignableFrom(collectionGroup.getCollectionObjectClass()) && !collectionGroup

                 .isShowInactive()) {

             List<Integer> activeIndexes = collectionGroup.getActiveCollectionFilter().filter(view, model,

                     collectionGroup);

             filteredIndexes = ListUtils.intersection(filteredIndexes, activeIndexes);

         }

         for (CollectionFilter collectionFilter : collectionGroup.getFilters()) {

             List<Integer> indexes = collectionFilter.filter(view, model, collectionGroup);

             filteredIndexes = ListUtils.intersection(filteredIndexes, indexes);

             if (filteredIndexes.isEmpty()) {

                 break;

             }

         }

         return filteredIndexes;

     }

         /**

          * Builds the fields for holding the collection add line and if necessary

          * makes call to setup the new line instance

          * 

          * @param view

          *            - view instance the collection belongs to

          * @param collectionGroup

          *            - collection group the layout manager applies to

          * @param model

          *            - Object containing the view data, should extend UifFormBase

          *            if using framework managed new lines

          */

     protected void buildAddLine(View view, Object model, CollectionGroup collectionGroup) {

         boolean addLineBindsToForm = false;

         // initialize new line if one does not already exist

         initializeNewCollectionLine(view, model, collectionGroup, false);

         // determine whether the add line binds to the generic form map or a

         // specified property

         if (StringUtils.isBlank(collectionGroup.getAddLinePropertyName())) {

             addLineBindsToForm = true;

         }

         String addLineBindingPath = collectionGroup.getAddLineBindingInfo().getBindingPath();

         List<ActionField> actions = getAddLineActions(view, model, collectionGroup);

         Object addLine = ObjectPropertyUtils.getPropertyValue(model, addLineBindingPath);

         buildLine(view, model, collectionGroup, addLineBindingPath, actions, addLineBindsToForm, addLine, -1);

     }

         /**

          * Builds the field instances for the collection line. A copy of the

          * configured items on the <code>CollectionGroup</code> is made and adjusted

          * for the line (id and binding). Then a call is made to the

          * <code>CollectionLayoutManager</code> to assemble the line as necessary

          * for the layout

          * 

          * @param view

          *            - view instance the collection belongs to

          * @param model

          *            - top level object containing the data

          * @param collectionGroup

          *            - collection group component for the collection

          * @param bindingPath

          *            - binding path for the line fields (if DataBinding)

          * @param actions

          *            - List of actions to set in the lines action column

          * @param bindToForm

          *            - whether the bindToForm property on the items bindingInfo

          *            should be set to true (needed for add line)

          * @param currentLine

          *            - object instance for the current line, or null if add line

          * @param lineIndex

          *            - index of the line in the collection, or -1 if we are

          *            building the add line

          */

         @SuppressWarnings("unchecked")

         protected void buildLine(View view, Object model, CollectionGroup collectionGroup, String bindingPath,

                         List<ActionField> actions, boolean bindToForm, Object currentLine, int lineIndex) {

                 CollectionLayoutManager layoutManager = (CollectionLayoutManager) collectionGroup.getLayoutManager();

                 // copy group items for new line

         List<Field> lineFields = (List<Field>) collectionGroup.getItems();

         String lineSuffix = UifConstants.IdSuffixes.LINE + Integer.toString(lineIndex);

         if (lineIndex == -1) {

             lineFields = (List<Field>) collectionGroup.getAddLineFields();

             lineSuffix = UifConstants.IdSuffixes.ADD_LINE;

         }

         if (StringUtils.isNotBlank(collectionGroup.getSubCollectionSuffix())) {

             lineSuffix = collectionGroup.getSubCollectionSuffix() + lineSuffix;

         }

         lineFields = (List<Field>) ComponentUtils.copyFieldList(lineFields, bindingPath, lineSuffix);

                 if(lineIndex == -1 && !lineFields.isEmpty()){

                     for(Field f: lineFields){

                         if(f instanceof InputField){

                             //sets up - skipping these fields in add area during standard form validation calls

                             //custom addLineToCollection js call will validate these fields manually on an add

                                 Control control = ((InputField) f).getControl();

                                 if (control != null) {

                                     control.addStyleClass(collectionGroup.getFactoryId() + "-addField");

                                         control.addStyleClass("ignoreValid");

                                 }

                         }

                     }

                     for(ActionField action: actions){

                         if(action.getActionParameter(UifParameters.ACTION_TYPE).equals(UifParameters.ADD_LINE)){

                             action.setFocusOnAfterSubmit(lineFields.get(0).getId());

                         }

                     }

                 }

                 ComponentUtils.updateContextsForLine(lineFields, currentLine, lineIndex);

                 if (bindToForm) {

                         ComponentUtils.setComponentsPropertyDeep(lineFields, UifPropertyPaths.BIND_TO_FORM, new Boolean(true));

                 }                

         // remove fields from the line that have render false

         lineFields = removeNonRenderLineFields(view, model, collectionGroup, lineFields, currentLine, lineIndex);

                 // if not add line build sub-collection field groups

                 List<FieldGroup> subCollectionFields = new ArrayList<FieldGroup>();

         if ((lineIndex != -1) && (collectionGroup.getSubCollections() != null)) {

             for (int subLineIndex = 0; subLineIndex < collectionGroup.getSubCollections().size(); subLineIndex++) {

                 CollectionGroup subCollectionPrototype = collectionGroup.getSubCollections().get(subLineIndex);

                 CollectionGroup subCollectionGroup = ComponentUtils.copy(subCollectionPrototype, lineSuffix);

                 // verify the sub-collection should be rendered

                 boolean renderSubCollection = checkSubCollectionRender(view, model, collectionGroup,

                         subCollectionGroup);

                 if (!renderSubCollection) {

                     continue;

                 }

                 subCollectionGroup.getBindingInfo().setBindByNamePrefix(bindingPath);

                 if (subCollectionGroup.isRenderAddLine()) {

                     subCollectionGroup.getAddLineBindingInfo().setBindByNamePrefix(bindingPath);

                 }

                 // set sub-collection suffix on group so it can be used for generated groups

                 String subCollectionSuffix = lineSuffix;

                 if (StringUtils.isNotBlank(subCollectionGroup.getSubCollectionSuffix())) {

                     subCollectionSuffix = subCollectionGroup.getSubCollectionSuffix() + lineSuffix;

                 }

                 subCollectionGroup.setSubCollectionSuffix(subCollectionSuffix);

                 FieldGroup fieldGroupPrototype = layoutManager.getSubCollectionFieldGroupPrototype();

                 FieldGroup subCollectionFieldGroup = ComponentUtils.copy(fieldGroupPrototype,

                         lineSuffix + UifConstants.IdSuffixes.SUB + subLineIndex);

                 subCollectionFieldGroup.setGroup(subCollectionGroup);

                 subCollectionFields.add(subCollectionFieldGroup);

             }

         }

                 // invoke layout manager to build the complete line

                 layoutManager.buildLine(view, model, collectionGroup, lineFields, subCollectionFields, bindingPath, actions,

                                 lineSuffix, currentLine, lineIndex);

         }

     /**

      * Evaluates the render property for the given list of <code>Field</code>

      * instances for the line and removes any fields from the returned list that

      * have render false. The conditional render string is also taken into

      * account. This needs to be done here as opposed to during the normal

      * condition evaluation so the the fields are not used while building the

      * collection lines

      * 

      * @param view

      *            - view instance the collection group belongs to

      * @param model

      *            - object containing the view data

      * @param collectionGroup

      *            - collection group for the line fields

      * @param lineFields

      *            - list of fields configured for the line

      * @param currentLine

      *            - object containing the line data

      * @param lineIndex

      *            - index of the line in the collection

      * @return List<Field> list of field instances that should be rendered

      */

     protected List<Field> removeNonRenderLineFields(View view, Object model, CollectionGroup collectionGroup,

             List<Field> lineFields, Object currentLine, int lineIndex) {

         List<Field> fields = new ArrayList<Field>();

         for (Field lineField : lineFields) {

             String conditionalRender = lineField.getPropertyExpression("render");

             // evaluate conditional render string if set

             if (StringUtils.isNotBlank(conditionalRender)) {

                 Map<String, Object> context = new HashMap<String, Object>();

                 context.putAll(view.getContext());

                 context.put(UifConstants.ContextVariableNames.PARENT, collectionGroup);

                 context.put(UifConstants.ContextVariableNames.COMPONENT, lineField);

                 context.put(UifConstants.ContextVariableNames.LINE, currentLine);

                 context.put(UifConstants.ContextVariableNames.INDEX, new Integer(lineIndex));

                 context.put(UifConstants.ContextVariableNames.IS_ADD_LINE, new Boolean(lineIndex == -1));

                 Boolean render = (Boolean) getExpressionEvaluatorService().evaluateExpression(model, context,

                         conditionalRender);

                 lineField.setRender(render);

             }

             // only add line field if set to render or if it is hidden by progressive render

             if (lineField.isRender() || StringUtils.isNotBlank(lineField.getProgressiveRender())) {

                 fields.add(lineField);

             }

         }

         return fields;

     }

     /**

      * Checks whether the given sub-collection should be rendered, any

      * conditional render string is evaluated

      * 

      * @param view

      *            - view instance the sub collection belongs to

      * @param model

      *            - object containing the view data

      * @param collectionGroup

      *            - collection group the sub collection belongs to

      * @param subCollectionGroup

      *            - sub collection group to check render status for

      * @return boolean true if sub collection should be rendered, false if it

      *         should not be rendered

      */

     protected boolean checkSubCollectionRender(View view, Object model, CollectionGroup collectionGroup,

             CollectionGroup subCollectionGroup) {

         String conditionalRender = subCollectionGroup.getPropertyExpression("render");

         // evaluate conditional render string if set

         if (StringUtils.isNotBlank(conditionalRender)) {

             Map<String, Object> context = new HashMap<String, Object>();

             context.putAll(view.getContext());

             context.put(UifConstants.ContextVariableNames.PARENT, collectionGroup);

             context.put(UifConstants.ContextVariableNames.COMPONENT, subCollectionGroup);

             Boolean render = (Boolean) getExpressionEvaluatorService().evaluateExpression(model, context,

                     conditionalRender);

             subCollectionGroup.setRender(render);

         }

         return subCollectionGroup.isRender();

     }

         /**

          * Creates new <code>ActionField</code> instances for the line

          * 

          * <p>

          * Adds context to the action fields for the given line so that the line the

          * action was performed on can be determined when that action is selected

          * </p>

          * 

          * @param view

          *            - view instance the collection belongs to

          * @param model

          *            - top level object containing the data

          * @param collectionGroup

          *            - collection group component for the collection

          * @param collectionLine

          *            - object instance for the current line

          * @param lineIndex

          *            - index of the line the actions should apply to

          */

         protected List<ActionField> getLineActions(View view, Object model, CollectionGroup collectionGroup,

                         Object collectionLine, int lineIndex) {

                 List<ActionField> lineActions = ComponentUtils.copyFieldList(collectionGroup.getActionFields(), Integer.toString(lineIndex));

                 for (ActionField actionField : lineActions) {

                         actionField.addActionParameter(UifParameters.SELLECTED_COLLECTION_PATH, collectionGroup.getBindingInfo()

                                         .getBindingPath());

                         actionField.addActionParameter(UifParameters.SELECTED_LINE_INDEX, Integer.toString(lineIndex));

                         actionField.setJumpToIdAfterSubmit(collectionGroup.getId() + "_div");

             actionField.setClientSideJs("performCollectionAction('"+collectionGroup.getId()+"');");

                 }

                 ComponentUtils.updateContextsForLine(lineActions, collectionLine, lineIndex);

                 return lineActions;

         }

         /**

          * Creates new <code>ActionField</code> instances for the add line

          * 

          * <p>

          * Adds context to the action fields for the add line so that the collection

          * the action was performed on can be determined

          * </p>

          * 

          * @param view

          *            - view instance the collection belongs to

          * @param model

          *            - top level object containing the data

          * @param collectionGroup

          *            - collection group component for the collection

          */

         protected List<ActionField> getAddLineActions(View view, Object model, CollectionGroup collectionGroup) {

                 List<ActionField> lineActions = ComponentUtils.copyFieldList(collectionGroup.getAddLineActionFields(), "_add");

                 for (ActionField actionField : lineActions) {

                         actionField.addActionParameter(UifParameters.SELLECTED_COLLECTION_PATH, collectionGroup.getBindingInfo()

                                         .getBindingPath());

                         //actionField.addActionParameter(UifParameters.COLLECTION_ID, collectionGroup.getId());

                         actionField.setJumpToIdAfterSubmit(collectionGroup.getId() + "_div");

                         actionField.addActionParameter(UifParameters.ACTION_TYPE, UifParameters.ADD_LINE);

             String baseId = collectionGroup.getFactoryId();

             if (StringUtils.isNotBlank(collectionGroup.getSubCollectionSuffix())) {

                 baseId += collectionGroup.getSubCollectionSuffix();

             }

             actionField.setClientSideJs("addLineToCollection('"+collectionGroup.getId()+"', '"+ baseId +"');");

                 }

                 // get add line for context

                 String addLinePath = collectionGroup.getAddLineBindingInfo().getBindingPath();

                 Object addLine = ObjectPropertyUtils.getPropertyValue(model, addLinePath);

                 ComponentUtils.updateContextsForLine(lineActions, addLine, -1);

                 return lineActions;

         }

     /**

      * Initializes a new instance of the collection class

      * 

      * <p>

      * If the add line property was not specified for the collection group the

      * new lines will be added to the generic map on the

      * <code>UifFormBase</code>, else it will be added to the property given by

      * the addLineBindingInfo

      * </p>

      * 

      * <p>

      * New line will only be created if the current line property is null or

      * clearExistingLine is true. In the case of a new line default values are

      * also applied

      * </p>

      * 

      * @see org.kuali.rice.krad.uif.container.CollectionGroup#

      *      initializeNewCollectionLine(View, Object, CollectionGroup, boolean)

      */

     public void initializeNewCollectionLine(View view, Object model, CollectionGroup collectionGroup,

             boolean clearExistingLine) {

         Object newLine = null;

         // determine if we are binding to generic form map or a custom property

         if (StringUtils.isBlank(collectionGroup.getAddLinePropertyName())) {

             // bind to form map

             if (!(model instanceof UifFormBase)) {

                 throw new RuntimeException("Cannot create new collection line for group: "

                         + collectionGroup.getPropertyName() + ". Model does not extend " + UifFormBase.class.getName());

             }

             // get new collection line map from form

             Map<String, Object> newCollectionLines = ObjectPropertyUtils.getPropertyValue(model,

                     UifPropertyPaths.NEW_COLLECTION_LINES);

             if (newCollectionLines == null) {

                 newCollectionLines = new HashMap<String, Object>();

                 ObjectPropertyUtils.setPropertyValue(model, UifPropertyPaths.NEW_COLLECTION_LINES, newCollectionLines);

             }

             // set binding path for add line

             String newCollectionLineKey = KRADUtils

                     .translateToMapSafeKey(collectionGroup.getBindingInfo().getBindingPath());

             String addLineBindingPath = UifPropertyPaths.NEW_COLLECTION_LINES + "['" + newCollectionLineKey + "']";

             collectionGroup.getAddLineBindingInfo().setBindingPath(addLineBindingPath);

             // if there is not an instance available or we need to clear create

             // a new instance

             if (!newCollectionLines.containsKey(newCollectionLineKey)

                     || (newCollectionLines.get(newCollectionLineKey) == null) || clearExistingLine) {

                 // create new instance of the collection type for the add line

                 newLine = ObjectUtils.newInstance(collectionGroup.getCollectionObjectClass());

                 newCollectionLines.put(newCollectionLineKey, newLine);

             }

         } else {

             // bind to custom property

             Object addLine = ObjectPropertyUtils.getPropertyValue(model, collectionGroup.getAddLineBindingInfo()

                     .getBindingPath());

             if ((addLine == null) || clearExistingLine) {

                 newLine = ObjectUtils.newInstance(collectionGroup.getCollectionObjectClass());

                 ObjectPropertyUtils.setPropertyValue(model, collectionGroup.getAddLineBindingInfo().getBindingPath(),

                         newLine);

             }

         }

         // apply default values if a new line was created

         if (newLine != null) {

             view.getViewHelperService().applyDefaultValuesForCollectionLine(view, model, collectionGroup, newLine);

         }

     }

     protected ExpressionEvaluatorService getExpressionEvaluatorService() {

         return KRADServiceLocatorWeb.getExpressionEvaluatorService();

     }

 }