/*
    * Copyright 2007 The Kuali Foundation
    *
    * Licensed under the Educational Community License, Version 1.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/ecl1.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.kns.uif.layout;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import org.kuali.rice.kns.uif.UifConstants;
  import org.kuali.rice.kns.uif.container.CollectionGroup;
  import org.kuali.rice.kns.uif.container.Container;
  import org.kuali.rice.kns.uif.container.View;
  import org.kuali.rice.kns.uif.core.Component;
  import org.kuali.rice.kns.uif.field.ActionField;
  import org.kuali.rice.kns.uif.field.AttributeField;
  import org.kuali.rice.kns.uif.field.Field;
  import org.kuali.rice.kns.uif.field.GroupField;
  import org.kuali.rice.kns.uif.field.LabelField;
  import org.kuali.rice.kns.uif.field.MessageField;
  import org.kuali.rice.kns.uif.util.ComponentFactory;
  import org.kuali.rice.kns.uif.util.ComponentUtils;
  import org.kuali.rice.kns.uif.widget.TableTools;
  
  /**
   * Layout manager that works with <code>CollectionGroup</code> components and
   * renders the collection as a Table
   * 
   * <p>
   * Based on the fields defined, the <code>TableLayoutManager</code> will
   * dynamically create instances of the fields for each collection row. In
   * addition, the manager can create standard fields like the action and sequence
   * fields for each row. The manager supports options inherited from the
   * <code>GridLayoutManager</code> such as rowSpan, colSpan, and cell width
   * settings.
   * </p>
   * 
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public class TableLayoutManager extends GridLayoutManager implements CollectionLayoutManager {
  	private static final long serialVersionUID = 3622267585541524208L;
  
  	private boolean useShortLabels;
  	private boolean repeatHeader;
  	private LabelField headerFieldPrototype;
  
  	private boolean renderSequenceField;
  	private String conditionalRenderSequenceField;
  	private boolean generateAutoSequence;
  	private Field sequenceFieldPrototype;
  
  	private GroupField actionFieldPrototype;
  
  	private GroupField subCollectionGroupFieldPrototype;
  
  	// internal counter for the data columns (not including sequence, action)
  	private int numberOfDataColumns;
  
  	private List<LabelField> headerFields;
  	private List<Field> dataFields;
  
  	private TableTools tableTools;
  	private boolean headerAdded = false;
  
  	public TableLayoutManager() {
  		useShortLabels = true;
  		repeatHeader = false;
  		renderSequenceField = true;
  		generateAutoSequence = false;
  
  		headerFields = new ArrayList<LabelField>();
  		dataFields = new ArrayList<Field>();
  	}
  	
  	/**
  	 * The following actions are performed:
  	 * 
  	 * <ul>
  	 * <li>Sets sequence field prototype if auto sequence is true</li>
  	 * <li>Initializes the prototypes</li>
  	 * </ul>
  	 * 
  	 * @see org.kuali.rice.kns.uif.layout.BoxLayoutManager#performInitialization(org.kuali.rice.kns.uif.container.View,
  	 *      org.kuali.rice.kns.uif.container.Container)
  	 */
  	@Override
  	public void performInitialization(View view, Container container) {
  		super.performInitialization(view, container);
 		
         if (generateAutoSequence && !(sequenceFieldPrototype instanceof MessageField)) {
             sequenceFieldPrototype = ComponentFactory.getMessageField();
         }
 
 		view.getViewHelperService().performComponentInitialization(view, headerFieldPrototype);
 		view.getViewHelperService().performComponentInitialization(view, sequenceFieldPrototype);
 		view.getViewHelperService().performComponentInitialization(view, actionFieldPrototype);
 		view.getViewHelperService().performComponentInitialization(view, subCollectionGroupFieldPrototype);
 	}
 
 	/**
 	 * Sets up the final column count for rendering based on whether the
 	 * sequence and action fields have been generated
 	 * 
 	 * @see org.kuali.rice.kns.uif.layout.LayoutManagerBase#performFinalize(org.kuali.rice.kns.uif.container.View,
 	 *      java.lang.Object, org.kuali.rice.kns.uif.container.Container)
 	 */
 	@Override
 	public void performFinalize(View view, Object model, Container container) {
 		super.performFinalize(view, model, container);
 
 		CollectionGroup collectionGroup = (CollectionGroup) container;
 
 		int totalColumns = getNumberOfDataColumns();
 		if (renderSequenceField) {
 			totalColumns++;
 		}
 
 		if (collectionGroup.isRenderLineActions() && !collectionGroup.isReadOnly()) {
 			totalColumns++;
 		}
 
 		setNumberOfColumns(totalColumns);
 
 	}
 
 	/**
 	 * Assembles the field instances for the collection line. The given sequence
 	 * field prototype is copied for the line sequence field. Likewise a copy of
 	 * the actionFieldPrototype is made and the given actions are set as the
 	 * items for the action field. Finally the generated items are assembled
 	 * together into the dataFields list with the given lineFields.
 	 * 
 	 * @see org.kuali.rice.kns.uif.layout.CollectionLayoutManager#buildLine(org.kuali.rice.kns.uif.container.View,
 	 *      java.lang.Object, org.kuali.rice.kns.uif.container.CollectionGroup,
 	 *      java.util.List, java.util.List, java.lang.String, java.util.List,
 	 *      java.lang.String, java.lang.Object, int)
 	 */
 	public void buildLine(View view, Object model, CollectionGroup collectionGroup, List<Field> lineFields,
 			List<GroupField> subCollectionFields, String bindingPath, List<ActionField> actions, String idSuffix,
 			Object currentLine, int lineIndex) {
 		boolean isAddLine = lineIndex == -1;
 		
         // if add line or first line set number of data columns
         if (isAddLine || ((!collectionGroup.isRenderAddLine() || collectionGroup.isReadOnly()) && (lineIndex == 0))) {
             if (isSuppressLineWrapping()) {
                 setNumberOfDataColumns(lineFields.size());
             } else {
                 setNumberOfDataColumns(getNumberOfColumns());
             }
         }
 
 		// if add line build table header first
 		// TODO: implement repeat header
 		if (!headerAdded) {
 			headerFields = new ArrayList<LabelField>();
 			dataFields = new ArrayList<Field>();
 
 			buildTableHeaderRows(collectionGroup, lineFields);
 			ComponentUtils.pushObjectToContext(headerFields, UifConstants.ContextVariableNames.LINE, currentLine);
 			ComponentUtils.pushObjectToContext(headerFields, UifConstants.ContextVariableNames.INDEX, new Integer(
 					lineIndex));
 			headerAdded = true;
 		}
 
 		// set label field rendered to true on line fields
 		for (Field field : lineFields) {
 			field.setLabelFieldRendered(true);
 
 			// don't display summary message
 			// TODO: remove once we have modifier
 			ComponentUtils.setComponentPropertyDeep(field, "summaryMessageField.render", new Boolean(false));
 		}
 
 		int rowCount = calculateNumberOfRows(collectionGroup.getItems());
 		int rowSpan = rowCount + subCollectionFields.size();
 
 		// sequence field is always first and should span all rows for the line
 		if (renderSequenceField) {
 			Field sequenceField = null;
             if (!isAddLine) {
                 sequenceField = ComponentUtils.copy(sequenceFieldPrototype, idSuffix);
 
                 if (generateAutoSequence && (sequenceField instanceof MessageField)) {
                     ((MessageField) sequenceField).setMessageText(Integer.toString(lineIndex + 1));
                 }
             }
 			else {
 				sequenceField = ComponentUtils.copy(collectionGroup.getAddLineLabelField(), idSuffix);
 			}
 			sequenceField.setRowSpan(rowSpan);
 
 			if (sequenceField instanceof AttributeField) {
 				((AttributeField) sequenceField).getBindingInfo().setBindByNamePrefix(bindingPath);
 			}
 
 			ComponentUtils.updateContextForLine(sequenceField, currentLine, lineIndex);
 
 			dataFields.add(sequenceField);
 		}
 
 		// now add the fields in the correct position
 		int cellPosition = 0;
 		for (Field lineField : lineFields) {
 			dataFields.add(lineField);
 
 			cellPosition += lineField.getColSpan();
 
 			// action field should be in last column
 			if ((cellPosition == getNumberOfDataColumns()) && collectionGroup.isRenderLineActions()
 					&& !collectionGroup.isReadOnly()) {
 				GroupField lineActionsField = ComponentUtils.copy(actionFieldPrototype, idSuffix);
 
 				ComponentUtils.updateContextForLine(lineActionsField, currentLine, lineIndex);
 				lineActionsField.setRowSpan(rowSpan);
 				lineActionsField.setItems(actions);
 
 				dataFields.add(lineActionsField);
 			}
 		}
 
 		// update colspan on sub-collection fields
 		for (GroupField subCollectionField : subCollectionFields) {
 			subCollectionField.setColSpan(numberOfDataColumns);
 		}
 
 		// add sub-collection fields to end of data fields
 		dataFields.addAll(subCollectionFields);
 	}
 
 	/**
 	 * Create the <code>LabelField</code> instances that will be used to render
 	 * the table header
 	 * 
 	 * <p>
 	 * For each column, a copy of headerFieldPrototype is made that determines
 	 * the label configuration. The actual label text comes from the field for
 	 * which the header applies to. The first column is always the sequence (if
 	 * enabled) and the last column contains the actions. Both the sequence and
 	 * action header fields will span all rows for the header.
 	 * </p>
 	 * 
 	 * <p>
 	 * The headerFields list will contain the final list of header fields built
 	 * </p>
 	 * 
 	 * @param collectionGroup
 	 *            - CollectionGroup container the table applies to
 	 * @param lineFields - fields for the data columns from which the headers are pulled
 	 */
 	protected void buildTableHeaderRows(CollectionGroup collectionGroup, List<Field> lineFields) {
 		// row count needed to determine the row span for the sequence and
 		// action fields, since they should span all rows for the line
 		int rowCount = calculateNumberOfRows(collectionGroup.getItems());
 
 		// first column is sequence label
 		if (renderSequenceField) {
 			sequenceFieldPrototype.setLabelFieldRendered(true);
 			sequenceFieldPrototype.setRowSpan(rowCount);
 			addHeaderField(sequenceFieldPrototype, 1);
 		}
 
 		// pull out label fields from the container's items
 		int cellPosition = 0;
 		for (Field field : lineFields) {
 		    if (!field.isRender()) {
 		        continue;
 		    }
 		    
 			cellPosition += field.getColSpan();
 			addHeaderField(field, cellPosition);
 
 			// add action header as last column in row
 			if ((cellPosition == getNumberOfDataColumns()) && collectionGroup.isRenderLineActions()
 					&& !collectionGroup.isReadOnly()) {
 				actionFieldPrototype.setLabelFieldRendered(true);
 				actionFieldPrototype.setRowSpan(rowCount);
 				addHeaderField(actionFieldPrototype, cellPosition);
 			}
 		}
 	}
 
 	/**
 	 * Creates a new instance of the header field prototype and then sets the
 	 * label to the short (if useShortLabels is set to true) or long label of
 	 * the given component. After created the header field is added to the list
 	 * making up the table header
 	 * 
 	 * @param field
 	 *            - field instance the header field is being created for
 	 * @param column
 	 *            - column number for the header, used for setting the id
 	 */
 	protected void addHeaderField(Field field, int column) {
 		LabelField headerField = ComponentUtils.copy(headerFieldPrototype, "_c" + column);
 		if (useShortLabels) {
 			headerField.setLabelText(field.getLabel());
 		}
 		else {
 			headerField.setLabelText(field.getLabel());
 		}
 
 		headerField.setRowSpan(field.getRowSpan());
 		headerField.setColSpan(field.getColSpan());
 
 		if ((field.getRequired() != null) && field.getRequired().booleanValue()) {
 			headerField.getRequiredMessageField().setRender(true);
 		}
 		else {
 			headerField.getRequiredMessageField().setRender(false);
 		}
 
 		headerFields.add(headerField);
 	}
 
 	/**
 	 * Calculates how many rows will be needed per collection line to display
 	 * the list of fields. Assumption is made that the total number of cells the
 	 * fields take up is evenly divisible by the configured number of columns
 	 * 
 	 * @param items
 	 *            - list of items that make up one collection line
 	 * @return int number of rows
 	 */
 	protected int calculateNumberOfRows(List<? extends Field> items) {
 		int rowCount = 0;
 		
 		// check flag that indicates only one row should be created
 		if (isSuppressLineWrapping()) {
 		    return 1;
 		}
 
 		int cellCount = 0;
 		for (Field field : items) {
 			cellCount += field.getColSpan() + field.getRowSpan() - 1;
 		}
 
 		if (cellCount != 0) {
 			rowCount = cellCount / getNumberOfDataColumns();
 		}
 
 		return rowCount;
 	}
 
 	/**
 	 * @see org.kuali.rice.kns.uif.layout.ContainerAware#getSupportedContainer()
 	 */
 	@Override
 	public Class<? extends Container> getSupportedContainer() {
 		return CollectionGroup.class;
 	}
 
 	/**
 	 * @see org.kuali.rice.kns.uif.layout.LayoutManagerBase#getNestedComponents()
 	 */
 	@Override
 	public List<Component> getNestedComponents() {
 		List<Component> components = super.getNestedComponents();
 
 		components.add(tableTools);
 		components.addAll(headerFields);
 		components.addAll(dataFields);
 
 		return components;
 	}
 
 	/**
 	 * Indicates whether the short label for the collection field should be used
 	 * as the table header or the regular label
 	 * 
 	 * @return boolean true if short label should be used, false if long label
 	 *         should be used
 	 */
 	public boolean isUseShortLabels() {
 		return this.useShortLabels;
 	}
 
 	/**
 	 * Setter for the use short label indicator
 	 * 
 	 * @param useShortLabels
 	 */
 	public void setUseShortLabels(boolean useShortLabels) {
 		this.useShortLabels = useShortLabels;
 	}
 
 	/**
 	 * Indicates whether the header should be repeated before each collection
 	 * row. If false the header is only rendered at the beginning of the table
 	 * 
 	 * @return boolean true if header should be repeated, false if it should
 	 *         only be rendered once
 	 */
 	public boolean isRepeatHeader() {
 		return this.repeatHeader;
 	}
 
 	/**
 	 * Setter for the repeat header indicator
 	 * 
 	 * @param repeatHeader
 	 */
 	public void setRepeatHeader(boolean repeatHeader) {
 		this.repeatHeader = repeatHeader;
 	}
 
 	/**
 	 * <code>LabelField</code> instance to use as a prototype for creating the
 	 * tables header fields. For each header field the prototype will be copied
 	 * and adjusted as necessary
 	 * 
 	 * @return LabelField instance to serve as prototype
 	 */
 	public LabelField getHeaderFieldPrototype() {
 		return this.headerFieldPrototype;
 	}
 
 	/**
 	 * Setter for the header field prototype
 	 * 
 	 * @param headerFieldPrototype
 	 */
 	public void setHeaderFieldPrototype(LabelField headerFieldPrototype) {
 		this.headerFieldPrototype = headerFieldPrototype;
 	}
 
 	/**
 	 * List of <code>LabelField</code> instances that should be rendered to make
 	 * up the tables header
 	 * 
 	 * @return List of label field instances
 	 */
 	public List<LabelField> getHeaderFields() {
 		return this.headerFields;
 	}
 
 	/**
 	 * Indicates whether the sequence field should be rendered for the
 	 * collection
 	 * 
 	 * @return boolean true if sequence field should be rendered, false if not
 	 */
 	public boolean isRenderSequenceField() {
 		return this.renderSequenceField;
 	}
 
 	/**
 	 * Setter for the render sequence field indicator
 	 * 
 	 * @param renderSequenceField
 	 */
 	public void setRenderSequenceField(boolean renderSequenceField) {
 		this.renderSequenceField = renderSequenceField;
 	}
 
 	/**
 	 * Expression language string for conditionally setting the render sequence
 	 * field property
 	 * 
 	 * @return String el that should evaluate to boolean
 	 */
 	public String getConditionalRenderSequenceField() {
 		return this.conditionalRenderSequenceField;
 	}
 
 	/**
 	 * Setter for the conditional render sequence field string
 	 * 
 	 * @param conditionalRenderSequenceField
 	 */
 	public void setConditionalRenderSequenceField(String conditionalRenderSequenceField) {
 		this.conditionalRenderSequenceField = conditionalRenderSequenceField;
 	}
 
 	/**
 	 * Attribute name to use as sequence value. For each collection line the
 	 * value of this field on the line will be retrieved and used as the
 	 * sequence value
 	 * 
 	 * @return String sequence property name
 	 */
     public String getSequencePropertyName() {
         if ((sequenceFieldPrototype != null) && (sequenceFieldPrototype instanceof AttributeField)) {
             return ((AttributeField) sequenceFieldPrototype).getPropertyName();
         }
 
         return null;
     }
 
     /**
      * Setter for the sequence property name
      * 
      * @param sequencePropertyName
      */
     public void setSequencePropertyName(String sequencePropertyName) {
         if ((sequenceFieldPrototype != null) && (sequenceFieldPrototype instanceof AttributeField)) {
             ((AttributeField) sequenceFieldPrototype).setPropertyName(sequencePropertyName);
         }
     }
 	
     /**
      * Indicates whether the sequence field should be generated with the current
      * line number
      * 
      * <p>
      * If set to true the sequence field prototype will be changed to a message
      * field (if not already a message field) and the text will be set to the
      * current line number
      * </p>
      * 
      * @return boolean true if the sequence field should be generated from the
      *         line number, false if not
      */
     public boolean isGenerateAutoSequence() {
         return this.generateAutoSequence;
     }
 
     /**
      * Setter for the generate auto sequence field
      * 
      * @param generateAutoSequence
      */
     public void setGenerateAutoSequence(boolean generateAutoSequence) {
         this.generateAutoSequence = generateAutoSequence;
     }
 
     /**
 	 * <code>Field</code> instance to serve as a prototype for the
 	 * sequence field. For each collection line this instance is copied and
 	 * adjusted as necessary
 	 * 
 	 * @return Attribute field instance
 	 */
 	public Field getSequenceFieldPrototype() {
 		return this.sequenceFieldPrototype;
 	}
 
 	/**
 	 * Setter for the sequence field prototype
 	 * 
 	 * @param sequenceFieldPrototype
 	 */
 	public void setSequenceFieldPrototype(Field sequenceFieldPrototype) {
 		this.sequenceFieldPrototype = sequenceFieldPrototype;
 	}
 
 	/**
 	 * <code>GroupField</code> instance to serve as a prototype for the actions
 	 * column. For each collection line this instance is copied and adjusted as
 	 * necessary. Note the actual actions for the group come from the collection
 	 * groups actions List
 	 * (org.kuali.rice.kns.uif.container.CollectionGroup.getActionFields()). The
 	 * GroupField prototype is useful for setting styling of the actions column
 	 * and for the layout of the action fields. Note also the label associated
 	 * with the prototype is used for the action column header
 	 * 
 	 * @return GroupField instance
 	 */
 	public GroupField getActionFieldPrototype() {
 		return this.actionFieldPrototype;
 	}
 
 	/**
 	 * Setter for the action field prototype
 	 * 
 	 * @param actionFieldPrototype
 	 */
 	public void setActionFieldPrototype(GroupField actionFieldPrototype) {
 		this.actionFieldPrototype = actionFieldPrototype;
 	}
 
 	/**
 	 * @see org.kuali.rice.kns.uif.layout.CollectionLayoutManager#getSubCollectionGroupFieldPrototype()
 	 */
 	public GroupField getSubCollectionGroupFieldPrototype() {
 		return this.subCollectionGroupFieldPrototype;
 	}
 
 	/**
 	 * Setter for the sub-collection field group prototype
 	 * 
 	 * @param subCollectionGroupFieldPrototype
 	 */
 	public void setSubCollectionGroupFieldPrototype(GroupField subCollectionGroupFieldPrototype) {
 		this.subCollectionGroupFieldPrototype = subCollectionGroupFieldPrototype;
 	}
 
 	/**
 	 * List of <code>Field</code> instances that make up the tables body. Pulled
 	 * by the layout manager template to send through the Grid layout
 	 * 
 	 * @return List<Field> table body fields
 	 */
 	public List<Field> getDataFields() {
 		return this.dataFields;
 	}
 
 	/**
 	 * Widget associated with the table to add functionality such as sorting,
 	 * paging, and export
 	 * 
 	 * @return TableTools instance
 	 */
 	public TableTools getTableTools() {
 		return this.tableTools;
 	}
 
 	/**
 	 * Setter for the table tools widget
 	 * 
 	 * @param tableTools
 	 */
 	public void setTableTools(TableTools tableTools) {
 		this.tableTools = tableTools;
 	}
 
 	/**
      * @return the numberOfDataColumns
      */
     public int getNumberOfDataColumns() {
     	return this.numberOfDataColumns;
     }
 
 	/**
      * @param numberOfDataColumns the numberOfDataColumns to set
      */
     public void setNumberOfDataColumns(int numberOfDataColumns) {
     	this.numberOfDataColumns = numberOfDataColumns;
     }
 
 }