package org.kuali.ole.gl.businessobject.lookup;
   
   import org.apache.commons.lang.StringUtils;
   
   import org.kuali.ole.gl.Constant;
   import org.kuali.ole.gl.GeneralLedgerConstants;
   import org.kuali.ole.gl.OJBUtility;
   import org.kuali.ole.gl.batch.service.BalanceCalculator;
   import org.kuali.ole.gl.batch.service.impl.PostBalance;
  import org.kuali.ole.gl.businessobject.Balance;
  import org.kuali.ole.gl.businessobject.CashBalance;
  import org.kuali.ole.gl.service.BalanceService;
  import org.kuali.ole.sys.OLEConstants;
  import org.kuali.ole.sys.OLEPropertyConstants;
  import org.kuali.ole.sys.businessobject.GeneralLedgerPendingEntry;
  import org.kuali.ole.sys.businessobject.UniversityDate;
  import org.kuali.ole.sys.context.SpringContext;
  import org.kuali.ole.sys.service.GeneralLedgerPendingEntryService;
  import org.kuali.ole.sys.service.UniversityDateService;
  import org.kuali.rice.core.api.util.RiceKeyConstants;
  import org.kuali.rice.core.api.util.type.KualiDecimal;
  import org.kuali.rice.kns.service.BusinessObjectDictionaryService;
  
  import org.kuali.rice.krad.lookup.LookupForm;
  import org.kuali.rice.krad.lookup.LookupableImpl;
  
  import org.kuali.rice.krad.util.GlobalVariables;
  import org.kuali.rice.krad.util.KRADConstants;
  
  import java.util.*;
  
  /**
   * Created by arunag on 9/29/14.
   */
  public class OLECashBalanceLookupableImpl extends LookupableImpl {
  
      private BalanceCalculator postBalance;
      //private BalanceService balanceService = SpringContext.getBean(glBalanceService);
      protected Class businessObjectClass;
      protected BusinessObjectDictionaryService businessObjectDictionaryService;
      protected GeneralLedgerPendingEntryService generalLedgerPendingEntryService;
      protected BalanceService balanceService;
  
  
      public BalanceService getBalanceService() {
          if(balanceService == null) {
               balanceService =  SpringContext.getBean(BalanceService.class);
          }
          return balanceService;
      }
  
      public void setBalanceService(BalanceService balanceService) {
          this.balanceService = balanceService;
      }
  
      @Override
      public Collection<?> performSearch(LookupForm form, Map<String, String> searchCriteria, boolean bounded) {
  
  
          for (Map.Entry<String, String> entry : searchCriteria.entrySet()) {
              if (entry.getKey().equalsIgnoreCase(OLEConstants.FISCAL_YEAR) && (entry.getValue()==null || entry.getValue().isEmpty())) {
                  GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_ERRORS,"Fiscal Year is a required field");
                  return new ArrayList<Object>();
              }if (entry.getKey().equalsIgnoreCase(OLEConstants.ACCOUNT_NUMBER) && (entry.getValue()==null || entry.getValue().isEmpty())) {
                  GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_ERRORS,"Account Number is a required field");
                  return new ArrayList<Object>();
              }if (entry.getKey().equalsIgnoreCase(OLEConstants.CHART_CODE) && (entry.getValue()==null || entry.getValue().isEmpty())) {
                  GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_ERRORS,"Chart Code is a required field");
                  return new ArrayList<Object>();
              }
          }
          String pendingEntryOption = searchCriteria.get(Constant.PENDING_ENTRY_OPTION);
          String consolidationOption = (String) searchCriteria.get(GeneralLedgerConstants.DummyBusinessObject.CONSOLIDATION_OPTION);
          boolean isConsolidated = isConsolidationSelected(searchCriteria);
          if (consolidationOption.equals(Constant.EXCLUDE_SUBACCOUNTS)){
              searchCriteria.put(Constant.SUB_ACCOUNT_OPTION, OLEConstants.getDashSubAccountNumber());
              isConsolidated = false;
          }
  
          searchCriteria.remove("dummyBusinessObject.pendingEntryOption");
  
          Iterator cashBalanceIterator = getBalanceService().lookupCashBalance(searchCriteria, isConsolidated);
          Collection searchResultsCollection = this.buildCashBalanceCollection(cashBalanceIterator, isConsolidated);
  
  /*
          if(searchResultsCollection.size() == 0){
              GlobalVariables.getMessageMap().putInfoForSectionId("resultsPropertyName",
                      RiceKeyConstants.INFO_LOOKUP_RESULTS_NONE_FOUND);
          }
  */
  
          // update search results according to the selected pending entry option
          updateByPendingLedgerEntry(searchResultsCollection, searchCriteria, pendingEntryOption, isConsolidated, false);
  
          // get the actual size of all qualified search results
          Integer recordCount = getBalanceService().getCashBalanceRecordCount(searchCriteria, isConsolidated);
          Long actualSize = OJBUtility.getResultActualSize(searchResultsCollection, recordCount, searchCriteria, new Balance());
  
          //return this.buildSearchResultList(searchResultsCollection, actualSize);
         return searchResultsCollection;
     }
 
     /**
      * This method builds the cash balance collection based on the input iterator
      *
      * @param iterator the iterator of search results of avaiable cash balance
      * @return the cash balance collection
      */
     private Collection buildCashBalanceCollection(Iterator iterator, boolean isConsolidated) {
         Collection balanceCollection = new ArrayList();
 
         while (iterator.hasNext()) {
             Object cashBalance = iterator.next();
 
             if (cashBalance.getClass().isArray()) {
                 int i = 0;
                 Object[] array = (Object[]) cashBalance;
                 Balance balance = new CashBalance();
 
                 balance.setUniversityFiscalYear(new Integer(array[i++].toString()));
                 balance.setChartOfAccountsCode(array[i++].toString());
                 balance.setAccountNumber(array[i++].toString());
 
                 String subAccountNumber = isConsolidated ? Constant.CONSOLIDATED_SUB_ACCOUNT_NUMBER : array[i++].toString();
                 balance.setSubAccountNumber(subAccountNumber);
 
                 balance.setBalanceTypeCode(array[i++].toString());
                 balance.setObjectCode(array[i++].toString());
 
                 String subObjectCode = isConsolidated ? Constant.CONSOLIDATED_SUB_OBJECT_CODE : array[i++].toString();
                 balance.setSubObjectCode(subObjectCode);
 
                 String objectTypeCode = isConsolidated ? Constant.CONSOLIDATED_OBJECT_TYPE_CODE : array[i++].toString();
                 balance.setObjectTypeCode(objectTypeCode);
 
                 KualiDecimal annualAmount = new KualiDecimal(array[i++].toString());
                 balance.setAccountLineAnnualBalanceAmount(annualAmount);
 
                 KualiDecimal beginningAmount = new KualiDecimal(array[i++].toString());
                 balance.setBeginningBalanceLineAmount(beginningAmount);
 
                 KualiDecimal CGBeginningAmount = new KualiDecimal(array[i].toString());
                 balance.setContractsGrantsBeginningBalanceAmount(CGBeginningAmount);
 
                 KualiDecimal totalAvailableAmount = this.getTotalAvailableCashAmount(balance);
                 balance.getDummyBusinessObject().setGenericAmount(totalAvailableAmount);
 
                 balanceCollection.add(balance);
             }
         }
         return balanceCollection;
     }
 
 
 
     protected void updateEntryCollection(Collection entryCollection, Map fieldValues, boolean isApproved, boolean isConsolidated, boolean isCostShareInclusive) {
 
         // convert the field names of balance object into corresponding ones of pending entry object
         Map pendingEntryFieldValues = BusinessObjectFieldConverter.convertToTransactionFieldValues(fieldValues);
 
         UniversityDate today = SpringContext.getBean(UniversityDateService.class).getCurrentUniversityDate();
         String currentFiscalPeriodCode = today.getUniversityFiscalAccountingPeriod();
         Integer currentFiscalYear = today.getUniversityFiscalYear();
 
         // use the pending entry to update the input entry collection
         Iterator pendingEntryIterator = getGeneralLedgerPendingEntryService().findPendingLedgerEntriesForCashBalance(pendingEntryFieldValues, isApproved);
         while (pendingEntryIterator.hasNext()) {
             GeneralLedgerPendingEntry pendingEntry = (GeneralLedgerPendingEntry) pendingEntryIterator.next();
 
             // Fix the fiscal period/year if they are null
             // Don't want to use the GLPE service.fillInFiscalPeriodYear. It totally kills performance.
             // generalLedgerPendingEntryService.fillInFiscalPeriodYear(pendingEntry);
 
             if (pendingEntry.getUniversityFiscalYear() == null) {
                 pendingEntry.setUniversityFiscalYear(currentFiscalYear);
             }
 
             if (pendingEntry.getUniversityFiscalPeriodCode() == null) {
                 pendingEntry.setUniversityFiscalPeriodCode(currentFiscalPeriodCode);
             }
 
             // if consolidated, change the following fields into the default values for consolidation
             if (isConsolidated) {
                 pendingEntry.setSubAccountNumber(Constant.CONSOLIDATED_SUB_ACCOUNT_NUMBER);
                 pendingEntry.setFinancialSubObjectCode(Constant.CONSOLIDATED_SUB_OBJECT_CODE);
                 pendingEntry.setFinancialObjectTypeCode(Constant.CONSOLIDATED_OBJECT_TYPE_CODE);
             }
             Balance balance = getPostBalance().findBalance(entryCollection, pendingEntry);
             getPostBalance().updateBalance(pendingEntry, balance);
 
             KualiDecimal totalAvailableAmount = this.getTotalAvailableCashAmount(balance);
             balance.getDummyBusinessObject().setGenericAmount(totalAvailableAmount);
         }
     }
 
     // calculate the total available cash amont of the given balance record
     private KualiDecimal getTotalAvailableCashAmount(Balance balance) {
         KualiDecimal annualAmount = balance.getAccountLineAnnualBalanceAmount();
         KualiDecimal beginningAmount = balance.getBeginningBalanceLineAmount();
         KualiDecimal CGBeginningAmount = balance.getContractsGrantsBeginningBalanceAmount();
 
         KualiDecimal totalAvailableAmount = annualAmount.add(beginningAmount);
         totalAvailableAmount = totalAvailableAmount.add(CGBeginningAmount);
 
         return totalAvailableAmount;
     }
 
 
 
     protected String getSelectedPendingEntryOption(Map fieldValues) {
         // truncate the non-property filed
         String pendingEntryOption = (String) fieldValues.get(Constant.PENDING_ENTRY_OPTION);
         fieldValues.remove(Constant.PENDING_ENTRY_OPTION);
 
         return pendingEntryOption;
     }
 
     protected boolean isConsolidationSelected(Map fieldValues) {
         // truncate the non-property filed
         String consolidationOption = (String) fieldValues.get(Constant.CONSOLIDATION_OPTION);
         fieldValues.remove(Constant.CONSOLIDATION_OPTION);
 
         // detail option would be used
         if (Constant.DETAIL.equals(consolidationOption)) {
             return false;
         }
 
         // if the subAccountNumber is specified, detail option could be used
         String subAccountNumber = (String) fieldValues.get(OLEPropertyConstants.SUB_ACCOUNT_NUMBER);
         if (!StringUtils.isBlank(subAccountNumber)) {
             //this.changeFieldValue(Constant.CONSOLIDATION_OPTION, Constant.DETAIL);
             return false;
         }
 
         // if the subObjectCode is specified, detail option could be used
         String subObjectCode = (String) fieldValues.get(OLEPropertyConstants.SUB_OBJECT_CODE);
         if (!StringUtils.isBlank(subObjectCode)) {
             //this.changeFieldValue(Constant.CONSOLIDATION_OPTION, Constant.DETAIL);
             return false;
         }
 
         // if the objectTypeCode is specified, detail option could be used
         String objectTypeCode = (String) fieldValues.get(OLEPropertyConstants.OBJECT_TYPE_CODE);
         if (!StringUtils.isBlank(objectTypeCode)) {
             //this.changeFieldValue(Constant.CONSOLIDATION_OPTION, Constant.DETAIL);
             return false;
         }
         return true;
     }
 
     protected void updateByPendingLedgerEntry(Collection entryCollection, Map fieldValues, String pendingEntryOption, boolean isConsolidated, boolean isCostShareInclusive) {
 
         // determine if search results need to be updated by pending ledger entries
         if (Constant.ALL_PENDING_ENTRY.equals(pendingEntryOption)) {
             updateEntryCollection(entryCollection, fieldValues, false, isConsolidated, isCostShareInclusive);
         }
         else if (Constant.APPROVED_PENDING_ENTRY.equals(pendingEntryOption)) {
             updateEntryCollection(entryCollection, fieldValues, true, isConsolidated, isCostShareInclusive);
         }
     }
 /*
     protected List buildSearchResultList(Collection searchResultsCollection, Long actualSize) {
         CollectionIncomplete results = new CollectionIncomplete(searchResultsCollection, actualSize);
 
         // sort list if default sort column given
         List searchResults = results;
         List defaultSortColumns = getDefaultSortColumns();
         if (defaultSortColumns.size() > 0) {
             Collections.sort(results, new BeanPropertyComparator(defaultSortColumns, true));
         }
         return searchResults;
     }*/
 
     public Class getBusinessObjectClass() {
         return businessObjectClass;
     }
 
     protected GeneralLedgerPendingEntryService getGeneralLedgerPendingEntryService() {
         if(generalLedgerPendingEntryService == null){
             generalLedgerPendingEntryService = SpringContext.getBean(GeneralLedgerPendingEntryService.class);
         }
         return generalLedgerPendingEntryService;
     }
 
     public BalanceCalculator getPostBalance() {
         if(postBalance == null){
             postBalance = SpringContext.getBean(BalanceCalculator.class);
         }
         return postBalance;
     }
 
     public void setPostBalance(BalanceCalculator postBalance) {
         this.postBalance = postBalance;
     }
 }