/*
 * Copyright 2006 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.gl.service.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.IteratorUtils;
import org.kuali.ole.coa.businessobject.Account;
import org.kuali.ole.coa.businessobject.OrganizationReversion;
import org.kuali.ole.coa.service.BalanceTypeService;
import org.kuali.ole.coa.service.ObjectTypeService;
import org.kuali.ole.coa.service.SubFundGroupService;
import org.kuali.ole.gl.GeneralLedgerConstants;
import org.kuali.ole.gl.OJBUtility;
import org.kuali.ole.gl.batch.BalanceForwardStep;
import org.kuali.ole.gl.batch.service.FilteringBalanceIterator;
import org.kuali.ole.gl.businessobject.Balance;
import org.kuali.ole.gl.businessobject.GlSummary;
import org.kuali.ole.gl.dataaccess.BalanceDao;
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.SystemOptions;
import org.kuali.ole.sys.context.SpringContext;
import org.kuali.ole.sys.service.OptionsService;
import org.kuali.ole.sys.service.UniversityDateService;
import org.kuali.rice.core.api.parameter.ParameterEvaluator;
import org.kuali.rice.core.api.parameter.ParameterEvaluatorService;
import org.kuali.rice.core.api.util.type.KualiDecimal;
import org.kuali.rice.coreservice.framework.parameter.ParameterService;
import org.springframework.transaction.annotation.Transactional;

/**
 * This class is the OJB implementation of the Balance Service
 */
@Transactional
public class BalanceServiceImpl implements BalanceService {
    private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(BalanceServiceImpl.class);

    protected static final String PARAMETER_PREFIX = "SELECTION_";

    protected BalanceDao balanceDao;
    protected OptionsService optionsService;
    protected ObjectTypeService objectTypeService;
    protected SubFundGroupService subFundGroupService;
    protected ParameterService parameterService;
    protected BalanceTypeService balanceTypService;
    // must have no asset, liability or fund balance balances other than object code 9899

    Collection<String> assetLiabilityFundBalanceObjectTypeCodes = null;
    Collection<String> encumbranceBaseBudgetBalanceTypeCodes = null;
    Collection<String> actualBalanceCodes = null;
    Collection<String> incomeObjectTypeCodes = null;
    Collection<String> expenseObjectTypeCodes = null;

    /**
     * @param universityFiscalYear the fiscal year to find balances for
     * @param balanceTypeCodes the balance types to summarize
     * @return a list of summarized GL balances
     * @see org.kuali.ole.gl.service.BalanceService#getGlSummary(int, java.util.List)
     */
    public List<GlSummary> getGlSummary(int universityFiscalYear, List<String> balanceTypeCodes) {
        LOG.debug("getGlSummary() started");

        List<GlSummary> sum = new ArrayList<GlSummary>();

        Iterator<Object[]> i = balanceDao.getGlSummary(universityFiscalYear, balanceTypeCodes);
        while (i.hasNext()) {
            Object[] data = i.next();
            sum.add(new GlSummary(data));
        }
        return sum;
    }

    /**
     * Defers to the DAO to find all balances in the fiscal year.
     * 
     * @param fiscalYear the fiscal year to find balances for
     * @return an Iterator full of balances from the given fiscal year
     * @see org.kuali.ole.gl.service.BalanceService#findBalancesForFiscalYear(java.lang.Integer)
     */
    public Iterator<Balance> findBalancesForFiscalYear(Integer fiscalYear) {
        return (Iterator<Balance>) balanceDao.findBalancesForFiscalYear(fiscalYear);
    }

