/**
    * Copyright 2005-2012 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.uif.view;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.log4j.Logger;
  import org.kuali.rice.krad.datadictionary.parse.BeanTag;
  import org.kuali.rice.krad.datadictionary.parse.BeanTagAttribute;
  import org.kuali.rice.krad.service.DataObjectMetaDataService;
  import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
  import org.kuali.rice.krad.uif.UifConstants;
  import org.kuali.rice.krad.uif.util.ObjectPropertyUtils;
  import org.kuali.rice.krad.uif.util.ViewModelUtils;
  import org.kuali.rice.krad.web.form.UifFormBase;
  
  import javax.servlet.http.HttpServletRequest;
  import java.io.Serializable;
  import java.io.UnsupportedEncodingException;
  import java.net.URLDecoder;
  import java.net.URLEncoder;
  import java.util.ArrayList;
  import java.util.Enumeration;
  import java.util.List;
  
  /**
   * History class used to keep track of views visited so they can be displayed in the ui
   * as breadcrumbs - both as homeward path and history path interpretations
   *
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  @BeanTag(name="history")
  public class History implements Serializable {
      private static final long serialVersionUID = -8279297694371557335L;
      private static final Logger LOG = Logger.getLogger(History.class);
  
      public static final String ENTRY_TOKEN = "$^$";
      public static final String VAR_TOKEN = "^$^";
  
      private boolean appendHomewardPath;
      private boolean appendPassedHistory;
  
      private HistoryEntry current;
  
      private List<HistoryEntry> homewardPath;
      private List<HistoryEntry> historyEntries;
  
      public History() {
          historyEntries = new ArrayList<HistoryEntry>();
      }
  
      /**
       * Generates a list of HistoryEntries that can be used as breadcrumbs by the breadcrumb widget.  This
       * method appends the appropriate history information on the HistoryEntry url variables so when a view is requested
       * its history can be regenerated for use in its breadcrumbs.  It also sets the the passed showHome variable to
       * false to prevent showing the homeward path more than once (as it is passed through the history
       * variable backwards). This does not include the current HistoryEntry as a breadcrumb but adds the formKey as the
       * LAST_FORM_KEY to assist with server side form cleanup.
       *
       * @return
       */
      public List<HistoryEntry> getGeneratedBreadcrumbs() {
          List<HistoryEntry> breadcrumbs = new ArrayList<HistoryEntry>();
          for (int i = 0; i < historyEntries.size(); i++) {
              if (i == 0) {
                  breadcrumbs.add(copyEntry(historyEntries.get(i)));
              } else {
                  HistoryEntry breadcrumb = copyEntry(historyEntries.get(i));
  
                  String historyParam = "";
                  for (int j = 0; j < i; j++) {
                      historyParam = historyParam + ENTRY_TOKEN + historyEntries.get(j).toParam();
                  }
                  historyParam = historyParam.replaceFirst("\\" + ENTRY_TOKEN, "");
  
                  try {
                      historyParam = URLEncoder.encode(historyParam, "UTF-8");
                  } catch (Exception e) {
                      throw new RuntimeException("Error encoding history param", e);
                  }
  
                  if (StringUtils.isEmpty(breadcrumb.getUrl())) {
                      continue;
                  }
  
                  String url = breadcrumb.getUrl();
                  if (url.contains("?")) {
                     url += "&";
                 } else {
                     url += "?";
                 }
 
                 url += UifConstants.UrlParams.HISTORY
                         + "="
                         + historyParam
                         + "&"
                         + UifConstants.UrlParams.LAST_FORM_KEY
                         + "="
                         + current.getFormKey();
 
                 breadcrumb.setUrl(url);
                 breadcrumbs.add(breadcrumb);
             }
         }
 
         return breadcrumbs;
     }
 
     /**
      * Gets the current HistoryEntry in the breadcrumb format described in getGeneratedBreadcrumbs
      */
     public HistoryEntry getGeneratedCurrentBreadcrumb() {
         if (current == null) {
             return new HistoryEntry();
         }
 
         HistoryEntry breadcrumb = copyEntry(current);
         String historyParam = "";
         for (int j = 0; j < historyEntries.size(); j++) {
             historyParam = historyParam + ENTRY_TOKEN + historyEntries.get(j).toParam();
         }
         historyParam = historyParam.replaceFirst("\\" + ENTRY_TOKEN, "");
 
         try {
             historyParam = URLEncoder.encode(historyParam, "UTF-8");
         } catch (Exception e) {
             throw new RuntimeException("Error encoding history param", e);
         }
 
         String url = "";
         if (breadcrumb.getUrl().contains("?")) {
             url = breadcrumb.getUrl() + "&" + UifConstants.UrlParams.HISTORY + "=" + historyParam;
         } else {
             url = breadcrumb.getUrl() + "?" + UifConstants.UrlParams.HISTORY + "=" + historyParam;
         }
         breadcrumb.setUrl(url);
 
         return breadcrumb;
     }
 
     /**
      * Copies a HistoryEntry, for use during breadcrumb generation.
      *
      * @param e
      * @return
      */
     private HistoryEntry copyEntry(HistoryEntry e) {
         return new HistoryEntry(e.getViewId(), e.getPageId(), e.getTitle(), e.getUrl(), e.getFormKey());
     }
 
     /**
      * Pushes the information passed in to history.
      * Note: currently only used internally in the class - be cautious about its external use.
      *
      * @param viewId
      * @param pageId
      * @param title
      * @param url
      * @param formKey
      */
     public void pushToHistory(String viewId, String pageId, String title, String url, String formKey) {
         HistoryEntry entry = new HistoryEntry(viewId, pageId, title, url, formKey);
         historyEntries.add(entry);
     }
 
     /**
      * Sets the current HistoryEntry using information from the form and the request.  This history parameter is
      * extracted out of the url in order for a "clean" url to be used in history parameter and
      * breadcrumb generation, as passing history history through the nested urls is unnecessary.
      *
      * @param form
      * @param request
      */
     public void buildCurrentEntryFromRequest(UifFormBase form, HttpServletRequest request) {
         boolean showHomeValue = false;
         boolean pageIdValue = false;
         boolean formKeyValue = false;
 
         String queryString = "";
         String url = request.getRequestURL().toString();
 
         // remove history attribute
         Enumeration<String> params = request.getParameterNames();
         while (params.hasMoreElements()) {
             String key = params.nextElement();
             if (!key.equals(UifConstants.UrlParams.HISTORY)) {
                 for (String value : request.getParameterValues(key)) {
                     try {
                         queryString = queryString + "&" + key + "=" + URLEncoder.encode(value, "UTF-8");
                     } catch (UnsupportedEncodingException e) {
                         throw new RuntimeException("Unable to encode parameter value", e);
                     }
                 }
             }
 
             if (key.equals(UifConstants.UrlParams.PAGE_ID)) {
                 pageIdValue = true;
             } else if (key.equals(UifConstants.UrlParams.SHOW_HOME)) {
                 showHomeValue = true;
             } else if (key.equals(UifConstants.UrlParams.FORM_KEY)) {
                 formKeyValue = true;
             }
         }
 
         // add formKey and pageId to url
         if (StringUtils.isNotBlank(form.getFormKey()) && !formKeyValue) {
             try {
                 queryString = queryString + "&" + UifConstants.UrlParams.FORM_KEY + "=" + URLEncoder.encode(
                         form.getFormKey(), "UTF-8");
             } catch (UnsupportedEncodingException e) {
                 throw new RuntimeException("Unable to encode form key", e);
             }
         }
 
         if (StringUtils.isNotBlank(form.getPageId()) && !pageIdValue) {
             queryString = queryString + "&" + UifConstants.UrlParams.PAGE_ID + "=" + form.getPageId();
         }
 
         if (!showHomeValue) {
             queryString = queryString + "&" + UifConstants.UrlParams.SHOW_HOME + "=false";
         }
 
         queryString = queryString.replaceFirst("&", "");
 
         if (StringUtils.isNotEmpty(queryString)) {
             url = url + "?" + queryString;
         }
 
         this.setCurrent(form.getViewId(), form.getPageId(), buildViewTitle(form), url, form.getFormKey());
     }
 
     /**
      * Takes in the encoded history query parameter string passed on the url and parses it to create
      * the list of historyEntries.  It will also append any homeward path if appendHomewardPath is true.  This
      * append will happen after the passedHistory entries are appended so it will not make sense to use both settings
      * in most cases.
      *
      * @param parameterString
      */
     public void buildHistoryFromParameterString(String parameterString) {
         if (StringUtils.isNotEmpty(parameterString)) {
             try {
                 parameterString = URLDecoder.decode(parameterString, "UTF-8");
             } catch (UnsupportedEncodingException e) {
                 throw new RuntimeException("Unable to get history from parameter string", e);
             }
 
             historyEntries = new ArrayList<HistoryEntry>();
             if (appendPassedHistory) {
                 String[] historyTokens = StringUtils.splitByWholeSeparator(parameterString, ENTRY_TOKEN);
                 for (String token : historyTokens) {
                     String[] params = StringUtils.splitByWholeSeparator(token, VAR_TOKEN);
                     pushToHistory(params[0], params[1], params[2], params[3], params[4]);
                 }
             }
         }
 
         if (appendHomewardPath) {
             historyEntries.addAll(homewardPath);
         }
     }
 
     /**
      * Gets the encoded and tokenized history parameter string that is representative of the HistoryEntries
      * currently in History and includes the current view's HistoryEntry.  This parameter should be appended on any
      * appropriate links which perform view swapping.
      *
      * @return String containing history entries
      */
     public String getHistoryParameterString() {
         String history = "";
 
         for (HistoryEntry entry : historyEntries) {
             if (StringUtils.isNotBlank(history)) {
                 history = history + ENTRY_TOKEN;
             }
             history = history + entry.toParam();
         }
 
         if (current != null) {
             if (StringUtils.isNotBlank(history)) {
                 history = history + ENTRY_TOKEN;
             }
             history = history + current.toParam();
         }
 
         try {
             history = URLEncoder.encode(history, "UTF-8");
         } catch (Exception e) {
             throw new RuntimeException("Error encoding history param", e);
         }
 
         return history;
     }
 
     /**
      * Builds the title for the view to display in history (for example breadcrumbs)
      *
      * <p>
      * Retrieves the viewLabelFieldPropertyName from the view if configured, otherwise attempts
      * to find the title attribute for the default data object. If view label property is found the
      * corresponding property value is retrieved and appended to the title for the view
      * </p>
      *
      * TODO: Possibly move so it can be used for the actual view title, not just history
      *
      * @param form - form instance containing the view and view data
      * @return String title string to use
      */
     protected String buildViewTitle(UifFormBase form) {
         View view = form.getView();
         String title = view.getHeaderText();
 
         // may move this into view logic instead in the future if it is required for the view's title (not just breadcrumb)
         // if so remove this and just use getTitle - this logic would be in performFinalize instead
         String viewLabelPropertyName = view.getBreadcrumbTitlePropertyName();
 
         // if view label property name given, try to retrieve the title attribute for the main data object
         if (StringUtils.isBlank(viewLabelPropertyName)) {
             Class<?> dataObjectClass;
             if (StringUtils.isNotBlank(view.getDefaultBindingObjectPath())) {
                 dataObjectClass = ObjectPropertyUtils.getPropertyType(form, view.getDefaultBindingObjectPath());
             } else {
                 dataObjectClass = view.getFormClass();
             }
 
             DataObjectMetaDataService mds = KRADServiceLocatorWeb.getDataObjectMetaDataService();
             if (dataObjectClass != null) {
                 viewLabelPropertyName = mds.getTitleAttribute(dataObjectClass);
             }
         }
 
         String viewLabelPropertyPath = "";
         if (StringUtils.isNotBlank(viewLabelPropertyName)) {
             // adjust binding prefix
             if (!viewLabelPropertyName.startsWith(UifConstants.NO_BIND_ADJUST_PREFIX)) {
                 if (StringUtils.isNotBlank(view.getDefaultBindingObjectPath())) {
                     viewLabelPropertyPath = view.getDefaultBindingObjectPath() + "." + viewLabelPropertyName;
                 }
             } else {
                 viewLabelPropertyPath = StringUtils.removeStart(viewLabelPropertyName,
                         UifConstants.NO_BIND_ADJUST_PREFIX);
             }
         } else {
             // attempt to get title attribute
             Class<?> dataObjectClass;
             if (StringUtils.isNotBlank(view.getDefaultBindingObjectPath())) {
                 dataObjectClass = ViewModelUtils.getObjectClassForMetadata(view, form,
                         view.getDefaultBindingObjectPath());
             } else {
                 dataObjectClass = view.getFormClass();
             }
 
             DataObjectMetaDataService mds = KRADServiceLocatorWeb.getDataObjectMetaDataService();
             if (dataObjectClass != null) {
                 String titleAttribute = mds.getTitleAttribute(dataObjectClass);
                 if (StringUtils.isNotBlank(titleAttribute)) {
                     viewLabelPropertyPath = view.getDefaultBindingObjectPath() + "." + titleAttribute;
                 }
             }
         }
 
         Object viewLabelPropertyValue = null;
         if (StringUtils.isNotBlank(viewLabelPropertyPath) && ObjectPropertyUtils.isReadableProperty(form,
                 viewLabelPropertyPath)) {
             viewLabelPropertyValue = ObjectPropertyUtils.getPropertyValue(form, viewLabelPropertyPath);
         }
 
         String titleAppend = "";
         if (viewLabelPropertyValue != null) {
             titleAppend = viewLabelPropertyValue.toString();
         }
 
         if (StringUtils.isNotBlank(titleAppend) && view.getBreadcrumbTitleDisplayOption() != null) {
             if (view.getBreadcrumbTitleDisplayOption().equalsIgnoreCase(UifConstants.TitleAppendTypes.DASH)) {
                 title = title + " - " + titleAppend;
             } else if (view.getBreadcrumbTitleDisplayOption().equalsIgnoreCase(
                     UifConstants.TitleAppendTypes.PARENTHESIS)) {
                 title = title + "(" + titleAppend + ")";
             } else if (view.getBreadcrumbTitleDisplayOption().equalsIgnoreCase(UifConstants.TitleAppendTypes.REPLACE)) {
                 title = titleAppend;
             }
             //else it is none or blank so no title modification will be used
         }
 
         return title;
     }
 
     /**
      * Gets the predetermined homeward path for this view's history.
      * This is set by the same property in the view's Breadcrumbs configuration.
      *
      * @return the homewardPath
      */
     @BeanTagAttribute(name="homewardPath",type= BeanTagAttribute.AttributeType.LISTBEAN)
     public List<HistoryEntry> getHomewardPath() {
         return this.homewardPath;
     }
 
     /**
      * @param homewardPath the homewardPath to set
      */
     public void setHomewardPath(List<HistoryEntry> homewardPath) {
         this.homewardPath = homewardPath;
     }
 
     /**
      * Gets a list of the current HistoryEntries not including the current entry.
      * This list does not include the "&history=" query parameter on each HistoryEntry's
      * url variable.  For HistoryEntries that include history information to be passed to the
      * view they are retrieving, getGeneratedBreadcrumbs is used.
      *
      * @return the history
      */
     @BeanTagAttribute(name="historyEntries",type= BeanTagAttribute.AttributeType.LISTBEAN)
     public List<HistoryEntry> getHistoryEntries() {
         return this.historyEntries;
     }
 
     /**
      * @param history the history to set
      */
     public void setHistoryEntries(List<HistoryEntry> history) {
         this.historyEntries = history;
     }
 
     /**
      * Gets the current view's HistoryEntry.
      * This does not include the "&history=" query parameter on its
      * url variable.  For the HistoryEntry that includes history information to be passed
      * on the url it is retrieving, getGeneratedCurrentBreadcrumb is used.
      *
      * @return the current
      */
     @BeanTagAttribute(name="current",type= BeanTagAttribute.AttributeType.SINGLEBEAN)
     public HistoryEntry getCurrent() {
         return this.current;
     }
 
     /**
      * Sets the current HistoryEntry to the current view
      *
      * @param viewId
      * @param pageId
      * @param title
      * @param url
      * @param formKey
      */
     private void setCurrent(String viewId, String pageId, String title, String url, String formKey) {
         HistoryEntry entry = new HistoryEntry(viewId, pageId, title, url, formKey);
         current = entry;
     }
 
     /**
      * @param current the current to set
      */
     public void setCurrent(HistoryEntry current) {
         this.current = current;
     }
 
     /**
      * When this is set to true, the homeward path will be appended.
      * Note:  For most cases this should only be on during the first view load.
      * This setting is set automatically in most cases.
      *
      * @param appendHomewardPath the appendHomewardPath to set
      */
     public void setAppendHomewardPath(boolean appendHomewardPath) {
         this.appendHomewardPath = appendHomewardPath;
     }
 
     /**
      * @return the appendHomewardPath
      */
     @BeanTagAttribute(name="appendHomewardPath")
     public boolean isAppendHomewardPath() {
         return appendHomewardPath;
     }
 
     /**
      * Appends the passed history as each different view is shown.  This setting should be used when displaying
      * passed history is relevant to the user (ie inquiry/lookup chains).  This setting is set automatically in
      * most cases.
      *
      * @param appendPassedHistory the appendPassedHistory to set
      */
     public void setAppendPassedHistory(boolean appendPassedHistory) {
         this.appendPassedHistory = appendPassedHistory;
     }
 
     /**
      * @return the appendPassedHistory
      */
     @BeanTagAttribute(name="appendPassedHistory")
     public boolean isAppendPassedHistory() {
         return appendPassedHistory;
     }
 
 }