/*
    * 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.view.facelets.tag.composite;
  
  import java.io.IOException;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import javax.el.ValueExpression;
  import javax.faces.FacesException;
  import javax.faces.FacesWrapper;
  import javax.faces.component.ContextCallback;
  import javax.faces.component.UIComponent;
  import javax.faces.component.behavior.ClientBehavior;
  import javax.faces.component.behavior.ClientBehaviorHolder;
  import javax.faces.component.visit.VisitCallback;
  import javax.faces.component.visit.VisitContext;
  import javax.faces.context.FacesContext;
  import javax.faces.el.ValueBinding;
  import javax.faces.event.AbortProcessingException;
  import javax.faces.event.ComponentSystemEvent;
  import javax.faces.event.ComponentSystemEventListener;
  import javax.faces.event.FacesEvent;
  import javax.faces.event.FacesListener;
  import javax.faces.event.SystemEvent;
  import javax.faces.event.SystemEventListener;
  import javax.faces.render.Renderer;
  
  /**
   * This class has two usages:
   * 
   * 1. On ClientBehaviorAttachedObjectTargetImpl to redirect the incoming sourceEvent
   * to the final targetEvent.   
   * 2. On FaceletsViewDeclarationLanguage.retargetAttachedObjects to redirect too, but
   * this time is to allow chain events for nested composite components.
   * 
   * This class also implements FacesWrapper interface, to make possible to retrieve the
   * real component if necessary.
   * 
   * @author Leonardo Uribe (latest modification by $Author$)
   * @version $Revision$ $Date$
   */
  public class ClientBehaviorRedirectEventComponentWrapper extends UIComponent 
      implements FacesWrapper<UIComponent>, ClientBehaviorHolder
  {
  
      private final UIComponent _delegate;
      private final String _sourceEvent; //cc:clientBehavior "name"
      private final String _targetEvent; //cc:clientBehavior "event"
  
      public ClientBehaviorRedirectEventComponentWrapper(UIComponent delegate,
              String sourceEvent, String targetEvent)
      {
          super();
          _delegate = delegate;
          _sourceEvent = sourceEvent;
          _targetEvent = targetEvent;
      }
  
      public UIComponent getWrapped()
      {
          return _delegate;
      }
  
      public void addClientBehavior(String eventName, ClientBehavior behavior)
      {
          if (_sourceEvent.equals(eventName))
          {
              String targetEventName = _targetEvent == null
                      ? ((ClientBehaviorHolder)_delegate).getDefaultEventName()
                      : _targetEvent;
              ((ClientBehaviorHolder)_delegate).addClientBehavior(targetEventName , behavior);
          }
      }
  
      public Map<String, List<ClientBehavior>> getClientBehaviors()
      {
          Map<String, List<ClientBehavior>> clientBehaviors = new HashMap<String, List<ClientBehavior>>(1);
          clientBehaviors.put(_sourceEvent, ((ClientBehaviorHolder)_delegate).getClientBehaviors().get(_targetEvent));
         return Collections.unmodifiableMap(clientBehaviors);
     }
 
     public String getDefaultEventName()
     {
         if (_targetEvent == null )
         {
             // There is no targetEvent assigned, so we need to check if there is 
             // a default event name on the delegate, if so return sourceEvent, otherwise
             // there is no default event and we can't resolve the redirection, so
             // return null. Note this usually could cause another exception later
             // (see AjaxHandler code 
             if (((ClientBehaviorHolder)_delegate).getDefaultEventName() != null)
             {
                 return _sourceEvent;
             }
             else
             {
                 return null;
             }
         }
         else
         {
             // We have a target event, so in this case we have to return the sourceEvent,
             // because it is expected the client behavior to be attached has this event name.
             return _sourceEvent;
         }
     }
 
     public Collection<String> getEventNames()
     {
         return Collections.singletonList(_sourceEvent);
     }
     
     // UIComponent wrapping. Just delegate.    
     public void broadcast(FacesEvent event) throws AbortProcessingException
     {
         _delegate.broadcast(event);
     }
 
     public void clearInitialState()
     {
         _delegate.clearInitialState();
     }
 
     public void decode(FacesContext context)
     {
         _delegate.decode(context);
     }
 
     public void encodeAll(FacesContext context) throws IOException
     {
         _delegate.encodeAll(context);
     }
 
     public void encodeBegin(FacesContext context) throws IOException
     {
         _delegate.encodeBegin(context);
     }
 
     public void encodeChildren(FacesContext context) throws IOException
     {
         _delegate.encodeChildren(context);
     }
 
     public void encodeEnd(FacesContext context) throws IOException
     {
         _delegate.encodeEnd(context);
     }
 
     public UIComponent findComponent(String expr)
     {
         return _delegate.findComponent(expr);
     }
 
     public Map<String, Object> getAttributes()
     {
         return _delegate.getAttributes();
     }
 
     public int getChildCount()
     {
         return _delegate.getChildCount();
     }
 
     public List<UIComponent> getChildren()
     {
         return _delegate.getChildren();
     }
 
     public String getClientId()
     {
         return _delegate.getClientId();
     }
 
     public String getClientId(FacesContext context)
     {
         return _delegate.getClientId(context);
     }
 
     public String getContainerClientId(FacesContext ctx)
     {
         return _delegate.getContainerClientId(ctx);
     }
 
     public UIComponent getFacet(String name)
     {
         return _delegate.getFacet(name);
     }
 
     public int getFacetCount()
     {
         return _delegate.getFacetCount();
     }
 
     public Map<String, UIComponent> getFacets()
     {
         return _delegate.getFacets();
     }
 
     public Iterator<UIComponent> getFacetsAndChildren()
     {
         return _delegate.getFacetsAndChildren();
     }
 
     public String getFamily()
     {
         return _delegate.getFamily();
     }
 
     public String getId()
     {
         return _delegate.getId();
     }
 
     public List<SystemEventListener> getListenersForEventClass(
             Class<? extends SystemEvent> eventClass)
     {
         return _delegate.getListenersForEventClass(eventClass);
     }
 
     public UIComponent getNamingContainer()
     {
         return _delegate.getNamingContainer();
     }
 
     public UIComponent getParent()
     {
         return _delegate.getParent();
     }
 
     public String getRendererType()
     {
         return _delegate.getRendererType();
     }
 
     public boolean getRendersChildren()
     {
         return _delegate.getRendersChildren();
     }
 
     public Map<String, String> getResourceBundleMap()
     {
         return _delegate.getResourceBundleMap();
     }
 
     public ValueBinding getValueBinding(String name)
     {
         return _delegate.getValueBinding(name);
     }
 
     public ValueExpression getValueExpression(String name)
     {
         return _delegate.getValueExpression(name);
     }
 
     public boolean initialStateMarked()
     {
         return _delegate.initialStateMarked();
     }
 
     public boolean invokeOnComponent(FacesContext context, String clientId,
             ContextCallback callback) throws FacesException
     {
         return _delegate.invokeOnComponent(context, clientId, callback);
     }
 
     public boolean isInView()
     {
         return _delegate.isInView();
     }
 
     public boolean isRendered()
     {
         return _delegate.isRendered();
     }
 
     public boolean isTransient()
     {
         return _delegate.isTransient();
     }
 
     public void markInitialState()
     {
         _delegate.markInitialState();
     }
 
     public void processDecodes(FacesContext context)
     {
         _delegate.processDecodes(context);
     }
 
     public void processEvent(ComponentSystemEvent event)
             throws AbortProcessingException
     {
         _delegate.processEvent(event);
     }
 
     public void processRestoreState(FacesContext context, Object state)
     {
         _delegate.processRestoreState(context, state);
     }
 
     public Object processSaveState(FacesContext context)
     {
         return _delegate.processSaveState(context);
     }
 
     public void processUpdates(FacesContext context)
     {
         _delegate.processUpdates(context);
     }
 
     public void processValidators(FacesContext context)
     {
         _delegate.processValidators(context);
     }
 
     public void queueEvent(FacesEvent event)
     {
         _delegate.queueEvent(event);
     }
 
     public void restoreState(FacesContext context, Object state)
     {
         _delegate.restoreState(context, state);
     }
 
     public Object saveState(FacesContext context)
     {
         return _delegate.saveState(context);
     }
 
     public void setId(String id)
     {
         _delegate.setId(id);
     }
 
     public void setInView(boolean isInView)
     {
         _delegate.setInView(isInView);
     }
 
     public void setParent(UIComponent parent)
     {
         _delegate.setParent(parent);
     }
 
     public void setRendered(boolean rendered)
     {
         _delegate.setRendered(rendered);
     }
 
     public void setRendererType(String rendererType)
     {
         _delegate.setRendererType(rendererType);
     }
 
     public void setTransient(boolean newTransientValue)
     {
         _delegate.setTransient(newTransientValue);
     }
 
     public void setValueBinding(String name, ValueBinding binding)
     {
         _delegate.setValueBinding(name, binding);
     }
 
     public void setValueExpression(String name, ValueExpression expression)
     {
         _delegate.setValueExpression(name, expression);
     }
 
     public void subscribeToEvent(Class<? extends SystemEvent> eventClass,
             ComponentSystemEventListener componentListener)
     {
         _delegate.subscribeToEvent(eventClass, componentListener);
     }
 
     public void unsubscribeFromEvent(Class<? extends SystemEvent> eventClass,
             ComponentSystemEventListener componentListener)
     {
         _delegate.unsubscribeFromEvent(eventClass, componentListener);
     }
 
     public boolean visitTree(VisitContext context, VisitCallback callback)
     {
         return _delegate.visitTree(context, callback);
     }
     
     // Some methods of UIComponent are protected, but for the scope of this
     // wrapper are never used, so it is safe to just do nothing or return null.
 
     @Override
     protected FacesContext getFacesContext()
     {
         return FacesContext.getCurrentInstance();
     }
 
     @Override
     protected void addFacesListener(FacesListener listener)
     {
     }
 
     @Override
     protected FacesListener[] getFacesListeners(Class clazz)
     {
         return null;
     }
 
     @Override
     protected Renderer getRenderer(FacesContext context)
     {
         return null;
     }
 
     @Override
     protected void removeFacesListener(FacesListener listener)
     {
     }
 
     @Override
     public Map<String, Object> getPassThroughAttributes(boolean create)
     {
         return getWrapped().getPassThroughAttributes(create);
     }
 }