/*
 * Copyright 2010 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.ole.coa.service.impl;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.lang.StringUtils;
import org.kuali.ole.coa.businessobject.Account;
import org.kuali.ole.coa.service.AccountPersistenceStructureService;
import org.kuali.ole.sys.OLEPropertyConstants;
import org.kuali.rice.kns.service.MaintenanceDocumentDictionaryService;
import org.kuali.rice.krad.bo.PersistableBusinessObject;
import org.kuali.rice.krad.service.impl.PersistenceStructureServiceImpl;
import org.kuali.rice.krad.util.KRADConstants;
import org.springframework.beans.factory.InitializingBean;

public class AccountPersistenceStructureServiceImpl extends PersistenceStructureServiceImpl implements AccountPersistenceStructureService, InitializingBean {
    
    protected List<AccountReferencePersistenceExemption> accountReferencePersistenceExemptions;
    protected Map<Class<?>, List<AccountReferencePersistenceExemption>> accountReferencePersistenceExemptionsMap;
                
    /* 
     * The following list is commented out as it's not used in code anymore, but still can server as a reference for testing. 
     * The list causes problems when referencing AwardAccount.class, a class in optional module;
     * also it's not a good practice to hard-code the list as it may have to be expanded when new sub/classes are added.
     * Instead of using "if (ACCOUNT_CLASSES.contains(clazz))" to judge whether whether a class is account-related,  
     * we now judge by whether the PKs of the class contain chartOfAccountsCode-accountNumber.
     * 
     *      
    // List of account-related BO classes (and all their subclasses) which have chartOfAccountsCode and accountNumber as (part of) the primary keys,
    // i.e. the complete list of all possible referenced BO classes with chart code and account number as (part of) the foreign keys. 
    protected static final HashSet<Class<? extends BusinessObject>> ACCOUNT_CLASSES = new HashSet<Class<? extends BusinessObject>>();    
    static {
        ACCOUNT_CLASSES.add(Account.class);
        ACCOUNT_CLASSES.add(SubAccount.class);
        ACCOUNT_CLASSES.add(A21SubAccount.class);
        ACCOUNT_CLASSES.add(AwardAccount.class); // this class can't be referenced by core code
        ACCOUNT_CLASSES.add(IndirectCostRecoveryExclusionAccount.class);
        ACCOUNT_CLASSES.add(PriorYearAccount.class);
        ACCOUNT_CLASSES.add(AccountDelegate.class);
        ACCOUNT_CLASSES.add(AccountDescription.class);
        ACCOUNT_CLASSES.add(AccountGlobalDetail.class);
        ACCOUNT_CLASSES.add(AccountGuideline.class);
        ACCOUNT_CLASSES.add(SubObjectCode.class);
        ACCOUNT_CLASSES.add(SubObjectCodeCurrent.class);
    }     
    */
    
    public boolean isAccountRelatedClass(Class clazz) {
        List<String> pks = listPrimaryKeyFieldNames(clazz);
        
        if (pks.contains(OLEPropertyConstants.CHART_OF_ACCOUNTS_CODE) && pks.contains(OLEPropertyConstants.ACCOUNT_NUMBER )) {
            return true;
        }
        else {
            return false;
        }
    }
    
    private MaintenanceDocumentDictionaryService maintenanceDocumentDictionaryService;

    public void setMaintenanceDocumentDictionaryService(MaintenanceDocumentDictionaryService maintenanceDocumentDictionaryService) {
        this.maintenanceDocumentDictionaryService = maintenanceDocumentDictionaryService;
    }

    @SuppressWarnings("rawtypes")
    public Map<String, Class> listCollectionAccountFields(PersistableBusinessObject bo) {
        Map<String, Class> accountFields = new HashMap<String, Class>(); 
        Iterator<Map.Entry<String, Class>> collObjs = listCollectionObjectTypes(bo).entrySet().iterator();
        
        while (collObjs.hasNext()) {
            Map.Entry<String, Class> entry = (Map.Entry<String, Class>)collObjs.next();
            String accountCollName = entry.getKey();
            Class accountCollType = entry.getValue();
            
            // if the reference object is of Account or Account-involved BO class (including all subclasses) 
            if (isAccountRelatedClass(accountCollType)) {
                // exclude non-maintainable account collection
                String docTypeName = maintenanceDocumentDictionaryService.getDocumentTypeName(bo.getClass());
                if (maintenanceDocumentDictionaryService.getMaintainableCollection(docTypeName, accountCollName) == null)
                    continue;
                
                // otherwise include the account field
                accountFields.put(accountCollName, accountCollType);                
            }
        }
        
        return accountFields;
    }
    
    @SuppressWarnings("rawtypes")
    public Set<String> listCollectionChartOfAccountsCodeNames(PersistableBusinessObject bo) {
        Set<String> coaCodeNames = new HashSet<String>();
        String docTypeName = maintenanceDocumentDictionaryService.getDocumentTypeName(bo.getClass());
        Iterator<Map.Entry<String, Class>> collObjs = listCollectionObjectTypes(bo).entrySet().iterator();
        
        while (collObjs.hasNext()) {
            Map.Entry<String, Class> entry = (Map.Entry<String, Class>)collObjs.next();
            String accountCollName = entry.getKey();
            Class accountCollType = entry.getValue();
            
            // if the reference object is of Account or Account-involved BO class (including all subclasses) 
            if (isAccountRelatedClass(accountCollType)) {
                // exclude non-maintainable account collection
                if (maintenanceDocumentDictionaryService.getMaintainableCollection(docTypeName, accountCollName) == null)
                    continue;

                // otherwise include the account field
                String coaCodeName = KRADConstants.ADD_PREFIX + "." + accountCollName + "." + OLEPropertyConstants.CHART_OF_ACCOUNTS_CODE;
                coaCodeNames.add(coaCodeName);
            }
        }

        return coaCodeNames;
    }
    
    @SuppressWarnings("rawtypes")
    public Map<String, Class> listReferenceAccountFields(PersistableBusinessObject bo) {
        Map<String, Class> accountFields = new HashMap<String, Class>();       
        Iterator<Map.Entry<String, Class>> refObjs = listReferenceObjectFields(bo).entrySet().iterator();
        
        while (refObjs.hasNext()) {
            Map.Entry<String, Class> entry = (Map.Entry<String, Class>)refObjs.next();
            String accountName = entry.getKey();
            Class accountType = entry.getValue();
            
            // if the reference object is of Account or Account-involved BO class (including all subclasses)            
            if (isAccountRelatedClass(accountType)) {
                String coaCodeName = getForeignKeyFieldName(bo.getClass(), accountName, OLEPropertyConstants.CHART_OF_ACCOUNTS_CODE);
                String acctNumName = getForeignKeyFieldName(bo.getClass(), accountName, OLEPropertyConstants.ACCOUNT_NUMBER);
                
                // exclude the case when chartOfAccountsCode-accountNumber don't exist as foreign keys in the BO:
                // for ex, in SubAccount, a21SubAccount is a reference object but its PKs don't exist as FKs in SubAccount;
                // rather, A21SubAccount has a nested reference account - costShareAccount, 
                // whose PKs exists in A21SubAccount as FKs, and are used in SubAccount maint doc as nested reference;
                // special treatment outside this method is needed for this case
                if (StringUtils.isEmpty(coaCodeName) || StringUtils.isEmpty(acctNumName)) 
                    continue;
                
                // in general we do want to have chartOfAccountsCode fields readOnly/auto-populated even when they are part of PKs,  
                // (such as in SubAccount), as the associated account shall only be chosen from existing accounts; 
                // however, when the BO is Account itself, we don't want to make the PK chartOfAccountsCode field readOnly, 
                // as it shall be editable when a new Account is being created; so we shall exclude such case 
                List<String> pks = listPrimaryKeyFieldNames(bo.getClass());
                if (bo instanceof Account && pks.contains(coaCodeName) && pks.contains(acctNumName )) 
                    continue;                
                
                // exclude non-maintainable account field
                String docTypeName = maintenanceDocumentDictionaryService.getDocumentTypeName(bo.getClass());
                if (maintenanceDocumentDictionaryService.getMaintainableField(docTypeName, coaCodeName) == null ||
                    maintenanceDocumentDictionaryService.getMaintainableField(docTypeName, acctNumName) == null)
                    continue;
                
                // otherwise include the account field
                accountFields.put(accountName, accountType);                
            }
        }
        
        return accountFields;
    }
    
    @SuppressWarnings("rawtypes")
    public Map<String, String> listChartCodeAccountNumberPairs(PersistableBusinessObject bo) {
        Map<String, String> chartAccountPairs = new HashMap<String, String>();       
        Iterator<Map.Entry<String, Class>> refObjs = listReferenceObjectFields(bo).entrySet().iterator();
        
        while (refObjs.hasNext()) {
            Map.Entry<String, Class> entry = (Map.Entry<String, Class>)refObjs.next();
            String accountName = entry.getKey();
            Class accountType = entry.getValue();
            
            // if the reference object is of Account or Account-involved BO class (including all subclasses)            
            if (isAccountRelatedClass(accountType)) {
                String coaCodeName = getForeignKeyFieldName(bo.getClass(), accountName, OLEPropertyConstants.CHART_OF_ACCOUNTS_CODE);
                String acctNumName = getForeignKeyFieldName(bo.getClass(), accountName, OLEPropertyConstants.ACCOUNT_NUMBER);
                
                // exclude the case when chartOfAccountsCode-accountNumber don't exist as foreign keys in the BO:
                // for ex, in SubAccount, a21SubAccount is a reference object but its PKs don't exist as FKs in SubAccount;
                // rather, A21SubAccount has a nested reference account - costShareAccount, 
                // whose PKs exists in A21SubAccount as FKs, and are used in SubAccount maint doc as nested reference
                // special treatment outside this method is needed for this case
                if (StringUtils.isEmpty(coaCodeName) || StringUtils.isEmpty(acctNumName)) 
                    continue;
                
                // in general we do want to have chartOfAccountsCode fields readOnly/auto-populated even when they are part of PKs,  
                // (such as in SubAccount), as the associated account shall only be chosen from existing accounts; 
                // however, when the BO is Account itself, we don't want to make the PK chartOfAccountsCode field readOnly, 
                // as it shall be editable when a new Account is being created; so we shall exclude such case 
                List<String> pks = listPrimaryKeyFieldNames(bo.getClass());
                if (bo instanceof Account && pks.contains(coaCodeName) && pks.contains(acctNumName )) 
                    continue;                
                                
                // if this relationship is specifically exempted then exempt it
                if (isExemptedFromAccountsCannotCrossChartsRules(bo.getClass(), coaCodeName, acctNumName)) {
                    continue;
                }
                                
                // exclude non-maintainable account field
                String docTypeName = maintenanceDocumentDictionaryService.getDocumentTypeName(bo.getClass());
                if (maintenanceDocumentDictionaryService.getMaintainableField(docTypeName, coaCodeName) == null ||
                    maintenanceDocumentDictionaryService.getMaintainableField(docTypeName, acctNumName) == null)
                    continue;
                
                // otherwise include the account field PKs
                chartAccountPairs.put(coaCodeName, acctNumName);                
            }
        }
        
        return chartAccountPairs;
    }
    
    @SuppressWarnings("rawtypes")
    public Map<String, String> listAccountNumberChartCodePairs(PersistableBusinessObject bo) {
        Map<String, String> accountChartPairs = new HashMap<String, String>(); 
        Iterator<Map.Entry<String, Class>> refObjs = listReferenceObjectFields(bo).entrySet().iterator();
        
        while (refObjs.hasNext()) {
            Map.Entry<String, Class> entry = (Map.Entry<String, Class>)refObjs.next();
            String accountName = entry.getKey();
            Class accountType = entry.getValue();
            
            // if the reference object is of Account or Account-involved BO class (including all subclasses)            
            if (isAccountRelatedClass(accountType)) {
                String coaCodeName = getForeignKeyFieldName(bo.getClass(), accountName, OLEPropertyConstants.CHART_OF_ACCOUNTS_CODE);
                String acctNumName = getForeignKeyFieldName(bo.getClass(), accountName, OLEPropertyConstants.ACCOUNT_NUMBER);
                
                // exclude the case when chartOfAccountsCode-accountNumber don't exist as foreign keys in the BO:
                // for ex, in SubAccount, a21SubAccount is a reference object but its PKs don't exist as FKs in SubAccount;
                // rather, A21SubAccount has a nested reference account - costShareAccount, 
                // whose PKs exists in A21SubAccount as FKs, and are used in SubAccount maint doc as nested reference
                // special treatment outside this method is needed for this case
                if (StringUtils.isEmpty(coaCodeName) || StringUtils.isEmpty(acctNumName)) 
                    continue;
                
                // in general we do want to have chartOfAccountsCode fields readOnly/auto-populated even when they are part of PKs,  
                // (such as in SubAccount), as the associated account shall only be chosen from existing accounts; 
                // however, when the BO is Account itself, we don't want to make the PK chartOfAccountsCode field readOnly, 
                // as it shall be editable when a new Account is being created; so we shall exclude such case 
                List<String> pks = listPrimaryKeyFieldNames(bo.getClass());
                if (bo instanceof Account && pks.contains(coaCodeName) && pks.contains(acctNumName )) 
                    continue;                
                
                // if this relationship is specifically exempted then exempt it
                if (isExemptedFromAccountsCannotCrossChartsRules(bo.getClass(), coaCodeName, acctNumName)) {
                    continue;
                }

                // exclude non-maintainable account field
                String docTypeName = maintenanceDocumentDictionaryService.getDocumentTypeName(bo.getClass());
                if (maintenanceDocumentDictionaryService.getMaintainableField(docTypeName, coaCodeName) == null ||
                    maintenanceDocumentDictionaryService.getMaintainableField(docTypeName, acctNumName) == null)
                    continue;
                
                // otherwise include the account field PKs
                accountChartPairs.put(acctNumName, coaCodeName);
            }
        }
        
        return accountChartPairs;
    }

    public Set<String> listChartOfAccountsCodeNames(PersistableBusinessObject bo) {;
        return listChartCodeAccountNumberPairs(bo).keySet();        
    }

    public Set<String> listAccountNumberNames(PersistableBusinessObject bo) {
        return listAccountNumberChartCodePairs(bo).keySet();     
    }
    
    public String getChartOfAccountsCodeName(PersistableBusinessObject bo, String accountNumberName) {
        return listAccountNumberChartCodePairs(bo).get(accountNumberName);        
    }
    
    public String getAccountNumberName(PersistableBusinessObject bo, String chartOfAccountsCodeName) {
        return listChartCodeAccountNumberPairs(bo).get(chartOfAccountsCodeName);        
    }
    
    /** 
     * Need to stop this method from running for objects which are not bound into the ORM layer (OJB),
     * for ex. OrgReviewRole is not persistable. In this case, we can just return an empty list.
     * 
     * @see org.kuali.rice.krad.service.impl.PersistenceStructureServiceImpl#listReferenceObjectFields(org.kuali.rice.krad.bo.PersistableBusinessObject)
     */
    @SuppressWarnings("rawtypes")
    @Override
    public Map<String, Class> listReferenceObjectFields(PersistableBusinessObject bo) {
        if ( isPersistable(bo.getClass() ) ) {
            return super.listReferenceObjectFields(bo);
        }
        return Collections.emptyMap();
    }
    
    /**
     * Determines if the relationship to an Account or Account-like business object, with keys of chartOfAccountsCodePropertyName and accountNumberPropertyName,
     * is exempted from accounts cannot cross charts roles
     * @param relationshipOwningClass the business object which possibly has an exempted relationship to Account
     * @param chartOfAccountsCodePropertyName the property name of the relationshipOwningClass which represents the chart of accounts code part of the foreign key
     * @param accountNumberPropertyName the property name of the relationshipOwningClass which represents the account number part of the foreign key
     * @return true if the relationship is exempted, false otherwise
     */
    public boolean isExemptedFromAccountsCannotCrossChartsRules(Class<?> relationshipOwningClass, String chartOfAccountsCodePropertyName, String accountNumberPropertyName) {
        final List<AccountReferencePersistenceExemption> exemptionList = accountReferencePersistenceExemptionsMap.get(relationshipOwningClass);
        if (exemptionList != null) {
            for (AccountReferencePersistenceExemption exemption : exemptionList) {
                if (exemption.matches(chartOfAccountsCodePropertyName, accountNumberPropertyName)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Sets the list of classes and relationships which are exempted from the accounts can't cross charts rules
     * @param accountReferencePersistenceExemptions the list of classes and relationships which are exempted from the accounts can't cross charts rules
     */
    public void setAccountReferencePersistenceExemptions(List<AccountReferencePersistenceExemption> accountReferencePersistenceExemptions) {
        this.accountReferencePersistenceExemptions = accountReferencePersistenceExemptions;
    }

    /**
     * Implemented to build the AccountReferencePersistenceExemptionsMap from the AccoutnReferencePersistenceExemptions List after intialization
     * @throws Exception well, we're not going to throw an exception
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        accountReferencePersistenceExemptionsMap = new HashMap<Class<?>, List<AccountReferencePersistenceExemption>>();
        if (accountReferencePersistenceExemptions != null) {
            for (AccountReferencePersistenceExemption exemption : accountReferencePersistenceExemptions) {
                List<AccountReferencePersistenceExemption> exemptionList = accountReferencePersistenceExemptionsMap.get(exemption.getParentBusinessObjectClass());
                if (exemptionList == null) {
                    exemptionList = new ArrayList<AccountReferencePersistenceExemption>();
                }
                exemptionList.add(exemption);
                accountReferencePersistenceExemptionsMap.put(exemption.getParentBusinessObjectClass(), exemptionList);
            }
        }
    }
    
}