/**

  * Copyright 2005-2011 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.web.form;

 import org.apache.commons.lang.StringUtils;

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

 import org.kuali.rice.krad.lookup.Lookupable;

 import org.kuali.rice.krad.uif.UifConstants.ViewType;

 import org.kuali.rice.krad.uif.view.LookupView;

 import org.kuali.rice.krad.uif.service.ViewHelperService;

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

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

 import javax.servlet.http.HttpServletRequest;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 /**

  * Form class for <code>LookupView</code> screens

  *

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class LookupForm extends UifFormBase {

     private static final long serialVersionUID = -7323484966538685327L;

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

     private String dataObjectClassName;

     private String docNum;

     private String referencesToRefresh;

     private boolean multipleValuesSelect;

     private String lookupCollectionName;

     private Map<String, String> criteriaFields;

     private Map<String, String> fieldConversions;

     private boolean atLeastOneRowReturnable;

     private boolean atLeastOneRowHasActions;

     private Collection<?> searchResults;

     public LookupForm() {

         super();

         setViewTypeName(ViewType.LOOKUP);

         atLeastOneRowReturnable = false;

         atLeastOneRowHasActions = false;

         multipleValuesSelect = false;

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

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

     }

     /**

      * Picks out business object name from the request to get retrieve a

      * lookupable and set properties

      */

     @Override

     public void postBind(HttpServletRequest request) {

         super.postBind(request);

         try {

             Lookupable lookupable = getLookupable();

             if (lookupable == null) {

                 LOG.error("Lookupable not found for view id " + getView().getId());

                 throw new RuntimeException("Lookupable not found for view id " + getView().getId());

             }

             if (StringUtils.isBlank(getDataObjectClassName())) {

                 setDataObjectClassName(((LookupView) getView()).getDataObjectClassName().getName());

             }

             // init lookupable with data object class

             Class<?> dataObjectClass = Class.forName(getDataObjectClassName());

             lookupable.setDataObjectClass(dataObjectClass);

             // if showMaintenanceLinks is not already true, only show maintenance links

             // if the lookup was called from the home application view

             if (!((LookupView) getView()).isShowMaintenanceLinks()) {

                 // TODO replace with check to history

                 if (StringUtils.contains(getReturnLocation(), "/" + KRADConstants.PORTAL_ACTION) ||

                         StringUtils.contains(getReturnLocation(), "/index.html")) {

                     ((LookupView) getView()).setShowMaintenanceLinks(true);

                 }

             }

             // populate lookup read only fields list on lookupable

             lookupable.setReadOnlyFieldsList(getReadOnlyFieldsList());

             // populate field conversions list

             if (request.getParameter(KRADConstants.CONVERSION_FIELDS_PARAMETER) != null) {

                 String conversionFields = request.getParameter(KRADConstants.CONVERSION_FIELDS_PARAMETER);

                 setFieldConversions(KRADUtils.convertStringParameterToMap(conversionFields));

                 lookupable.setFieldConversions(getFieldConversions());

             }

             // perform upper casing of lookup parameters

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

             Map<String, String> formFields = getCriteriaFields();

             if (formFields != null) {

                 for (Map.Entry<String, String> entry : formFields.entrySet()) {

                     // check here to see if this field is a criteria element on the form

                     fieldValues.put(entry.getKey(),

                             LookupUtils.forceUppercase(dataObjectClass, entry.getKey(), entry.getValue()));

                 }

             }

             // fieldValues.put(UifParameters.RETURN_FORM_KEY, getReturnFormKey());

             // fieldValues.put(UifParameters.RETURN_LOCATION, getReturnLocation());

             if (StringUtils.isNotBlank(getDocNum())) {

                 fieldValues.put(KRADConstants.DOC_NUM, getDocNum());

             }

             this.setCriteriaFields(fieldValues);

         } catch (ClassNotFoundException e) {

             LOG.error("Object class " + getDataObjectClassName() + " not found");

             throw new RuntimeException("Object class " + getDataObjectClassName() + " not found", e);

         }

     }

     public Lookupable getLookupable() {

         ViewHelperService viewHelperService = getView().getViewHelperService();

         if (viewHelperService == null) {

             LOG.error("ViewHelperService is null.");

             throw new RuntimeException("ViewHelperService is null.");

         }

         if (!Lookupable.class.isAssignableFrom(viewHelperService.getClass())) {

             LOG.error("ViewHelperService class '" + viewHelperService.getClass().getName() +

                     "' is not assignable from '" + Lookupable.class + "'");

             throw new RuntimeException("ViewHelperService class '" + viewHelperService.getClass().getName() +

                     "' is not assignable from '" + Lookupable.class + "'");

         }

         return (Lookupable) viewHelperService;

     }

     protected Boolean processBooleanParameter(String parameterValue) {

         if (StringUtils.isNotBlank(parameterValue)) {

             if ("YES".equals(parameterValue.toUpperCase())) {

                 return Boolean.TRUE;

             }

             return new Boolean(parameterValue);

         }

         return null;

     }

     public String getDataObjectClassName() {

         return this.dataObjectClassName;

     }

     public void setDataObjectClassName(String dataObjectClassName) {

         this.dataObjectClassName = dataObjectClassName;

     }

     public String getDocNum() {

         return this.docNum;

     }

     public void setDocNum(String docNum) {

         this.docNum = docNum;

     }

     public String getReferencesToRefresh() {

         return referencesToRefresh;

     }

     public void setReferencesToRefresh(String referencesToRefresh) {

         this.referencesToRefresh = referencesToRefresh;

     }

     /**

      * Indicates whether multiple values select should be enabled for the lookup

      *

      * <p>

      * When set to true, the select field is enabled for the lookup results group that allows the user

      * to select one or more rows for returning

      * </p>

      *

      * @return boolean true if multiple values should be enabled, false otherwise

      */

     public boolean isMultipleValuesSelect() {

         return multipleValuesSelect;

     }

     /**

      * Setter for the multiple values select indicator

      *

      * @param multipleValuesSelect

      */

     public void setMultipleValuesSelect(boolean multipleValuesSelect) {

         this.multipleValuesSelect = multipleValuesSelect;

     }

     /**

      * For the case of multi-value lookup, indicates the collection that should be populated with

      * the return results

      *

      * @return String collection name (must be full binding path)

      */

     public String getLookupCollectionName() {

         return lookupCollectionName;

     }

     /**

      * Setter for the name of the collection that should be populated with lookup results

      *

      * @param lookupCollectionName

      */

     public void setLookupCollectionName(String lookupCollectionName) {

         this.lookupCollectionName = lookupCollectionName;

     }

     public Map<String, String> getCriteriaFields() {

         return this.criteriaFields;

     }

     public void setCriteriaFields(Map<String, String> criteriaFields) {

         this.criteriaFields = criteriaFields;

     }

     public Map<String, String> getFieldConversions() {

         return this.fieldConversions;

     }

     public void setFieldConversions(Map<String, String> fieldConversions) {

         this.fieldConversions = fieldConversions;

     }

     public Collection<?> getSearchResults() {

         return this.searchResults;

     }

     public void setSearchResults(Collection<?> searchResults) {

         this.searchResults = searchResults;

     }

     public boolean isAtLeastOneRowReturnable() {

         return atLeastOneRowReturnable;

     }

     public void setAtLeastOneRowReturnable(boolean atLeastOneRowReturnable) {

         this.atLeastOneRowReturnable = atLeastOneRowReturnable;

     }

     public boolean isAtLeastOneRowHasActions() {

         return atLeastOneRowHasActions;

     }

     public void setAtLeastOneRowHasActions(boolean atLeastOneRowHasActions) {

         this.atLeastOneRowHasActions = atLeastOneRowHasActions;

     }

 }