/**
    * Copyright 2005-2016 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.lang.StringUtils;
  import org.kuali.rice.krad.uif.UifConstants.ViewType;
  import org.kuali.rice.krad.util.KRADConstants;
  import org.kuali.rice.krad.util.KRADUtils;
  import org.kuali.rice.krad.web.bind.RequestAccessible;
  import org.kuali.rice.krad.web.form.UifFormBase;
  import org.springframework.http.HttpMethod;
  
  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 containing backing data for {@link LookupView}.
   *
   * @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);
  
      @RequestAccessible
      private String dataObjectClassName;
  
      @RequestAccessible
      private boolean multipleValuesSelect;
  
      @RequestAccessible
      private boolean redirectedLookup;
  
      @RequestAccessible
      private boolean returnByScript;
  
      @RequestAccessible
      private String returnTarget;
  
      @RequestAccessible
      private String lookupCollectionName;
  
      @RequestAccessible
      private String lookupCollectionId;
  
      @RequestAccessible
      private String referencesToRefresh;
  
      @RequestAccessible
      private String quickfinderId;
  
      @RequestAccessible
      private Map<String, String> fieldConversions;
      private List<String> multiValueReturnFields;
  
      @RequestAccessible
      private Map<String, String> lookupCriteria;
  
      private Collection<?> lookupResults;
  
      @RequestAccessible
      private boolean displayResults;
  
      public LookupForm() {
          super();
  
          setViewTypeName(ViewType.LOOKUP);
  
          lookupCriteria = new HashMap<String, String>();
          fieldConversions = new HashMap<String, String>();
          multiValueReturnFields = new ArrayList<String>();
      }
  
      /**
       * Picks out data object name from the request to retrieve a lookupable and for the initial get request
       * populates the {@link #getFieldConversions()} property.
       *
       * {@inheritDoc}
       */
      @Override
      public void postBind(HttpServletRequest request) {
          super.postBind(request);
 
         if (StringUtils.isBlank(getDataObjectClassName())) {
             setDataObjectClassName(((LookupView) getView()).getDataObjectClass().getName());
         }
 
         Lookupable lookupable = getLookupable();
         if (lookupable != null) {
             Class<?> dataObjectClass;
             try {
                 dataObjectClass = Class.forName(getDataObjectClassName());
             } catch (ClassNotFoundException e) {
                 throw new RuntimeException("Object class " + getDataObjectClassName() + " not found", e);
             }
 
             lookupable.setDataObjectClass(dataObjectClass);
         }
 
         // populate field conversions map on initial GET request
         if (request.getMethod().equals(HttpMethod.GET.name()) && (request.getParameter(
                 KRADConstants.CONVERSION_FIELDS_PARAMETER) != null)) {
             String conversionFields = request.getParameter(KRADConstants.CONVERSION_FIELDS_PARAMETER);
             setFieldConversions(KRADUtils.convertStringParameterToMap(conversionFields));
         }
     }
 
     /**
      * Returns an {@link Lookupable} instance associated with the lookup view.
      *
      * @return Lookupable instance or null if one does not exist
      */
     public Lookupable getLookupable() {
         if (getViewHelperService() != null) {
             return (Lookupable) getViewHelperService();
         }
 
         return null;
     }
 
     /**
      * Class name for the data object the lookup should be performed against.
      *
      * <p>The object class name is used to pick up a dictionary entry which will feed the attribute field
      * definitions and other configuration. In addition it is to configure the
      * {@link org.kuali.rice.krad.lookup.Lookupable} which will carry out the search action</p>
      *
      * @return lookup data object class
      */
     public String getDataObjectClassName() {
         return this.dataObjectClassName;
     }
 
     /**
      * Setter for {@link LookupForm#getDataObjectClassName()}
      * 
      * @param dataObjectClassName property value
      */
     public void setDataObjectClassName(String dataObjectClassName) {
         this.dataObjectClassName = dataObjectClassName;
     }
 
     /**
      * 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;
     }
 
     /**
      * @see LookupForm#isMultipleValuesSelect()
      */
     public void setMultipleValuesSelect(boolean multipleValuesSelect) {
         this.multipleValuesSelect = multipleValuesSelect;
     }
 
     /**
      * Indicates whether the requested was redirected from the lookup framework due to an external object
      * request.
      *
      * <p>This prevents the framework from performing another redirect check</p>
      *
      * @return boolean true if request was a redirect, false if not
      */
     public boolean isRedirectedLookup() {
         return redirectedLookup;
     }
 
     /**
      * @see LookupForm#isRedirectedLookup()
      */
     public void setRedirectedLookup(boolean redirectedLookup) {
         this.redirectedLookup = redirectedLookup;
     }
 
     /**
       * Indicates whether the return value from the lookup should occur through script or a server side
       * post (default is false, server side post).
       *
       * @return boolean true if return should occur though script, false if return should be done through server
       *         side post
       */
      public boolean isReturnByScript() {
          return returnByScript;
      }
 
      /**
       * @see LookupForm#isReturnByScript()
       */
      public void setReturnByScript(boolean returnByScript) {
          this.returnByScript = returnByScript;
      }
 
     /**
      * Name of the window the lookup should return to.
      *
      * <p>The lookup can be invoked from several different contexts: new tab, lightbox within top window, lightbox
      * within portal window. When the request is made, this parameter can be sent to specify the target for
      * the return links.</p>
      *
      * @return String return target window name
      */
     public String getReturnTarget() {
         return returnTarget;
     }
 
     /**
      * org.kuali.rice.krad.lookup.LookupForm#getReturnTarget()
      */
     public void setReturnTarget(String returnTarget) {
         this.returnTarget = returnTarget;
     }
 
     /**
      * 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;
     }
 
     /**
      * @see LookupForm#getLookupCollectionName()
      */
     public void setLookupCollectionName(String lookupCollectionName) {
         this.lookupCollectionName = lookupCollectionName;
     }
 
     public String getLookupCollectionId() {
         return lookupCollectionId;
     }
 
     public void setLookupCollectionId(String lookupCollectionId) {
         this.lookupCollectionId = lookupCollectionId;
     }
 
     /**
      * String containing references that should be refreshed when the lookup returns, passed back on the
      * return URL.
      *
      * @return String containing references that should be refreshed on return from lookup
      */
     public String getReferencesToRefresh() {
         return referencesToRefresh;
     }
 
     /**
      * @see LookupForm#getReferencesToRefresh()
      */
     public void setReferencesToRefresh(String referencesToRefresh) {
         this.referencesToRefresh = referencesToRefresh;
     }
 
     /**
      * Id for the quickfinder that triggered the lookup action (if any).
      *
      * <p>When the lookup is triggered from a quickfinder, the return URLs will be present on the lookup
      * results. In addition, the quickfinder id is passed back on the return URL so the caller can perform logic
      * based on which quickfinder was invoked.</p>
      *
      * @return String id for quickfinder that invoked the lookup
      */
     public String getQuickfinderId() {
         return quickfinderId;
     }
 
     /**
      * @see LookupForm#getQuickfinderId()
      */
     public void setQuickfinderId(String quickfinderId) {
         this.quickfinderId = quickfinderId;
     }
 
     /**
      * Map of conversions that should occur on the lookup return between properties on the lookup data object
      * and properties on the calling view.
      *
      * <p>When a lookup is invoked from a calling view, the purpose is to return one or more values that will
      * populate fields on the calling view. To accomplish this, values for properties on the selected record
      * are passed back on the URL as values for properties on the calling view. This map specifies which properties
      * on the lookup data object should be pulled, and for each one what is the property on the caller to
      * send the value back as.</p>
      *
      * <p>For example, suppose the map contained the entries id:document.bookId and title:document.bookTitle. When the
      * return URL is selected for a record, the value for the id property will be retrieved and added to the return
      * URL query string as 'document.bookId={idValue}'. Likewise the value for the title property will be pulled
      * and added to the return URL query string as 'document.bookTitle={titleValue}'. So the query string will contain
      * something like 'document.bookId=3&document.bookTitle=Animals'</p>
      *
      * @return Map of field conversions, each entry is a conversion between two properties. Key is property name
      *         on the lookup data object, entry value is the property name on the calling view/model
      */
     public Map<String, String> getFieldConversions() {
         return this.fieldConversions;
     }
 
     /**
      * @see LookupForm#getFieldConversions()
      */
     public void setFieldConversions(Map<String, String> fieldConversions) {
         this.fieldConversions = fieldConversions;
     }
 
     /**
      * Holds the column names for the multi-value lookup selected values
      *
      * Note: as of KULRICE-12125 secure field names will not be stored in this parameter
      * @return a list of column names for the multi-value lookup
      */
     public List<String> getMultiValueReturnFields() {
         return multiValueReturnFields;
     }
 
     /**
      * @see LookupForm#getMultiValueReturnFields()
      */
     public void setMultiValueReturnFields(List<String> multiValueReturnFields) {
         this.multiValueReturnFields = multiValueReturnFields;
     }
 
     /**
      * Map containing the criteria to be used for performing the search.
      *
      * <p>Fields that are defined in the {@link org.kuali.rice.krad.lookup.LookupView#getCriteriaGroup()} bind
      * to this map. The key of the map is the property path specified for the field, and the value of the map
      * is the search value (if any) entered by the user. This map is then passed into the {@link Lookupable} to
      * carry out the search.</p>
      *
      * @return Map of search criteria where key is the property the criteria will be applied to and the value is
      *         the search value entered by the user (if any)
      */
     public Map<String, String> getLookupCriteria() {
         return this.lookupCriteria;
     }
 
     /**
      * @see LookupForm#getLookupCriteria()
      */
     public void setLookupCriteria(Map<String, String> lookupCriteria) {
         this.lookupCriteria = lookupCriteria;
     }
 
     /**
      * Holds the results of a search action.
      *
      * <p>After the search action is invoked, the results of the search will be held by this property. The
      * {@link org.kuali.rice.krad.lookup.LookupView#getResultsGroup()} binds to this property for displaying
      * the results.</p>
      *
      * @return Collection of data objects that are the result of a search
      */
     public Collection<?> getLookupResults() {
         return this.lookupResults;
     }
 
     /**
      * @see LookupForm#getLookupResults()
      */
     public void setLookupResults(Collection<?> lookupResults) {
         this.lookupResults = lookupResults;
     }
 
     public boolean isDisplayResults() {
         return displayResults;
     }
 
     public void setDisplayResults(boolean displayResults) {
         this.displayResults = displayResults;
     }
 }