/*

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

 import java.io.Serializable;

 import java.util.logging.Logger;

 import javax.el.ValueExpression;

 import javax.faces.FacesException;

 import javax.faces.component.UIViewRoot;

 import javax.faces.context.FacesContext;

 import javax.faces.event.AbortProcessingException;

 import javax.faces.event.PhaseEvent;

 import javax.faces.event.PhaseId;

 import javax.faces.event.PhaseListener;

 import javax.faces.webapp.UIComponentELTag;

 import javax.servlet.jsp.JspException;

 import javax.servlet.jsp.tagext.Tag;

 import javax.servlet.jsp.tagext.TagSupport;

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

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

 import org.apache.myfaces.shared.util.ClassUtils;

 /**

  * Register a PhaseListener instance

  * 

  * @author martin.haimberger

  * @version $Revision$ $Date$

  */

 @JSFJspTag(name = "f:phaseListener", bodyContent = "empty")

 public class PhaseListenerTag extends TagSupport

 {

     private static final Logger log = Logger.getLogger(PhaseListenerTag.class.getName());

     /**

      * The fully qualified class name of the PhaseListener which should be created.

      */

     private ValueExpression type = null;

     /**

      * A value binding expression used to create a PhaseListener instance.

      */

     private ValueExpression binding = null;

     /**

      * Class name of the PhaseListener to be created and registered.

      */

     @JSFJspAttribute(className="javax.el.ValueExpression",

             deferredValueType="java.lang.String")

     public void setType(ValueExpression type)

     {

         this.type = type;

     }

     /**

      * Value binding expression that evaluates to a PhaseListener.

      */

     @JSFJspAttribute(className="javax.el.ValueExpression",

             deferredValueType="javax.faces.event.PhaseListener")

     public void setBinding(ValueExpression binding)

     {

         this.binding = binding;

     }

     @Override

     public int doStartTag() throws JspException

     {

         // JSF-Spec 1.2 9.4.9

         // Locate the one and only UIViewRoot custom action instance by walking up the tag tree

         // until you find a UIComponentELTag instance that has no parent. If the

         // getCreated() method of this instance returns true, check the binding attribute.

         Tag parent = this;

         UIComponentELTag parentTag = null;

         while ((parent = parent.getParent()) != null)

         {

             if (parent instanceof UIComponentELTag)

             {

                 parentTag = (UIComponentELTag)parent;

             }

         }

         if (parentTag == null)

         {

             throw new JspException("Not nested in a UIViewRoot Error for tag with handler class: "

                     + this.getClass().getName());

         }

         if (!parentTag.getCreated())

         {

             return SKIP_BODY;

         }

         UIViewRoot root = (UIViewRoot)parentTag.getComponentInstance();

         // JSF-Spec 1.2 9.4.9

         // If binding is set, call binding.getValue() to obtain a reference to the

         // PhaseListener instance. If there is no exception thrown, and binding.getValue()

         // returned a non-null object that implements javax.faces.event.PhaseListener, register

         // it by calling addPhaseListener(). If there was an exception thrown, rethrow the

         // exception as a JspException.

         // If the listener instance could not be created, check the type attribute. If the type

         // attribute is set, instantiate an instance of the specified class, and register it by calling

         // addPhaseListener(). If the binding attribute was also set, store the listener instance

         // by calling binding.setValue(). If there was an exception thrown, rethrow the

         // exception as a JspException.

         PhaseListener listener = null;

         try

         {

             listener = new BindingPhaseListener(binding, type);

         }

         catch (Exception ex)

         {

             throw new JspException(ex.getMessage(), ex);

         }

         root.addPhaseListener(listener);

         return SKIP_BODY;

     }

     private static class BindingPhaseListener implements PhaseListener, Serializable

     {

         private transient PhaseListener phaseListenerCache = null;

         private ValueExpression type;

         private ValueExpression binding;

         //private final Log log = LogFactory.getLog(PhaseListenerTag.class);

         BindingPhaseListener(ValueExpression binding, ValueExpression type)

         {

             this.binding = binding;

             this.type = type;

         }

         public void afterPhase(PhaseEvent event)

         {

             PhaseListener listener = getPhaseListener();

             if (listener != null)

             {

                 listener.afterPhase(event);

             }

         }

         public void beforePhase(PhaseEvent event)

         {

             PhaseListener listener = getPhaseListener();

             if (listener != null)

             {

                 listener.beforePhase(event);

             }

         }

         public PhaseId getPhaseId()

         {

             PhaseListener listener = getPhaseListener();

             if (listener != null)

             {

                 return listener.getPhaseId();

             }

             return null;

         }

         private PhaseListener getPhaseListener()

         {

             if (phaseListenerCache != null)

             {

                 return phaseListenerCache;

             }

             else

             {

                 // create PhaseListenerInstance

                 phaseListenerCache = getPhaseListnerInstance(binding, type);

             }

             if (phaseListenerCache == null)

             {

                 log.warning("PhaseListener will not be installed. Both binding and type are null.");

             }

             return phaseListenerCache;

         }

         private PhaseListener getPhaseListnerInstance(ValueExpression binding, ValueExpression type)

         {

             FacesContext currentFacesContext = FacesContext.getCurrentInstance();

             Object phasesInstance = null;

             if (binding != null)

             {

                 phasesInstance = binding.getValue(currentFacesContext.getELContext());

             }

             else if (type != null)

             {

                 try

                 {

                     phasesInstance = ClassUtils.newInstance((String)type.getValue(currentFacesContext.getELContext()));

                 }

                 catch (FacesException ex)

                 {

                     throw new AbortProcessingException(ex.getMessage(), ex);

                 }

             }

             return (PhaseListener)phasesInstance;

         }

     }

 }