    /**
     * Checks the given account to see if there are any non zero asset fund liability fund balances for them
     * 
     * @param account an account to find balances for
     * @return true if there are non zero asset liability fund balances, false if otherwise
     * @see org.kuali.ole.gl.service.BalanceService#hasAssetLiabilityFundBalanceBalances(org.kuali.ole.coa.businessobject.Account)
     */
    public boolean hasAssetLiabilityFundBalanceBalances(Account account) {

        /*
         * Here is an excerpt from the original Oracle trigger: SELECT fin_object_cd FROM gl_balance_t WHERE univ_fiscal_yr =
         * p_univ_fiscal_yr AND fin_coa_cd = p_fin_coa_cd AND account_nbr = p_account_nbr AND fin_object_cd != '9899' AND
         * fin_obj_typ_cd IN ('AS', 'LI', 'FB') AND fin_balance_typ_cd = 'AC' GROUP BY fin_object_cd HAVING
         * ABS(SUM(fin_beg_bal_ln_amt + acln_annl_bal_amt)) > 0); added absolute value function to sum--prevents the case of 2
         * entries (1 pos and 1 neg) from canceling each other out and allowing the acct to be closed when it shouldn't be.
         */

        // FIXME! - date service should be injected
        Integer fiscalYear = SpringContext.getBean(UniversityDateService.class).getCurrentFiscalYear();
        ArrayList fundBalanceObjectCodes = new ArrayList();
        fundBalanceObjectCodes.add(null == account.getChartOfAccounts() ? null : account.getChartOfAccounts().getFundBalanceObjectCode());
        Iterator balances = balanceDao.findBalances(account, fiscalYear, null, fundBalanceObjectCodes, getAssetLiabilityFundBalanceBalanceTypeCodes(), getActualBalanceCodes());

        KualiDecimal begin;
        KualiDecimal annual;

        // TODO KULCOA-335 - is absolute value necessary to prevent obscure sets of values
        // from masking accounts that should remain open?

        Map groups = new HashMap();

        while (balances.hasNext()) {
            Balance balance = (Balance) balances.next();
            begin = balance.getBeginningBalanceLineAmount();
            annual = balance.getAccountLineAnnualBalanceAmount();

            String objectCode = balance.getObjectCode();

            KualiDecimal runningTotal = (KualiDecimal) groups.get(objectCode);

            if (runningTotal == null) {
                runningTotal = KualiDecimal.ZERO;
            }

            runningTotal = runningTotal.add(begin);
            runningTotal = runningTotal.add(annual);

            groups.put(objectCode, runningTotal);


        }

        boolean success = false;

        Iterator iter = groups.keySet().iterator();
        while (iter.hasNext()) {
            success |= ((KualiDecimal) groups.get(iter.next())).isNonZero();
        }

        return success;

    }

    /**
     * Given an iterator of balances, this returns the sum of each balance's beginning balance line amount + annual account linge
     * balance amount
     * 
     * @param balances an Iterator of balances to sum
     * @return the sum of all of those balances
     */
    protected KualiDecimal sumBalances(Iterator balances) {
        KualiDecimal runningTotal = KualiDecimal.ZERO;

        KualiDecimal begin;
        KualiDecimal annual;

        while (balances.hasNext()) {
            Balance balance = (Balance) balances.next();
            begin = balance.getBeginningBalanceLineAmount();
            annual = balance.getAccountLineAnnualBalanceAmount();

            runningTotal = runningTotal.add(begin);
            runningTotal = runningTotal.add(annual);
        }

        return runningTotal;

    }

    /**
     * Returns the sum of balances considered as income for the given account
     * 
     * @param account the account to find income balances for
     * @return the sum of income balances
     */
    protected KualiDecimal incomeBalances(Account account) {

        /*
         * SELECT SUM(fin_beg_bal_ln_amt + acln_annl_bal_amt) INTO v_y FROM gl_balance_t WHERE univ_fiscal_yr = p_univ_fiscal_yr AND
         * fin_coa_cd = p_fin_coa_cd AND account_nbr = p_account_nbr AND (fin_object_cd = '9899' OR fin_obj_typ_cd IN ('CH', 'IC',
         * 'IN', 'TI')) AND fin_balance_typ_cd = 'AC';
         * @return
         */

        // FIXME! - date service should be injected
        Integer fiscalYear = SpringContext.getBean(UniversityDateService.class).getCurrentFiscalYear();

        ArrayList fundBalanceObjectCodes = new ArrayList();
        fundBalanceObjectCodes.add(account.getChartOfAccounts().getFundBalanceObjectCode());
        Iterator balances = balanceDao.findBalances(account, fiscalYear, fundBalanceObjectCodes, null, getIncomeObjectTypeCodes(), getActualBalanceCodes());

        return sumBalances(balances);

    }

