/*

  * Copyright 2007-2009 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.service.impl;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import org.apache.commons.lang.StringUtils;

 import org.apache.log4j.Logger;

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

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

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

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

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

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

 import org.kuali.rice.kns.util.KNSConstants;

 /**

  * See ParameterService. The componentClass must be the business object, document, or step class that the parameter is associated

  * with. Implementations of this class know how to translate that to a namespace (for ParameterService Impl, determine what module

  * the Class is associated with by parsing the package) and detail type (for ParameterServiceImpl, document Class --> use simple

  * class name minus the word Document / business object Class --> use simple class name, batch step class --> use the simple class

  * name). In cases where the parameter is applicable to all documents, all lookups, all batch steps, or all components in a

  * particular module, you should pass in the appropriate constant class in KfsParameterConstants for the component Class (e.g. all

  * purchasing documents = PURCHASING_DOCUMENT.class, all purchasing lookups = PURCHASING_LOOKUP.class, all purchasing batch steps =

  * PURCHASING_BATCH.class, and all purchasing components = PURCHASING_ALL.class). In addition, certain methods take

  * constrainingValue and constrainedValue Strings. The constrainedValue is the value that you want to compare to the Parameter

  * value, and the constrainingValue is used for complex parameters that limit one field value based on the value of another field,

  * e.g VALID_OBJECT_LEVELS_BY_OBJECT_TYPE.

  */

 public class ParameterServiceImpl extends ParameterServiceBase implements ParameterServerService {

         protected BusinessObjectService businessObjectService;

         protected LookupService lookupService;

         public Parameter retrieveParameter(String namespaceCode, String detailTypeCode, String parameterName) {

             String applicationNamespace = KNSServiceLocator.getKualiConfigurationService().getPropertyString(KNSConstants.APPLICATION_CODE);

             if (StringUtils.isEmpty(applicationNamespace)) {

                 applicationNamespace = KNSConstants.DEFAULT_APPLICATION_CODE;

             }

             Parameter parameter = fetchFromCache(namespaceCode, detailTypeCode, parameterName);

         if (parameter != null) {

             return parameter;

         }

             HashMap<String, String> crit = new HashMap<String, String>(3);

             crit.put("parameterNamespaceCode", namespaceCode);

             crit.put("parameterDetailTypeCode", detailTypeCode);

             crit.put("parameterName", parameterName);

             //crit.put("parameterApplicationNamespaceCode", applicationNamespace);

             List<Parameter> parameters = (List<Parameter>)getBusinessObjectService().findMatching(Parameter.class, crit);

             Parameter parameterDefault = null;

             for (Parameter parm : parameters) {

                 if (StringUtils.equals(applicationNamespace, parm.getParameterApplicationNamespaceCode())) {

                     parameter = parm;

                     break;

                 } else if (StringUtils.equals(KNSConstants.DEFAULT_APPLICATION_CODE, parm.getParameterApplicationNamespaceCode())) {

                     parameterDefault = parm;

                 }

             }

             if (parameter == null) {

                 parameter = parameterDefault;

             }

             insertIntoCache(parameter); 

             //if (parameter != null 

             //        && StringUtils.equals(KNSConstants.DEFAULT_APPLICATION_CODE, parameter.getParameterApplicationNamespaceCode())

             //        && !StringUtils.equals(KNSConstants.DEFAULT_APPLICATION_CODE, applicationNamespace)) {

             //    insertIntoCache(parameter, applicationNamespace); 

             //}

             return parameter;

         }

    /**

     * This method can be used to retrieve a list of parameters that

     * match the given fieldValues criteria. You could also specify the "like"

     * criteria in the Map.

     * 

     * @param   fieldValues The Map containing the key value pairs to be used 

     *                      to build the criteria.

     * @return  List of Parameters that match the criteria.

     */

         @SuppressWarnings("unchecked")

         public List<Parameter> retrieveParametersGivenLookupCriteria(Map<String, String> fieldValues) {

                 Collection<Parameter> results = getLookupService().findCollectionBySearch(Parameter.class, fieldValues);

                 return new ArrayList<Parameter>( results );

     }    

         public List<ParameterDetailType> getNonDatabaseComponents() {

                 return KNSServiceLocator.getRiceApplicationConfigurationMediationService().getNonDatabaseComponents();

         }

         @SuppressWarnings("unchecked")

         public void setParameterForTesting(Class componentClass, String parameterName, String parameterText) {

             Parameter parameter = (Parameter) getParameter(componentClass, parameterName);

             parameter.setParameterValue(parameterText);

             getBusinessObjectService().save(parameter);

         } 

         public void setBusinessObjectService(BusinessObjectService businessObjectService) {

             this.businessObjectService = businessObjectService;

         }

         protected LookupService getLookupService() {

                 if ( lookupService == null ) {

                         lookupService = KNSServiceLocator.getLookupService();

                 }

                 return lookupService;

         }

         protected BusinessObjectService getBusinessObjectService() {

                 if ( businessObjectService == null ) {

                         businessObjectService = KNSServiceLocator.getBusinessObjectService();

                 }

                 return this.businessObjectService;

         }        

 }