/*
    * 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 javax.faces.component;
  
  import javax.el.MethodExpression;
  import javax.faces.context.FacesContext;
  import javax.faces.context.FacesContextWrapper;
  import javax.faces.el.MethodBinding;
  import javax.faces.event.AbortProcessingException;
  import javax.faces.event.ActionEvent;
  import javax.faces.event.ActionListener;
  import javax.faces.event.FacesEvent;
  import javax.faces.event.PhaseId;
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFComponent;
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFListener;
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFProperty;
  
  /**
   * @since 2.2
   */
  @JSFComponent(name = "f:viewAction")
  public class UIViewAction extends UIComponentBase implements ActionSource2
  {
      //private static final Logger log = Logger.getLogger(UIViewAction.class.getName());
      public static final String COMPONENT_FAMILY = "javax.faces.ViewAction";
      public static final String COMPONENT_TYPE = "javax.faces.ViewAction";
      
      /**
       * Key in facesContext attribute map to check if a viewAction broadcast is 
       * being processed. This is used to check when a JSF lifecycle restart is required
       * by the NavigationHandler implementation.
       */
      private static final String BROADCAST_PROCESSING_KEY = "oam.viewAction.broadcast";
      
      /**
       * Key in facesContext attribute map to count the number of viewAction events that 
       * remains to be processed.
       */
      private static final String EVENT_COUNT_KEY = "oam.viewAction.eventCount";
  
      public UIViewAction()
      {
          setRendererType(null);
      }
  
      @Override
      public void broadcast(FacesEvent event) throws AbortProcessingException
      {
          super.broadcast(event);
          
          FacesContext context = getFacesContext();
          
          if (context.getResponseComplete())
          {
              return;
          }
          
          UIComponent c = event.getComponent();
          UIViewRoot sourceViewRoot = null;
          do
          {
              if (c instanceof UIViewRoot)
              {
                  sourceViewRoot = (UIViewRoot) c;
                  break;
              }
              else
              {
                  c = c.getParent();
              }
          } while (c != null);
          
          if (!context.getViewRoot().equals(sourceViewRoot))
          {
              return;
          }
          
          if (event instanceof ActionEvent)
          {
              ActionListener defaultActionListener = context.getApplication().getActionListener();
              if (defaultActionListener != null)
              {
                  String  viewIdBeforeAction = context.getViewRoot().getViewId();
                 Boolean oldBroadcastProcessing = (Boolean) context.getAttributes().
                     get(BROADCAST_PROCESSING_KEY);
                 try
                 {
                     context.getAttributes().put(BROADCAST_PROCESSING_KEY, Boolean.TRUE);
 
                     ViewActionFacesContextWrapper wrappedFacesContext = new ViewActionFacesContextWrapper(context);
 
                     try
                     {
                         wrappedFacesContext.setWrapperAsCurrentFacesContext();
 
                         MethodBinding mb = getActionListener();
                         if (mb != null)
                         {
                             mb.invoke(context, new Object[]
                             { event });
                         }
 
                         if (defaultActionListener != null)
                         {
                             defaultActionListener.processAction((ActionEvent) event);
                         }
                         
                         // Decrement count
                         Integer count = (Integer) context.getAttributes().get(EVENT_COUNT_KEY);
                         count = (count == null) ? 0 : count - 1;
                         context.getAttributes().put(EVENT_COUNT_KEY, count);
                     }
                     finally
                     {
                         wrappedFacesContext.restoreCurrentFacesContext();
                     }
                 }
                 finally
                 {
                     context.getAttributes().put(BROADCAST_PROCESSING_KEY, 
                         oldBroadcastProcessing == null ? Boolean.FALSE : oldBroadcastProcessing);
                 }
 
                 if (context.getResponseComplete())
                 {
                     return;
                 }
                 else
                 {
                     Integer count = (Integer) context.getAttributes().get(EVENT_COUNT_KEY);
                     count = (count == null) ? 0 : count;
                     String viewIdAfterAction = context.getViewRoot().getViewId();
 
                     if (viewIdBeforeAction.equals(viewIdAfterAction) && count == 0)
                     {
                         context.renderResponse();
                     }
                     // "... Otherwise, execute the lifecycle on the new UIViewRoot ..."
                     // Note these words are implemented in the NavigationHandler, but 
                     // the original proposal from seam s:viewAction did a trick here 
                     // to restart the JSF lifecycle.
                 }
             }
         }
     }
 
     @Override
     public void decode(FacesContext context)
     {
         super.decode(context);
         
         if (context.isPostback() && !isOnPostback())
         {
             return;
         }
         
         if (!isRendered())
         {
             return;
         }
         
         ActionEvent evt = new ActionEvent(this);
         String phase = getPhase();
         PhaseId phaseId = (phase != null) ? PhaseId.phaseIdValueOf(phase) :
             isImmediate() ? PhaseId.APPLY_REQUEST_VALUES : PhaseId.INVOKE_APPLICATION;
         evt.setPhaseId(phaseId);
         this.queueEvent(evt);
         
         // "... Keep track of the number of events that are queued in this way 
         // on this run through the lifecycle. ...". The are two options:
         // 1. Use an attribute over FacesContext attribute map
         // 2. Use an attribute over the component
         // If the view is recreated again with the same viewId, the component 
         // state get lost, so the option 1 is preferred.
         Integer count = (Integer) context.getAttributes().get(EVENT_COUNT_KEY);
         count = (count == null) ? 1 : count + 1;
         context.getAttributes().put(EVENT_COUNT_KEY, count);
     }
 
     @Deprecated
     public MethodBinding getAction()
     {
         MethodExpression actionExpression = getActionExpression();
         if (actionExpression instanceof _MethodBindingToMethodExpression)
         {
             return ((_MethodBindingToMethodExpression) actionExpression)
                     .getMethodBinding();
         }
         if (actionExpression != null)
         {
             return new _MethodExpressionToMethodBinding(actionExpression);
         }
         return null;
     }
 
     /**
      * @deprecated Use setActionExpression instead.
      */
     @Deprecated
     public void setAction(MethodBinding action)
     {
         if (action != null)
         {
             setActionExpression(new _MethodBindingToMethodExpression(action));
         }
         else
         {
             setActionExpression(null);
         }
     }
 
     @JSFProperty
     public boolean isImmediate()
     {
         return (Boolean) getStateHelper().eval(PropertyKeys.immediate, Boolean.FALSE);
     }
 
     public void setImmediate(boolean immediate)
     {
         getStateHelper().put(PropertyKeys.immediate, immediate );
     }
 
     @JSFProperty(stateHolder=true, returnSignature = "java.lang.Object", jspName = "action", clientEvent="action")
     public MethodExpression getActionExpression()
     {
         return (MethodExpression) getStateHelper().eval(PropertyKeys.actionExpression);
     }
 
     public void setActionExpression(MethodExpression actionExpression)
     {
         getStateHelper().put(PropertyKeys.actionExpression, actionExpression);
     }
 
     @Deprecated
     @JSFProperty(stateHolder=true, returnSignature = "void", methodSignature = "javax.faces.event.ActionEvent")
     public MethodBinding getActionListener()
     {
         return (MethodBinding) getStateHelper().eval(PropertyKeys.actionListener);
     }
 
     /**
      * @deprecated
      */
     @Deprecated
     @JSFProperty(returnSignature="void",methodSignature="javax.faces.event.ActionEvent")
     public void setActionListener(MethodBinding actionListener)
     {
         getStateHelper().put(PropertyKeys.actionListener, actionListener);
         // Note f:viewAction does not have actionListener property defined.
         //throw new UnsupportedOperationException();
     }
 
     public void addActionListener(ActionListener listener)
     {
         addFacesListener(listener);
     }
 
     public void removeActionListener(ActionListener listener)
     {
         removeFacesListener(listener);
     }
 
     @JSFListener(event="javax.faces.event.ActionEvent",
             phases="Invoke Application, Apply Request Values")
     public ActionListener[] getActionListeners()
     {
         return (ActionListener[]) getFacesListeners(ActionListener.class);
     }
     
     @JSFProperty
     public String getPhase()
     {
         return (String) getStateHelper().get(PropertyKeys.phase);
     }
     
     public void setPhase(String phase)
     {
         getStateHelper().put(PropertyKeys.phase, phase);
     }
     
     @JSFProperty
     public boolean isOnPostback()
     {
         return (Boolean) getStateHelper().eval(PropertyKeys.onPostback, Boolean.FALSE);
     }
 
     public void setOnPostback(boolean onPostback)
     {
         getStateHelper().put(PropertyKeys.onPostback, onPostback );
     }    
     
     public static boolean isProcessingBroadcast(FacesContext context)
     {
         return Boolean.TRUE.equals(context.getAttributes().get(BROADCAST_PROCESSING_KEY));
     }
 
     enum PropertyKeys
     {
          immediate
         , value
         , actionExpression
         , actionListener
         , phase
         , onPostback
     }
 
     @Override
     public String getFamily()
     {
         return COMPONENT_FAMILY;
     }
     
     private static class ViewActionFacesContextWrapper extends FacesContextWrapper
     {
         private FacesContext delegate;
         private boolean renderResponseCalled;
 
         public ViewActionFacesContextWrapper(FacesContext delegate)
         {
             this.delegate = delegate;
             this.renderResponseCalled = false;
         }
 
         @Override
         public void renderResponse()
         {
             //Take no action
             renderResponseCalled = true;
         }
         
         public boolean isRenderResponseCalled()
         {
             return renderResponseCalled;
         }
         
         @Override
         public FacesContext getWrapped()
         {
             return delegate;
         }
         
         void setWrapperAsCurrentFacesContext()
         {
             setCurrentInstance(this);
         }
         
         void restoreCurrentFacesContext()
         {
             setCurrentInstance(delegate);
         }
     }
 }