    /**
     * Sums all the balances associated with a given account that would be considered "expense" balances
     * 
     * @param account an account to find expense balances for
     * @return the sum of those balances
     */
    protected KualiDecimal expenseBalances(Account account) {
        /*
         * Here is an excerpt from the original Oracle Trigger: SELECT SUM(fin_beg_bal_ln_amt || acln_annl_bal_amt) INTO v_x FROM
         * gl_balance_t WHERE univ_fiscal_yr = p_univ_fiscal_yr AND fin_coa_cd = p_fin_coa_cd AND account_nbr = p_account_nbr AND
         * fin_obj_typ_cd IN ('EE', 'ES', 'EX', 'TE') AND fin_balance_typ_cd = 'AC'; This method...
         */

        // FIXME! - date service should be injected
        Integer fiscalYear = SpringContext.getBean(UniversityDateService.class).getCurrentFiscalYear();
        Iterator balances = balanceDao.findBalances(account, fiscalYear, null, null, getExpenseObjectTypeCodes(), getActualBalanceCodes());

        return sumBalances(balances);

    }

    /**
     * Checks to see if the total income balances for the given account equal the total expense balances for the given account
     * 
     * @param an account to find balances for
     * @return true if income balances equal expense balances, false otherwise
     * @see org.kuali.ole.gl.service.BalanceService#fundBalanceWillNetToZero(org.kuali.ole.coa.businessobject.Account)
     */
    public boolean fundBalanceWillNetToZero(Account account) {
        KualiDecimal income = incomeBalances(account);
        KualiDecimal expense = expenseBalances(account);

        return income.equals(expense);
    }

    /**
     * Finds all of the encumbrance balances for the given account, and figures out if those encumbrances will have a net impact on
     * the budget
     * 
     * @param account an account to find balances for
     * @return true if summed encumbrances for the account are not zero (meaning encumbrances will have a net impact on the budget),
     *         false if otherwise
     * @see org.kuali.ole.gl.service.BalanceService#hasEncumbrancesOrBaseBudgets(org.kuali.ole.coa.businessobject.Account)
     */
    public boolean hasEncumbrancesOrBaseBudgets(Account account) {

        /*
         * check for Encumbrances and base budgets Here is an excerpt from the original Oracle Trigger: SELECT
         * SUM(fin_beg_bal_ln_amt + acln_annl_bal_amt) INTO v_y FROM gl_balance_t WHERE univ_fiscal_yr = p_univ_fiscal_yr AND
         * fin_coa_cd = p_fin_coa_cd AND account_nbr = p_account_nbr AND fin_balance_typ_cd IN ('EX', 'IE', 'PE', 'BB'); v_rowcnt :=
         * SQL%ROWCOUNT;
         */

        // FIXME! - date service should be injected
        Integer fiscalYear = SpringContext.getBean(UniversityDateService.class).getCurrentFiscalYear();
        Iterator balances = balanceDao.findBalances(account, fiscalYear, null, null, null, getEncumbranceBaseBudgetBalanceTypeCodes());

        return sumBalances(balances).isNonZero();
    }

    /**
     * Returns whether or not the beginning budget is loaded for the given account. Of course, it doesn't really check the
     * account...just the options for the current year to see if all the beginning balances have been loaded
     * 
     * @param an account to check whether the beginning balance is loaded for
     * @return true if the beginning balance is loaded, false otherwise
     * @see org.kuali.ole.gl.service.BalanceService#beginningBalanceLoaded(org.kuali.ole.coa.businessobject.Account)
     */
    public boolean beginningBalanceLoaded(Account account) {
        return optionsService.getCurrentYearOptions().isFinancialBeginBalanceLoadInd();
    }

