/*
    * Copyright 2000-2001,2004 The Apache Software Foundation.
    * 
    * Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0
    * 
   * 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.apache.jetspeed.om.registry.base;
  
  import java.util.Iterator;
  import java.util.Vector;
  import java.util.Map;
  import java.util.Hashtable;
  import java.util.HashMap;
  
  import org.apache.jetspeed.om.registry.*;
  import org.apache.jetspeed.services.Registry;
  
  /***
   * Default bean like implementation of the PortletEntry interface
   * suitable for serialization with Castor
   *
   * @author <a href="mailto:raphael@apache.org">Raphaël Luta</a>
   * @version $Id: BasePortletEntry.java,v 1.5 2004/02/23 03:08:26 jford Exp $
   */
  public class BasePortletEntry extends BasePortletInfoEntry
     implements PortletEntry, java.io.Serializable
  {
  
      private String parent;
  
      private ContentURL url = new BaseContentURL();
  
      protected Vector categories = new Vector();
  
      private boolean application;
  
      private String type = PortletEntry.TYPE_ABSTRACT;
  
      private boolean isRef = true;
  
      /***
       * Implements the equals operation so that 2 elements are equal if
       * all their member values are equal.
       */
      public boolean equals(Object object)
      {
          if (object==null)
          {
              return false;
          }
  
          BasePortletEntry obj = (BasePortletEntry)object;
  
          if (application!=obj.isApplication())
          {
              return false;
          }
  
          if (parent!=null)
          {
              if (!parent.equals(obj.getParent()))
              {
                  return false;
              }
          }
          else
          {
              if (obj.getParent()!=null)
              {
                  return false;
              }
          }
  
          if (type!=null)
          {
              if (!type.equals(obj.getType()))
              {
                  return false;
              }
          }
          else
          {
              if (obj.getType()!=null)
              {
                  return false;
              }
          }
  
          if (url!=null)
         {
             if (!url.equals(obj.getContentURL()))
             {
                 return false;
             }
         }
         else
         {
             if (obj.getContentURL()!=null)
             {
                 return false;
             }
         }
 
         Iterator i = categories.iterator();
         Iterator i2 = obj.getCategories().iterator();
         while(i.hasNext())
         {
             BaseCategory c1 = (BaseCategory)i.next();
             BaseCategory c2 = null;
 
             if (i2.hasNext())
             {
                 c2 = (BaseCategory)i2.next();
             }
             else
             {
                 return false;
             }
 
             if (!c1.equals(c2))
             {
                 return false;
             }
         }
 
         if (i2.hasNext())
         {
             return false;
         }
 
         return super.equals(object);
     }
 
     /*** @return the URL associated with this portlet or null */
     public String getURL()
     {
         return this.url.getURL();
     }
 
     /***
      * Sets the URL for this PortletEntry
      * @param url the new PortletEntry URL
      */
     public void setURL( String url )
     {
         this.url.setURL(url);
     }
 
     public boolean isCachedOnURL()
     {
         return url.isCacheKey();
     }
 
     public void setCachedOnURL(boolean cache)
     {
         url.setCachedOnURL(cache);
     }
 
     public ContentURL getURLEntry()
     {
         return url;
     }
 
     /*** @return the entry name from which this one is derived */
     public String getParent()
     {
         return this.parent;
     }
 
     /*** @return the classname associated to this entry */
     public String getClassname()
     {
         if (isRef && (classname == null) )
         {
             return getParentEntry().getClassname();
         }
 
         return classname;
     }
 
 
     /***
      * Sets the ancestor for this PortletEntry.
      * @param parent the new ancestor entry name. This name should
      * be defined in the system registry
      */
     public void setParent( String parent )
     {
         this.parent = parent;
     }
 
     /*** @return true is this entry is only accessible by the
       * portal administrators.
       */
     public boolean isAdmin()
     {
         if (getSecurity()!=null)
         {
             return "admin".equals(getSecurity().getRole());
         }
 
         return false;
     }
 
     /*** @return true is the PortletEntry is marked as an application */
     public boolean isApplication()
     {
         return this.application;
     }
 
     /*** Sets the application status of this portlet entry. If an entry
      *  is maked as application, the associated portlet will only be displayed
      *  in Maximized mode and can be retrieved specifically
      *
      *  @param application the new application status
      */
     public void setApplication( boolean application )
     {
         this.application = application;
     }
 
     /*** @return the type of this entry */
     public String getType()
     {
         return this.type;
     }
 
     /*** Sets the type of this entry. The type specifies whether it is
      *  abstract, instance or ref
      *
      *  @param type the new type for the PortletEntry
      */
     public void setType( String type )
     {
         this.isRef = PortletEntry.TYPE_REF.equals(type);
         this.type = type;
     }
 
     /*** This method is used by the Castor persistence system to retrieve
      *  the application status
      *
      * @see PortletEntry#isApplication
      * @return the application status of this entry
      */
     public boolean getApplication()
     {
         return this.application;
     }
 
     public String getTitle()
     {
         String title = super.getTitle();
         if (title != null)
             return title;
         if (isRef)
         {
            return getParentEntry().getTitle();
         }
         return null;
     }
 
     public String getDescription()
     {
         String desc = super.getDescription();
         if (desc != null)
             return desc;
 
         if (isRef)
         {
             return getParentEntry().getDescription();
         }
         return null;
     }
 
     /*** Looks up in the Registry the parent entry for this real entry */
     public PortletEntry getParentEntry()
     {
         PortletEntry parent = null;
         parent = (PortletEntry)Registry.getEntry( Registry.PORTLET, getParent() );
         if (parent == null)
         {
             parent = new BasePortletEntry();
             parent.setName(getParent());
             parent.setType(PortletEntry.TYPE_ABSTRACT);
         }
         return parent;
     }
 
     public MetaInfo getMetaInfo()
     {
         MetaInfo meta = super.getMetaInfo();
         if (meta == null)
         {
             return getParentEntry().getMetaInfo();
         }
         return meta;
     }
 
     /*** @return an enumeration of this entry parameter names */
     public Iterator getParameterNames()
     {
         if (isRef)
         {
             Hashtable hash = new Hashtable();
             Iterator i = super.getParameterNames();
             while(i.hasNext())
             {
                 hash.put(i.next(),"1");
             }
             i = getParentEntry().getParameterNames();
             while(i.hasNext())
             {
                 hash.put(i.next(),"1");
             }
 
             return hash.keySet().iterator();
         }
 
         return super.getParameterNames();
     }
 
     /*** Search for a named parameter and return the associated
      *  parameter object. The search is case sensitive.
      *
      *  @return the parameter object for a given parameter name
      *  @param name the parameter name to look for
      */
     public Parameter getParameter( String name )
     {
         Parameter p = super.getParameter(name);
         if (isRef && p == null)
         {
             return getParentEntry().getParameter(name);
         }
         return p;
     }
 
     public CachedParameter getCachedParameter( String name )
     {
         Parameter p = getParameter(name);
         return (CachedParameter)p;
     }
 
     /*** Returns a map of parameter values keyed on the parameter names
      *  @return the parameter values map
      */
     public Map getParameterMap()
     {
         Hashtable params = (Hashtable)super.getParameterMap();
 
         if (isRef)
         {
             Map map = getParentEntry().getParameterMap();
             map.putAll(params);
             return map;
         }
 
         return params;
     }
 
     /***
      * Returns a list of the supported media type names
      *
      * @return an iterator on the supported media type names
      */
     public Iterator listMediaTypes()
     {
         if (isRef)
         {
             Map types = new HashMap();
 
             Iterator i = super.listMediaTypes();
             while(i.hasNext())
             {
                 types.put(i.next(),"1");
             }
 
             i = getParentEntry().listMediaTypes();
             while(i.hasNext())
             {
                 types.put(i.next(),"1");
             }
 
             return types.keySet().iterator();
         }
 
         return super.listMediaTypes();
     }
 
     /***
      * Test if a given media type is supported by this entry.
      * The test is done by a case sensitive name comparison
      *
      * @param name the media type name to test for.
      * @return true is the media type is supported false otherwise
      */
     public boolean hasMediaType(String name)
     {
         if (isRef)
         {
             return super.hasMediaType(name) || getParentEntry().hasMediaType(name);
         }
 
         return super.hasMediaType(name);
     }
 
     /*** @return the URL associated with this portlet or null */
     public BaseContentURL getContentURL()
     {
         return (BaseContentURL)this.url;
     }
 
     /***
      * Sets the URL for this PortletEntry
      * @param url the new PortletEntry URL
      */
     public void setContentURL( BaseContentURL url )
     {
         this.url = url;
     }
 
     /*
      * Categories
      */
     public Vector getCategories()
     {
         return this.categories;
     }
 
     public void setCategories(Vector v)
     {
         this.categories = v;
     }
 
     /***
      * Returns a list of the supported media type names
      *
      * @return an iterator on the supported media type names
      */
     public Iterator listCategories()
     {
         return new PortletIterator(this, "getCategories");
     }
 
     /***
      * Test if a given category exists for this entry
      *
      * @param name the category name
      * @return true is the category exists in the default group
      */
     public boolean hasCategory(String name)
     {
         return hasCategory(name, PortletEntry.DEFAULT_GROUP);
     }
 
     /***
      * Test if a given category exists for this entry, in the specified group of categories.
      *
      * @param name the category name
      * @param group the category group
      * @return true is the category exists in the specified group
      */
     public boolean hasCategory(String name, String group)
     {
         Iterator it = listCategories();
         while (it.hasNext())
         {
             Category cat = (Category)it.next();
             if (cat.getName().equals(name) && cat.getGroup().equals(group))
                 return true;
         }
         return false;
     }
 
 
     /***
      * Add a new category to this portlet entry in the default group.
      *
      * @param name the category name
      */
     public void addCategory(String name)
     {
         addCategory(name, PortletEntry.DEFAULT_GROUP);
     }
 
     /***
      * Add a new category to this portlet entry.
      *
      * @param name the category name
      * @param group the category group name
      */
     public void addCategory(String name, String group)
     {
         if (!hasCategory(name, group))
         {
             Category cat = new BaseCategory();
             cat.setName(name);
             cat.setGroup(group);
             categories.add(cat);
         }
     }
 
     /***
      * Remove a category from this portlet entry in the default group.
      *
      * @param name the category name
      */
     public void removeCategory(String name)
     {
         removeCategory(name, PortletEntry.DEFAULT_GROUP);
     }
 
     /***
      * Remove a category from this portlet entry in the specified group.
      *
      * @param name the media type name to remove.
      * @param group the category group name
      */
     public void removeCategory(String name, String group)
     {
         for (int ix = 0; ix < categories.size(); ix++)
         {
             Category cat = (Category)categories.elementAt(ix);
             if (cat.getName().equals(name) && cat.getGroup().equals(group))
             {
                 categories.remove(ix);
                 return;
             }
         }
     }
 }