/*
    * 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.fp.document.validation.impl;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import org.kuali.ole.fp.document.TransferOfFundsDocument;
  import org.kuali.ole.fp.document.service.TransferOfFundsService;
  import org.kuali.ole.sys.OLEKeyConstants;
  import org.kuali.ole.sys.businessobject.AccountingLine;
  import org.kuali.ole.sys.document.AccountingDocument;
  import org.kuali.ole.sys.document.validation.GenericValidation;
  import org.kuali.ole.sys.document.validation.event.AttributedDocumentEvent;
  import org.kuali.rice.core.api.util.type.KualiDecimal;
  import org.kuali.rice.krad.util.GlobalVariables;
  
  /**
   * Transfer of Funds document validation which checks that mandatory and non-mandatory transfer totals are in balance.
   */
  public class TransferOfFundsTransferTotalsBalancedValidation extends GenericValidation {
      private AccountingDocument accountingDocumentForValidation;
      private TransferOfFundsService transferOfFundsService;
  
      /**
       * This method checks the sum of all of the "From" accounting lines with mandatory transfer object codes against the sum of all
       * of the "To" accounting lines with mandatory transfer object codes. In addition, it does the same, but for accounting lines
       * with non-mandatory transfer object code. This is to enforce the rule that the document must balance within the object code
       * object sub-type codes of mandatory transfers and non-mandatory transfers.
       * @see org.kuali.ole.sys.document.validation.Validation#validate(org.kuali.ole.sys.document.validation.event.AttributedDocumentEvent)
       */
      public boolean validate(AttributedDocumentEvent event) {
          TransferOfFundsDocument tofDoc = (TransferOfFundsDocument)accountingDocumentForValidation;
          List lines = new ArrayList();
  
          lines.addAll(tofDoc.getSourceAccountingLines());
          lines.addAll(tofDoc.getTargetAccountingLines());
  
          // sum the from lines.
          KualiDecimal mandatoryTransferFromAmount = KualiDecimal.ZERO;
          KualiDecimal nonMandatoryTransferFromAmount = KualiDecimal.ZERO;
          KualiDecimal mandatoryTransferToAmount = KualiDecimal.ZERO;
          KualiDecimal nonMandatoryTransferToAmount = KualiDecimal.ZERO;
  
          for (Iterator i = lines.iterator(); i.hasNext();) {
              AccountingLine line = (AccountingLine) i.next();
              String objectSubTypeCode = line.getObjectCode().getFinancialObjectSubTypeCode();
  
              if (transferOfFundsService.isNonMandatoryTransfersSubType(objectSubTypeCode)) {
                  if (line.isSourceAccountingLine()) {
                      nonMandatoryTransferFromAmount = nonMandatoryTransferFromAmount.add(line.getAmount());
                  }
                  else {
                      nonMandatoryTransferToAmount = nonMandatoryTransferToAmount.add(line.getAmount());
                  }
              }
              else if (transferOfFundsService.isMandatoryTransfersSubType(objectSubTypeCode)) {
                  if (line.isSourceAccountingLine()) {
                      mandatoryTransferFromAmount = mandatoryTransferFromAmount.add(line.getAmount());
                  }
                  else {
                      mandatoryTransferToAmount = mandatoryTransferToAmount.add(line.getAmount());
                  }
              }
          }
  
          // check that the amounts balance across mandatory transfers and non-mandatory transfers
          boolean isValid = true;
  
          if (mandatoryTransferFromAmount.compareTo(mandatoryTransferToAmount) != 0) {
              isValid = false;
              GlobalVariables.getMessageMap().putError("document.sourceAccountingLines", OLEKeyConstants.ERROR_DOCUMENT_TOF_MANDATORY_TRANSFERS_DO_NOT_BALANCE);
          }
  
          if (nonMandatoryTransferFromAmount.compareTo(nonMandatoryTransferToAmount) != 0) {
              isValid = false;
              GlobalVariables.getMessageMap().putError("document.sourceAccountingLines", OLEKeyConstants.ERROR_DOCUMENT_TOF_NON_MANDATORY_TRANSFERS_DO_NOT_BALANCE);
          }
  
          return isValid;
      }
  
      /**
       * Gets the accountingDocumentForValidation attribute. 
       * @return Returns the accountingDocumentForValidation.
      */
     public AccountingDocument getAccountingDocumentForValidation() {
         return accountingDocumentForValidation;
     }
 
     /**
      * Sets the accountingDocumentForValidation attribute value.
      * @param accountingDocumentForValidation The accountingDocumentForValidation to set.
      */
     public void setAccountingDocumentForValidation(AccountingDocument accountingDocumentForValidation) {
         this.accountingDocumentForValidation = accountingDocumentForValidation;
     }
 
     /**
      * Gets the transferOfFundsService attribute. 
      * @return Returns the transferOfFundsService.
      */
     public TransferOfFundsService getTransferOfFundsService() {
         return transferOfFundsService;
     }
 
     /**
      * Sets the transferOfFundsService attribute value.
      * @param transferOfFundsService The transferOfFundsService to set.
      */
     public void setTransferOfFundsService(TransferOfFundsService transferOfFundsService) {
         this.transferOfFundsService = transferOfFundsService;
     }
 }