    /**
     * Determines if the account has asset/liability balances associated with it that will have a net impact
     * 
     * @param account an account to check balances for
     * @return true if the account has an asset liability balance, false otherwise
     * @see org.kuali.ole.gl.service.BalanceService#hasAssetLiabilityOrFundBalance(org.kuali.ole.coa.businessobject.Account)
     */
    public boolean hasAssetLiabilityOrFundBalance(Account account) {
        return hasAssetLiabilityFundBalanceBalances(account) || !fundBalanceWillNetToZero(account) || hasEncumbrancesOrBaseBudgets(account);
    }

    public void setBalanceDao(BalanceDao balanceDao) {
        this.balanceDao = balanceDao;
    }

    public void setOptionsService(OptionsService optionsService) {
        this.optionsService = optionsService;
    }

    /**
     * This method finds the summary records of balance entries according to input fields an values, using the DAO. The results will
     * be limited to the system lookup results limit.
     * 
     * @param fieldValues the input fields an values
     * @param isConsolidated consolidation option is applied or not
     * @return the summary records of balance entries
     * @see org.kuali.ole.gl.service.BalanceService#lookupCashBalance(java.util.Map, boolean)
     */
    public Iterator lookupCashBalance(Map fieldValues, boolean isConsolidated) {
        LOG.debug("findCashBalance() started");

        return balanceDao.lookupCashBalance(fieldValues, isConsolidated, getEncumbranceBalanceTypes(fieldValues));
    }

    /**
     * This method gets the size of cash balance entries according to input fields and values
     * 
     * @param fieldValues the input fields and values
     * @param isConsolidated consolidation option is applied or not
     * @return the count of cash balance entries
     * @see org.kuali.ole.gl.service.BalanceService#getCashBalanceRecordCount(java.util.Map, boolean)
     */
    public Integer getCashBalanceRecordCount(Map fieldValues, boolean isConsolidated) {
        LOG.debug("getCashBalanceRecordCount() started");

        Integer recordCount = new Integer(0);
        if (!isConsolidated) {
            recordCount = balanceDao.getDetailedCashBalanceRecordCount(fieldValues, getEncumbranceBalanceTypes(fieldValues));
        }
        else {
            recordCount = balanceDao.getConsolidatedCashBalanceRecordCount(fieldValues, getEncumbranceBalanceTypes(fieldValues));
        }
        return recordCount;
    }

    /**
     * This method gets the size of balance entries according to input fields and values
     * 
     * @param fieldValues the input fields and values
     * @param isConsolidated consolidation option is applied or not
     * @return the size of balance entries
     * @see org.kuali.ole.gl.service.BalanceService#findBalance(java.util.Map, boolean)
     */
    public Iterator findBalance(Map fieldValues, boolean isConsolidated) {
        LOG.debug("findBalance() started");
        return balanceDao.findBalance(fieldValues, isConsolidated, getEncumbranceBalanceTypes(fieldValues));
    }

    /**
     * This method finds the summary records of balance entries according to input fields and values
     * 
     * @param fieldValues the input fields and values
     * @param isConsolidated consolidation option is applied or not
     * @return the summary records of balance entries
     * @see org.kuali.ole.gl.service.BalanceService#getBalanceRecordCount(java.util.Map, boolean)
     */
    public Integer getBalanceRecordCount(Map fieldValues, boolean isConsolidated) {
        LOG.debug("getBalanceRecordCount() started");

        Integer recordCount = null;
        if (!isConsolidated) {
            recordCount = OJBUtility.getResultSizeFromMap(fieldValues, new Balance()).intValue();
        }
        else {
            Iterator recordCountIterator = balanceDao.getConsolidatedBalanceRecordCount(fieldValues, getEncumbranceBalanceTypes(fieldValues));
            // TODO: WL: why build a list and waste time/memory when we can just iterate through the iterator and do a count?
            List recordCountList = IteratorUtils.toList(recordCountIterator);
            recordCount = recordCountList.size();
        }
        return recordCount;
    }

