/*
    * 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.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import javax.el.MethodExpression;
  import javax.faces.application.NavigationCase;
  import javax.faces.context.FacesContext;
  import javax.faces.flow.Flow;
  import javax.faces.flow.FlowCallNode;
  import javax.faces.flow.FlowNode;
  import javax.faces.flow.MethodCallNode;
  import javax.faces.flow.Parameter;
  import javax.faces.flow.ReturnNode;
  import javax.faces.flow.SwitchNode;
  import javax.faces.flow.ViewNode;
  import javax.faces.lifecycle.ClientWindow;
  
  /**
   *
   * @since 2.2
   * @author Leonardo Uribe
   */
  public class FlowImpl extends Flow implements Freezable
  {
      private MethodExpression _initializer;
      private MethodExpression _finalizer;
      private String _startNodeId;
      private String _id;
      private String _definingDocumentId;
      
      private Map<String, FlowNode> _flowNodeMap;
      
      // The idea is use a normal HashMap, since there will not be modifications
      // after initialization ( all setters must call checkInitialized() )
      private Map<String, Parameter> _inboundParametersMap;
      private Map<String, FlowCallNode> _flowCallsMap;
      private List<MethodCallNode> _methodCallsList;
      private Map<String, ReturnNode> _returnsMap;
      private Map<String, SwitchNode> _switchesMap;
      private List<ViewNode> _viewsList;
      
      // Note this class should be thread safe and inmutable once
      // the flow is initialized or placed into service by the runtime.
      private Map<String, Parameter> _unmodifiableInboundParametersMap;
      private Map<String, FlowCallNode> _unmodifiableFlowCallsMap;
      private List<MethodCallNode> _unmodifiableMethodCallsList;
      private Map<String, ReturnNode> _unmodifiableReturnsMap;
      private Map<String, SwitchNode> _unmodifiableSwitchesMap;
      private List<ViewNode> _unmodifiableViewsList;
      
      private Map<String, Set<NavigationCase>> _navigationCases;
      private Map<String, Set<NavigationCase>> _unmodifiableNavigationCases;
      
      // No need to make it volatile, because FlowImpl instances are
      // created and initialized only at application startup, by a single
      // thread.
      private boolean _initialized;
      
      public FlowImpl()
      {
          _flowNodeMap = new HashMap<String, FlowNode>();
          _inboundParametersMap = new HashMap<String, Parameter>();
          _flowCallsMap = new HashMap<String, FlowCallNode>();
          _methodCallsList = new ArrayList<MethodCallNode>();
          _returnsMap = new HashMap<String, ReturnNode>();
          _switchesMap = new HashMap<String, SwitchNode>();
          _viewsList = new ArrayList<ViewNode>();
          _navigationCases = new HashMap<String, Set<NavigationCase>>();
          
          // Collections.unmodifiableMap(...) uses delegation pattern, so as long
          // as we don't modify _inboundParametersMap in the wrong time, it
          // will be thread safe and inmutable.
          _unmodifiableInboundParametersMap = Collections.unmodifiableMap(_inboundParametersMap);
          _unmodifiableFlowCallsMap = Collections.unmodifiableMap(_flowCallsMap);
          _unmodifiableMethodCallsList = Collections.unmodifiableList(_methodCallsList);
          _unmodifiableReturnsMap = Collections.unmodifiableMap(_returnsMap);
         _unmodifiableSwitchesMap = Collections.unmodifiableMap(_switchesMap);
         _unmodifiableViewsList = Collections.unmodifiableList(_viewsList);
         
         _unmodifiableNavigationCases = Collections.unmodifiableMap(_navigationCases);
     }
     
     public void freeze()
     {
         
         
         _initialized = true;
         
         for (Map.Entry<String, Parameter> entry : _inboundParametersMap.entrySet())
         {
             if (entry.getValue() instanceof Freezable)
             {
                 ((Freezable)entry.getValue()).freeze();
             }
         }
             
         for (Map.Entry<String, FlowCallNode> entry : _flowCallsMap.entrySet())
         {
             if (entry.getValue() instanceof Freezable)
             {
                 ((Freezable)entry.getValue()).freeze();
             }
         }
 
         for (MethodCallNode value : _methodCallsList)
         {
             if (value instanceof Freezable)
             {
                 ((Freezable)value).freeze();
             }
         }
 
         for (Map.Entry<String, ReturnNode> entry : _returnsMap.entrySet())
         {
             if (entry.getValue() instanceof Freezable)
             {
                 ((Freezable)entry.getValue()).freeze();
             }
         }
 
         for (Map.Entry<String, SwitchNode> entry : _switchesMap.entrySet())
         {
             if (entry.getValue() instanceof Freezable)
             {
                 ((Freezable)entry.getValue()).freeze();
             }
         }
         
         for (ViewNode value : _viewsList)
         {
             if (value instanceof Freezable)
             {
                 ((Freezable)value).freeze();
             }
         }
     }
 
     @Override
     public String getClientWindowFlowId(ClientWindow curWindow)
     {
         String id = getId();
         String documentId = getDefiningDocumentId();
         // Faces Flow relies on ClientWindow feature, so it should be enabled,
         // and the expected id cannot be null.
         String windowId = curWindow.getId();
         StringBuilder sb = new StringBuilder( id.length() + 1 + windowId.length() );
         sb.append(windowId).append('_').append(documentId).append('_').append(id);
         return sb.toString();
     }
 
     @Override
     public String getDefiningDocumentId()
     {
         return _definingDocumentId;
     }
     
     public void setDefiningDocumentId(String definingDocumentId)
     {
         checkInitialized();
         _definingDocumentId = definingDocumentId;
     }
 
     @Override
     public String getId()
     {
         return _id;
     }
     
     public void setId(String id)
     {
         checkInitialized();
         _id = id;
     }
 
     @Override
     public MethodExpression getInitializer()
     {
         return _initializer;
     }
     
     public void setInitializer(MethodExpression initializer)
     {
         checkInitialized();
         _initializer = initializer;
     }
 
     @Override
     public MethodExpression getFinalizer()
     {
         return _finalizer;
     }
     
     public void setFinalizer(MethodExpression finalizer)
     {
         checkInitialized();
         _finalizer = finalizer;
     }
 
     @Override
     public String getStartNodeId()
     {
         return _startNodeId;
     }
     
     public void setStartNodeId(String startNodeId)
     {
         checkInitialized();
         _startNodeId = startNodeId;
     }
     
     @Override
     public Map<String, Parameter> getInboundParameters()
     {
         return _unmodifiableInboundParametersMap;
     }
     
     public void putInboundParameter(String key, Parameter value)
     {
         checkInitialized();
         _inboundParametersMap.put(key, value);
     }
     
     @Override
     public Map<String, FlowCallNode> getFlowCalls()
     {
         return _unmodifiableFlowCallsMap;
     }
     
     public void putFlowCall(String key, FlowCallNode value)
     {
         checkInitialized();
         _flowCallsMap.put(key, value);
         _flowNodeMap.put(value.getId(), value);
     }
 
     @Override
     public List<MethodCallNode> getMethodCalls()
     {
         return _unmodifiableMethodCallsList;
     }
 
     public void addMethodCall(MethodCallNode value)
     {
         checkInitialized();
         _methodCallsList.add(value);
         _flowNodeMap.put(value.getId(), value);
     }
 
     @Override
     public Map<String, ReturnNode> getReturns()
     {
         return _unmodifiableReturnsMap;
     }
     
     public void putReturn(String key, ReturnNode value)
     {
         checkInitialized();
         _returnsMap.put(key, value);
         _flowNodeMap.put(value.getId(), value);
     }
 
     @Override
     public Map<String, SwitchNode> getSwitches()
     {
         return _unmodifiableSwitchesMap;
     }
     
     public void putSwitch(String key, SwitchNode value)
     {
         checkInitialized();
         _switchesMap.put(key, value);
         _flowNodeMap.put(value.getId(), value);
     }
 
     @Override
     public List<ViewNode> getViews()
     {
         return _unmodifiableViewsList;
     }
     
     public void addView(ViewNode value)
     {
         checkInitialized();
         _viewsList.add(value);
         _flowNodeMap.put(value.getId(), value);
     }
 
     @Override
     public FlowCallNode getFlowCall(Flow targetFlow)
     {
         FacesContext facesContext = null;
         for (Map.Entry<String, FlowCallNode> entry : _flowCallsMap.entrySet())
         {
             if (facesContext == null)
             {
                 facesContext = FacesContext.getCurrentInstance();
             }
             String calledDocumentId = entry.getValue().getCalledFlowDocumentId(facesContext);
             String calledFlowId = entry.getValue().getCalledFlowId(facesContext);
             if (targetFlow.getDefiningDocumentId().equals(calledDocumentId) &&
                 targetFlow.getId().equals(calledFlowId) )
             {
                 return entry.getValue();
             }
         }
         return null;
     }
     
     @Override
     public FlowNode getNode(String nodeId)
     {
         return _flowNodeMap.get(nodeId);
     }
     
     public void addNavigationCases(String fromViewId, Set<NavigationCase> navigationCases)
     {
         checkInitialized();
         Set<NavigationCase> navigationCaseSet = _navigationCases.get(fromViewId);
         if (navigationCaseSet == null)
         {
             navigationCaseSet = new HashSet<NavigationCase>();
             _navigationCases.put(fromViewId, navigationCaseSet);
         }
         navigationCaseSet.addAll(navigationCases);
     }
     
     public void addNavigationCase(NavigationCase navigationCase)
     {
         checkInitialized();
         Set<NavigationCase> navigationCaseSet = _navigationCases.get(navigationCase.getFromViewId());
         if (navigationCaseSet == null)
         {
             navigationCaseSet = new HashSet<NavigationCase>();
             _navigationCases.put(navigationCase.getFromViewId(), navigationCaseSet);
         }
         navigationCaseSet.add(navigationCase);
     }
     
     public void removeNavigationCase(NavigationCase navigationCase)
     {
         checkInitialized();
         Set<NavigationCase> navigationCaseSet = _navigationCases.get(navigationCase.getFromViewId());
         if (navigationCaseSet == null)
         {
             return;
         }
         navigationCaseSet.remove(navigationCase);
     }
 
     private void checkInitialized() throws IllegalStateException
     {
         if (_initialized)
         {
             throw new IllegalStateException("Flow is inmutable once initialized");
         }
     }
 
     @Override
     public Map<String, Set<NavigationCase>> getNavigationCases()
     {
         return _unmodifiableNavigationCases;
     }
     
 }