/*
    * The Kuali Financial System, a comprehensive financial management system for higher education.
    * 
    * Copyright 2005-2014 The Kuali Foundation
    * 
    * This program is free software: you can redistribute it and/or modify
    * it under the terms of the GNU Affero General Public License as
    * published by the Free Software Foundation, either version 3 of the
    * License, or (at your option) any later version.
   * 
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Affero General Public License for more details.
   * 
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  package org.kuali.kfs.gl.businessobject.lookup;
  
  import java.sql.Date;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang.StringUtils;
  import org.kuali.kfs.coa.businessobject.Account;
  import org.kuali.kfs.gl.Constant;
  import org.kuali.kfs.gl.businessobject.Balance;
  import org.kuali.kfs.gl.businessobject.CurrentAccountBalance;
  import org.kuali.kfs.gl.service.AccountBalanceService;
  import org.kuali.kfs.sys.ConfigureContext;
  import org.kuali.kfs.sys.KFSPropertyConstants;
  import org.kuali.kfs.sys.ObjectUtil;
  import org.kuali.kfs.sys.businessobject.lookup.LookupableSpringContext;
  import org.kuali.kfs.sys.context.SpringContext;
  import org.kuali.kfs.sys.fixture.AccountFixture;
  import org.kuali.rice.kim.api.identity.Person;
  import org.kuali.rice.kim.api.identity.PersonService;
  import org.kuali.rice.kns.lookup.HtmlData.AnchorHtmlData;
  import org.kuali.rice.krad.bo.PersistableBusinessObjectBase;
  import org.kuali.rice.krad.datadictionary.DataDictionary;
  import org.kuali.rice.krad.exception.ValidationException;
  import org.kuali.rice.krad.service.BusinessObjectService;
  import org.kuali.rice.krad.service.DataDictionaryService;
  import org.kuali.rice.krad.util.GlobalVariables;
  import org.kuali.rice.krad.util.ObjectUtils;
  
  @ConfigureContext
  public class CurrentAccountBalanceLookupableHelperServiceTest extends AbstractGeneralLedgerLookupableHelperServiceTestBase {
  
      // Enum, for sake of readability in method calls
      private enum ExpectException{YES, NO};
  
      // Class variables, service key, namely the class being tested
      private static final String LOOKUP_HELPER_SERVICE_KEY = "glCurrentAccountBalanceLookupableHelperService";
  
      // Class variables, search parameter keys
      private static final String UNIVERSITY_FISCAL_YEAR_KEY = KFSPropertyConstants.UNIVERSITY_FISCAL_YEAR; // universityFiscalYear
      private static final String UNIVERSITY_FISCAL_PERIOD_CODE_KEY =  KFSPropertyConstants.UNIVERSITY_FISCAL_PERIOD_CODE; // universityFiscalPeriodCode
      private static final String CHART_OF_ACCOUNTS_CODE_KEY =  KFSPropertyConstants.ACCOUNT + "." + KFSPropertyConstants.CHART_OF_ACCOUNTS_CODE; // chartOfAccountsCode
      private static final String ACCOUNT_NUMBER_KEY =   KFSPropertyConstants.ACCOUNT + "." + KFSPropertyConstants.ACCOUNT_NUMBER; // account.accountNumber
      private static final String FISCAL_OFFICER_PRINCIPAL_NAME_KEY = KFSPropertyConstants.ACCOUNT + "." + KFSPropertyConstants.ACCOUNT_FISCAL_OFFICER_USER + "." + KFSPropertyConstants.PERSON_USER_ID; // account.accountFiscalOfficerUser.principalName;
      private static final String ACCOUNT_SUPERVISOR_PRINCIPAL_NAME_KEY = KFSPropertyConstants.ACCOUNT + "." + KFSPropertyConstants.ACCOUNT_SUPERVISORY_USER + "." + KFSPropertyConstants.PERSON_USER_ID; // account.accountSupervisoryUser.principalName
      private static final String SUB_ACCOUNT_NUMBER_KEY = KFSPropertyConstants.SUB_ACCOUNT_NUMBER; // subAccountNumber
      private static final String ORGINIZATION_CODE_KEY = KFSPropertyConstants.ACCOUNT + "." + KFSPropertyConstants.ORGANIZATION_CODE; // account.organizationCode
  
      // Class variables, magic strings; necessity since these values (mostly) weren't found in any Constants or Fixture classes
      private static final String FISCAL_OFFICER_PRINCIPAL_NAME_VAL = "mhkozlow";  // Name in UserNameFixture.java, but wish to stay consistant
      private static final String ACCOUNT_SUPERVISOR_PRINCIPAL_NAME_VAL = "jaraujo"; // Name not in UserNameFixture.java
      private static final String ORGINIZATION_CODE_VAL = "PSY"; // Only found in DB bootstrap *.sql
      private static final String ACCOUNT_EXPIRATION_DATE = "2101-09-30";
      private static final Integer UNIVERSITY_FISCAL_YEAR = 2014;
  
      // Instance variables, required service classes
      private AccountBalanceService accountBalanceService;
      private PersonService personService;
      private DataDictionary dataDictionary;
  
      // Instance variables, vanilla
      private Map<String, String> fullFieldToValueMap;
      private Map<String, String> requiredFieldToValueMap;
      private Map<String, String> semiRequiredFieldToValueMap;
      private Map<String, String> optionalFieldToValueMap;
  
  
  
  
      /**
       * This method:
       * 1. Calls super.setUp()
       * 2. Sets service spring beans
       * 3. Initializes ancestor's testDataGenerator
       * 4. Collects entries placed in local maps used for test data
       * 5. Generates an Account and sets it in delegate of ancestor
       *
       * @see org.kuali.kfs.gl.businessobject.lookup.AbstractGeneralLedgerLookupableHelperServiceTestBase#setUp()
      */
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         accountBalanceService = SpringContext.getBean(AccountBalanceService.class);
         personService = SpringContext.getBean(PersonService.class);
         dataDictionary = SpringContext.getBean(DataDictionaryService.class).getDataDictionary();
         lookupableHelperServiceImpl = LookupableSpringContext.getLookupableHelperService(LOOKUP_HELPER_SERVICE_KEY);
         lookupableHelperServiceImpl.setBusinessObjectClass(CurrentAccountBalance.class);
         testDataGenerator.generateTransactionData(pendingEntry);
         initFieldToValueMaps(); // generateAccount() is dependant on this
         pendingEntry.setAccount(generateAccount());
     }
 
 
     /*
      * Helper method that sets up each type of search parameter map.
      */
     private void initFieldToValueMaps(){
         initRequiredFieldToValueMap();
         initSemiRequiredFieldToValueMap();
         initOptionalFieldToValueMap();
         initFullFieldToValueMap();
     }
 
 
     /*
      * Initialize required search parameter key/value pairs.
      */
     private void initRequiredFieldToValueMap(){
         requiredFieldToValueMap = new HashMap<String, String>();
         requiredFieldToValueMap.put(UNIVERSITY_FISCAL_YEAR_KEY, UNIVERSITY_FISCAL_YEAR.toString());
         requiredFieldToValueMap.put(UNIVERSITY_FISCAL_PERIOD_CODE_KEY, pendingEntry.getUniversityFiscalPeriodCode());
         requiredFieldToValueMap.put(Constant.CONSOLIDATION_OPTION, Constant.CONSOLIDATION);
     }
 
 
     /*
      * Initialize "at-least-one" search parameter key/value pairs.
      */
     private void initSemiRequiredFieldToValueMap(){
         /*
          * These are related to creating an Account object to set on the
          * pendingEntry object, and a subsequent join on the Account table
          * during DB searches.
          */
         semiRequiredFieldToValueMap = new HashMap<String, String>();
         semiRequiredFieldToValueMap.put(ACCOUNT_NUMBER_KEY, pendingEntry.getAccountNumber());
         semiRequiredFieldToValueMap.put(CHART_OF_ACCOUNTS_CODE_KEY, pendingEntry.getChartOfAccountsCode());
         semiRequiredFieldToValueMap.put(FISCAL_OFFICER_PRINCIPAL_NAME_KEY, FISCAL_OFFICER_PRINCIPAL_NAME_VAL);
         semiRequiredFieldToValueMap.put(ACCOUNT_SUPERVISOR_PRINCIPAL_NAME_KEY, ACCOUNT_SUPERVISOR_PRINCIPAL_NAME_VAL);
     }
 
 
     /*
      * Initialize completely optional search parameter key/value pairs.
      */
     private void initOptionalFieldToValueMap(){
         optionalFieldToValueMap = new HashMap<String, String>();
         optionalFieldToValueMap.put(SUB_ACCOUNT_NUMBER_KEY, pendingEntry.getSubAccountNumber());
 
         // This correlates to the test accountNumber and is
         // joined across the real Account table, so must be valid
         // for this accoutNumber. Could not find any test fixtures
         // or constants class to pull this from.
         optionalFieldToValueMap.put(ORGINIZATION_CODE_KEY, ORGINIZATION_CODE_VAL);
     }
 
 
     /*
      * Combine all search parameter key/value pairs into ine map.
      */
     private void initFullFieldToValueMap(){
         fullFieldToValueMap = new HashMap<String, String>();
         fullFieldToValueMap.putAll(requiredFieldToValueMap);
         fullFieldToValueMap.putAll(semiRequiredFieldToValueMap);
         fullFieldToValueMap.putAll(optionalFieldToValueMap);
     }
 
 
     /**
      * This method tests the returned hyperlink for each of the search result's
      * column values if the value's type has an inquiry page. For instance, the
      * column "Fiscal Year" might have a value of "2014", and the "2014" value
      * would be hyperlinked to perform an auto search and return the user to a
      * "System Options Inquiry" results page with details about that
      * "Fiscal Year" entry.
      *
      * In this specific test case, the "subAccountCode" hyperlink should not
      * exist when the "Consolidation Option" of the search is selected to be
      * "Consolidation". Selecting this option means that subAccountNumber is
      * not displayed, and the "----" placeholder should not be used as a
      * subAccountNumber inquiry hyperlink.
      *
      * @see org.kuali.kfs.gl.businessobject.lookup.AbstractGeneralLedgerLookupableHelperServiceTestBase#testGetInquiryUrl()
      */
     @Override
     public void testGetInquiryUrl() {
 
         // Set sentinal that there is no subAccountNumber present
         pendingEntry.setSubAccountNumber(Constant.CONSOLIDATED_SUB_ACCOUNT_NUMBER);
 
         Balance balance = new Balance(pendingEntry);
         CurrentAccountBalance currentAccountBalance = generateCurrentAccountBalance(balance);
 
         List<String> inquiryFieldNames = new ArrayList<String>();
         inquiryFieldNames.add(UNIVERSITY_FISCAL_YEAR_KEY);
         inquiryFieldNames.add(UNIVERSITY_FISCAL_PERIOD_CODE_KEY);
         inquiryFieldNames.add(CHART_OF_ACCOUNTS_CODE_KEY);
         inquiryFieldNames.add(ORGINIZATION_CODE_KEY);
         inquiryFieldNames.add(FISCAL_OFFICER_PRINCIPAL_NAME_KEY);
         inquiryFieldNames.add(SUB_ACCOUNT_NUMBER_KEY);
 
         //List<String> inquiryFieldNames = new ArrayList<String>();
         for(String fieldName : inquiryFieldNames){
             AnchorHtmlData htmlData = (AnchorHtmlData)lookupableHelperServiceImpl.getInquiryUrl(currentAccountBalance, fieldName);
             assertTrue("Null inquiryUrl for property: " + fieldName, ObjectUtils.isNotNull(htmlData));
 
             String href = htmlData.getHref();
             if(SUB_ACCOUNT_NUMBER_KEY.equals(fieldName)){
                 assertTrue("The href anchor for the property " + fieldName + "is not blank.", StringUtils.isBlank(href));
             }else{
                 assertTrue("The href anchor for the property " + fieldName + "is blank.", StringUtils.isNotBlank(href));
             }
         }
 
         // Revert back to original test value for other tests
         pendingEntry.setSubAccountNumber(optionalFieldToValueMap.get(SUB_ACCOUNT_NUMBER_KEY));
 
     }
 
 
     /**
      * This test validates search paramaters specific to CurrentAccountBalanceLookupableHelperServiceImpl.
      *
      * Validation of actual values via services only occur for universityFiscalYear and
      * universityFiscalPeriodCode. This means that test values must be present in the
      * coresponding FS_OPTION_T and SH_ACCT_PERIOD_T DB tables.
      *
      * Validation for the remaining parameters consist of ensuring the parameters line up
      * with public properties of the CurrentAccountBalance class, as defined in the
      * CurrentAccountBalance.xml Data Dictionary(DD) configuration, and that the values of
      * the properties are non-null if they are defined as such in the DD.
      *
      * Additionally, it should be noted that this method tests the various combinations
      * of parameters, since one subset is always required, another subset requires only
      * one from the set, and the final subset is entirely optional.
      *
      * Coverage for Override of {@link org.kuali.kfs.gl.businessobject.lookup.AbstractGeneralLedgerLookupableHelperServiceImpl#validateSearchParameters(java.util.Map)}
      */
     public void testValidateSearchParameters(){
         /*
          * Search Parameter Subsets:
          *
          * Both required:
          * - universityFiscalYear
          * - universityFiscalPeriodCode
          *
          * At least one required (aka, semi-required):
          * - account.accountNumber
          * - account.organizationCode
          * - account.accountFiscalOfficerUser.principalName
          * - account.accountSupervisoryUser.principalName
          *
          * Optional:
          * - chartOfAccountsCode
          * - subAccountNumber
          */
 
         // Data structure to hold different combinations of parameters.
         Map<String, String> testMap = new HashMap<String, String>();
 
         // Test with no parameters, should throw exception
         // Validating parameters: []
         validateMap(testMap, ExpectException.YES);
 
         // Test with required fields, should throw exception.
         // Validating parameters: [universityFiscalYear, universityFiscalPeriodCode]
         testMap.putAll(requiredFieldToValueMap);
         validateMap(testMap, ExpectException.YES);
 
         // Test the "at least one required" params, should *not* throw exception.
         // Validating parameters: [universityFiscalYear, universityFiscalPeriodCode, account.accountNumber,
         //                         account.organizationCode, account.accountSupervisoryUser.principalName,
         //                         account.accountFiscalOfficerUser.principalName, chartOfAccountsCode]
         testMap.putAll(semiRequiredFieldToValueMap);
         validateMap(testMap, ExpectException.NO);
 
 
         // Test with "optional" params, should *not* throw exception.
         // Validating parameters: [universityFiscalYear, universityFiscalPeriodCode, account.accountNumber,
         //                         account.organizationCode, account.accountSupervisoryUser.principalName,
         //                         account.accountFiscalOfficerUser.principalName, chartOfAccountsCode]
         testMap.putAll(optionalFieldToValueMap);
         validateMap(testMap, ExpectException.NO);
 
         // Test with all parameters present
         validateMap(fullFieldToValueMap, ExpectException.NO);
 
     }
 
 
     /*
      * This method will:
      * 1. Create a "failure" message containing the field parameters being vaildated
      * 2. Perform validation against the input map, both positive and negative testing
      * 3. Clear any global error messages since an error count will fail other tests
      */
     private void validateMap(Map<String, String> fieldToValueMap, ExpectException shouldExpectException){
         String message = String.format("Validation failed for search parameters: %s", fieldToValueMap.keySet());
         try{
             if(shouldExpectException == ExpectException.YES){
                 assertTrue(message, validateSearchParametersThrowsException(fieldToValueMap));
             }else{
                 assertFalse(message, validateSearchParametersThrowsException(fieldToValueMap));
             }
         } finally {
             // Need to ensure this gets cleared -- negative tests will generate
             // a ValidationException, which in turn creates an error message
             GlobalVariables.getMessageMap().clearErrorMessages();
         }
     }
 
 
     /*
      * Note, this helper method will propagate any Throwable that is not of
      * type ValidationException -- this is on purpose, as we want the test
      * to blow up if an unexpected error manifests.
      */
     private boolean validateSearchParametersThrowsException(Map<String, String> fieldToValueMap) {
         try{
             lookupableHelperServiceImpl.validateSearchParameters(fieldToValueMap);
         }catch(ValidationException e){
             return true;
         }
         return false;
     }
 
 
     /**
     * This method will run several searches with various combos
     * of search parameter key/value pairs.
     *
     * @throw java.lang.Exception Thrown when any exception occurs that is not of type ValidationException
     * @see org.kuali.kfs.gl.businessobject.lookup.AbstractGeneralLedgerLookupableHelperServiceTestBase#testGetSearchResults()
     */
    @Override
    public void testGetSearchResults() throws Exception {
 
        // Used to persist generated record
        Balance balance = new Balance(pendingEntry);
        balance.setUniversityFiscalYear(UNIVERSITY_FISCAL_YEAR);
 
        // Used for testing lookup
        CurrentAccountBalance currentAccountBalance = generateCurrentAccountBalance(balance);
 
        // Test without having inserted Balance
        Map<String, String> fieldValues = getLookupFieldValues(currentAccountBalance, false);
        List searchResults = lookupableHelperServiceImpl.getSearchResults(fieldValues);
        assertTrue(testDataGenerator.getMessageValue("noSuchRecord"), !contains(searchResults, currentAccountBalance));
 
        // Add record to DB
        insertNewRecord(balance);
 
        // Search with only the required params, should return 1 result
        fieldValues = getLookupFieldValues(currentAccountBalance, false);
        searchResults = lookupableHelperServiceImpl.getSearchResults(fieldValues);
        int numOfFirstResult = searchResults.size();
        assertTrue(testDataGenerator.getMessageValue("wrongRecordSize"), searchResults.size() >= 1);
        assertTrue(testDataGenerator.getMessageValue("failToFindRecord"), contains(searchResults, currentAccountBalance));
 
        // Search with all available search params, should return 1 result
        fieldValues = getLookupFieldValues(currentAccountBalance, true);
        searchResults = lookupableHelperServiceImpl.getSearchResults(fieldValues);
        assertTrue(testDataGenerator.getMessageValue("wrongRecordSize"), searchResults.size() >= numOfFirstResult);
        assertTrue(testDataGenerator.getMessageValue("failToFindRecord"), contains(searchResults, currentAccountBalance));
 
    }
 
 
    /**
     * This method will return a map of entries suitable for building a record
     * query.
     *
     * Need to override since TestDataGenerator only handles key/value pairs
     * contained in the data.properties test file.
     *
     * If one places properties in the file that are not relevant to a Transaction objects,
     * an exception is thrown.
     *
     * @param businessObject Moot, this is just to follow the parents method signature
     * @param isExtended If true, will include all search kay/pair values, if false, will only return bare minimum kay/pair values
     * @see org.kuali.kfs.gl.businessobject.lookup.AbstractGeneralLedgerLookupableHelperServiceTestBase#getLookupFieldValues(org.kuali.rice.krad.bo.PersistableBusinessObjectBase, boolean)
     */
    @Override
    public Map<String, String> getLookupFieldValues(PersistableBusinessObjectBase businessObject, boolean isExtended) throws Exception{
        if(isExtended){
            return fullFieldToValueMap;
        }else{
            // Don't add in the optional fields
            Map<String, String> results = new HashMap<String, String>();
            results.putAll(requiredFieldToValueMap);
            results.put(ACCOUNT_NUMBER_KEY, semiRequiredFieldToValueMap.get(ACCOUNT_NUMBER_KEY));
            return results;
        }
    }
 
 
    /*
     * Build a CuurentAccountBalance from the given Balance
     */
    private CurrentAccountBalance generateCurrentAccountBalance(Balance balance){
        CurrentAccountBalance currentAccountBalance = new CurrentAccountBalance();
        ObjectUtil.buildObject(currentAccountBalance, balance);
        currentAccountBalance.setUniversityFiscalYear(UNIVERSITY_FISCAL_YEAR);
        currentAccountBalance.setAccount(generateAccount());
        currentAccountBalance.setUniversityFiscalPeriodCode(requiredFieldToValueMap.get(UNIVERSITY_FISCAL_PERIOD_CODE_KEY));
        return currentAccountBalance;
    }
 
 
    /*
     * Create a minimal Account object, which will be set on
     * super.pendingEntry, and used in generating test data.
     */
    private Account generateAccount(){
        Account account = AccountFixture.ACCOUNT_PRESENCE_ACCOUNT.createAccount();
        account.setAccountExpirationDate(Date.valueOf(ACCOUNT_EXPIRATION_DATE));
        account.setActive(true);
        account.setAccountNumber(testDataGenerator.getPropertyValue(KFSPropertyConstants.ACCOUNT_NUMBER));
        account.setChartOfAccountsCode(pendingEntry.getChartOfAccountsCode());
        account.setOrganizationCode(optionalFieldToValueMap.get(ORGINIZATION_CODE_KEY));
 
        Person accountFiscalOfficerUser = personService.getPersonByPrincipalName(semiRequiredFieldToValueMap.get(FISCAL_OFFICER_PRINCIPAL_NAME_KEY));
        account.setAccountFiscalOfficerSystemIdentifier(accountFiscalOfficerUser.getPrincipalId());
        account.setAccountFiscalOfficerUser(accountFiscalOfficerUser);
 
        Person accountSupervisoryUser = personService.getPersonByPrincipalName(semiRequiredFieldToValueMap.get(ACCOUNT_SUPERVISOR_PRINCIPAL_NAME_KEY));
        account.setAccountFiscalOfficerSystemIdentifier(accountSupervisoryUser.getPrincipalId());
        account.setAccountSupervisoryUser(accountSupervisoryUser);
 
        return account;
    }
 
 
    /*
     * This method inserts a new Balance record into database.
     *
     * @param transaction the given transaction to persist.
     */
    private void insertNewRecord(Balance balance) {
        SpringContext.getBean(BusinessObjectService.class).save(balance);
    }
 
 
     /**
      * Returns the fields that are used for a Current Account Balance Lookup.
      *
      * @param isExtended true if extended attributes should be included for checking, false otherwise
      * @return a List of field names to check
      * @see org.kuali.kfs.gl.businessobject.lookup.AbstractGeneralLedgerLookupableHelperServiceTestBase#getLookupFields(boolean)
      */
     @Override
     public List<String> getLookupFields(boolean isExtended) {
         List<String> lookupFields = new LinkedList<String>();
         lookupFields.add(UNIVERSITY_FISCAL_YEAR_KEY);
         lookupFields.add(UNIVERSITY_FISCAL_PERIOD_CODE_KEY);
         lookupFields.add(ACCOUNT_NUMBER_KEY);
         if(isExtended){
             lookupFields.add(ORGINIZATION_CODE_KEY);
             lookupFields.add(FISCAL_OFFICER_PRINCIPAL_NAME_KEY);
             lookupFields.add(ACCOUNT_SUPERVISOR_PRINCIPAL_NAME_KEY);
             lookupFields.add(CHART_OF_ACCOUNTS_CODE_KEY);
             lookupFields.add(SUB_ACCOUNT_NUMBER_KEY);
         }
         return lookupFields;
     }
 
 
 }