    /**
     * Purge the balance table by year/chart
     * 
     * @param chart the chart of balances to purge
     * @param year the year of balances to purge
     */
    public void purgeYearByChart(String chart, int year) {
        LOG.debug("purgeYearByChart() started");

        balanceDao.purgeYearByChart(chart, year);
    }

    /**
     * Private method to load the values from the system options service and store them locally for later use.
     */
    protected void loadConstantsFromOptions() {
        LOG.debug("loadConstantsFromOptions() started");
        SystemOptions options = optionsService.getCurrentYearOptions();
        // String[] actualBalanceCodes = new String[] { "AC" };
        actualBalanceCodes = Arrays.asList( options.getActualFinancialBalanceTypeCd() ); // AC
        // String[] incomeObjectTypeCodes = new String[] { "CH", "IC", "IN", "TI" };
        incomeObjectTypeCodes = Arrays.asList( options.getFinObjTypeIncomeNotCashCd(), // IC
                options.getFinObjectTypeIncomecashCode(), // IN
                options.getFinObjTypeCshNotIncomeCd(), // CH
                options.getFinancialObjectTypeTransferIncomeCd() // TI
        );
        // String[] expenseObjectTypeCodes = new String[] { "EE", "ES", "EX", "TE" };
        expenseObjectTypeCodes = Arrays.asList( options.getFinObjTypeExpendNotExpCode(), // EE?
                options.getFinObjTypeExpenditureexpCd(), // ES
                options.getFinObjTypeExpNotExpendCode(), // EX?
                options.getFinancialObjectTypeTransferExpenseCd() // TE
        );
        // String[] assetLiabilityFundBalanceBalanceTypeCodes = new String[] { "AS", "LI", "FB" };
        assetLiabilityFundBalanceObjectTypeCodes = Arrays.asList( options.getFinancialObjectTypeAssetsCd(), // AS
                options.getFinObjectTypeLiabilitiesCode(), // LI
                options.getFinObjectTypeFundBalanceCd() // FB
        );
        // String[] encumbranceBaseBudgetBalanceTypeCodes = new String[] { "EX", "IE", "PE", "BB" };
        encumbranceBaseBudgetBalanceTypeCodes = Arrays.asList( options.getExtrnlEncumFinBalanceTypCd(), // EX
                options.getIntrnlEncumFinBalanceTypCd(), // IE
                options.getPreencumbranceFinBalTypeCd(), // PE
                options.getBaseBudgetFinancialBalanceTypeCd() // BB
        );
    }

    /**
     * Use the options table to get a list of all the balance type codes associated with actual balances
     * 
     * @return an array of balance type codes for actual balances
     */
    protected Collection<String> getActualBalanceCodes() {
        if (actualBalanceCodes == null) {
            loadConstantsFromOptions();
        }
        return actualBalanceCodes;
    }

    /**
     * Uses the options table to find all the balance type codes associated with income
     * 
     * @return an array of income balance type codes
     */
    protected Collection<String> getIncomeObjectTypeCodes() {
        if (incomeObjectTypeCodes == null) {
            loadConstantsFromOptions();
        }
        return incomeObjectTypeCodes;
    }

    /**
     * Uses the options table to find all the balance type codes associated with expenses
     * 
     * @return an array of expense option type codes
     */
    protected Collection<String> getExpenseObjectTypeCodes() {
        if (expenseObjectTypeCodes == null) {
            loadConstantsFromOptions();
        }
        return expenseObjectTypeCodes;
    }

    /**
     * Uses the options table to find all the balance type codes associated with asset/liability
     * 
     * @return an array of asset/liability balance type codes
     */
    protected Collection<String> getAssetLiabilityFundBalanceBalanceTypeCodes() {
        if (assetLiabilityFundBalanceObjectTypeCodes == null) {
            loadConstantsFromOptions();
        }
        return assetLiabilityFundBalanceObjectTypeCodes;
    }

    /**
     * Uses the options table to create a list of all the balance type codes associated with encumbrances
     * 
     * @return an array of encumbrance balance type codes
     */
    protected Collection<String> getEncumbranceBaseBudgetBalanceTypeCodes() {
        if (encumbranceBaseBudgetBalanceTypeCodes == null) {
            loadConstantsFromOptions();
        }
        return encumbranceBaseBudgetBalanceTypeCodes;
    }

