/*

  * 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.jsf.core;

 import java.io.IOException;

 import java.io.Serializable;

 import java.util.Collection;

 import java.util.Iterator;

 import javax.el.ELContext;

 import javax.el.ELException;

 import javax.el.MethodExpression;

 import javax.el.MethodNotFoundException;

 import javax.faces.FacesException;

 import javax.faces.component.PartialStateHolder;

 import javax.faces.component.UIComponent;

 import javax.faces.component.UIViewRoot;

 import javax.faces.context.FacesContext;

 import javax.faces.event.ComponentSystemEvent;

 import javax.faces.event.ComponentSystemEventListener;

 import javax.faces.event.PostAddToViewEvent;

 import javax.faces.event.PreRenderViewEvent;

 import javax.faces.view.facelets.ComponentHandler;

 import javax.faces.view.facelets.FaceletContext;

 import javax.faces.view.facelets.FaceletException;

 import javax.faces.view.facelets.TagAttribute;

 import javax.faces.view.facelets.TagAttributeException;

 import javax.faces.view.facelets.TagConfig;

 import javax.faces.view.facelets.TagHandler;

 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFFaceletAttribute;

 import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFFaceletTag;

 import org.apache.myfaces.config.RuntimeConfig;

 import org.apache.myfaces.view.facelets.FaceletCompositionContext;

 import org.apache.myfaces.view.facelets.FaceletViewDeclarationLanguage;

 import org.apache.myfaces.view.facelets.el.CompositeComponentELUtils;

 import org.apache.myfaces.view.facelets.tag.jsf.ComponentSupport;

 import org.apache.myfaces.view.facelets.util.ReflectionUtil;

 /**

  * Registers a listener for a given system event class on the UIComponent associated with this tag.

  */

 @JSFFaceletTag(

         name = "f:event",

         bodyContent = "empty")

 public final class EventHandler extends TagHandler

 {

     private static final Class<?>[] COMPONENT_SYSTEM_EVENT_PARAMETER = new Class<?>[] { ComponentSystemEvent.class };

     private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];

     @JSFFaceletAttribute(name="listener",

             className="javax.el.MethodExpression",

             deferredMethodSignature=

             "public void listener(javax.faces.event.ComponentSystemEvent evt) "

             + "throws javax.faces.event.AbortProcessingException")

     private TagAttribute listener;

     @JSFFaceletAttribute(name="type",

             className="javax.el.ValueExpression",

             deferredValueType="java.lang.String")

     private TagAttribute type;

     private Class<?> eventClassLiteral;

     private boolean listenerIsCompositeComponentME;

     public EventHandler (TagConfig tagConfig)

     {

         super (tagConfig);

         listener = getRequiredAttribute("listener");

         if (!listener.isLiteral())

         {

             listenerIsCompositeComponentME

                     = CompositeComponentELUtils.isCompositeComponentExpression(listener.getValue());

         }

         else

         {

             listenerIsCompositeComponentME = false;

         }

         type = getRequiredAttribute("type");

     }

     public void apply (FaceletContext ctx, UIComponent parent)

             throws ELException, FacesException, FaceletException, IOException

     {

         //Apply only if we are creating a new component

         if (!ComponentHandler.isNew(parent))

         {

             return;

         }

         if (parent instanceof UIViewRoot)

         {

             if (FaceletCompositionContext.getCurrentInstance(ctx).isRefreshingTransientBuild())

             {

                 return;

             }

             else if (!FaceletViewDeclarationLanguage.isBuildingViewMetadata(ctx.getFacesContext()) &&

                     UIViewRoot.METADATA_FACET_NAME.equals((String) parent.getAttributes().get(FacetHandler.KEY)))

             {

                 // Already processed when the view metadata was created

                 return;

             }

         }

         Class<? extends ComponentSystemEvent> eventClass = getEventClass(ctx);

         // Note: The listener attribute can now also take a zero-argument MethodExpression,

         // thus we need two different MethodExpressions (see MYFACES-2503 for details).

         MethodExpression methodExpOneArg 

                 = listener.getMethodExpression(ctx, void.class, COMPONENT_SYSTEM_EVENT_PARAMETER);

         MethodExpression methodExpZeroArg

                 = listener.getMethodExpression(ctx, void.class, EMPTY_CLASS_ARRAY);

         if (eventClass == PreRenderViewEvent.class)

         {

             // ensure ViewRoot for PreRenderViewEvent

             UIViewRoot viewRoot = ComponentSupport.getViewRoot(ctx, parent);

             if (listenerIsCompositeComponentME)

             {

                 // Subscribe after the view is built, so we can calculate a

                 // findComponent valid expression, and then use it to

                 // put the expression in context.

                 UIComponent parentCompositeComponent

                         = FaceletCompositionContext.getCurrentInstance(ctx).getCompositeComponentFromStack();

                 parentCompositeComponent.subscribeToEvent(PostAddToViewEvent.class, 

                         new SubscribeEventListener(eventClass, methodExpOneArg, methodExpZeroArg,

                                                    (eventClass == PreRenderViewEvent.class) ? null : parent));

             }

             else

             {

                 viewRoot.subscribeToEvent(eventClass, new Listener(methodExpOneArg, methodExpZeroArg));

             }

         }

         else

         {

             // Simply register the event on the component.

             parent.subscribeToEvent(eventClass, new Listener(methodExpOneArg, methodExpZeroArg));

         }

     }

     /**

      * Gets the event class defined by the tag (either in the "name" or "type" attribute).

      * 

      * @param context the Facelet context

      * @return a Class containing the event class defined by the tag.

      */

     @SuppressWarnings("unchecked")

     private Class<? extends ComponentSystemEvent> getEventClass (FaceletContext context)

     {

         Class<?> eventClass = null;

         String value = null;

         if (type.isLiteral() && eventClassLiteral != null)

         {

             // if type is literal it does not change, avoid Reflection and use cached value

             return (Class<? extends ComponentSystemEvent>) eventClassLiteral;

         }

         if (type.isLiteral())

         {

             value = type.getValue();

         }

         else

         {

             value = (String) type.getValueExpression (context, String.class).

                 getValue (context.getFacesContext().getELContext());

         }

         Collection<Class<? extends ComponentSystemEvent>> events;

         // We can look up the event class by name in the NamedEventManager.

         events = RuntimeConfig.getCurrentInstance(

                 context.getFacesContext().getExternalContext()).

                     getNamedEventManager().getNamedEvent(value);

         if (events == null)

         {

             try

             {

                 eventClass = ReflectionUtil.forName (value);

                 if (type.isLiteral())

                 {

                     eventClassLiteral = eventClass;

                 }

             }

             catch (Throwable e)

             {

                 throw new TagAttributeException (type, "Couldn't create event class", e);

             }

         }

         else if (events.size() > 1)

         {

             StringBuilder classNames = new StringBuilder ("[");

             Iterator<Class<? extends ComponentSystemEvent>> eventIterator = events.iterator();

             // TODO: The spec is somewhat vague, but I think we're supposed to throw an exception

             // here.  The @NamedEvent javadocs say that if a short name is registered to more than one

             // event class that we must throw an exception listing the short name and the classes in

             // the list _when the application makes reference to it_.  I believe processing this tag

             // qualifies as the application "making reference" to the short name.  Why the exception

             // isn't thrown when processing the @NamedEvent annotation, I don't know.  Perhaps follow

             // up with the EG to see if this is correct.

             while (eventIterator.hasNext())

             {

                 classNames.append (eventIterator.next().getName());

                 if (eventIterator.hasNext())

                 {

                     classNames.append (", ");

                 }

                 else

                 {

                     classNames.append ("]");

                 }

             }

             throw new FacesException ("The event name '" + value + "' is mapped to more than one " +

                 " event class: " + classNames.toString());

         }

         else

         {

             eventClass = events.iterator().next();

         }

         if (!ComponentSystemEvent.class.isAssignableFrom (eventClass))

         {

             throw new TagAttributeException (type, "Event class " + eventClass.getName() +

                 " is not of type javax.faces.event.ComponentSystemEvent");

         }

         return (Class<? extends ComponentSystemEvent>) eventClass;

     }

     public static class Listener implements ComponentSystemEventListener, Serializable 

     {

         private static final long serialVersionUID = 7318240026355007052L;

         private MethodExpression methodExpOneArg;

         private MethodExpression methodExpZeroArg;

         public Listener()

         {

             super();

         }

         /**

          * Note: The listener attribute can now also take a zero-argument MethodExpression,

          * thus we need two different MethodExpressions (see MYFACES-2503 for details).

          * @param methodExpOneArg

          * @param methodExpZeroArg

          */

         private Listener(MethodExpression methodExpOneArg, MethodExpression methodExpZeroArg)

         {

             this.methodExpOneArg = methodExpOneArg;

             this.methodExpZeroArg = methodExpZeroArg;

         }

         public void processEvent(ComponentSystemEvent event)

         {

             ELContext elContext = FacesContext.getCurrentInstance().getELContext();

             try

             {

                 // first try to invoke the MethodExpression with one argument

                 this.methodExpOneArg.invoke(elContext, new Object[] { event });

             }

             catch (MethodNotFoundException mnfeOneArg)

             {

                 try

                 {

                     // if that fails try to invoke the MethodExpression with zero arguments

                     this.methodExpZeroArg.invoke(elContext, new Object[0]);

                 }

                 catch (MethodNotFoundException mnfeZeroArg)

                 {

                     // if that fails too rethrow the original MethodNotFoundException

                     throw mnfeOneArg;

                 }

             }

         }

     }

     public static class CompositeComponentRelativeListener  implements ComponentSystemEventListener, Serializable 

     {

         /**

          * 

          */

         private static final long serialVersionUID = 3822330995358746099L;

         private String _compositeComponentExpression;

         private MethodExpression methodExpOneArg;

         private MethodExpression methodExpZeroArg;

         public CompositeComponentRelativeListener()

         {

             super();

         }

         public CompositeComponentRelativeListener(MethodExpression methodExpOneArg, 

                                 MethodExpression methodExpZeroArg, 

                                 String compositeComponentExpression)

         {

             this.methodExpOneArg = methodExpOneArg;

             this.methodExpZeroArg = methodExpZeroArg;

             this._compositeComponentExpression = compositeComponentExpression;

         }

         public void processEvent(ComponentSystemEvent event)

         {

             FacesContext facesContext = FacesContext.getCurrentInstance();

             UIComponent cc = facesContext.getViewRoot().findComponent(_compositeComponentExpression);

             if (cc != null)

             {

                 pushAllComponentsIntoStack(facesContext, cc);

                 cc.pushComponentToEL(facesContext, cc);

                 try

                 {

                     ELContext elContext = facesContext.getELContext();

                     try

                     {

                         // first try to invoke the MethodExpression with one argument

                         this.methodExpOneArg.invoke(elContext, new Object[] { event });

                     }

                     catch (MethodNotFoundException mnfeOneArg)

                     {

                         try

                         {

                             // if that fails try to invoke the MethodExpression with zero arguments

                             this.methodExpZeroArg.invoke(elContext, new Object[0]);

                         }

                         catch (MethodNotFoundException mnfeZeroArg)

                         {

                             // if that fails too rethrow the original MethodNotFoundException

                             throw mnfeOneArg;

                         }

                     }

                 }

                 finally

                 {

                     popAllComponentsIntoStack(facesContext, cc);

                 }

             }

             else

             {

                 throw new NullPointerException("Composite Component associated with expression cannot be found");

             }

         }

         private void pushAllComponentsIntoStack(FacesContext facesContext, UIComponent component)

         {

             UIComponent parent = component.getParent();

             if (parent != null)

             {

                 pushAllComponentsIntoStack(facesContext, parent);

             }

             component.pushComponentToEL(facesContext, component);

         }

         private void popAllComponentsIntoStack(FacesContext facesContext, UIComponent component)

         {

             UIComponent parent = component.getParent();

             component.popComponentFromEL(facesContext);

             if (parent != null)

             {

                 popAllComponentsIntoStack(facesContext, parent);

             }

         }

     }

     public static final class SubscribeEventListener implements ComponentSystemEventListener, PartialStateHolder

     {

         private MethodExpression methodExpOneArg;

         private MethodExpression methodExpZeroArg;

         private Class<? extends ComponentSystemEvent> eventClass;

         private UIComponent _targetComponent;

         private String _targetFindComponentExpression;

         private boolean markInitialState;

         public SubscribeEventListener()

         {

         }

         public SubscribeEventListener(

                 Class<? extends ComponentSystemEvent> eventClass,

                 MethodExpression methodExpOneArg, 

                 MethodExpression methodExpZeroArg,

                 UIComponent targetComponent)

         {

             //_listener = listener;

             this.eventClass = eventClass;

             this.methodExpOneArg = methodExpOneArg;

             this.methodExpZeroArg = methodExpZeroArg;

             this._targetComponent = targetComponent;

         }

         public void processEvent(ComponentSystemEvent event)

         {

             UIComponent parentCompositeComponent = event.getComponent();

             FacesContext facesContext = FacesContext.getCurrentInstance();

             //Calculate a findComponent expression to locate the right instance so PreRenderViewEvent could be called

             String findComponentExpression

                     = ComponentSupport.getFindComponentExpression(facesContext, parentCompositeComponent);

             //Note in practice this is only used for PreRenderViewEvent, but in the future it could be more events that

             //require this hack.

             if (eventClass == PreRenderViewEvent.class)

             {

                 // ensure ViewRoot for PreRenderViewEvent

                 UIViewRoot viewRoot = facesContext.getViewRoot();

                 viewRoot.subscribeToEvent(eventClass, new CompositeComponentRelativeListener(methodExpOneArg,

                                                                         methodExpZeroArg, findComponentExpression));

             }

             else

             {

                 if (_targetComponent == null)

                 {

                     if (_targetFindComponentExpression.startsWith(findComponentExpression) )

                     {

                         _targetComponent = ComponentSupport.findComponentChildOrFacetFrom(

                                 facesContext, parentCompositeComponent, 

                                 _targetFindComponentExpression.substring(findComponentExpression.length()));

                     }

                     else

                     {

                         _targetComponent = facesContext.getViewRoot().findComponent(_targetFindComponentExpression);

                     }

                 }

                 _targetComponent.subscribeToEvent(eventClass,

                         new CompositeComponentRelativeListener(methodExpOneArg, methodExpZeroArg,

                                                                findComponentExpression));

             }

         }

         public Object saveState(FacesContext context)

         {

             if (!initialStateMarked())

             {

                 Object[] values = new Object[4];

                 values[0] = (String) ( (_targetComponent != null && _targetFindComponentExpression == null) ? 

                                             ComponentSupport.getFindComponentExpression(context, _targetComponent) : 

                                             _targetFindComponentExpression );

                 values[1] = eventClass;

                 values[2] = methodExpZeroArg;

                 values[3] = methodExpOneArg;

                 return values;

             }

             // If the listener was marked, no need to save anything, because 

             // this object is immutable after that.

             return null;

         }

         public void restoreState(FacesContext context, Object state)

         {

             if (state == null)

             {

                 return;

             }

             Object[] values = (Object[])state;

             _targetFindComponentExpression = (String) values[0];

             eventClass = (Class) values[1];

             methodExpZeroArg = (MethodExpression) values[2];

             methodExpOneArg = (MethodExpression) values[3];

         }

         public boolean isTransient()

         {

             return false;

         }

         public void setTransient(boolean newTransientValue)

         {

             // no-op as listener is transient

         }

         public void clearInitialState()

         {

             markInitialState = false;

         }

         public boolean initialStateMarked()

         {

             return markInitialState;

         }

         public void markInitialState()

         {

             markInitialState = true;

         }

     }

 }