/*
    * 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 org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  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_impl.util.ClassUtils;
  
  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 java.io.Serializable;
  
  /**
   * Register a PhaseListener instance
   * 
   * @author martin.haimberger
   * @version $Revision: 462929 $ $Date: 2006-10-11 21:26:36 +0100 (mi�, 11 oct 2006) $
   */
  @JSFJspTag(
          name="f:phaseListener",
          bodyContent="empty")
  public class PhaseListenerTag extends TagSupport {
  
      private final Log log = LogFactory.getLog(PhaseListenerTag.class);
  
      /**
       * 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(
              rtexprvalue=true,
              className="java.lang.String")
      public void setType(ValueExpression type) {
          this.type = type;
      }
  
      /**
       * Value binding expression that evaluates to a PhaseListener.
       */
      @JSFJspAttribute(
              className="javax.faces.event.PhaseListener",
              rtexprvalue=true)
      public void setBinding(ValueExpression binding) {
          this.binding = binding;
      }
  
  
      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.warn("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;
 
         }
 
     }
 }