/*
    * 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.sys.document.validation.impl;
  
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.commons.lang.StringUtils;
  import org.kuali.ole.sys.OLEConstants;
  import org.kuali.ole.sys.OLEKeyConstants;
  import org.kuali.ole.sys.OLEPropertyConstants;
  import org.kuali.ole.sys.businessobject.AccountingLine;
  import org.kuali.ole.sys.businessobject.FinancialSystemDocumentHeader;
  import org.kuali.ole.sys.document.AccountingDocument;
  import org.kuali.ole.sys.document.Correctable;
  import org.kuali.ole.sys.document.authorization.AccountingLineAuthorizer;
  import org.kuali.ole.sys.document.authorization.AccountingLineAuthorizerBase;
  import org.kuali.ole.sys.document.datadictionary.AccountingLineGroupDefinition;
  import org.kuali.ole.sys.document.datadictionary.FinancialSystemTransactionalDocumentEntry;
  import org.kuali.ole.sys.document.validation.GenericValidation;
  import org.kuali.ole.sys.document.validation.event.AddAccountingLineEvent;
  import org.kuali.ole.sys.document.validation.event.AttributedDocumentEvent;
  import org.kuali.ole.sys.document.validation.event.DeleteAccountingLineEvent;
  import org.kuali.ole.sys.document.validation.event.UpdateAccountingLineEvent;
  import org.kuali.rice.kim.api.identity.Person;
  import org.kuali.rice.krad.service.DataDictionaryService;
  import org.kuali.rice.krad.rules.rule.event.KualiDocumentEvent;
  import org.kuali.rice.krad.util.GlobalVariables;
  
  /**
   * A validation that checks whether the given accounting line is accessible to the given user or not
   */
  public class AccountingLineAccessibleValidation extends GenericValidation {
      protected DataDictionaryService dataDictionaryService;
      protected AccountingDocument accountingDocumentForValidation;
      protected AccountingLine accountingLineForValidation;
      
      /**
       * Indicates what is being done to an accounting line. This allows the same method to be used for different actions.
       */
      public enum AccountingLineAction {
          ADD(OLEKeyConstants.ERROR_ACCOUNTINGLINE_INACCESSIBLE_ADD), DELETE(OLEKeyConstants.ERROR_ACCOUNTINGLINE_INACCESSIBLE_DELETE), UPDATE(OLEKeyConstants.ERROR_ACCOUNTINGLINE_INACCESSIBLE_UPDATE);
  
          public final String accessibilityErrorKey;
  
          AccountingLineAction(String accessabilityErrorKey) {
              this.accessibilityErrorKey = accessabilityErrorKey;
          }
      }
  
      /**
       * Validates that the given accounting line is accessible for editing by the current user.
       * <strong>This method expects a document as the first parameter and an accounting line as the second</strong>
       * @see org.kuali.ole.sys.document.validation.Validation#validate(java.lang.Object[])
       */
      public boolean validate(AttributedDocumentEvent event) {        
          final Person currentUser = GlobalVariables.getUserSession().getPerson();
          
          if (accountingDocumentForValidation instanceof Correctable) {
              final String errorDocumentNumber = ((FinancialSystemDocumentHeader)accountingDocumentForValidation.getDocumentHeader()).getFinancialDocumentInErrorNumber();
              if (StringUtils.isNotBlank(errorDocumentNumber))
                  return true;
          }
          
          final AccountingLineAuthorizer accountingLineAuthorizer = lookupAccountingLineAuthorizer();
          final boolean lineIsAccessible = accountingLineAuthorizer.hasEditPermissionOnAccountingLine(accountingDocumentForValidation, accountingLineForValidation, getAccountingLineCollectionProperty(), currentUser, true);
          final boolean isAccessible = accountingLineAuthorizer.hasEditPermissionOnField(accountingDocumentForValidation, accountingLineForValidation, getAccountingLineCollectionProperty(), OLEPropertyConstants.ACCOUNT_NUMBER, lineIsAccessible, true, currentUser);
  
          // report errors
          if (!isAccessible) {
              final String principalName = currentUser.getPrincipalName();
              
              final String[] chartErrorParams = new String[] { getDataDictionaryService().getAttributeLabel(accountingLineForValidation.getClass(), OLEPropertyConstants.CHART_OF_ACCOUNTS_CODE), accountingLineForValidation.getChartOfAccountsCode(),  principalName};
              GlobalVariables.getMessageMap().putError(OLEPropertyConstants.CHART_OF_ACCOUNTS_CODE, convertEventToMessage(event), chartErrorParams);
              
              final String[] accountErrorParams = new String[] { getDataDictionaryService().getAttributeLabel(accountingLineForValidation.getClass(), OLEPropertyConstants.ACCOUNT_NUMBER), accountingLineForValidation.getAccountNumber(), principalName };
              GlobalVariables.getMessageMap().putError(OLEPropertyConstants.ACCOUNT_NUMBER, convertEventToMessage(event), accountErrorParams);
          }
  
          return isAccessible;
      }
      
      /**
       * Returns the name of the accounting line group which holds the proper authorizer to do the KIM check
       * @return the name of the accouting line group to get the authorizer from
      */
     protected String getGroupName() {
         return (accountingLineForValidation.isSourceAccountingLine() ? OLEConstants.SOURCE_ACCOUNTING_LINES_GROUP_NAME : OLEConstants.TARGET_ACCOUNTING_LINES_GROUP_NAME);
     }
     
     /**
      * @return hopefully, the best accounting line authorizer implementation to do the KIM check for to see if lines are accessible
      */
     protected AccountingLineAuthorizer lookupAccountingLineAuthorizer() {
         final String groupName = getGroupName();
         final Map<String, AccountingLineGroupDefinition> groups = ((FinancialSystemTransactionalDocumentEntry)dataDictionaryService.getDataDictionary().getDictionaryObjectEntry(accountingDocumentForValidation.getClass().getName())).getAccountingLineGroups();
         
         if (groups.isEmpty()) return new AccountingLineAuthorizerBase(); // no groups? just use the default...
         if (groups.containsKey(groupName)) return groups.get(groupName).getAccountingLineAuthorizer(); // we've got the group
 
         final Set<String> groupNames = groups.keySet(); // we've got groups, just not the proper name; try our luck and get the first group iterator
         final Iterator<String> groupNameIterator = groupNames.iterator();
         final String firstGroupName = groupNameIterator.next();
         return groups.get(firstGroupName).getAccountingLineAuthorizer();
     }
     
     /**
      * Determines the property of the accounting line collection from the error prefixes
      * @return the accounting line collection property
      */
     protected String getAccountingLineCollectionProperty() {
         String propertyName = null;
         if (GlobalVariables.getMessageMap().getErrorPath().size() > 0) {
             propertyName = ((String)GlobalVariables.getMessageMap().getErrorPath().get(0)).replaceFirst(".*?document\\.", "");
         } else {
             propertyName = accountingLineForValidation.isSourceAccountingLine() ? OLEConstants.PermissionAttributeValue.SOURCE_ACCOUNTING_LINES.value : OLEConstants.PermissionAttributeValue.TARGET_ACCOUNTING_LINES.value;
         }
         if (propertyName.equals("newSourceLine")) return OLEConstants.PermissionAttributeValue.SOURCE_ACCOUNTING_LINES.value;
         if (propertyName.equals("newTargetLine")) return OLEConstants.PermissionAttributeValue.TARGET_ACCOUNTING_LINES.value;
         return propertyName;
     }
     
     /**
      * Determines what error message should be shown based on the event that required this validation
      * @param event the event to use to determine the error message
      * @return the key of the error message to display
      */
     protected String convertEventToMessage(KualiDocumentEvent event) {
         if (event instanceof AddAccountingLineEvent) {
             return AccountingLineAction.ADD.accessibilityErrorKey;
         } else if (event instanceof UpdateAccountingLineEvent) {
             return AccountingLineAction.UPDATE.accessibilityErrorKey;
         } else if (event instanceof DeleteAccountingLineEvent) {
             return AccountingLineAction.DELETE.accessibilityErrorKey;
         } else {
             return "";
         }
     }
 
     /**
      * 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 accountingLineForValidation attribute. 
      * @return Returns the accountingLineForValidation.
      */
     public AccountingLine getAccountingLineForValidation() {
         return accountingLineForValidation;
     }
 
     /**
      * Sets the accountingLineForValidation attribute value.
      * @param accountingLineForValidation The accountingLineForValidation to set.
      */
     public void setAccountingLineForValidation(AccountingLine accountingLineForValidation) {
         this.accountingLineForValidation = accountingLineForValidation;
     }
 
     /**
      * Gets the dataDictionaryService attribute. 
      * @return Returns the dataDictionaryService.
      */
     public DataDictionaryService getDataDictionaryService() {
         return dataDictionaryService;
     }
 
     /**
      * Sets the dataDictionaryService attribute value.
      * @param dataDictionaryService The dataDictionaryService to set.
      */
     public void setDataDictionaryService(DataDictionaryService dataDictionaryService) {
         this.dataDictionaryService = dataDictionaryService;
     }
     
 }