/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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.capabilities.impl;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.jetspeed.capabilities.CapabilityMap;
  import org.apache.jetspeed.capabilities.Client;
  import org.apache.jetspeed.capabilities.Capability;
  import org.apache.jetspeed.capabilities.MediaType;
  
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import org.apache.jetspeed.capabilities.MimeType;
  
  /***
   * Implementation for capabilityMap interface
   *
   * @author <a href="mailto:roger.ruttimann@earthlink.net">Roger Ruttimann</a>
   * @version $Id: CapabilityMapImpl.java 553014 2007-07-03 23:10:53Z ate $
   */
  class CapabilityMapImpl implements CapabilityMap
  {
      private static final Log log =
          LogFactory.getLog(JetspeedCapabilities.class);
      
      // Members
      private String useragent; // User agent for request
      private Map mimeTypeMap = new HashMap(); // supported Mimetypes for Agent
      private Map capabilityMap = new HashMap();
      // supported Capabilities for Agent
      private Map mediaTypeMap = new HashMap(); // supported MediaTypes for Agent
      private Client client; // client for Agent
      private MediaType preferredMediaType; // Preferred MediaType for client.
  
      /***
          Sets the client for the CapabilityMap
      */
      public void setClient(Client client)
      {
          this.client = client;
      }
  
      /***
          Returns the Client for the CapabilityMap
      */
      public Client getClient()
      {
          return this.client;
      }
  
      /***
          Add capability to the CapabilityMap
      */
      public void addCapability(Capability capability)
      {	
      	if (capability != null) // avoid null due to duplicates in database 
      		this.capabilityMap.put(capability.getName(), capability);
      }
  
      /***
          Add Mimetype to the MimetypeMap
      */
      public void addMimetype(MimeType mimetype)
      {
      	if (mimetype != null) // avoid null due to duplicates in database
          this.mimeTypeMap.put(mimetype.getName(), mimetype);
      }
  
      /***
          Add MediaType to the MediaTypeMap
      */
      public void addMediaType(MediaType mediatype)
      {
      	if (mediatype != null) // avoid null due to duplicates in database
          this.mediaTypeMap.put(mediatype.getName(), mediatype);
      }
  
      /***
      Returns the preferred MIME type for the current user-agent
      */
      public MimeType getPreferredType()
      {
         // Return the value that matches the preferredMimeType defined in the Client
         int prefMimeTypeId = this.client.getPreferredMimeTypeId();
 
         MimeType mt = null;        
         Iterator e = this.mimeTypeMap.values().iterator();
         while (e.hasNext())
         {            
             mt = (MimeType) e.next();
             
             if (mt.getMimetypeId() == prefMimeTypeId)
                 return mt;
         }
         log.error("Could not find preferred Mime Type for " + prefMimeTypeId);        
 
         // Should never reach this point. A preferred value needs to be set
         return null; // TODO: NEVER RETURN NULL
     }
 
     /***
           * Sets the preferred MediaType for this CapabilityMap
           * @param MediaTypeEntry 
         */
     public void setPreferredMediaType(MediaType type)
     {
         this.preferredMediaType = type;
     }
 
     /***
     Returns the preferred media type for the current user-agent
     */
     public MediaType getPreferredMediaType()
     {
         return this.preferredMediaType;
     }
 
     /***
      * Returns an ordered list of supported media-types, from most preferred
      * to least preferred
      */
     public Iterator listMediaTypes()
     {
         return mediaTypeMap.values().iterator();
     }
 
     /***
     Returns the user-agent string
     */
     public String getAgent()
     {
         return this.useragent;
     }
 
     /***
      * set userAgent
      */
     public void setAgent(String userAgent)
     {
         this.useragent = userAgent;
     }
 
     /***
      * Checks to see if the current agent has the specified capability
      */
     public boolean hasCapability(int capability)
     {
         Iterator capabilities = capabilityMap.values().iterator();
         while (capabilities.hasNext())
         {
             if (((Capability) capabilities.next()).getCapabilityId()
                 == capability)
             {
                 return true;
             }
         }
         return false;
     }
 
     /***
      *  Checks to see if the current agent has the specified capability
      */
     public boolean hasCapability(String capability)
     {
         Iterator capabilities = capabilityMap.values().iterator();
         while (capabilities.hasNext())
         {
             if (((Capability) capabilities.next()).getName().equals(capability))
             {
                 return true;
             }
         }
         return false;
     }
 
     /***
     Get the mime types that this CapabilityMap supports.
     */
     public Iterator getMimeTypes()
     {
         return mimeTypeMap.values().iterator();
     }
 
     /***
     Return true if this CapabilityMap supports the given MimeType
     */
     public boolean supportsMimeType(MimeType mimeType)
     {
         Iterator mimetypes = mimeTypeMap.values().iterator();
         while (mimetypes.hasNext())
         {
             if (((MimeType) mimetypes.next()).getName().equals(mimeType.getName()))
             {
                 return true;
             }
         }
         return false;
     }
 
     /***
      * Return true if this CapabilityMap supports the given media type
      *
      * @param media the name of a media type registered in the
      * MediaType registry
      *
      * @return true is the capabilities of this agent at least match those
      * required by the media type
      */
     public boolean supportsMediaType(String media)
     {
         Iterator mediatypes = mediaTypeMap.values().iterator();
         while (mediatypes.hasNext())
         {
             if (((MediaType) mediatypes.next()).getName() == media)
             {
                 return true;
             }
         }
         return false;
     }
 
     /***
      * Create a map -> string representation
      */
     public String toString()
     {
         return "";
     }
 
 }