    /**
     * Uses the DAO to count the number of balances associated with the given fiscal year
     * 
     * @param fiscal year a fiscal year to count balances for
     * @return an integer with the number of balances
     * @see org.kuali.ole.gl.service.BalanceService#countBalancesForFiscalYear(java.lang.Integer)
     */
    public int countBalancesForFiscalYear(Integer year) {
        return balanceDao.countBalancesForFiscalYear(year);
    }

    /**
     * This method returns all of the balances specifically for the nominal activity closing job
     * 
     * @param year year to find balances for
     * @return an Iterator of nominal activity balances
     * @see org.kuali.ole.gl.service.BalanceService#findNominalActivityBalancesForFiscalYear(java.lang.Integer)
     */
    public Iterator<Balance> findNominalActivityBalancesForFiscalYear(Integer year) {
        // generate List of nominal activity object type codes
        List<String> nominalActivityObjectTypeCodes = objectTypeService.getNominalActivityClosingAllowedObjectTypes(year);
        SystemOptions currentYearOptions = optionsService.getCurrentYearOptions();
        return balanceDao.findNominalActivityBalancesForFiscalYear(year, nominalActivityObjectTypeCodes, currentYearOptions);
    }

    /**
     * Returns all the balances to be forwarded for the "cumulative" rule
     * 
     * @param year the fiscal year to find balances for
     * @return an Iterator of balances to process for the cumulative/active balance forward process
     * @see org.kuali.ole.gl.service.BalanceService#findCumulativeBalancesToForwardForFiscalYear(java.lang.Integer)
     */
    public Iterator<Balance> findCumulativeBalancesToForwardForFiscalYear(Integer year) {
        List<String> cumulativeForwardBalanceObjectTypes = objectTypeService.getCumulativeForwardBalanceObjectTypes(year);
        Collection<String> contractsAndGrantsDenotingValues = subFundGroupService.getContractsAndGrantsDenotingValues();
        Collection<String> subFundGroupsForCumulativeBalanceForwardingArray = parameterService.getParameterValuesAsString(BalanceForwardStep.class, GeneralLedgerConstants.BalanceForwardRule.SUB_FUND_GROUPS_FOR_INCEPTION_TO_DATE_REPORTING);
        Collection<String> cumulativeBalanceForwardBalanceTypesArray = parameterService.getParameterValuesAsString(BalanceForwardStep.class, GeneralLedgerConstants.BalanceForwardRule.BALANCE_TYPES_TO_ROLL_FORWARD_FOR_INCOME_EXPENSE);
        boolean fundGroupDenotesCGInd = parameterService.getParameterValueAsBoolean(Account.class, OLEConstants.ChartApcParms.ACCOUNT_FUND_GROUP_DENOTES_CG);
        Iterator<Balance> balances = balanceDao.findCumulativeBalancesToForwardForFiscalYear(year, cumulativeForwardBalanceObjectTypes, contractsAndGrantsDenotingValues, subFundGroupsForCumulativeBalanceForwardingArray, cumulativeBalanceForwardBalanceTypesArray, fundGroupDenotesCGInd);

        FilteringBalanceIterator filteredBalances = SpringContext.getBean(FilteringBalanceIterator.class, "glBalanceAnnualAndCGTotalNotZeroIterator");
        filteredBalances.setBalancesSource(balances);

        return filteredBalances;
    }

