/*

  * Copyright 2006-2007 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.rice.krad.lookup;

 import org.apache.commons.beanutils.PropertyUtils;

 import org.apache.commons.lang.StringUtils;

 import org.kuali.rice.core.api.encryption.EncryptionService;

 import org.kuali.rice.core.api.search.SearchOperator;

 import org.kuali.rice.krad.bo.BusinessObject;

 import org.kuali.rice.krad.bo.ExternalizableBusinessObject;

 import org.kuali.rice.krad.datadictionary.BusinessObjectEntry;

 import org.kuali.rice.krad.datadictionary.RelationshipDefinition;

 import org.kuali.rice.krad.service.KRADServiceLocatorWeb;

 import org.kuali.rice.krad.service.ModuleService;

 import org.kuali.rice.krad.util.BeanPropertyComparator;

 import org.kuali.rice.krad.util.ExternalizableBusinessObjectUtils;

 import org.kuali.rice.krad.util.KRADConstants;

 import org.kuali.rice.krad.util.ObjectUtils;

 import org.springframework.transaction.annotation.Transactional;

 import java.security.GeneralSecurityException;

 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;

 @Transactional

 public class KualiLookupableHelperServiceImpl extends AbstractLookupableHelperServiceImpl {

     protected static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(KualiLookupableHelperServiceImpl.class);

     protected boolean searchUsingOnlyPrimaryKeyValues = false;

     /**

      * Uses Lookup Service to provide a basic search.

      *

      * @param fieldValues - Map containing prop name keys and search values

      *

      * @return List found business objects

      * @see org.kuali.rice.krad.lookup.LookupableHelperService#getSearchResults(java.util.Map)

      */

     public List<? extends BusinessObject> getSearchResults(Map<String, String> fieldValues) {

         return getSearchResultsHelper(LookupUtils.forceUppercase(getBusinessObjectClass(), fieldValues), false);

     }

     /**

      * Uses Lookup Service to provide a basic unbounded search.

      *

      * @param fieldValues - Map containing prop name keys and search values

      *

      * @return List found business objects

      * @see org.kuali.rice.krad.lookup.LookupableHelperService#getSearchResultsUnbounded(java.util.Map)

      */

     public List<? extends BusinessObject> getSearchResultsUnbounded(Map<String, String> fieldValues) {

         return getSearchResultsHelper(LookupUtils.forceUppercase(getBusinessObjectClass(), fieldValues), true);

     }

     // TODO: Fix? - this does not handle nested properties within the EBO.

     /**

      * Check whether the given property represents a property within an EBO starting

      * with the sampleBo object given.  This is used to determine if a criteria needs

      * to be applied to the EBO first, before sending to the normal lookup DAO.

      */

     protected boolean isExternalBusinessObjectProperty(Object sampleBo, String propertyName) {

         try {

                 if ( propertyName.indexOf( "." ) > 0 && !StringUtils.contains( propertyName, "add." ) ) {

                         Class propertyClass = PropertyUtils.getPropertyType(

                                                 sampleBo, StringUtils.substringBeforeLast( propertyName, "." ) );

                         if ( propertyClass != null ) {

                                 return ExternalizableBusinessObjectUtils.isExternalizableBusinessObjectInterface( propertyClass );

                         } else {

                                 if ( LOG.isDebugEnabled() ) {

                                         LOG.debug( "unable to get class for " + StringUtils.substringBeforeLast( propertyName, "." ) + " on " + sampleBo.getClass().getName() );

                                 }

                         }

                 }

         } catch (Exception e) {

                 LOG.debug("Unable to determine type of property for " + sampleBo.getClass().getName() + "/" + propertyName, e );

         }

         return false;

     }

     /**

      * Get the name of the property which represents the ExternalizableBusinessObject for the given property.

      *

      * This method can not handle nested properties within the EBO.

      *

      * Returns null if the property is not a nested property or is part of an add line.

      */

     protected String getExternalBusinessObjectProperty(Object sampleBo, String propertyName) {

             if ( propertyName.indexOf( "." ) > 0 && !StringUtils.contains( propertyName, "add." ) ) {

                     return StringUtils.substringBeforeLast( propertyName, "." );

             }

         return null;

     }

     /**

      * Checks whether any of the fieldValues being passed refer to a property within an ExternalizableBusinessObject.

      */

     protected boolean hasExternalBusinessObjectProperty(Class boClass, Map<String,String> fieldValues ) {

             try {

                     Object sampleBo = boClass.newInstance();

                     for ( String key : fieldValues.keySet() ) {

                             if ( isExternalBusinessObjectProperty( sampleBo, key )) {

                                     return true;

                             }

                     }

             } catch ( Exception ex ) {

                 LOG.debug("Unable to check " + boClass + " for EBO properties.", ex );

             }

             return false;

     }

     /**

      * Returns a map stripped of any properties which refer to ExternalizableBusinessObjects.  These values may not be passed into the

      * lookup service, since the objects they refer to are not in the local database.

      */

     protected Map<String,String> removeExternalizableBusinessObjectFieldValues(Class boClass, Map<String,String> fieldValues ) {

             Map<String,String> eboFieldValues = new HashMap<String,String>();

             try {

                     Object sampleBo = boClass.newInstance();

                     for ( String key : fieldValues.keySet() ) {

                             if ( !isExternalBusinessObjectProperty( sampleBo, key )) {

                                     eboFieldValues.put( key, fieldValues.get( key ) );

                             }

                     }

             } catch ( Exception ex ) {

                 LOG.debug("Unable to check " + boClass + " for EBO properties.", ex );

             }

             return eboFieldValues;

     }

     /**

      * Return the EBO fieldValue entries explicitly for the given eboPropertyName.  (I.e., any properties with the given

      * property name as a prefix.

      */

     protected Map<String,String> getExternalizableBusinessObjectFieldValues(String eboPropertyName, Map<String,String> fieldValues ) {

             Map<String,String> eboFieldValues = new HashMap<String,String>();

             for ( String key : fieldValues.keySet() ) {

                     if ( key.startsWith( eboPropertyName + "." ) ) {

                             eboFieldValues.put( StringUtils.substringAfterLast( key, "." ), fieldValues.get( key ) );

                     }

             }

             return eboFieldValues;

     }

     /**

      * Get the complete list of all properties referenced in the fieldValues that are ExternalizableBusinessObjects.

      *

      * This is a list of the EBO object references themselves, not of the properties within them.

      */

     protected List<String> getExternalizableBusinessObjectProperties(Class boClass, Map<String,String> fieldValues ) {

             Set<String> eboPropertyNames = new HashSet<String>();

             try {

                     Object sampleBo = boClass.newInstance();

                     for ( String key : fieldValues.keySet() ) {

                             if ( isExternalBusinessObjectProperty( sampleBo, key )) {

                                     eboPropertyNames.add( StringUtils.substringBeforeLast( key, "." ) );

                             }

                     }

             } catch ( Exception ex ) {

                 LOG.debug("Unable to check " + boClass + " for EBO properties.", ex );

             }

             return new ArrayList<String>(eboPropertyNames);

     }

     /**

      * Given an property on the main BO class, return the defined type of the ExternalizableBusinessObject.  This will be used

      * by other code to determine the correct module service to call for the lookup.

      *

      * @param boClass

      * @param propertyName

      * @return

      */

     protected Class<? extends ExternalizableBusinessObject> getExternalizableBusinessObjectClass(Class boClass, String propertyName) {

         try {

                 return PropertyUtils.getPropertyType(

                                         boClass.newInstance(), StringUtils.substringBeforeLast( propertyName, "." ) );

         } catch (Exception e) {

                 LOG.debug("Unable to determine type of property for " + boClass.getName() + "/" + propertyName, e );

         }

         return null;

     }

     /**

      *

      * This method does the actual search, with the parameters specified, and returns the result.

      *

      * NOTE that it will not do any upper-casing based on the DD forceUppercase. That is handled through an external call to

      * LookupUtils.forceUppercase().

      *

      * @param fieldValues A Map of the fieldNames and fieldValues to be searched on.

      * @param unbounded Whether the results should be bounded or not to a certain max size.

      * @return A List of search results.

      *

      */

     protected List<? extends BusinessObject> getSearchResultsHelper(Map<String, String> fieldValues, boolean unbounded) {

         // remove hidden fields

         LookupUtils.removeHiddenCriteriaFields( getBusinessObjectClass(), fieldValues );

         searchUsingOnlyPrimaryKeyValues = getLookupService().allPrimaryKeyValuesPresentAndNotWildcard(getBusinessObjectClass(), fieldValues);

         setBackLocation(fieldValues.get(KRADConstants.BACK_LOCATION));

         setDocFormKey(fieldValues.get(KRADConstants.DOC_FORM_KEY));

         setReferencesToRefresh(fieldValues.get(KRADConstants.REFERENCES_TO_REFRESH));

         List searchResults;

             Map<String,String> nonBlankFieldValues = new HashMap<String, String>();

             for (String fieldName : fieldValues.keySet()) {

                     String fieldValue = fieldValues.get(fieldName);

                     if (StringUtils.isNotBlank(fieldValue) ) {

                             if (fieldValue.endsWith(EncryptionService.ENCRYPTION_POST_PREFIX)) {

                                     String encryptedValue = StringUtils.removeEnd(fieldValue, EncryptionService.ENCRYPTION_POST_PREFIX);

                                     try {

                                             fieldValue = getEncryptionService().decrypt(encryptedValue);

                                     }

                                     catch (GeneralSecurityException e) {

                                     LOG.error("Error decrypting value for business object " + getBusinessObjectService() + " attribute " + fieldName, e);

                                     throw new RuntimeException("Error decrypting value for business object " + getBusinessObjectService() + " attribute " + fieldName, e);

                             }

                             }

                             nonBlankFieldValues.put(fieldName, fieldValue);

                     }

             }

         // If this class is an EBO, just call the module service to get the results

         if ( ExternalizableBusinessObject.class.isAssignableFrom( getBusinessObjectClass() ) ) {

                 ModuleService eboModuleService = KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService( getBusinessObjectClass() );

                 BusinessObjectEntry ddEntry = eboModuleService.getExternalizableBusinessObjectDictionaryEntry(getBusinessObjectClass());

                 Map<String,String> filteredFieldValues = new HashMap<String, String>();

                 for (String fieldName : nonBlankFieldValues.keySet()) {

                         if (ddEntry.getAttributeNames().contains(fieldName)) {

                                 filteredFieldValues.put(fieldName, nonBlankFieldValues.get(fieldName));

                         }

                 }

                 searchResults = eboModuleService.getExternalizableBusinessObjectsListForLookup(getBusinessObjectClass(), (Map)filteredFieldValues, unbounded);

         // if any of the properties refer to an embedded EBO, call the EBO lookups first and apply to the local lookup

         } else if ( hasExternalBusinessObjectProperty( getBusinessObjectClass(), nonBlankFieldValues ) ) {

                 if ( LOG.isDebugEnabled() ) {

                         LOG.debug( "has EBO reference: " + getBusinessObjectClass() );

                         LOG.debug( "properties: " + nonBlankFieldValues );

                 }

                 // remove the EBO criteria

                 Map<String,String> nonEboFieldValues = removeExternalizableBusinessObjectFieldValues( getBusinessObjectClass(), nonBlankFieldValues );

                 if ( LOG.isDebugEnabled() ) {

                         LOG.debug( "Non EBO properties removed: " + nonEboFieldValues );

                 }

                 // get the list of EBO properties attached to this object

                 List<String> eboPropertyNames = getExternalizableBusinessObjectProperties( getBusinessObjectClass(), nonBlankFieldValues );

                 if ( LOG.isDebugEnabled() ) {

                         LOG.debug( "EBO properties: " + eboPropertyNames );

                 }

                 // loop over those properties

                 for ( String eboPropertyName : eboPropertyNames ) {

                         // extract the properties as known to the EBO

                         Map<String,String> eboFieldValues = getExternalizableBusinessObjectFieldValues( eboPropertyName, nonBlankFieldValues );

                     if ( LOG.isDebugEnabled() ) {

                             LOG.debug( "EBO properties for master EBO property: " + eboPropertyName );

                             LOG.debug( "properties: " + eboFieldValues );

                     }

                     // run search against attached EBO's module service

                     ModuleService eboModuleService = KRADServiceLocatorWeb.getKualiModuleService().getResponsibleModuleService( getExternalizableBusinessObjectClass( getBusinessObjectClass(), eboPropertyName) );

                     // KULRICE-4401 made eboResults an empty list and only filled if service is found.

                           List eboResults = Collections.emptyList();

                           if (eboModuleService != null) 

                           {

                                   eboResults = eboModuleService.getExternalizableBusinessObjectsListForLookup( getExternalizableBusinessObjectClass( getBusinessObjectClass(), eboPropertyName), (Map)eboFieldValues, unbounded);

                           }

                                   else

                           {

                                   LOG.debug( "EBO ModuleService is null: " + eboPropertyName );

                           }

                         // get the mapping/relationship between the EBO object and it's parent object

                         // use that to adjust the fieldValues

                         // get the parent property type

                         Class eboParentClass;

                         String eboParentPropertyName;

                         if ( ObjectUtils.isNestedAttribute( eboPropertyName ) ) {

                                 eboParentPropertyName = StringUtils.substringBeforeLast( eboPropertyName, "." );

                                 try {

                                         eboParentClass = PropertyUtils.getPropertyType( getBusinessObjectClass().newInstance(), eboParentPropertyName );

                                 } catch ( Exception ex ) {

                                         throw new RuntimeException( "Unable to create an instance of the business object class: " + getBusinessObjectClass().getName(), ex );

                                 }

                         } else {

                                 eboParentClass = getBusinessObjectClass();

                                 eboParentPropertyName = null;

                         }

                         if ( LOG.isDebugEnabled() ) {

                                 LOG.debug( "determined EBO parent class/property name: " + eboParentClass + "/" + eboParentPropertyName );

                         }

                         // look that up in the DD (BOMDS)

                         // find the appropriate relationship

                         // CHECK THIS: what if eboPropertyName is a nested attribute - need to strip off the eboParentPropertyName if not null

                         RelationshipDefinition rd = getBusinessObjectMetaDataService().getBusinessObjectRelationshipDefinition( eboParentClass, eboPropertyName );

                         if ( LOG.isDebugEnabled() ) {

                                 LOG.debug( "Obtained RelationshipDefinition for " + eboPropertyName );

                                 LOG.debug( rd );

                         }

                         // copy the needed properties (primary only) to the field values

                         // KULRICE-4446 do so only if the relationship definition exists

                         // NOTE: this will work only for single-field PK unless the ORM layer is directly involved

                         // (can't make (field1,field2) in ( (v1,v2),(v3,v4) ) style queries in the lookup framework

                         if ( ObjectUtils.isNotNull(rd)) {

                                 if ( rd.getPrimitiveAttributes().size() > 1 ) {

                                         throw new RuntimeException( "EBO Links don't work for relationships with multiple-field primary keys." );

                                 }

                                 String boProperty = rd.getPrimitiveAttributes().get( 0 ).getSourceName();

                                 String eboProperty = rd.getPrimitiveAttributes().get( 0 ).getTargetName();

                                 StringBuffer boPropertyValue = new StringBuffer();

                                 // loop over the results, making a string that the lookup DAO will convert into an

                                 // SQL "IN" clause

                                 for ( Object ebo : eboResults ) {

                                         if ( boPropertyValue.length() != 0 ) {

                                                 boPropertyValue.append( SearchOperator.OR.op() );

                                         }

                                         try {

                                                 boPropertyValue.append( PropertyUtils.getProperty( ebo, eboProperty ).toString() );

                                         } catch ( Exception ex ) {

                                                 LOG.warn( "Unable to get value for " + eboProperty + " on " + ebo );

                                         }

                                 }

                                 if ( eboParentPropertyName == null ) {

                                         // non-nested property containing the EBO

                                         nonEboFieldValues.put( boProperty, boPropertyValue.toString() );

                                 } else {

                                         // property nested within the main searched-for BO that contains the EBO

                                         nonEboFieldValues.put( eboParentPropertyName + "." + boProperty, boPropertyValue.toString() );

                                 }

                         }

                 }

                 if ( LOG.isDebugEnabled() ) {

                         LOG.debug( "Passing these results into the lookup service: " + nonEboFieldValues );

                 }

                 // add those results as criteria

                 // run the normal search (but with the EBO critieria added)

                     searchResults = (List) getLookupService().findCollectionBySearchHelper(getBusinessObjectClass(), nonEboFieldValues, unbounded);

         } else {

             searchResults = (List) getLookupService().findCollectionBySearchHelper(getBusinessObjectClass(), nonBlankFieldValues, unbounded);

         }

         if (searchResults == null) {

                 searchResults = new ArrayList();

         }

         // sort list if default sort column given

         List defaultSortColumns = getDefaultSortColumns();

         if (defaultSortColumns.size() > 0) {

             Collections.sort(searchResults, new BeanPropertyComparator(defaultSortColumns, true));

         }

         return searchResults;

     }

     /**

      * @see LookupableHelperService#isSearchUsingOnlyPrimaryKeyValues()

      */

     @Override

     public boolean isSearchUsingOnlyPrimaryKeyValues() {

         return searchUsingOnlyPrimaryKeyValues;

 }

     /**

      * Returns a comma delimited list of primary key field labels, to be used on the UI to tell the user which fields were used to search

      *

      * These labels are generated from the DD definitions for the lookup fields

      *

      * @return a comma separated list of field attribute names.  If no fields found, returns "N/A"

      * @see LookupableHelperService#isSearchUsingOnlyPrimaryKeyValues()

      * @see LookupableHelperService#getPrimaryKeyFieldLabels()

      */

     @Override

     public String getPrimaryKeyFieldLabels() {

         StringBuilder buf = new StringBuilder();

         List<String> primaryKeyFieldNames = getBusinessObjectMetaDataService().listPrimaryKeyFieldNames(getBusinessObjectClass());

         Iterator<String> pkIter = primaryKeyFieldNames.iterator();

         while (pkIter.hasNext()) {

             String pkFieldName = (String) pkIter.next();

             buf.append(getDataDictionaryService().getAttributeLabel(getBusinessObjectClass(), pkFieldName));

             if (pkIter.hasNext()) {

                 buf.append(", ");

             }

         }

         return buf.length() == 0 ? KRADConstants.NOT_AVAILABLE_STRING : buf.toString();

     }

 }