/*
    * 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.flow;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import javax.faces.FacesWrapper;
  import javax.faces.application.ConfigurableNavigationHandler;
  import javax.faces.application.NavigationCase;
  import javax.faces.application.NavigationHandler;
  import javax.faces.application.NavigationHandlerWrapper;
  import javax.faces.context.FacesContext;
  import javax.faces.event.SystemEvent;
  import javax.faces.event.SystemEventListener;
  import javax.faces.flow.Flow;
  import javax.faces.flow.FlowCallNode;
  import javax.faces.flow.FlowHandler;
  import javax.faces.flow.FlowNode;
  import javax.faces.flow.Parameter;
  import javax.faces.flow.ReturnNode;
  import javax.faces.lifecycle.ClientWindow;
  import org.apache.myfaces.event.PostClientWindowAndViewInitializedEvent;
  import org.apache.myfaces.spi.FacesFlowProvider;
  import org.apache.myfaces.spi.FacesFlowProviderFactory;
  
  /**
   *
   * @since 2.2
   * @author Leonardo Uribe
   */
  public class FlowHandlerImpl extends FlowHandler implements SystemEventListener
  {
      private final static String CURRENT_FLOW_STACK = "oam.flow.STACK.";
      private final static String ROOT_LAST_VIEW_ID = "oam.flow.ROOT_LAST_VIEW_ID.";
      
      private final static String RETURN_MODE = "oam.flow.RETURN_MODE";
      private final static String FLOW_RETURN_STACK = "oam.flow.RETURN_STACK.";
      private final static String CURRENT_FLOW_REQUEST_STACK = "oam.flow.REQUEST_STACK.";
      
      private Map<String, Map<String, Flow>> _flowMapByDocumentId;
      private Map<String, Flow> _flowMapById;
      
      private FacesFlowProvider _facesFlowProvider;
      
      public FlowHandlerImpl()
      {
          _flowMapByDocumentId = new ConcurrentHashMap<String, Map<String, Flow>>();
          _flowMapById = new ConcurrentHashMap<String, Flow>();
      }
  
      @Override
      public Flow getFlow(FacesContext context, String definingDocumentId, String id)
      {
          checkNull(context, "context");
          checkNull(definingDocumentId, "definingDocumentId");
          checkNull(id, "id");
          
          // First try the combination.
          Map<String, Flow> flowMap = _flowMapByDocumentId.get(definingDocumentId);
          if (flowMap != null)
          {
              Flow flow = flowMap.get(id);
              if (flow != null)
              {
                  return flow;
              }
          }
          
          //if definingDocumentId is an empty string, 
          if ("".equals(definingDocumentId))
          {
              return _flowMapById.get(id);
          }
          return null;
      }
  
      @Override
      public void addFlow(FacesContext context, Flow toAdd)
      {
         checkNull(context, "context");
         checkNull(toAdd, "toAdd");
         
         String id = toAdd.getId();
         String definingDocumentId = toAdd.getDefiningDocumentId();
         
         if (id == null)
         {
             throw new IllegalArgumentException("Flow must have a non null id");
         }
         else if (id.length() == 0)
         {
             throw new IllegalArgumentException("Flow must have a non empty id");
         }
         if (definingDocumentId == null)
         {
             throw new IllegalArgumentException("Flow must have a non null definingDocumentId");
         }
         
         Map<String, Flow> flowMap = _flowMapByDocumentId.get(definingDocumentId);
         if (flowMap == null)
         {
             flowMap = new ConcurrentHashMap<String, Flow>();
             _flowMapByDocumentId.put(definingDocumentId, flowMap);
         }
         flowMap.put(id, toAdd);
         
         Flow duplicateFlow = _flowMapById.get(id);
         if (duplicateFlow != null)
         {
             // There are two flows with the same flowId.
             // Raise an exception if flows share a duplicate ID and definingDocumentId
             if (toAdd.getDefiningDocumentId().equals(duplicateFlow.getDefiningDocumentId()))
             {
                 throw new IllegalArgumentException("There cannot be multiple flows with both the" 
                                                    + " same ID and the same definingDocumentId");
             }
             // Give priority to the flow with no defining document id
             else if ("".equals(toAdd.getDefiningDocumentId()))
             {
                 _flowMapById.put(id, toAdd);
             }
             else if ("".equals(duplicateFlow.getDefiningDocumentId()))
             {
                 // Already added, skip
             }
             else
             {
                 // Put the last one
                 _flowMapById.put(id, toAdd);
             }
         }
         else
         {
             _flowMapById.put(id, toAdd);
         }
 
         // Once the flow is added to the map, it is still necessary to 
         // pass the flow to the ConfigurableNavigationHandler, so it can be
         // inspected for navigation rules. This is the best place to do that because
         // the spec says "... Called by the flow system to cause the flow to 
         // be inspected for navigation rules... " (note it says "flow system" not
         // "configuration system" where the calls to addFlow() are done).
         invokeInspectFlow(context, context.getApplication().getNavigationHandler(), toAdd);
     }
 
     @Override
     public Flow getCurrentFlow(FacesContext context)
     {
         Object session = context.getExternalContext().getSession(false);
         if (session == null)
         {
             return null;
         }
         ClientWindow clientWindow = context.getExternalContext().getClientWindow();
         if (clientWindow == null)
         {
             return null;
         }
         
         
         _FlowContextualInfo info = getCurrentFlowReference(context, clientWindow);
         if (info == null)
         {
             return null;
         }
         FlowReference flowReference = info.getFlowReference();
         return getFlow(context, flowReference.getDocumentId(), flowReference.getId());
     }
     
     @Override
     public void transition(FacesContext context, Flow sourceFlow, Flow targetFlow, 
         FlowCallNode outboundCallNode, String toViewId)
     {
         checkNull(context, "context");
         checkNull(toViewId, "toViewId");
         ClientWindow clientWindow = context.getExternalContext().getClientWindow();
         boolean outboundCallNodeProcessed = false;
         if (clientWindow == null)
         {
             return;
         }
         
         if (sourceFlow == null && targetFlow == null)
         {
             return;
         }
 
         // Calculate the parentFlowReference, since it will be used later.
         FlowReference parentFlowReference = (outboundCallNode != null && sourceFlow != null) ?
             new FlowReference(sourceFlow.getDefiningDocumentId(), sourceFlow.getId()) : null;
         
         if (sourceFlow == null)
         {
             // Entering a flow
             Map<String, Object> outboundParameters = doBeforeEnterFlow(context, 
                 targetFlow, !outboundCallNodeProcessed ? outboundCallNode : null);
             outboundCallNodeProcessed = true;
             pushFlowReference(context, clientWindow, 
                     new FlowReference(targetFlow.getDefiningDocumentId(), targetFlow.getId()), 
                     toViewId, parentFlowReference);
             doAfterEnterFlow(context, targetFlow, outboundParameters);
         }
         else if (targetFlow == null)
         {
             // Getting out of the flow, since targetFlow is null,
             // we need to take sourceFlow and take it out and all the chain
             List<_FlowContextualInfo> currentFlowStack = getCurrentFlowStack(context, clientWindow);
             if (currentFlowStack != null)
             {
                 removeFlowFromStack(context, currentFlowStack, sourceFlow);
             }
         }
         else
         {
             // Both sourceFlow and targetFlow are not null, if there is no call node set (force enter flow)
             // we need to check the direction
             // If targetFlow is on the stack, remove elements until get there.
             // If targetFlow is not there, add it to the stack.
             List<_FlowContextualInfo> currentFlowStack = getCurrentFlowStack(context, clientWindow);
             if (currentFlowStack != null && outboundCallNode == null)
             {
                 FlowReference targetFlowReference = new FlowReference(
                         targetFlow.getDefiningDocumentId(), targetFlow.getId());
                 int targetFlowIndex = -1;
                 for (int j = currentFlowStack.size()-1; j >= 0; j--)
                 {
                     if (targetFlowReference.equals(currentFlowStack.get(j).getFlowReference()))
                     {
                         targetFlowIndex = j;
                         break;
                     }
                 }
                 if (targetFlowIndex >= 0)
                 {
                     // targetFlow is on the stack, so it is a return.
                     removeFlowFromStack(context, currentFlowStack, sourceFlow);
                 }
                 else
                 {
                     // targetFlow is not on the stack, so it is flow call.
                     Map<String, Object> outboundParameters = doBeforeEnterFlow(context,
                         targetFlow, !outboundCallNodeProcessed ? outboundCallNode : null);
                     outboundCallNodeProcessed = true;
                     pushFlowReference(context, clientWindow, 
                             new FlowReference(targetFlow.getDefiningDocumentId(), targetFlow.getId()), toViewId,
                             parentFlowReference);
                     doAfterEnterFlow(context, targetFlow, outboundParameters);
                 }
             }
             else
             {
                 // sourceFlow and targetFlow are not null, but there is no currentFlowStack. It that
                 // case just enter into targetFlow
                 Map<String, Object> outboundParameters = doBeforeEnterFlow(context, 
                     targetFlow, !outboundCallNodeProcessed ? outboundCallNode : null);
                 outboundCallNodeProcessed = true;
                 pushFlowReference(context, clientWindow, 
                         new FlowReference(targetFlow.getDefiningDocumentId(), targetFlow.getId()), toViewId,
                         parentFlowReference);
                 doAfterEnterFlow(context, targetFlow, outboundParameters);
             }
         }
     }
     
     private void removeFlowFromStack(FacesContext context, List<_FlowContextualInfo> currentFlowStack, Flow sourceFlow)
     {
         // Steps to remove a flow:
         // 1. locate where is the flow in the chain
         int sourceFlowIndex = -1;
         FlowReference sourceFlowReference = new FlowReference(sourceFlow.getDefiningDocumentId(),
             sourceFlow.getId());
         List<_FlowContextualInfo> flowsToRemove = new ArrayList<_FlowContextualInfo>();
         for (int i = currentFlowStack.size()-1; i >= 0; i--)
         {
             _FlowContextualInfo fci = currentFlowStack.get(i);
             if (fci.getFlowReference().equals(sourceFlowReference))
             {
                 sourceFlowIndex = i;
                 flowsToRemove.add(fci);
                 break;
             }
         }
 
         if (sourceFlowIndex != -1)
         {
             // From sourceFlowIndex, remove(add to flowsToRemove list) all flows 
             traverseDependantFlows(sourceFlowReference, sourceFlowIndex+1, currentFlowStack, flowsToRemove);
 
             // Remove all marked elements
             if (!flowsToRemove.isEmpty())
             {
                 for (int i = flowsToRemove.size()-1; i >= 0; i--)
                 {
                     _FlowContextualInfo fci = flowsToRemove.get(i);
                     FlowReference fr = fci.getFlowReference();
                     doBeforeExitFlow(context, getFlow(context, fr.getDocumentId(), fr.getId()));
                     //popFlowReference(context, clientWindow, currentFlowStack, i);
 
                     //Remove flows from the last to the first to keep the right sequence.
                     for (int j = currentFlowStack.size()-1; j >= 0; j--)
                     {
                         if (currentFlowStack.get(j) == fci)
                         {
                             currentFlowStack.remove(j);
                             break;
                         }
                     }
                 }
             }
 
             if (currentFlowStack.isEmpty())
             {
                 // Remove it from session but keep it in request scope.
                 context.getAttributes().put(ROOT_LAST_VIEW_ID, 
                     context.getExternalContext().getSessionMap().remove(ROOT_LAST_VIEW_ID + 
                     context.getExternalContext().getClientWindow().getId()));
             }
         }
     }
     
     private void traverseDependantFlows(FlowReference sourceFlowReference, 
         int index, List<_FlowContextualInfo> currentFlowStack, List<_FlowContextualInfo> flowsToRemove)
     {
         if (index < currentFlowStack.size())
         {
             for (int i = index; i < currentFlowStack.size(); i++)
             {
                 _FlowContextualInfo info = currentFlowStack.get(i);
                 if (sourceFlowReference.equals(info.getSourceFlowReference()) &&
                     !flowsToRemove.contains(info))
                 {
                     flowsToRemove.add(info);
                     traverseDependantFlows(info.getFlowReference(), i+1, currentFlowStack, flowsToRemove);
                 }
             }
         }
     }
     
     private Map<String, Object> doBeforeEnterFlow(FacesContext context, Flow flow, FlowCallNode outboundCallNode)
     {
         Map<String, Object> outboundParameters = null;
         if (outboundCallNode != null && !outboundCallNode.getOutboundParameters().isEmpty())
         {
             outboundParameters = new HashMap<String, Object>();
             for (Map.Entry<String, Parameter> entry : outboundCallNode.getOutboundParameters().entrySet())
             {
                 Parameter parameter = entry.getValue();
                 if (parameter.getValue() != null)
                 {
                     outboundParameters.put(entry.getKey(), parameter.getValue().getValue(context.getELContext()));
                 }
             }
         }
         return outboundParameters;
     }
     
     private void doAfterEnterFlow(FacesContext context, Flow flow, Map<String, Object> outboundParameters)
     {
         getFacesFlowProvider(context).doAfterEnterFlow(context, flow);
         
         if (outboundParameters != null)
         {
             for (Map.Entry<String, Parameter> entry : flow.getInboundParameters().entrySet())
             {
                 Parameter parameter = entry.getValue();
                 if (parameter.getValue() != null && outboundParameters.containsKey(entry.getKey()))
                 {
                     parameter.getValue().setValue(context.getELContext(), outboundParameters.get(entry.getKey()));
                 }
             }
         }
 
         if (flow.getInitializer() != null)
         {
             flow.getInitializer().invoke(context.getELContext(), null);
         }
     }
     
     public FacesFlowProvider getFacesFlowProvider(FacesContext facesContext)
     {
         if (_facesFlowProvider == null)
         {
             FacesFlowProviderFactory factory = 
                 FacesFlowProviderFactory.getFacesFlowProviderFactory(
                     facesContext.getExternalContext());
             _facesFlowProvider = factory.getFacesFlowProvider(
                     facesContext.getExternalContext());
             
             facesContext.getApplication().unsubscribeFromEvent(PostClientWindowAndViewInitializedEvent.class, this);
             facesContext.getApplication().subscribeToEvent(PostClientWindowAndViewInitializedEvent.class, this);
         }
         return _facesFlowProvider;
     }
     
     private void doBeforeExitFlow(FacesContext context, Flow flow)
     {
         if (flow.getFinalizer() != null)
         {
             flow.getFinalizer().invoke(context.getELContext(), null);
         }
         
         getFacesFlowProvider(context).doBeforeExitFlow(context, flow);
     }
 
     @Override
     public boolean isActive(FacesContext context, String definingDocumentId, String id)
     {
         checkNull(context, "context");
         checkNull(definingDocumentId, "definingDocumentId");
         checkNull(id, "id");
         
         Object session = context.getExternalContext().getSession(false);
         if (session == null)
         {
             return false;
         }
         ClientWindow clientWindow = context.getExternalContext().getClientWindow();
         if (clientWindow == null)
         {
             return false;
         }
         Map<String, Object> sessionMap = context.getExternalContext().getSessionMap();
         String currentFlowMapKey = CURRENT_FLOW_STACK + clientWindow.getId();
 
         List<_FlowContextualInfo> currentFlowStack = (List<_FlowContextualInfo>) sessionMap.get(currentFlowMapKey);
         if (currentFlowStack == null)
         {
             return false;
         }
         FlowReference reference = new FlowReference(definingDocumentId, id);
         
         for (_FlowContextualInfo info : currentFlowStack)
         {
             if (reference.equals(info.getFlowReference()))
             {
                 return true;
             }
         }
         return false;
     }
 
     @Override
     public Map<Object, Object> getCurrentFlowScope()
     {
         FacesContext facesContext = FacesContext.getCurrentInstance();
         return getFacesFlowProvider(facesContext).getCurrentFlowScope(facesContext);
     }
 
     /**
      * The interpretation done for this issue is this:
      * 
      * There are two basic cases: Enter into a flow and return from a flow.
      * 
      * - FlowHandler.TO_FLOW_DOCUMENT_ID_REQUEST_PARAM_NAME : value of the toFlowDocumentId property 
      *   of the navigation case when enter into a flow OR FlowHandler.NULL_FLOW when return from a flow.
      * 
      * - FlowHandler.FLOW_ID_REQUEST_PARAM_NAME : value of the fromOutcome property of the navigation case.
      * According to the intention it has multiple options:
      * 
      *  1. It can be a flowId, which means enter into a flow.
      *  2. It can be a flow call id, which means enter into a flow.
      *  3. It can be a flow return id, which means return from a flow.
 
      * - The javadoc of NavigationCase.getToFlowDocumentId() says this:
      * "... If this navigation case represents a flow invocation, this property is the documentId in 
      * which the flow whose id is given by the return from getFromOutcome() is defined. Implementations 
      * must override this method to return the value defined in the corresponding application 
      * configuration resources element. The base implementation returns the empty string. ..."
      * 
      * This is consistent with the previous interpretation, but we need to include the case where 
      * toFlowDocumentId is FlowHandler.NULL_FLOW too, which is derived implicitly. The key of the trick 
      * is override fromOutcome / toFlowDocumentId in the navigation algorithm to indicate when the 
      * navigation case is entering into a flow or return from a flow. In that way, it is possible 
      * to use ConfigurableNavigationHandler.getNavigationCase(...) to know the "route" using the 
      * initial fromOutcome given in FLOW_ID_REQUEST_PARAM_NAME.
      * 
      * @param context 
      */
     @Override
     public void clientWindowTransition(FacesContext context)
     {
         String flowDocumentIdRequestParam = (String) context.getExternalContext().
             getRequestParameterMap().get(FlowHandler.TO_FLOW_DOCUMENT_ID_REQUEST_PARAM_NAME);
         
         if (flowDocumentIdRequestParam != null)
         {
             String flowIdRequestParam = (String) context.getExternalContext().
                 getRequestParameterMap().get(FlowHandler.FLOW_ID_REQUEST_PARAM_NAME);
             
             if (flowIdRequestParam == null)
             {
                 // If we don't have an fromOutcome, it is not possible to calculate the transitions
                 // involved.
                 return;
             }
             
             FlowHandler flowHandler = context.getApplication().getFlowHandler();
             ConfigurableNavigationHandler nh = 
                 (ConfigurableNavigationHandler) context.getApplication().getNavigationHandler();
             
             if (FlowHandler.NULL_FLOW.equals(flowDocumentIdRequestParam))
             {
                 // It is a return node. The trick here is we need to calculate
                 // where the flow should return, because that information was not passed
                 // in the parameters of the link. 
                 String toFlowDocumentId = FlowHandler.NULL_FLOW;
                 String fromOutcome = flowIdRequestParam;
                 //Flow sourceFlow = null;
                 List<Flow> sourceFlows = null;
                 List<Flow> targetFlows = null;
                 
                 boolean failed = false;
                 int i = 0;
                 while (FlowHandler.NULL_FLOW.equals(toFlowDocumentId) && !failed)
                 {
                     Flow currentFlow = flowHandler.getCurrentFlow(context);
                     if (currentFlow == null)
                     {
                         failed = true;
                         break;
                     }
                     String currentLastDisplayedViewId = flowHandler.getLastDisplayedViewId(context);
                     FlowNode node = currentFlow.getNode(fromOutcome);
                     if (node instanceof ReturnNode)
                     {
                         if (targetFlows == null)
                         {
                             sourceFlows = new ArrayList<Flow>(4);
                             targetFlows = new ArrayList<Flow>(4);
                         }
                         // Get the navigation case using the outcome
                         Flow sourceFlow = currentFlow;
                         flowHandler.pushReturnMode(context);
                         currentFlow = flowHandler.getCurrentFlow(context);
                         i++;
                         
                         NavigationCase navCase = nh.getNavigationCase(context, null, 
                             ((ReturnNode) node).getFromOutcome(context), FlowHandler.NULL_FLOW);
 
                         if (navCase == null)
                         {
                             if (currentLastDisplayedViewId != null)
                             {
                                 sourceFlows.add(sourceFlow);
                                 if (currentFlow != null)
                                 {
                                     toFlowDocumentId = currentFlow.getDefiningDocumentId();
                                     targetFlows.add(currentFlow);
                                 }
                                 else
                                 {
                                     // No active flow
                                     toFlowDocumentId = null;
                                     targetFlows.add(null);
                                 }
                             }
                             else
                             {
                                 // Invalid state because no navCase and 
                                 // no saved lastDisplayedViewId into session
                                 failed = true;
                             }
                         }
                         else
                         {
                             if (FlowHandler.NULL_FLOW.equals(navCase.getToFlowDocumentId()))
                             {
                                 fromOutcome = navCase.getFromOutcome();
                             }
                             else
                             {
                                 sourceFlows.add(sourceFlow);
                                 // The absence of FlowHandler.NULL_FLOW means the return went somewhere else.
                                 if (currentFlow != null)
                                 {
                                     toFlowDocumentId = currentFlow.getDefiningDocumentId();
                                     targetFlows.add(currentFlow);
                                 }
                                 else
                                 {
                                     // No active flow
                                     toFlowDocumentId = null;
                                     targetFlows.add(null);
                                 }
                             }
                         }
                     }
                     else
                     {
                         // No return node found in current flow, push it and check 
                         // the next flow
                         flowHandler.pushReturnMode(context);
                         currentFlow = flowHandler.getCurrentFlow(context);
                         i++;
                         if (currentFlow == null)
                         {
                             failed = true;
                         }
                     }
                 }
                 for (int j = 0; j<i; j++)
                 {
                     flowHandler.popReturnMode(context);
                 }
                 if (!failed)
                 {
                     //Call transitions.
                     for (int j = 0; j < targetFlows.size(); j++)
                     {
                         Flow sourceFlow = sourceFlows.get(j);
                         Flow targetFlow = targetFlows.get(j);
                         flowHandler.transition(context, 
                             sourceFlow,
                             targetFlow, null, context.getViewRoot().getViewId());
                         
                     }
                 }
             }
             else
             {
                 // This transition is for start a new flow. In this case 
                 // FlowHandler.FLOW_ID_REQUEST_PARAM_NAME could be the flow name to enter
                 // or the flow call node to activate.
                 // 1. check if is a flow
                 Flow targetFlow = flowHandler.getFlow(context, flowDocumentIdRequestParam, flowIdRequestParam);
                 Flow currentFlow = null;
                 FlowCallNode outboundCallNode = null;
                 FlowNode node = null;
                 if (targetFlow == null)
                 {
                     //Check if is a call flow node
                     List<Flow> activeFlows = FlowHandlerImpl.getActiveFlows(context, flowHandler);
                     for (Flow activeFlow : activeFlows)
                     {
                         node = activeFlow != null ? activeFlow.getNode(flowIdRequestParam) : null;
                         if (node != null && node instanceof FlowCallNode)
                         {
                             outboundCallNode = (FlowCallNode) node;
 
                             String calledFlowDocumentId = outboundCallNode.getCalledFlowDocumentId(context);
                             if (calledFlowDocumentId == null)
                             {
                                 calledFlowDocumentId = activeFlow.getDefiningDocumentId();
                             }
                             targetFlow = flowHandler.getFlow(context, 
                                 calledFlowDocumentId, 
                                 outboundCallNode.getCalledFlowId(context));
                             if (targetFlow == null && !"".equals(calledFlowDocumentId))
                             {
                                 targetFlow = flowHandler.getFlow(context, "", 
                                     outboundCallNode.getCalledFlowId(context));
                             }
                             if (targetFlow != null)
                             {
                                 currentFlow = activeFlow;
                                 break;
                             }
                         }
                     }
                 }
                 
                 if (targetFlow != null)
                 {
                     if (flowHandler.isActive(context, targetFlow.getDefiningDocumentId(), targetFlow.getId()))
                     {
                         Flow baseReturnFlow = flowHandler.getCurrentFlow();
                         if (!(baseReturnFlow.getDefiningDocumentId().equals(targetFlow.getDefiningDocumentId()) &&
                              baseReturnFlow.getId().equals(targetFlow.getId())))
                         {
                             flowHandler.transition(context, 
                                 baseReturnFlow, targetFlow, outboundCallNode, context.getViewRoot().getViewId());
                         }
                         flowHandler.pushReturnMode(context);
                         Flow previousFlow = flowHandler.getCurrentFlow(context);
                         flowHandler.popReturnMode(context);
                         flowHandler.transition(context, 
                                 targetFlow, previousFlow, outboundCallNode, context.getViewRoot().getViewId());
                     }
                     // Invoke transition
                     flowHandler.transition(context, 
                         currentFlow, targetFlow, outboundCallNode, context.getViewRoot().getViewId());
 
                     // Handle 2 or more flow consecutive start.
                     boolean failed = false;
                     
                     String startNodeId = targetFlow.getStartNodeId();
                     while (startNodeId != null && !failed)
                     {
                         NavigationCase navCase = nh.getNavigationCase(context, null, 
                                     startNodeId, targetFlow.getDefiningDocumentId());
                         
                         if (navCase != null && navCase.getToFlowDocumentId() != null)
                         {
                             currentFlow = flowHandler.getCurrentFlow(context);
                             node = currentFlow.getNode(navCase.getFromOutcome());
                             if (node != null && node instanceof FlowCallNode)
                             {
                                 outboundCallNode = (FlowCallNode) node;
                                 
                                 String calledFlowDocumentId = outboundCallNode.getCalledFlowDocumentId(context);
                                 if (calledFlowDocumentId == null)
                                 {
                                     calledFlowDocumentId = currentFlow.getDefiningDocumentId();
                                 }
                                 targetFlow = flowHandler.getFlow(context, 
                                     calledFlowDocumentId, 
                                     outboundCallNode.getCalledFlowId(context));
                                 if (targetFlow == null && !"".equals(calledFlowDocumentId))
                                 {
                                     targetFlow = flowHandler.getFlow(context, "", 
                                         outboundCallNode.getCalledFlowId(context));
                                 }
                             }
                             else
                             {
                                 String calledFlowDocumentId = navCase.getToFlowDocumentId();
                                 if (calledFlowDocumentId == null)
                                 {
                                     calledFlowDocumentId = currentFlow.getDefiningDocumentId();
                                 }
                                 targetFlow = flowHandler.getFlow(context, 
                                     calledFlowDocumentId, 
                                     navCase.getFromOutcome());
                                 if (targetFlow == null && !"".equals(calledFlowDocumentId))
                                 {
                                     targetFlow = flowHandler.getFlow(context, "", 
                                         navCase.getFromOutcome());
                                 }
                             }
                             if (targetFlow != null)
                             {
                                 flowHandler.transition(context, 
                                     currentFlow, targetFlow, outboundCallNode, context.getViewRoot().getViewId());
                                 startNodeId = targetFlow.getStartNodeId();
                             }
                             else
                             {
                                 startNodeId = null;
                             }
                         }
                         else
                         {
                             startNodeId = null;
                         }
                     }
                 }
                 
             }
         }
     }
     
     private void checkNull(final Object o, final String param)
     {
         if (o == null)
         {
             throw new NullPointerException(param + " can not be null.");
         }
     }
     
     private void invokeInspectFlow(FacesContext context, NavigationHandler navHandler, Flow toAdd)
     {
         if (navHandler instanceof ConfigurableNavigationHandler)
         {
             ((ConfigurableNavigationHandler)navHandler).inspectFlow(context, toAdd);
         }
         else if (navHandler instanceof NavigationHandlerWrapper)
         {
             invokeInspectFlow(context, ((NavigationHandlerWrapper)navHandler).getWrapped(), toAdd);
         }
     }
     
     private _FlowContextualInfo getCurrentFlowReference(FacesContext context, ClientWindow clientWindow)
     {
         if ( Boolean.TRUE.equals(context.getAttributes().get(RETURN_MODE)) )
         {
             List<_FlowContextualInfo> returnFlowList = getCurrentReturnModeFlowStack(
                     context, clientWindow, CURRENT_FLOW_REQUEST_STACK);
             if (returnFlowList != null && !returnFlowList.isEmpty())
             {
                 _FlowContextualInfo info = returnFlowList.get(returnFlowList.size()-1);
                 return info;
             }
             return null;
         }
         else
         {
             Map<String, Object> sessionMap = context.getExternalContext().getSessionMap();
             String currentFlowMapKey = CURRENT_FLOW_STACK + clientWindow.getId();
             List<_FlowContextualInfo> currentFlowStack = 
                 (List<_FlowContextualInfo>) sessionMap.get(currentFlowMapKey);
             if (currentFlowStack == null)
             {
                 return null;
             }
             return currentFlowStack.size() > 0 ? 
                 currentFlowStack.get(currentFlowStack.size()-1) : null;
         }
     }
     
     private void pushFlowReference(FacesContext context, ClientWindow clientWindow, FlowReference flowReference,
         String toViewId, FlowReference sourceFlowReference)
     {
         Map<String, Object> sessionMap = context.getExternalContext().getSessionMap();
         String currentFlowMapKey = CURRENT_FLOW_STACK + clientWindow.getId();
         List<_FlowContextualInfo> currentFlowStack = (List<_FlowContextualInfo>) sessionMap.get(currentFlowMapKey);
         if (currentFlowStack == null)
         {
             currentFlowStack = new ArrayList<_FlowContextualInfo>(4);
             sessionMap.put(currentFlowMapKey, currentFlowStack);
         }
         if (!currentFlowStack.isEmpty())
         {
             currentFlowStack.get(currentFlowStack.size()-1).setLastDisplayedViewId(context.getViewRoot().getViewId());
         }
         else
         {
             //Save root lastDisplayedViewId
             context.getExternalContext().getSessionMap().put(ROOT_LAST_VIEW_ID + clientWindow.getId(), 
                 context.getViewRoot().getViewId());
         }
         currentFlowStack.add(new _FlowContextualInfo(flowReference, toViewId, sourceFlowReference));
     }
     
     private List<_FlowContextualInfo> getCurrentFlowStack(FacesContext context, ClientWindow clientWindow)
     {
         Map<String, Object> sessionMap = context.getExternalContext().getSessionMap();
         String currentFlowMapKey = CURRENT_FLOW_STACK + clientWindow.getId();
         List<_FlowContextualInfo> currentFlowStack = (List<_FlowContextualInfo>) sessionMap.get(currentFlowMapKey);
         return currentFlowStack;
     }
 
     @Override
     public String getLastDisplayedViewId(FacesContext context)
     {
         Object session = context.getExternalContext().getSession(false);
         if (session == null)
         {
             return null;
         }
         ClientWindow clientWindow = context.getExternalContext().getClientWindow();
         if (clientWindow == null)
         {
             return null;
         }
         
         _FlowContextualInfo info = getCurrentFlowReference(context, clientWindow);
         if (info == null)
         {
             String lastDisplayedViewId = (String) context.getAttributes().get(ROOT_LAST_VIEW_ID);
             if (lastDisplayedViewId == null)
             {
                 lastDisplayedViewId = (String) context.getExternalContext().getSessionMap().
                     get(ROOT_LAST_VIEW_ID + clientWindow.getId());
             }
             return lastDisplayedViewId;
         }
         return info.getLastDisplayedViewId();
     }
 
     @Override
     public void pushReturnMode(FacesContext context)
     {
         // The return mode is a way to allow NavigationHandler to know the context
         // without expose it. The idea is call pushReturnMode()/popReturnMode() and
         // then check for getCurrentFlow(). 
         //
         // Remember the navigation algorithm is split in two parts:
         // - Calculates the navigation
         // - Perform the navigation
         //
         // Generated links requires only to perform the first one, but the operations
         // are only perfomed when the transition between pages occur or in a get request
         // when there is a pending navigation. 
         ClientWindow clientWindow = context.getExternalContext().getClientWindow();
         
         if (clientWindow == null)
         {
             return;
         }
         
         if ( !Boolean.TRUE.equals(context.getAttributes().get(RETURN_MODE)) )
         {
             // Return mode not active, activate it, copy the current flow stack.
             List<_FlowContextualInfo> currentFlowStack = getCurrentFlowStack(context, clientWindow);
             
             Map<Object, Object> attributesMap = context.getAttributes();
             String returnFlowMapKey = CURRENT_FLOW_REQUEST_STACK + clientWindow.getId();
             List<_FlowContextualInfo> returnFlowStack = new ArrayList<_FlowContextualInfo>(currentFlowStack);
             attributesMap.put(returnFlowMapKey, returnFlowStack);
             context.getAttributes().put(RETURN_MODE, Boolean.TRUE);
         }
         
         _FlowContextualInfo flowReference = popFlowReferenceReturnMode(context, 
             clientWindow, CURRENT_FLOW_REQUEST_STACK);
         pushFlowReferenceReturnMode(context, clientWindow, FLOW_RETURN_STACK, flowReference);
     }
 
     @Override
     public void popReturnMode(FacesContext context)
     {
         ClientWindow clientWindow = context.getExternalContext().getClientWindow();
         
         if (clientWindow == null)
         {
             return;
         }
         
         _FlowContextualInfo flowReference = popFlowReferenceReturnMode(context, clientWindow, FLOW_RETURN_STACK);
         pushFlowReferenceReturnMode(context, clientWindow, CURRENT_FLOW_REQUEST_STACK, flowReference);
         
         Map<Object, Object> attributesMap = context.getAttributes();
         String returnFlowMapKey = FLOW_RETURN_STACK + clientWindow.getId();
         List<_FlowContextualInfo> returnFlowStack = (List<_FlowContextualInfo>) attributesMap.get(returnFlowMapKey);
         if (returnFlowStack != null && returnFlowStack.isEmpty())
         {
             context.getAttributes().put(RETURN_MODE, Boolean.FALSE);
         }
     }
     
     public List<Flow> getActiveFlows(FacesContext context)
     {
         Object session = context.getExternalContext().getSession(false);
         if (session == null)
         {
             return Collections.emptyList();
         }
         ClientWindow clientWindow = context.getExternalContext().getClientWindow();
         if (clientWindow == null)
         {
             return Collections.emptyList();
         }
         if ( Boolean.TRUE.equals(context.getAttributes().get(RETURN_MODE)) )
         {
             // Use the standard form
             FlowHandler fh = context.getApplication().getFlowHandler();
             Flow curFlow = fh.getCurrentFlow(context);
             if (curFlow != null)
             {
                 List<Flow> activeFlows = new ArrayList<Flow>();
                 while (curFlow != null)
                 {
                     activeFlows.add(curFlow);
                     fh.pushReturnMode(context);
                     curFlow = fh.getCurrentFlow(context);
                 }
 
                 for (int i = 0; i < activeFlows.size(); i++)
                 {
                     fh.popReturnMode(context);
                 }
                 return activeFlows;
             }
             else
             {
                 return Collections.emptyList();
             }
         }
         else
         {
             Map<String, Object> sessionMap = context.getExternalContext().getSessionMap();
             String currentFlowMapKey = CURRENT_FLOW_STACK + clientWindow.getId();
 
             List<_FlowContextualInfo> currentFlowStack = (List<_FlowContextualInfo>) sessionMap.get(currentFlowMapKey);
             if (currentFlowStack == null)
             {
                 return Collections.emptyList();
             }
 
             if (!currentFlowStack.isEmpty())
             {
                 List<Flow> activeFlows = new ArrayList<Flow>();
                 for(_FlowContextualInfo info : currentFlowStack)
                 {
                     activeFlows.add(0, getFlow(context, 
                         info.getFlowReference().getDocumentId(), 
                         info.getFlowReference().getId()));
                 }
                 return activeFlows;
             }
 
             return Collections.emptyList();
         }
     }
 
     private void pushFlowReferenceReturnMode(FacesContext context, ClientWindow clientWindow,
             String stackKey, _FlowContextualInfo flowReference)
     {
         Map<Object, Object> attributesMap = context.getAttributes();
         String currentFlowMapKey = stackKey + clientWindow.getId();
         List<_FlowContextualInfo> currentFlowStack = (List<_FlowContextualInfo>) attributesMap.get(currentFlowMapKey);
         if (currentFlowStack == null)
         {
             currentFlowStack = new ArrayList<_FlowContextualInfo>(4);
             attributesMap.put(currentFlowMapKey, currentFlowStack);
         }
         currentFlowStack.add(flowReference);
     }
 
     private _FlowContextualInfo popFlowReferenceReturnMode(FacesContext context, ClientWindow clientWindow,
             String stackKey)
     {
         Map<Object, Object> attributesMap = context.getAttributes();
         String currentFlowMapKey = stackKey + clientWindow.getId();
         List<_FlowContextualInfo> currentFlowStack = (List<_FlowContextualInfo>) attributesMap.get(currentFlowMapKey);
         if (currentFlowStack == null)
         {
             return null;
         }
         return currentFlowStack.size() > 0 ? currentFlowStack.remove(currentFlowStack.size()-1) : null;
     }
     
     private List<_FlowContextualInfo> getCurrentReturnModeFlowStack(FacesContext context, ClientWindow clientWindow,
             String stackKey)
     {
         Map<Object, Object> attributesMap = context.getAttributes();
         String currentFlowMapKey = stackKey + clientWindow.getId();
         List<_FlowContextualInfo> currentFlowStack = (List<_FlowContextualInfo>) attributesMap.get(currentFlowMapKey);
         return currentFlowStack;
     }
     
     public static List<Flow> getActiveFlows(FacesContext facesContext, FlowHandler fh)
     {
         FlowHandler flowHandler = fh;
         while (flowHandler != null)
         {
             if (flowHandler instanceof FlowHandlerImpl)
             {
                 break;
             }
             else if (flowHandler instanceof FacesWrapper)
             {
                 flowHandler = ((FacesWrapper<FlowHandler>)flowHandler).getWrapped();
             }
             else
             {
                 flowHandler = null;
             }
         }
         if (flowHandler == null)
         {
             // Use the standard form
             Flow curFlow = fh.getCurrentFlow(facesContext);
             if (curFlow != null)
             {
                 List<Flow> activeFlows = new ArrayList<Flow>();
                 while (curFlow != null)
                 {
                     activeFlows.add(curFlow);
                     fh.pushReturnMode(facesContext);
                     curFlow = fh.getCurrentFlow(facesContext);
                 }
 
                 for (int i = 0; i < activeFlows.size(); i++)
                 {
                     fh.popReturnMode(facesContext);
                 }
                 return activeFlows;
             }
             else
             {
                 return Collections.emptyList();
             }
         }
         else
         {
             FlowHandlerImpl flowHandlerImpl = (FlowHandlerImpl) flowHandler;
             return flowHandlerImpl.getActiveFlows(facesContext);
         }
     }
 
     @Override
     public boolean isListenerForSource(Object source)
     {
         return source instanceof ClientWindow;
     }
 
     @Override
     public void processEvent(SystemEvent event)
     {
         // refresh client window to faces flow provider
         FacesContext facesContext = FacesContext.getCurrentInstance();
         FacesFlowProvider provider = getFacesFlowProvider(facesContext);
         provider.refreshClientWindow(facesContext);
     }
 
 }