/**
    * Licensed under the Artistic License; you may not use this file
    * except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *      http://displaytag.sourceforge.net/license.html
    *
    * THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
    * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
   * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
   */
  package org.displaytag.util;
  
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  import java.util.StringTokenizer;
  
  import org.apache.commons.lang.ObjectUtils;
  import org.apache.commons.lang.StringEscapeUtils;
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.lang.UnhandledException;
  import org.apache.commons.lang.builder.EqualsBuilder;
  import org.apache.commons.lang.builder.HashCodeBuilder;
  
  
  /**
   * @author Fabrizio Giustina
   * @version $Revision$ ($Author$)
   */
  public class DefaultHref implements Href
  {
  
      /**
       * D1597A17A6.
       */
      private static final long serialVersionUID = 899149338534L;
  
      /**
       * Base url for the href.
       */
      private String url;
  
      /**
       * Url parameters.
       */
      private Map parameters;
  
      /**
       * Anchor (to be added at the end of URL).
       */
      private String anchor;
  
      /**
       * Construct a new Href parsing a URL. Parameters are stripped from the base url and saved in the parameters map.
       * @param baseUrl String
       */
      public DefaultHref(String baseUrl)
      {
          this.parameters = new HashMap();
          setFullUrl(baseUrl);
      }
  
      /**
       * @see org.displaytag.util.Href#setFullUrl(java.lang.String)
       */
      public void setFullUrl(String baseUrl)
      {
          this.url = null;
          this.anchor = null;
          String noAnchorUrl;
          int anchorposition = baseUrl.indexOf('#');
  
          // extract anchor from url
          if (anchorposition != -1)
          {
              noAnchorUrl = baseUrl.substring(0, anchorposition);
              this.anchor = baseUrl.substring(anchorposition + 1);
          }
          else
          {
              noAnchorUrl = baseUrl;
          }
  
          if (noAnchorUrl.indexOf('?') == -1)
          {
              // simple url, no parameters
              this.url = noAnchorUrl;
              return;
          }
  
          // the Url already has parameters, put them in the parameter Map
          StringTokenizer tokenizer = new StringTokenizer(noAnchorUrl, "?"); //$NON-NLS-1$
  
          if (baseUrl.startsWith("?")) //$NON-NLS-1$
          {
              // support fake URI's which are just parameters to use with the current uri
              url = TagConstants.EMPTY_STRING;
         }
         else
         {
             // base url (before "?")
             url = tokenizer.nextToken();
         }
 
         if (!tokenizer.hasMoreTokens())
         {
             return;
         }
 
         // process parameters
         StringTokenizer paramTokenizer = new StringTokenizer(tokenizer.nextToken(), "&"); //$NON-NLS-1$
 
         // split parameters (key=value)
         while (paramTokenizer.hasMoreTokens())
         {
             // split key and value ...
             String[] keyValue = StringUtils.split(paramTokenizer.nextToken(), '=');
 
             // encode name/value to prevent css
             String escapedKey = StringEscapeUtils.escapeHtml(keyValue[0]);
             String escapedValue = keyValue.length > 1
                 ? StringEscapeUtils.escapeHtml(keyValue[1])
                 : TagConstants.EMPTY_STRING;
 
             if (!this.parameters.containsKey(escapedKey))
             {
                 // ... and add it to the map
                 this.parameters.put(escapedKey, escapedValue);
             }
             else
             {
                 // additional value for an existing parameter
                 Object previousValue = this.parameters.get(escapedKey);
                 if (previousValue != null && previousValue.getClass().isArray())
                 {
                     Object[] previousArray = (Object[]) previousValue;
                     Object[] newArray = new Object[previousArray.length + 1];
 
                     int j;
 
                     for (j = 0; j < previousArray.length; j++)
                     {
                         newArray[j] = previousArray[j];
                     }
 
                     newArray[j] = escapedValue;
                     this.parameters.put(escapedKey, newArray);
                 }
                 else
                 {
                     this.parameters.put(escapedKey, new Object[]{previousValue, escapedValue});
                 }
             }
         }
     }
 
     /**
      * Adds a parameter to the href.
      * @param name String
      * @param value Object
      * @return this Href instance, useful for concatenation.
      */
     public Href addParameter(String name, Object value)
     {
         this.parameters.put(name, ObjectUtils.toString(value, null));
         return this;
     }
 
     /**
      * Removes a parameter from the href.
      * @param name String
      */
     public void removeParameter(String name)
     {
         // warning, param names are escaped
         this.parameters.remove(StringEscapeUtils.escapeHtml(name));
     }
 
     /**
      * Adds an int parameter to the href.
      * @param name String
      * @param value int
      * @return this Href instance, useful for concatenation.
      */
     public Href addParameter(String name, int value)
     {
         this.parameters.put(name, new Integer(value));
         return this;
     }
 
     /**
      * Getter for the map containing link parameters. The returned map is always a copy and not the original instance.
      * @return parameter Map (copy)
      */
     public Map getParameterMap()
     {
         Map copyMap = new HashMap(this.parameters.size());
         copyMap.putAll(this.parameters);
         return copyMap;
     }
 
     /**
      * Adds all the parameters contained in the map to the Href. The value in the given Map will be escaped before
      * added. Any parameter already present in the href object is removed.
      * @param parametersMap Map containing parameters
      */
     public void setParameterMap(Map parametersMap)
     {
         // create a new HashMap
         this.parameters = new HashMap(parametersMap.size());
 
         // copy the parameters
         addParameterMap(parametersMap);
     }
 
     /**
      * Adds all the parameters contained in the map to the Href. The value in the given Map will be escaped before
      * added. Parameters in the original href are kept and not overridden.
      * @param parametersMap Map containing parameters
      */
     public void addParameterMap(Map parametersMap)
     {
         // handle nulls
         if (parametersMap == null)
         {
             return;
         }
 
         // copy value, escaping html
         Iterator mapIterator = parametersMap.entrySet().iterator();
         while (mapIterator.hasNext())
         {
             Map.Entry entry = (Map.Entry) mapIterator.next();
             String key = StringEscapeUtils.escapeHtml((String) entry.getKey());
 
             // don't overwrite parameters
             if (!this.parameters.containsKey(key))
             {
                 Object value = entry.getValue();
 
                 if (value != null)
                 {
                     if (value.getClass().isArray())
                     {
                         String[] values = (String[]) value;
                         for (int i = 0; i < values.length; i++)
                         {
                             values[i] = StringEscapeUtils.escapeHtml(values[i]);
                         }
                     }
                     else
                     {
                         value = StringEscapeUtils.escapeHtml(value.toString());
                     }
                 }
 
                 this.parameters.put(key, value);
             }
         }
     }
 
     /**
      * Getter for the base url (without parameters).
      * @return String
      */
     public String getBaseUrl()
     {
         return this.url;
     }
 
     /**
      * Returns the URI anchor.
      * @return anchor or <code>null</code> if no anchor has been set.
      */
     public String getAnchor()
     {
         return this.anchor;
     }
 
     /**
      * Setter for the URI anchor.
      * @param name string to be used as anchor name (without #).
      */
     public void setAnchor(String name)
     {
         this.anchor = name;
     }
 
     /**
      * toString: output the full url with parameters.
      * @return String
      */
     public String toString()
     {
         StringBuffer buffer = new StringBuffer(30);
 
         buffer.append(this.url);
 
         if (this.parameters.size() > 0)
         {
             buffer.append('?');
             Set parameterSet = this.parameters.entrySet();
 
             Iterator iterator = parameterSet.iterator();
 
             while (iterator.hasNext())
             {
                 Map.Entry entry = (Map.Entry) iterator.next();
 
                 Object key = entry.getKey();
                 Object value = entry.getValue();
 
                 if (value == null)
                 {
                     buffer.append(key).append('='); // no value
                 }
                 else if (value.getClass().isArray())
                 {
                     Object[] values = (Object[]) value;
                     for (int i = 0; i < values.length; i++)
                     {
                         if (i > 0)
                         {
                             buffer.append(TagConstants.AMPERSAND);
                         }
 
                         buffer.append(key).append('=').append(values[i]);
                     }
                 }
                 else
                 {
                     buffer.append(key).append('=').append(value);
                 }
 
                 if (iterator.hasNext())
                 {
                     buffer.append(TagConstants.AMPERSAND);
                 }
             }
         }
 
         if (this.anchor != null)
         {
             buffer.append('#');
             buffer.append(this.anchor);
         }
 
         return buffer.toString();
     }
 
     /**
      * @see java.lang.Object#clone()
      */
     public Object clone()
     {
         final DefaultHref href;
         try
         {
             href = (DefaultHref) super.clone();
         }
         catch (CloneNotSupportedException e)
         {
             throw new UnhandledException(e);
         }
 
         href.parameters = new HashMap(this.parameters);
         return href;
     }
 
     /**
      * @see java.lang.Object#equals(Object)
      */
     public boolean equals(Object object)
     {
         if (!(object instanceof DefaultHref))
         {
             return false;
         }
         DefaultHref rhs = (DefaultHref) object;
         return new EqualsBuilder().append(this.parameters, rhs.parameters).append(this.url, rhs.url).append(
             this.anchor,
             rhs.anchor).isEquals();
     }
 
     /**
      * @see java.lang.Object#hashCode()
      */
     public int hashCode()
     {
         return new HashCodeBuilder(1313733113, -431360889)
             .append(this.parameters)
             .append(this.url)
             .append(this.anchor)
             .toHashCode();
     }
 }