/*

  * Copyright 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.kns.util;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 import java.util.Set;

 import java.util.StringTokenizer;

 import org.apache.commons.lang.StringUtils;

 import org.kuali.rice.kew.exception.WorkflowException;

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

 import org.kuali.rice.kns.datadictionary.AttributeSecurity;

 import org.kuali.rice.kns.datadictionary.MaintainableCollectionDefinition;

 import org.kuali.rice.kns.datadictionary.MaintainableFieldDefinition;

 import org.kuali.rice.kns.datadictionary.MaintainableItemDefinition;

 import org.kuali.rice.kns.datadictionary.MaintainableSectionDefinition;

 import org.kuali.rice.kns.datadictionary.MaintenanceDocumentEntry;

 import org.kuali.rice.kns.document.MaintenanceDocument;

 import org.kuali.rice.kns.exception.KualiExceptionIncident;

 import org.kuali.rice.kns.exception.ValidationException;

 import org.kuali.rice.kns.lookup.LookupUtils;

 import org.kuali.rice.kns.lookup.SelectiveReferenceRefresher;

 import org.kuali.rice.kns.maintenance.Maintainable;

 import org.kuali.rice.kns.service.DataDictionaryService;

 import org.kuali.rice.kns.service.KNSServiceLocator;

 import org.kuali.rice.kns.service.KualiConfigurationService;

 import org.kuali.rice.kns.service.KualiExceptionIncidentService;

 import org.kuali.rice.kns.service.MaintenanceDocumentDictionaryService;

 import org.kuali.rice.kns.service.MaintenanceDocumentService;

 import org.kuali.rice.kns.web.ui.Field;

 import org.kuali.rice.kns.web.ui.Row;

 import org.kuali.rice.kns.web.ui.Section;

 import org.kuali.rice.kns.workflow.service.KualiWorkflowDocument;

 import org.kuali.rice.kns.workflow.service.WorkflowDocumentService;

 public class MaintenanceUtils {

     private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(MaintenanceUtils.class);

     private static MaintenanceDocumentService maintenanceDocumentService;

     private static WorkflowDocumentService workflowDocumentService;

     private static KualiConfigurationService kualiConfigurationService;

     private static KualiExceptionIncidentService kualiExceptionIncidentService; 

     private static MaintenanceDocumentDictionaryService maintenanceDocumentDictionaryService;

     private static DataDictionaryService dataDictionaryService;

     /**

      * Returns the field templates defined in the maint dictionary xml files. Field templates are used in multiple value lookups.

      * When doing a MV lookup on a collection, the returned BOs are not necessarily of the same type as the elements of the

      * collection. Therefore, a means of mapping between the fields for the 2 BOs are necessary. The template attribute of

      * <maintainableField>s contained within <maintainableCollection>s tells us this mapping. Example: a

      * <maintainableField name="collectionAttrib" template="lookupBOAttrib"> definition means that when a list of BOs are

      * returned, the lookupBOAttrib value of the looked up BO will be placed into the collectionAttrib value of the BO added to the

      * collection

      * 

      * @param sections the sections of a document

      * @param collectionName the name of a collection. May be a nested collection with indices (e.g. collA[1].collB)

      * @return

      */

     public static Map<String, String> generateMultipleValueLookupBOTemplate(List<MaintainableSectionDefinition> sections, String collectionName) {

         MaintainableCollectionDefinition definition = findMaintainableCollectionDefinition(sections, collectionName);

         if (definition == null) {

             return null;

         }

         Map<String, String> template = null;

         for (MaintainableFieldDefinition maintainableField : definition.getMaintainableFields()) {

             String templateString = maintainableField.getTemplate();

             if (StringUtils.isNotBlank(templateString)) {

                 if (template == null) {

                     template = new HashMap<String, String>();

                 }

                 template.put(maintainableField.getName(), templateString);

             }

         }

         return template;

     }

     /**

      * Finds the MaintainableCollectionDefinition corresponding to the given collection name. For example, if the collection name is

      * "A.B.C", it will attempt to find the MaintainableCollectionDefinition for C that is nested in B that is nested under A. This

      * may not work correctly if there are duplicate collection definitions within the sections

      * 

      * @param sections the sections of a maint doc

      * @param collectionName the name of a collection, relative to the root of the BO being maintained. This value may have index

      *        values (e.g. [1]), but these are ignored.

      * @return

      */

     public static MaintainableCollectionDefinition findMaintainableCollectionDefinition(List<MaintainableSectionDefinition> sections, String collectionName) {

         String[] collectionNameParts = StringUtils.split(collectionName, ".");

         for (MaintainableSectionDefinition section : sections) {

             MaintainableCollectionDefinition collDefinition = findMaintainableCollectionDefinitionHelper(section.getMaintainableItems(), collectionNameParts, 0);

             if (collDefinition != null) {

                 return collDefinition;

             }

         }

         return null;

     }

     private static <E extends MaintainableItemDefinition> MaintainableCollectionDefinition findMaintainableCollectionDefinitionHelper(Collection<E> items, String[] collectionNameParts, int collectionNameIndex) {

         if (collectionNameParts.length <= collectionNameIndex) {

             // we've gone too far down the nesting without finding it

             return null;

         }

         // we only care about the coll name, and not the index, since the coll definitions do not include the indexing characters,

         // i.e. [ and ]

         String collectionToFind = StringUtils.substringBefore(collectionNameParts[collectionNameIndex], "[");

         for (MaintainableItemDefinition item : items) {

             if (item instanceof MaintainableCollectionDefinition) {

                 MaintainableCollectionDefinition collection = (MaintainableCollectionDefinition) item;

                 if (collection.getName().equals(collectionToFind)) {

                     // we found an appropriate coll, now we have to see if we need to recurse even more (more nested collections),

                     // or just return the one we found.

                     if (collectionNameIndex == collectionNameParts.length - 1) {

                         // we're at the last part of the name, so we return

                         return collection;

                     }

                     else {

                         // go deeper

                         return findMaintainableCollectionDefinitionHelper(collection.getMaintainableCollections(), collectionNameParts, collectionNameIndex + 1);

                     }

                 }

             }

         }

         return null;

     }

     /**

      * Checks to see if there has been an override lookup declared for the maintenance field. If so, the override will be used for

      * the quickfinder and lookup utils will not be called. If no override was given, LookupUtils.setFieldQuickfinder will be called

      * to set the system generated quickfinder based on the attributes relationship to the parent business object.

      * 

      * @return Field with quickfinder set if one was found

      */

     public static final Field setFieldQuickfinder(BusinessObject businessObject, String attributeName, MaintainableFieldDefinition maintainableFieldDefinition, Field field, List<String> displayedFieldNames, SelectiveReferenceRefresher srr) {

         if (maintainableFieldDefinition.getOverrideLookupClass() != null && StringUtils.isNotBlank(maintainableFieldDefinition.getOverrideFieldConversions())) {

             field.setQuickFinderClassNameImpl(maintainableFieldDefinition.getOverrideLookupClass().getName());

             field.setFieldConversions(maintainableFieldDefinition.getOverrideFieldConversions());

             field.setBaseLookupUrl(LookupUtils.getBaseLookupUrl(false));

             field.setReferencesToRefresh(LookupUtils.convertReferencesToSelectCollectionToString(

                     srr.getAffectedReferencesFromLookup(businessObject, attributeName, "")));

             return field;

         }

         if (maintainableFieldDefinition.isNoLookup()){

                 return field;

         }

         return LookupUtils.setFieldQuickfinder(businessObject, null, false, 0, attributeName, field, displayedFieldNames, maintainableFieldDefinition.isNoLookup());

     }

     public static final Field setFieldQuickfinder(BusinessObject businessObject, String collectionName, boolean addLine, int index,

             String attributeName, Field field, List<String> displayedFieldNames, Maintainable maintainable, MaintainableFieldDefinition maintainableFieldDefinition) {

         if (maintainableFieldDefinition.getOverrideLookupClass() != null && StringUtils.isNotBlank(maintainableFieldDefinition.getOverrideFieldConversions())) {

             if (maintainable != null) {

                 String collectionPrefix = "";

                 if ( collectionName != null ) {

                     if (addLine) {

                         collectionPrefix = KNSConstants.MAINTENANCE_ADD_PREFIX + collectionName + ".";

                     }

                     else {

                         collectionPrefix = collectionName + "[" + index + "].";

                     }

                 }

                 field.setQuickFinderClassNameImpl(maintainableFieldDefinition.getOverrideLookupClass().getName());

                 String prefixedFieldConversions = prefixFieldConversionsDestinationsWithCollectionPrefix(maintainableFieldDefinition.getOverrideFieldConversions(), collectionPrefix);

                 field.setFieldConversions(prefixedFieldConversions);

                 field.setBaseLookupUrl(LookupUtils.getBaseLookupUrl(false));

                 field.setReferencesToRefresh(LookupUtils.convertReferencesToSelectCollectionToString(

                         maintainable.getAffectedReferencesFromLookup(businessObject, attributeName, collectionPrefix)));

             }

             return field;

         }

         if(maintainableFieldDefinition.isNoLookup()){

                 return field;

         }

         return LookupUtils.setFieldQuickfinder(businessObject, collectionName, addLine, index,

                 attributeName, field, displayedFieldNames, maintainable);

     }

     private static String prefixFieldConversionsDestinationsWithCollectionPrefix(String originalFieldConversions, String collectionPrefix) {

         StringBuilder buf = new StringBuilder();

         StringTokenizer tok = new StringTokenizer(originalFieldConversions, KNSConstants.FIELD_CONVERSIONS_SEPARATOR);

         boolean needsSeparator = false;

         while (tok.hasMoreTokens()) {

             String conversionPair = tok.nextToken();

             if (StringUtils.isBlank(conversionPair)) {

                 continue;

             }

             String fromValue = StringUtils.substringBefore(conversionPair, KNSConstants.FIELD_CONVERSION_PAIR_SEPARATOR);

             String toValue = StringUtils.substringAfter(conversionPair, KNSConstants.FIELD_CONVERSION_PAIR_SEPARATOR);

             if (needsSeparator) {

                 buf.append(KNSConstants.FIELD_CONVERSIONS_SEPARATOR);

             }

             needsSeparator = true;

             buf.append(fromValue).append(KNSConstants.FIELD_CONVERSION_PAIR_SEPARATOR).append(collectionPrefix).append(toValue);

         }

         return buf.toString();

     }

     public static final void setFieldDirectInquiry(BusinessObject businessObject, String attributeName, MaintainableFieldDefinition maintainableFieldDefinition, Field field, List<String> displayedFieldNames) {

         LookupUtils.setFieldDirectInquiry(businessObject, attributeName, field);

     }

     public static final void setFieldDirectInquiry(BusinessObject businessObject, String collectionName, boolean addLine, int index,

             String attributeName, Field field, List<String> displayedFieldNames, Maintainable maintainable, MaintainableFieldDefinition maintainableFieldDefinition) {

         LookupUtils.setFieldDirectInquiry(businessObject, attributeName, field);

     }

     /**

      * Given a section, returns a comma delimited string of all fields, representing the error keys that exist for a section

      * 

      * @param section a section

      * @return

      */

     public static String generateErrorKeyForSection(Section section) {

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

         addRowsToErrorKeySet(section.getRows(), fieldPropertyNames);

         StringBuilder buf = new StringBuilder();

         buf.append(section.getSectionId()).append(",");

         Iterator<String> nameIter = fieldPropertyNames.iterator();

         while (nameIter.hasNext()) {

             buf.append(nameIter.next());

             if (nameIter.hasNext()) {

                 buf.append(",");

             }

         }

         if (section.getContainedCollectionNames() != null && section.getContainedCollectionNames().size() > 0) {

             buf.append(",");

             Iterator<String> collectionIter = section.getContainedCollectionNames().iterator();

             while (collectionIter.hasNext()) {

                 buf.append(KNSConstants.MAINTENANCE_NEW_MAINTAINABLE + collectionIter.next());

                 if (collectionIter.hasNext()) {

                     buf.append(",");

                 }

             }

         }

         return buf.toString();

     }

     /**

      * This method recurses through all the fields of the list of rows and adds each field's property name to the set if it starts

      * with Constants.MAINTENANCE_NEW_MAINTAINABLE

      * 

      * @see KNSConstants#MAINTENANCE_NEW_MAINTAINABLE

      * @param listOfRows

      * @param errorKeys

      */

     protected static void addRowsToErrorKeySet(List<Row> listOfRows, Set<String> errorKeys) {

         if (listOfRows == null) {

             return;

         }

         for (Row row : listOfRows) {

             List<Field> fields = row.getFields();

             if (fields == null) {

                 continue;

             }

             for (Field field : fields) {

                 String fieldPropertyName = field.getPropertyName();

                 if (fieldPropertyName != null && fieldPropertyName.startsWith(KNSConstants.MAINTENANCE_NEW_MAINTAINABLE)) {

                     errorKeys.add(field.getPropertyName());

                 }

                 addRowsToErrorKeySet(field.getContainerRows(), errorKeys);

             }

         }

     }

     public static boolean isMaintenanceDocumentCreatingNewRecord(String maintenanceAction) {

         if (KNSConstants.MAINTENANCE_EDIT_ACTION.equalsIgnoreCase(maintenanceAction)) {

             return false;

         }

         else if (KNSConstants.MAINTENANCE_NEWWITHEXISTING_ACTION.equalsIgnoreCase(maintenanceAction)) {

             return false;

         }

         else if (KNSConstants.MAINTENANCE_DELETE_ACTION.equalsIgnoreCase(maintenanceAction)) {

             return false;

         }

         else if (KNSConstants.MAINTENANCE_NEW_ACTION.equalsIgnoreCase(maintenanceAction)) {

             return true;

         }

         else if (KNSConstants.MAINTENANCE_COPY_ACTION.equalsIgnoreCase(maintenanceAction)) {

             return true;

         }

         else {

             return true;

         }

     }

     /**

      * This method will throw a {@link ValidationException} if there is a valid locking document in existence and throwExceptionIfLocked is true.

      */

     public static void checkForLockingDocument(MaintenanceDocument document, boolean throwExceptionIfLocked) {

         LOG.info("starting checkForLockingDocument (by MaintenanceDocument)");

         // get the docHeaderId of the blocking docs, if any are locked and blocking

         //String blockingDocId = getMaintenanceDocumentService().getLockingDocumentId(document);

         String blockingDocId = document.getNewMaintainableObject().getLockingDocumentId();

         checkDocumentBlockingDocumentId(blockingDocId, throwExceptionIfLocked);

     }

     /**

      * This method will throw a {@link ValidationException} if there is a valid locking document in existence and throwExceptionIfLocked is true.

      */

     public static void checkForLockingDocument(Maintainable maintainable, boolean throwExceptionIfLocked) {

         LOG.info("starting checkForLockingDocument (by Maintainable)");

         // get the docHeaderId of the blocking docs, if any are locked and blocking

         //String blockingDocId = getMaintenanceDocumentService().getLockingDocumentId(maintainable, null);

         String blockingDocId = maintainable.getLockingDocumentId();

         checkDocumentBlockingDocumentId(blockingDocId, throwExceptionIfLocked);

     }

     private static void checkDocumentBlockingDocumentId(String blockingDocId, boolean throwExceptionIfLocked) {

         // if we got nothing, then no docs are blocking, and we're done

         if (StringUtils.isBlank(blockingDocId)) {

             return;

         }

         if ( LOG.isInfoEnabled() ) {

             LOG.info("Locking document found:  docId = " + blockingDocId + ".");

         }

         // load the blocking locked document

         KualiWorkflowDocument lockedDocument = null;

         try {

                 // need to perform this check to prevent an exception from being thrown by the

                 // createWorkflowDocument call - the throw itself causes transaction rollback problems to

                 // occur, even though the exception would be caught here

                 if ( getWorkflowDocumentService().workflowDocumentExists(blockingDocId) ) {

                         lockedDocument = getWorkflowDocumentService().createWorkflowDocument(Long.valueOf(blockingDocId), GlobalVariables.getUserSession().getPerson() );

                 }

         } catch (Exception ex) {

                 // clean up the lock and notify the admins

                 LOG.error("Unable to retrieve locking document specified in the maintenance lock table: " + blockingDocId, ex);

                 cleanOrphanLocks(blockingDocId, ex);

                 return;

         }

         if ( lockedDocument == null ) {

                 LOG.warn( "Locking document header for " + blockingDocId + "came back null." );

                 cleanOrphanLocks(blockingDocId, null);

         }

         // if we can ignore the lock (see method notes), then exit cause we're done

         if (lockCanBeIgnored(lockedDocument)) {

             return;

         }

         // build the link URL for the blocking document

         Properties parameters = new Properties();

         parameters.put(KNSConstants.PARAMETER_DOC_ID, blockingDocId);

         parameters.put(KNSConstants.PARAMETER_COMMAND, KNSConstants.METHOD_DISPLAY_DOC_SEARCH_VIEW);

         String blockingUrl = UrlFactory.parameterizeUrl(getKualiConfigurationService().getPropertyString(KNSConstants.WORKFLOW_URL_KEY) + "/" + KNSConstants.DOC_HANDLER_ACTION, parameters);

         if ( LOG.isDebugEnabled() ) {

             LOG.debug("blockingUrl = '" + blockingUrl + "'");

             LOG.debug("Maintenance record: " + lockedDocument.getAppDocId() + "is locked.");

         }

         String[] errorParameters = { blockingUrl, blockingDocId };

         // If specified, add an error to the ErrorMap and throw an exception; otherwise, just add a warning to the ErrorMap instead.

         if (throwExceptionIfLocked) {

                 // post an error about the locked document

             GlobalVariables.getMessageMap().putError(KNSConstants.GLOBAL_ERRORS, RiceKeyConstants.ERROR_MAINTENANCE_LOCKED, errorParameters);

             throw new ValidationException("Maintenance Record is locked by another document.");

         }

         else {

                 // Post a warning about the locked document.

                 GlobalVariables.getMessageMap().putWarning(KNSConstants.GLOBAL_MESSAGES, RiceKeyConstants.WARNING_MAINTENANCE_LOCKED, errorParameters);

         }

     }

     /**

      * This method guesses whether the current user should be allowed to change a document even though it is locked. It probably

      * should use Authorization instead? See KULNRVSYS-948

      * 

      * @param lockedDocument

      * @return

      * @throws WorkflowException

      */

     private static boolean lockCanBeIgnored(KualiWorkflowDocument lockedDocument) {

         // TODO: implement real authorization for Maintenance Document Save/Route - KULNRVSYS-948

             if ( lockedDocument == null ) {

                     return true;

                 }

         // get the user-id. if no user-id, then we can do this test, so exit

         String userId = GlobalVariables.getUserSession().getPrincipalId().trim();

         if (StringUtils.isBlank(userId)) {

             return false; // dont bypass locking

         }

         // if the current user is not the initiator of the blocking document

         if (!userId.equalsIgnoreCase(lockedDocument.getRouteHeader().getInitiatorPrincipalId().trim())) {

             return false;

         }

         // if the blocking document hasn't been routed, we can ignore it

         return lockedDocument.stateIsInitiated();

     }

     private static void cleanOrphanLocks( String lockingDocumentNumber, Exception workflowException ) {

             // put a try/catch around the whole thing - the whole reason we are doing this is to prevent data errors

             // from stopping a document

             try {

                     // delete the locks for this document since it does not seem to exist

                     getMaintenanceDocumentService().deleteLocks(lockingDocumentNumber);

                     // notify the incident list

             Map<String, String> parameters = new HashMap<String, String>(1);

             parameters.put(KNSConstants.PARAMETER_DOC_ID, lockingDocumentNumber);

                 KualiExceptionIncident kei = getKualiExceptionIncidentService().getExceptionIncident(workflowException, parameters);

                     getKualiExceptionIncidentService().report(kei);

             } catch ( Exception ex ) {

                     LOG.error("Unable to delete and notify upon locking document retrieval failure.", ex);

             }

     }

         private static MaintenanceDocumentService getMaintenanceDocumentService() {

                 if ( maintenanceDocumentService == null ) {

                         maintenanceDocumentService = KNSServiceLocator.getMaintenanceDocumentService();

                 }

                 return maintenanceDocumentService;

         }

         private static WorkflowDocumentService getWorkflowDocumentService() {

                 if ( workflowDocumentService == null ) {

                         workflowDocumentService = KNSServiceLocator.getWorkflowDocumentService();

                 }

                 return workflowDocumentService;

         }

         private static KualiConfigurationService getKualiConfigurationService() {

                 if ( kualiConfigurationService == null ) {

                         kualiConfigurationService = KNSServiceLocator.getKualiConfigurationService();

                 }

                 return kualiConfigurationService;

         }

         private static KualiExceptionIncidentService getKualiExceptionIncidentService() {

                 if ( kualiExceptionIncidentService == null ) {

                         kualiExceptionIncidentService = KNSServiceLocator.getKualiExceptionIncidentService();

                 }

                 return kualiExceptionIncidentService;

         }

         private static MaintenanceDocumentDictionaryService getMaintenanceDocumentDictionaryService() {

                 if ( maintenanceDocumentDictionaryService == null ) {

                         maintenanceDocumentDictionaryService = KNSServiceLocator.getMaintenanceDocumentDictionaryService();

                 }

                 return maintenanceDocumentDictionaryService;

         }

         private static DataDictionaryService getDataDictionaryService() {

                 if ( dataDictionaryService == null ) {

                         dataDictionaryService = KNSServiceLocator.getDataDictionaryService();

                 }

                 return dataDictionaryService;

         }

         public static Map<String, AttributeSecurity> retrievePropertyPathToAttributeSecurityMappings(String docTypeName) {

                 Map<String, AttributeSecurity> results = new HashMap<String, AttributeSecurity>();

                 MaintenanceDocumentEntry entry = getMaintenanceDocumentDictionaryService().getMaintenanceDocumentEntry(docTypeName);

                 String className = entry.getBusinessObjectClass().getName();

                 for (MaintainableSectionDefinition section : entry.getMaintainableSections()) {

                         for (MaintainableItemDefinition item : section.getMaintainableItems()) {

                                 if (item instanceof MaintainableFieldDefinition) {

                                         MaintainableFieldDefinition field = (MaintainableFieldDefinition) item;

                                         AttributeSecurity attributeSecurity = getDataDictionaryService().getAttributeSecurity(className, field.getName());

                                         if (attributeSecurity != null) {

                                                 results.put(field.getName(), attributeSecurity);

                                         }

                                 }

                                 else if (item instanceof MaintainableCollectionDefinition) {

                                         addMaintenanceDocumentCollectionPathToSecurityMappings(results, "", (MaintainableCollectionDefinition) item);

                                 }

                         }

                 }

                 return results;

         }

         private static void addMaintenanceDocumentCollectionPathToSecurityMappings(Map<String, AttributeSecurity> mappings, String propertyPathPrefix, MaintainableCollectionDefinition collectionDefinition) {

                 propertyPathPrefix = propertyPathPrefix + collectionDefinition.getName() + ".";

                 String boClassName = collectionDefinition.getBusinessObjectClass().getName();

                 for (MaintainableFieldDefinition field : collectionDefinition.getMaintainableFields()) {

                         AttributeSecurity attributeSecurity = getDataDictionaryService().getAttributeSecurity(boClassName, field.getName());

                         if (attributeSecurity != null) {

                                 mappings.put(propertyPathPrefix + field.getName(), attributeSecurity);

                         }

                 }

                 for (MaintainableCollectionDefinition nestedCollection : collectionDefinition.getMaintainableCollections()) {

                         addMaintenanceDocumentCollectionPathToSecurityMappings(mappings, propertyPathPrefix, nestedCollection);

                 }

         }

 }