/*
    * Copyright 2008 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.ole.sys.document.web;
  
  import java.io.IOException;
  import java.util.List;
  import java.util.Map;
  
  import javax.servlet.jsp.JspException;
  import javax.servlet.jsp.PageContext;
  import javax.servlet.jsp.tagext.JspFragment;
  import javax.servlet.jsp.tagext.Tag;
  
  import org.kuali.ole.sys.document.AccountingDocument;
  import org.kuali.ole.sys.document.datadictionary.AccountingLineGroupDefinition;
  import org.kuali.ole.sys.document.datadictionary.TotalDefinition;
  import org.kuali.ole.sys.document.web.renderers.CellCountCurious;
  import org.kuali.ole.sys.document.web.renderers.CollectionPropertiesCurious;
  import org.kuali.ole.sys.document.web.renderers.GroupErrorsRenderer;
  import org.kuali.ole.sys.document.web.renderers.GroupTitleLineRenderer;
  import org.kuali.ole.sys.document.web.renderers.Renderer;
  import org.kuali.ole.sys.document.web.renderers.RepresentedCellCurious;
  import org.kuali.rice.kew.api.WorkflowDocument;
  import org.kuali.rice.krad.util.GlobalVariables;
  
  /**
   * This represents an accounting line group in renderable state
   */
  public class DefaultAccountingLineGroupImpl implements AccountingLineGroup {
      protected AccountingLineGroupDefinition groupDefinition;
      protected JspFragment importLineOverride;
      protected String collectionPropertyName;
      protected List<? extends AccountingLineRenderingContext> containers;
      protected AccountingDocument accountingDocument;
      protected int cellCount = 0;
      protected int arbitrarilyHighIndex;
      protected Map<String, Object> displayedErrors;
      protected Map<String, Object> displayedWarnings;
      protected Map<String, Object> displayedInfo;
      protected boolean canEdit;
      protected String collectionItemPropertyName;
      protected List errorKeys;
      
      /**
       * Constructs a DefaultAccountingLineGroupImpl
       */
      public DefaultAccountingLineGroupImpl() {}
  
      /**
       * Initializes the DefaultAccountingLineGroupImpl
       * 
       * @param groupDefinition the data dictionary group definition for this accounting line group
       * @param accountingDocument the document which owns or will own the accounting line being rendered
       * @param containers the containers within this group
       * @param collectionPropertyName the property name of the collection of accounting lines owned by this group
       * @param errors a List of errors keys for errors on the page
       * @param displayedErrors a Map of errors that have already been displayed
       * @param canEdit determines if the page can be edited or not
       */
      public void initialize(AccountingLineGroupDefinition groupDefinition, AccountingDocument accountingDocument, List<RenderableAccountingLineContainer> containers, String collectionPropertyName, String collectionItemPropertyName, Map<String, Object> displayedErrors, Map<String, Object> displayedWarnings, Map<String, Object> displayedInfo, boolean canEdit) {
          this.groupDefinition = groupDefinition;
          this.accountingDocument = accountingDocument;
          this.containers = containers;
          this.collectionPropertyName = collectionPropertyName;
          this.collectionItemPropertyName = collectionItemPropertyName;
          this.displayedErrors = displayedErrors;
          this.displayedWarnings = displayedWarnings;
          this.displayedInfo = displayedInfo;
          this.canEdit = canEdit;
      }
  
      /**
       * Renders the whole of this accounting line group
       * 
       * @param pageContext the page context to render to
       * @param parentTag the AccountingLinesTag that is requesting this rendering
       */
      public void renderEverything(PageContext pageContext, Tag parentTag) throws JspException {
          if (groupDefinition.isHeaderRendering()) {
              renderGroupHeader(pageContext, parentTag);
          }
          renderAccountingLineContainers(pageContext, parentTag);
  
          boolean renderTotals = !accountingDocument.getSourceAccountingLines().isEmpty() || !accountingDocument.getTargetAccountingLines().isEmpty();
          renderTotals &= groupDefinition.getTotals() != null && groupDefinition.getTotals().size() > 0;
          if (renderTotals) {
             renderTotals(pageContext, parentTag);
         }
     }
 
     /**
      * Finds the maximum number of cells in the accounting line table row
      * 
      * @param rows the rows which are being rendered
      * @return the maximum number of cells to render
      */
     public int getWidthInCells() {
         if (groupDefinition.getForceColumnCount() > 0)
             return groupDefinition.getForceColumnCount();
         if (cellCount > 0)
             return cellCount;
 
         int max = 0;
         for (AccountingLineRenderingContext line : containers) {
             if (line.getRenderableCellCount() > max) {
                 max = line.getRenderableCellCount();
             }
         }
         cellCount = max;
         return cellCount;
     }
 
     /**
      * Renders the group header/import line for the accounting line group. Renders importLineOverride if present; otherwise, uses
      * ImportLineRenderer to do its dirty work
      * 
      * @param accountingLineGroupDefinition the accounting line group definition
      * @param rows the rows to render
      * @throws JspException thrown if something goes wrong in rendering the header
      */
     protected void renderGroupHeader(PageContext pageContext, Tag parentTag) throws JspException {
         if (importLineOverride != null) {
             try {
                 importLineOverride.invoke(pageContext.getOut());
             }
             catch (IOException ioe) {
                 throw new JspException("Could not render import line override fragment", ioe);
             }
         }
         else {
             GroupTitleLineRenderer groupTitleLineRenderer = new GroupTitleLineRenderer();
             groupTitleLineRenderer.setAccountingLineGroupDefinition(groupDefinition);
             groupTitleLineRenderer.setCellCount(getWidthInCells());
             groupTitleLineRenderer.setLineCollectionProperty(collectionPropertyName);
             groupTitleLineRenderer.setAccountingDocument(accountingDocument);
             groupTitleLineRenderer.setCanEdit(canEdit);
 
             boolean isGroupEditable = groupDefinition.getAccountingLineAuthorizer().isGroupEditable(accountingDocument, containers, GlobalVariables.getUserSession().getPerson());            
             groupTitleLineRenderer.overrideCanUpload(groupDefinition.isImportingAllowed() && isGroupEditable);
             groupTitleLineRenderer.setGroupActionsRendered(!this.isDocumentEnrouted() && isGroupEditable);
 
             groupTitleLineRenderer.render(pageContext, parentTag);
             groupTitleLineRenderer.clear();
         }
 
         renderErrors(pageContext, parentTag);
     }
     
     /**
      * Renders any errors for the group
      * @param pageContext the page context where the errors will be rendered on
      * @param parentTag the parent tag requesting the rendering
      */
     protected void renderErrors(PageContext pageContext, Tag parentTag) throws JspException {
         GroupErrorsRenderer errorRenderer = getErrorRenderer();
         errorRenderer.setErrorKeyMatch(groupDefinition.getErrorKey());
         errorRenderer.setColSpan(getWidthInCells());
         errorRenderer.render(pageContext, parentTag);
 
         moveListToMap(errorRenderer.getErrorsRendered(), getDisplayedErrors());
         moveListToMap(errorRenderer.getWarningsRendered(), getDisplayedWarnings());
         moveListToMap(errorRenderer.getInfoRendered(), getDisplayedInfo());
 
         errorRenderer.clear();
     }
     
     /**
      * Moves all of the members of theList into theMap as a key with the value always being the String "true"
      * @param theList the List of Strings to be keys
      * @param theMap the Map of keys and values
      */
     protected void moveListToMap(List<String> theList, Map theMap) {
         for (String s : theList) {
             theMap.put(s, "true");
         }
     }
     
     /**
      * @return get a GroupErrorsRenderer in a way which can be overridden
      */
     protected GroupErrorsRenderer getErrorRenderer() {
         return new GroupErrorsRenderer();
     }
 
     /**
      * Renders the accounting line containers
      * 
      * @param containers the containers to render
      * @throws JspException thrown if rendering goes badly
      */
     protected void renderAccountingLineContainers(PageContext pageContext, Tag parentTag) throws JspException {
         for (AccountingLineRenderingContext container : containers) {
             container.populateValuesForFields();
             container.populateWithTabIndexIfRequested(arbitrarilyHighIndex);
             container.renderElement(pageContext, parentTag, container);
         }
     }
 
     /**
      * Renders all of the totals required by the group total definition
      * 
      * @param groupDefinition the accounting line view group definition
      * @param lines the lines that will be rendered - so we can count how many cells we're rendering
      * @throws JspException thrown if something goes wrong
      */
     protected void renderTotals(PageContext pageContext, Tag parentTag) throws JspException {
         int cellCount = getWidthInCells();
 
         List<? extends TotalDefinition> groupTotals = groupDefinition.getTotals();
         for (TotalDefinition definition : groupTotals) {
             if (definition instanceof NestedFieldTotaling) {
                 NestedFieldTotaling nestedFieldTotaling = (NestedFieldTotaling) definition;
 
                 if (nestedFieldTotaling.isNestedProperty()) {
                     int index = groupTotals.indexOf(definition);
                     AccountingLineRenderingContext container = this.containers.get(index);
                     String containingObjectPropertyName = container.getAccountingLineContainingObjectPropertyName();
                     nestedFieldTotaling.setContainingPropertyName(containingObjectPropertyName);
                 }
             }
 
             Renderer renderer = definition.getTotalRenderer();
             if (renderer instanceof CellCountCurious) {
                 ((CellCountCurious) renderer).setCellCount(cellCount);
             }
 
             if (renderer instanceof RepresentedCellCurious) {
                 RepresentedCellCurious representedCellCurious = ((RepresentedCellCurious) renderer);
                 int columnNumberOfRepresentedCell = this.getRepresentedColumnNumber(representedCellCurious.getRepresentedCellPropertyName());
                 representedCellCurious.setColumnNumberOfRepresentedCell(columnNumberOfRepresentedCell);
             }
             
             if (renderer instanceof CollectionPropertiesCurious) {
                 ((CollectionPropertiesCurious)renderer).setCollectionProperty(this.collectionPropertyName);
                 ((CollectionPropertiesCurious)renderer).setCollectionItemProperty(this.collectionItemPropertyName);
             }
 
             renderer.render(pageContext, parentTag);
             renderer.clear();
         }
     }
 
     /**
      * get the column number of the tabel cell with the given property name in an accounting line table
      * 
      * @param propertyName the given property name that is associated with the column
      * @return the column number of the tabel cell with the given property name in an accounting line table
      */
     protected int getRepresentedColumnNumber(String propertyName) {
         for (AccountingLineRenderingContext container : containers) {
             List<AccountingLineTableRow> tableRows = container.getRows();
 
             for (AccountingLineTableRow row : tableRows) {
                 List<AccountingLineTableCell> tableCells = row.getCells();
                 int cumulativeDisplayCellCount = 0;
 
                 for (AccountingLineTableCell cell : tableCells) {
                     cumulativeDisplayCellCount += cell.getColSpan();
                     List<RenderableElement> fields = cell.getRenderableElement();
 
                     for (RenderableElement field : fields) {
                         if (field instanceof ElementNamable == false) {
                             continue;
                         }
 
                         if (((ElementNamable) field).getName().equals(propertyName)) {
                             return cumulativeDisplayCellCount;
                         }
                     }
                 }
             }
         }
 
         return -1;
     }
 
     /**
      * Sets the cellCount attribute value.
      * 
      * @param cellCount The cellCount to set.
      */
     public void setCellCount(int cellCount) {
         this.cellCount = cellCount;
     }
 
     /**
      * Sets the importLineOverride attribute value.
      * 
      * @param importLineOverride The importLineOverride to set.
      */
     public void setImportLineOverride(JspFragment importLineOverride) {
         this.importLineOverride = importLineOverride;
     }
 
     /**
      * Sets the form's arbitrarily high tab index
      * 
      * @param arbitrarilyHighIndex the index to set
      */
     public void setArbitrarilyHighIndex(int arbitrarilyHighIndex) {
         this.arbitrarilyHighIndex = arbitrarilyHighIndex;
     }
 
     /**
      * Gets the displayedWarnings attribute. 
      * @return Returns the displayedWarnings.
      */
     public Map getDisplayedWarnings() {
         return displayedWarnings;
     }
 
     /**
      * Gets the displayedInfo attribute. 
      * @return Returns the displayedInfo.
      */
     public Map getDisplayedInfo() {
         return displayedInfo;
     }
 
     /**
      * Gets the errorKeys attribute. 
      * @return Returns the errorKeys.
      */
     public List getErrorKeys() {
         return errorKeys;
     }
 
     /**
      * Sets the errorKeys attribute value.
      * @param errorKeys The errorKeys to set.
      */
     public void setErrorKeys(List errorKeys) {
         this.errorKeys = errorKeys;
     }
 
     /**
      * Determines if the current document is enrouted
      */
     private boolean isDocumentEnrouted() {
         WorkflowDocument workflowDocument = accountingDocument.getDocumentHeader().getWorkflowDocument();
 
         return !workflowDocument.isInitiated() && !workflowDocument.isSaved();
     }
     
     /**
      * Determines if there is more than one editable line in this group; if so, then it allows deleting
      */
     public void updateDeletabilityOfAllLines() {
         if (this.isDocumentEnrouted()) {
             if (hasEnoughAccountingLinesForDelete()) {
                 for (AccountingLineRenderingContext accountingLineRenderingContext : containers) {
                     if (accountingLineRenderingContext.isEditableLine()) {
                         accountingLineRenderingContext.makeDeletable();
                     }
                 }
             }
         } else {
             // we're pre-route - everybody is deletable!
             for (AccountingLineRenderingContext accountingLineRenderingContext : containers) {
                 accountingLineRenderingContext.makeDeletable();
             }
         }
     }
     
     /**
      * Determines if there are enough accounting lines in this group for delete buttons to be present
      * @return true if there are enough accounting lines for a delete, false otherwise
      */
     protected boolean hasEnoughAccountingLinesForDelete() {
         // 1. get the count of how many accounting lines are editable
         int editableLineCount = 0;
         for (AccountingLineRenderingContext accountingLineRenderingContext : containers) {
             if (!accountingLineRenderingContext.isNewLine() && accountingLineRenderingContext.isEditableLine()) {
                 editableLineCount += 1;
             }
             if (editableLineCount == 2) return true; // we know we're good...skip out early
         }
         return false;
     }
 
     /**
      * Gets the collectionItemPropertyName attribute. 
      * @return Returns the collectionItemPropertyName.
      */
     public String getCollectionItemPropertyName() {
         return collectionItemPropertyName;
     }
 
     /**
      * Gets the groupDefinition attribute. 
      * @return Returns the groupDefinition.
      */
     public AccountingLineGroupDefinition getGroupDefinition() {
         return groupDefinition;
     }
 
     /**
      * Sets the groupDefinition attribute value.
      * @param groupDefinition The groupDefinition to set.
      */
     public void setGroupDefinition(AccountingLineGroupDefinition groupDefinition) {
         this.groupDefinition = groupDefinition;
     }
 
     /**
      * Gets the displayedErrors attribute. 
      * @return Returns the displayedErrors.
      */
     public Map getDisplayedErrors() {
         return displayedErrors;
     }
 
     /**
      * Sets the displayedErrors attribute value.
      * @param displayedErrors The displayedErrors to set.
      */
     public void setDisplayedErrors(Map displayedErrors) {
         this.displayedErrors = displayedErrors;
     }
 
     /**
      * Gets the collectionPropertyName attribute. 
      * @return Returns the collectionPropertyName.
      */
     public String getCollectionPropertyName() {
         return collectionPropertyName;
     }
 
     /**
      * Sets the collectionPropertyName attribute value.
      * @param collectionPropertyName The collectionPropertyName to set.
      */
     public void setCollectionPropertyName(String collectionPropertyName) {
         this.collectionPropertyName = collectionPropertyName;
     }
 
     /**
      * Sets the collectionItemPropertyName attribute value.
      * @param collectionItemPropertyName The collectionItemPropertyName to set.
      */
     public void setCollectionItemPropertyName(String collectionItemPropertyName) {
         this.collectionItemPropertyName = collectionItemPropertyName;
     }
 
 
     public AccountingDocument getAccountingDocument() {
         return accountingDocument;
     }
 
     public void setAccountingDocument(AccountingDocument accountingDocument) {
         this.accountingDocument = accountingDocument;
     }
 }