/*
    * 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.ui;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.EnumSet;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import javax.el.ELContext;
  import javax.el.ValueExpression;
  import javax.faces.component.EditableValueHolder;
  import javax.faces.component.UIComponent;
  import javax.faces.component.UIViewRoot;
  import javax.faces.component.visit.VisitCallback;
  import javax.faces.component.visit.VisitContext;
  import javax.faces.component.visit.VisitHint;
  import javax.faces.component.visit.VisitResult;
  import javax.faces.context.FacesContext;
  import javax.faces.event.PhaseEvent;
  import javax.faces.event.PhaseId;
  import javax.faces.event.PhaseListener;
  
  import org.apache.myfaces.renderkit.ErrorPageWriter;
  
  /**
   * PhaseListener to create extended debug information.
   * Installed in FacesConfigurator.configureLifecycle() if ProjectStage is Development.
   * 
   * @author Jakob Korherr (latest modification by $Author$)
   * @version $Revision$ $Date$
   */
  public class DebugPhaseListener implements PhaseListener
  {
      
      private static final long serialVersionUID = -1517198431551012882L;
      
      private static final String SUBMITTED_VALUE_FIELD = "submittedValue";
      private static final String LOCAL_VALUE_FIELD = "localValue";
      private static final String VALUE_FIELD = "value";
      
      /**
       * Returns the debug-info Map for the given component.
       * ATTENTION: this method is duplicate in UIInput.
       * @param clientId
       * @return
       */
      @SuppressWarnings("unchecked")
      public static Map<String, List<Object[]>> getDebugInfoMap(String clientId)
      {
          final Map<String, Object> requestMap = FacesContext.getCurrentInstance()
                  .getExternalContext().getRequestMap();
          Map<String, List<Object[]>> debugInfo = (Map<String, List<Object[]>>) 
                  requestMap.get(ErrorPageWriter.DEBUG_INFO_KEY + clientId);
          if (debugInfo == null)
          {
              // no debug info available yet, create one and put it on the attributes map
              debugInfo = new HashMap<String, List<Object[]>>();
              requestMap.put(ErrorPageWriter.DEBUG_INFO_KEY + clientId, debugInfo);
          }
          return debugInfo;
      }
      
      /**
       * Returns the field's debug-infos from the component's debug-info Map.
       * ATTENTION: this method is duplicate in UIInput.
       * @param field
       * @param clientId
       * @return
       */
      public static List<Object[]> getFieldDebugInfos(final String field, String clientId)
      {
          Map<String, List<Object[]>> debugInfo = getDebugInfoMap(clientId);
          List<Object[]> fieldDebugInfo = debugInfo.get(field);
          if (fieldDebugInfo == null)
          {
              // no field debug-infos yet, create them and store it in the Map
              fieldDebugInfo = new ArrayList<Object[]>();
              debugInfo.put(field, fieldDebugInfo);
          }
          return fieldDebugInfo;
     }
     
     /**
      * Creates the field debug-info for the given field, which changed
      * from oldValue to newValue in the given component.
      * ATTENTION: this method is duplicate in UIInput.
      * @param facesContext
      * @param field
      * @param oldValue
      * @param newValue
      * @param clientId
      */
     public static void createFieldDebugInfo(FacesContext facesContext,
             final String field, Object oldValue, 
             Object newValue, String clientId)
     {
         if ((oldValue == null && newValue == null)
                 || (oldValue != null && oldValue.equals(newValue)))
         {
             // nothing changed - NOTE that this is a difference to the method in 
             // UIInput, because in UIInput every call to this method comes from
             // setSubmittedValue or setLocalValue and here every call comes
             // from the VisitCallback of the PhaseListener.
             return;
         }
         
         // convert Array values into a more readable format
         if (oldValue != null && oldValue.getClass().isArray())
         {
             oldValue = Arrays.deepToString((Object[]) oldValue);
         }
         if (newValue != null && newValue.getClass().isArray())
         {
             newValue = Arrays.deepToString((Object[]) newValue);
         }
         
         // NOTE that the call stack does not make much sence here
         
         // create the debug-info array
         // structure:
         //     - 0: phase
         //     - 1: old value
         //     - 2: new value
         //     - 3: StackTraceElement List
         // NOTE that we cannot create a class here to encapsulate this data,
         // because this is not on the spec and the class would not be available in impl.
         Object[] debugInfo = new Object[4];
         debugInfo[0] = facesContext.getCurrentPhaseId();
         debugInfo[1] = oldValue;
         debugInfo[2] = newValue;
         debugInfo[3] = null; // here we have no call stack (only in UIInput)
         
         // add the debug info
         getFieldDebugInfos(field, clientId).add(debugInfo);
     }
 
     /**
      * VisitCallback used for visitTree()  
      *  
      * @author Jakob Korherr
      */
     private class DebugVisitCallback implements VisitCallback
     {
 
         public VisitResult visit(VisitContext context, UIComponent target)
         {
             if (target instanceof EditableValueHolder)
             {
                 EditableValueHolder evh = (EditableValueHolder) target;
                 final String clientId = target.getClientId(context.getFacesContext());
                 Map<String, Object> requestMap = context.getFacesContext()
                         .getExternalContext().getRequestMap();
                 
                 if (_afterPhase)
                 {
                     // afterPhase - check for value changes
                     
                     // submittedValue
                     _createFieldDebugInfosIfNecessary(SUBMITTED_VALUE_FIELD, clientId,
                             evh.getSubmittedValue(), requestMap, context.getFacesContext());
                     
                     // localValue
                     final Object localValue = evh.getLocalValue();
                     _createFieldDebugInfosIfNecessary(LOCAL_VALUE_FIELD, clientId,
                             localValue, requestMap, context.getFacesContext());
                     
                     // value
                     final Object value = _getRealValue(evh, target, localValue,
                             context.getFacesContext().getELContext());
                     _createFieldDebugInfosIfNecessary(VALUE_FIELD, clientId,
                             value, requestMap, context.getFacesContext());
                 }
                 else
                 {
                     // beforePhase - save the current value state
                     
                     // submittedValue
                     requestMap.put(ErrorPageWriter.DEBUG_INFO_KEY + clientId 
                             + SUBMITTED_VALUE_FIELD, evh.getSubmittedValue());
                     
                     // localValue
                     final Object localValue = evh.getLocalValue();
                     requestMap.put(ErrorPageWriter.DEBUG_INFO_KEY + clientId 
                             + LOCAL_VALUE_FIELD, localValue);
                     
                     // value
                     final Object value = _getRealValue(evh, target, localValue,
                             context.getFacesContext().getELContext());
                     requestMap.put(ErrorPageWriter.DEBUG_INFO_KEY + clientId 
                             + VALUE_FIELD, value);
                 }
             }
             
             return VisitResult.ACCEPT;
         }
         
         /**
          * Checks if there are debug infos available for the given field and the
          * current Phase and if NOT, it creates and adds them to the request Map.
          * @param field
          * @param clientId
          * @param newValue
          * @param requestMap
          * @param facesContext
          */
         private void _createFieldDebugInfosIfNecessary(final String field, 
                 final String clientId, Object newValue,
                 Map<String, Object> requestMap, FacesContext facesContext)
         {
             // check if there are already debugInfos from UIInput
             List<Object[]> fieldDebugInfos = getFieldDebugInfos(field, clientId);
             boolean found = false;
             for (int i = 0, size = fieldDebugInfos.size(); i < size; i++)
             {
                 Object[] debugInfo = fieldDebugInfos.get(i);
                 if (debugInfo[0].equals(_currentPhase))
                 {
                     found = true;
                     break;
                 }
             }
             if (!found)
             {
                 // there are no debug infos for this field in this lifecycle phase yet
                 // --> create them
                 Object oldValue = requestMap.remove(ErrorPageWriter.DEBUG_INFO_KEY 
                         + clientId + field);
                 createFieldDebugInfo(facesContext, field,
                         oldValue, newValue, clientId);
             }
         }
         
         /**
          * Gets the real value of the EditableValueHolder component.
          * This is necessary, because if the localValue is set, getValue()
          * normally returns the localValue and not the real value.
          * @param evh
          * @param target
          * @param localValue
          * @param elCtx
          * @return
          */
         private Object _getRealValue(EditableValueHolder evh, UIComponent target,
                 final Object localValue, ELContext elCtx)
         {
             Object value = evh.getValue();
             if (localValue != null && localValue.equals(value))
             {
                 // getValue() normally returns the localValue, if it is set
                 // --> try to get the real value from the ValueExpression
                 ValueExpression valueExpression = target.getValueExpression("value");
                 if (valueExpression != null)
                 {
                     value = valueExpression.getValue(elCtx);
                 }
             }
             return value;
         }
         
     }
     
     private boolean _afterPhase = false;
     private PhaseId _currentPhase;
     private DebugVisitCallback _visitCallback = new DebugVisitCallback();
 
     public void afterPhase(PhaseEvent event)
     {
         _doTreeVisit(event, true);
     }
 
     public void beforePhase(PhaseEvent event)
     {
         _doTreeVisit(event, false);
     }
 
     public PhaseId getPhaseId()
     {
         return PhaseId.ANY_PHASE;
     }
     
     private void _doTreeVisit(PhaseEvent event, boolean afterPhase)
     {
         _afterPhase = afterPhase;
         _currentPhase = event.getPhaseId();
         
         // visitTree() on the UIViewRoot
         UIViewRoot viewroot = event.getFacesContext().getViewRoot();
         if (viewroot != null)
         {
             // skip all unrendered components to really only show
             // the rendered components and to circumvent data access problems
             viewroot.visitTree(VisitContext.createVisitContext(
                     event.getFacesContext(), null, 
                     EnumSet.of(VisitHint.SKIP_UNRENDERED)),
                     _visitCallback);
         }
     }
 
 }