/*

  * 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.myfaces.component.visit;

 import java.util.AbstractCollection;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.EnumSet;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Iterator;

 import java.util.Map;

 import java.util.Set;

 import javax.faces.component.NamingContainer;

 import javax.faces.component.UIComponent;

 import javax.faces.component.visit.VisitCallback;

 import javax.faces.component.visit.VisitContext;

 import javax.faces.component.visit.VisitHint;

 import javax.faces.component.visit.VisitResult;

 import javax.faces.context.FacesContext;

 /**

  * <p>A VisitContext implementation that is

  * used when performing a partial component tree visit.</p>

  * 

  * @author Werner Punz, Blake Sullivan (latest modification by $Author$)

  * @version $Rev$ $Date$

  */

 public class PartialVisitContext extends VisitContext

 {

   /**

    * Creates a PartialVisitorContext instance.

    * @param facesContext the FacesContext for the current request

    * @param clientIds the client ids of the components to visit

    * @throws NullPointerException  if {@code facesContext}

    *                               is {@code null}

    */    

   public PartialVisitContext(

     FacesContext facesContext,

     Collection<String> clientIds)

   {

     this(facesContext, clientIds, null);

   }

   /**

    * Creates a PartialVisitorContext instance with the specified hints.

    * @param facesContext the FacesContext for the current request

    * @param clientIds the client ids of the components to visit

    * @param hints a the VisitHints for this visit

    * @throws NullPointerException  if {@code facesContext}

    *                               is {@code null}

    * @throws IllegalArgumentException if the phaseId is specified and

    * hints does not contain VisitHint.EXECUTE_LIFECYCLE

    */    

   public PartialVisitContext(FacesContext facesContext,

                              Collection<String> clientIds,

                              Set<VisitHint> hints)

   {

     if (facesContext == null)

     {

         throw new NullPointerException();

     }

     _facesContext = facesContext;

     // Copy the client ids into a HashSet to allow for quick lookups.

 //    Set<String> clientIdSet = (clientIds == null)

 //            ? new HashSet<String>()

 //                    : new HashSet<String>(clientIds);

     // Initialize our various collections

     // We maintain 4 collections:

     //

     // 1. clientIds: contains all of the client ids to visit

     // 2. ids: contains just ids (not client ids) to visit.

     //    We use this to optimize our check to see whether a

     //    particular component is in the visit set (ie. to

     //    avoid having to compute the client id).

     // 3. subtreeClientIds: contains client ids to visit broken

     //    out by naming container subtree.  (Needed by

     //    getSubtreeIdsToVisit()).

     // 4. unvisitedClientIds: contains the client ids to visit that

     //    have not yet been visited.

     //

     // We populate these now.

     //

     // Note that we use default HashSet/Map initial capacities, though

     // perhaps we could pick more intelligent defaults.

     // Initialize unvisitedClientIds collection

     _unvisitedClientIds = new HashSet<String>();

     // Initialize ids collection

     _ids = new HashSet<String>();

     // Intialize subtreeClientIds collection

     _subtreeClientIds = new HashMap<String, Collection<String>>();

     // Initialize the clientIds collection.  Note that we proxy 

     // this collection so that we can trap adds/removes and sync 

     // up all of the other collections.

     _clientIds = new CollectionProxy<String>(new HashSet<String>());

     // Finally, populate the clientIds collection.  This has the

     // side effect of populating all of the other collections.

     org.apache.myfaces.shared.util.ArrayUtils.addAll(_clientIds, clientIds);

     //_clientIds.addAll(clientIdSet);

     // Copy and store hints - ensure unmodifiable and non-empty

     EnumSet<VisitHint> hintsEnumSet = ((hints == null) || (hints.isEmpty()))

                                         ? EnumSet.noneOf(VisitHint.class)

                                         : EnumSet.copyOf(hints);

     _hints = Collections.unmodifiableSet(hintsEnumSet);

   }

   /**

    * @see VisitContext#getFacesContext VisitContext.getFacesContext()

    */

   @Override

   public FacesContext getFacesContext()

   {

     return _facesContext;

   }

   /**

    * @see VisitContext#getHints VisitContext.getHints

    */

   @Override

   public Set<VisitHint> getHints()

   {

     return _hints;

   }

   /**

    * @see VisitContext#getIdsToVisit VisitContext.getIdsToVisit()

    */

   @Override

   public Collection<String> getIdsToVisit()

   {

     // We just return our clientIds collection.  This is

     // the modifiable (but proxied) collection of all of

     // the client ids to visit.

     return _clientIds;

   }

   /**

    * @see VisitContext#getSubtreeIdsToVisit VisitContext.getSubtreeIdsToVisit()

    */

   @Override

   public Collection<String> getSubtreeIdsToVisit(UIComponent component)

   {

     // Make sure component is a NamingContainer

     if (!(component instanceof NamingContainer))

     {

       throw new IllegalArgumentException("Component is not a NamingContainer: " + component);

     }

     String clientId = component.getClientId(getFacesContext());

     Collection<String> ids = _subtreeClientIds.get(clientId);

     if (ids == null)

     {

         return Collections.emptyList();

     }

     else

     {

         return Collections.unmodifiableCollection(ids);

     }

   }

   /**

    * @see VisitContext#invokeVisitCallback VisitContext.invokeVisitCallback()

    */

   @Override

   public VisitResult invokeVisitCallback(

     UIComponent component, 

     VisitCallback callback)

   {

     // First sure that we should visit this component - ie.

     // that this component is represented in our id set.

     String clientId = _getVisitId(component);

     if (clientId == null)

     {

       // Not visiting this component, but allow visit to

       // continue into this subtree in case we've got

       // visit targets there.

       return VisitResult.ACCEPT;

     }

     // If we made it this far, the component matches one of

     // client ids, so perform the visit.

     VisitResult result = callback.visit(this, component);

     // Remove the component from our "unvisited" collection

     _unvisitedClientIds.remove(clientId);

     // If the unvisited collection is now empty, we are done.

     // Return VisitResult.COMPLETE to terminate the visit.

     if (_unvisitedClientIds.isEmpty())

     {

         return VisitResult.COMPLETE;

     }

     else

     {

       // Otherwise, just return the callback's result 

       return result;

     }

   }

   // Called by CollectionProxy to notify PartialVisitContext that

   // an new id has been added.

   private void _idAdded(String clientId)

   {

     // An id to visit has been added, update our other

     // collections to reflect this.

     // Update the ids collection

     _ids.add(_getIdFromClientId(clientId));

     // Update the unvisited ids collection

     _unvisitedClientIds.add(clientId);

     // Update the subtree ids collection

     _addSubtreeClientId(clientId);

   }

   // Called by CollectionProxy to notify PartialVisitContext that

   // an id has been removed

   private void _idRemoved(String clientId)

   {

     // An id to visit has been removed, update our other

     // collections to reflect this.  Note that we don't

     // update the ids collection, since we ids (non-client ids)

     // may not be unique.

     // Update the unvisited ids collection

     _unvisitedClientIds.remove(clientId);

     // Update the subtree ids collection

     _removeSubtreeClientId(clientId);

   }

   // Tests whether the specified component should be visited.

   // If so, returns its client id.  If not, returns null.

   private String _getVisitId(UIComponent component)

   {

     // We first check to see whether the component's id

     // is in our id collection.  We do this before checking

     // for the full client id because getting the full client id

     // is more expensive than just getting the local id.

     String id = component.getId();

     if ((id != null) && !_ids.contains(id))

     {

         return null;

     }

       // The id was a match - now check the client id.

     // note that client id should never be null (should be

     // generated even if id is null, so asserting this.)

     String clientId = component.getClientId(getFacesContext());

     assert(clientId != null);

     return _clientIds.contains(clientId) ? clientId : null;

   }

   // Converts an client id into a plain old id by ripping

   // out the trailing id segmetn.

   private String _getIdFromClientId(String clientId)

   {

     final char separator = getFacesContext().getNamingContainerSeparatorChar();

     int lastIndex = clientId.lastIndexOf(separator);

     String id = null;

     if (lastIndex < 0)

     {

       id = clientId;

     }

     else if (lastIndex < (clientId.length() - 1))

     {

       id = clientId.substring(lastIndex + 1);              

     }

     //else

     //{

       // TODO log warning for trailing colon case

     //}

     return id;

   }

   // Given a single client id, populate the subtree map with all possible

   // subtree client ids

   private void _addSubtreeClientId(String clientId)

   {

     // Loop over the client id and find the substring corresponding to

     // each ancestor NamingContainer client id.  For each ancestor

     // NamingContainer, add an entry into the map for the full client

     // id.

     final char separator = getFacesContext().getNamingContainerSeparatorChar();

     int length = clientId.length();

     for (int i = 0; i < length; i++)

     {

       if (clientId.charAt(i) == separator)

       {

         // We found an ancestor NamingContainer client id - add 

         // an entry to the map.

         String namingContainerClientId = clientId.substring(0, i);

         // Check to see whether we've already ids under this

         // NamingContainer client id.  If not, create the 

         // Collection for this NamingContainer client id and

         // stash it away in our map

         Collection<String> c = _subtreeClientIds.get(namingContainerClientId);

         if (c == null)

         {

           // TODO: smarter initial size?

           c = new ArrayList<String>();

           _subtreeClientIds.put(namingContainerClientId, c);

         }

         // Stash away the client id

         c.add(clientId);

       }

     }

   }

   // Given a single client id, remove any entries corresponding

   // entries from our subtree collections

   private void _removeSubtreeClientId(String clientId)

   {

     // Loop through each entry in the map and check to see whether

     // the client id to remove should be contained in the corresponding

     // collection - ie. whether the key (the NamingContainer client id)

     // is present at the start of the client id to remove.

     for (String key : _subtreeClientIds.keySet())

     {

       if (clientId.startsWith(key))

       {

         // If the clientId starts with the key, we should

         // have an entry for this clientId in the corresponding

         // collection.  Remove it.

         Collection<String> ids = _subtreeClientIds.get(key);

         ids.remove(clientId);

       }

     }

   }

   // Little proxy collection implementation.  We proxy the id

   // collection so that we can detect modifications and update

   // our internal state when ids to visit are added or removed.

   private class CollectionProxy<E extends String> extends AbstractCollection<E>

   {

     private CollectionProxy(Collection<E> wrapped)

     {

       _wrapped = wrapped;

     }

     @Override

     public int size()

     {

       return _wrapped.size();

     }

     @Override

     public Iterator<E> iterator()

     {

       return new IteratorProxy<E>(_wrapped.iterator());

     }

     @Override

     public boolean add(E o)

     {

       boolean added = _wrapped.add(o);

       if (added)

       {

         _idAdded(o);

       }

       return added;

     }

     private final Collection<E> _wrapped;

   }

   // Little proxy iterator implementation used by CollectionProxy

   // so that we can catch removes.

   private class IteratorProxy<E extends String> implements Iterator<E>

   {

     private IteratorProxy(Iterator<E> wrapped)

     {

       _wrapped = wrapped;

     }

     public boolean hasNext()

     {

       return _wrapped.hasNext();

     }

     public E next()

     {

       _current = _wrapped.next();

       return _current;

     }

     public void remove()

     {

       if (_current != null)

       {

         _idRemoved(_current);

       }

       _wrapped.remove();

     }

     private final Iterator<E> _wrapped;

     private E _current = null;

   }

   // The client ids to visit

   private final Collection<String> _clientIds;

   // The ids to visit

   private final Collection<String> _ids;

   // The client ids that have yet to be visited

   private final Collection<String> _unvisitedClientIds;

   // This map contains the information needed by getIdsToVisit().

   // The keys in this map are NamingContainer client ids.  The values

   // are collections containing all of the client ids to visit within

   // corresponding naming container.

   private final Map<String,Collection<String>> _subtreeClientIds;

   // The FacesContext for this request

   private final FacesContext _facesContext;

   // Our visit hints

   private final Set<VisitHint> _hints;

 }