    /**
     * Returns all the balances specifically to be processed by the balance forwards job for the "general" rule
     * 
     * @param year the fiscal year to find balances for
     * @return an Iterator of balances to process for the general balance forward process
     * @see org.kuali.ole.gl.service.BalanceService#findGeneralBalancesToForwardForFiscalYear(java.lang.Integer)
     */
    public Iterator<Balance> findGeneralBalancesToForwardForFiscalYear(Integer year) {
        List<String> generalForwardBalanceObjectTypes = objectTypeService.getGeneralForwardBalanceObjectTypes(year);
        Collection<String> generalBalanceForwardBalanceTypesArray = parameterService.getParameterValuesAsString(BalanceForwardStep.class, GeneralLedgerConstants.BalanceForwardRule.BALANCE_TYPES_TO_ROLL_FORWARD_FOR_BALANCE_SHEET);
        Iterator<Balance> balances = balanceDao.findGeneralBalancesToForwardForFiscalYear(year, generalForwardBalanceObjectTypes, generalBalanceForwardBalanceTypesArray);

        Map<String, FilteringBalanceIterator> balanceIterators = SpringContext.getBeansOfType(FilteringBalanceIterator.class);
        FilteringBalanceIterator filteredBalances = balanceIterators.get("glBalanceTotalNotZeroIterator");
        filteredBalances.setBalancesSource(balances);

        return filteredBalances;
    }

    /**
     * Returns all of the balances to be forwarded for the organization reversion process
     * 
     * @param year the year of balances to find
     * @param endOfYear whether the organization reversion process is running end of year (before the fiscal year change over) or
     *        beginning of year (after the fiscal year change over)
     * @return an iterator of balances to put through the strenuous organization reversion process
     * @see org.kuali.ole.gl.service.BalanceService#findOrganizationReversionBalancesForFiscalYear(java.lang.Integer, boolean)
     */
    public Iterator<Balance> findOrganizationReversionBalancesForFiscalYear(Integer year, boolean endOfYear) {
        SystemOptions options = SpringContext.getBean(OptionsService.class).getOptions(year);
        List<ParameterEvaluator> parameterEvaluators = new ArrayList<ParameterEvaluator>();

        int i = 1;
        boolean moreParams = true;
        while (moreParams) {
            if (parameterService.parameterExists(OrganizationReversion.class, PARAMETER_PREFIX + i)) {
                ParameterEvaluator parameterEvaluator = /*REFACTORME*/SpringContext.getBean(ParameterEvaluatorService.class).getParameterEvaluator(OrganizationReversion.class, PARAMETER_PREFIX + i);
                parameterEvaluators.add(parameterEvaluator);
            }
            else {
                moreParams = false;
            }
            i++;
        }
        return balanceDao.findOrganizationReversionBalancesForFiscalYear(year, endOfYear, options, parameterEvaluators);
    }

    /**
     * Gets the encumbrance balance types.
     * 
     * @param fieldValues
     * @return a list with the encumbrance balance types
     */
    protected List<String> getEncumbranceBalanceTypes(Map fieldValues) {

        List<String> encumbranceBalanceTypes = null;
        if (fieldValues.containsKey(OLEPropertyConstants.UNIVERSITY_FISCAL_YEAR)) {
            // the year should be part of the results for both the cash balance and regular balance lookupables
            String universityFiscalYearStr = (String) fieldValues.get(OLEPropertyConstants.UNIVERSITY_FISCAL_YEAR);
            Integer universityFiscalYear = new Integer(universityFiscalYearStr);
            encumbranceBalanceTypes = balanceTypService.getEncumbranceBalanceTypes(universityFiscalYear);
        }
        return encumbranceBalanceTypes;
    }

    /**
     * Sets the objectTypeService.
     * 
     * @param objectTypeService
     */
    public void setObjectTypeService(ObjectTypeService objectTypeService) {
        this.objectTypeService = objectTypeService;
    }

    /**
     * Sets the subFundGroupService.
     * 
     * @param subFundGroupService
     */
    public void setSubFundGroupService(SubFundGroupService subFundGroupService) {
        this.subFundGroupService = subFundGroupService;
    }

    /**
     * Sets the parameterService.
     * 
     * @param parameterService
     */
    public void setParameterService(ParameterService parameterService) {
        this.parameterService = parameterService;
    }

    /**
     * Sets the balanceTypService.
     * 
     * @param balanceTypService
     */
    public void setBalanceTypService(BalanceTypeService balanceTypService) {
        this.balanceTypService = balanceTypService;
    }

}