/*
    * 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.context.servlet;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  
  import javax.faces.FactoryFinder;
  import javax.faces.application.ApplicationFactory;
  import javax.faces.application.FacesMessage;
  import javax.faces.context.ExternalContext;
  import javax.faces.context.FacesContext;
  import javax.faces.context.PartialViewContext;
  import javax.faces.context.PartialViewContextFactory;
  import javax.faces.context.ResponseStream;
  import javax.faces.context.ResponseWriter;
  import javax.faces.event.PhaseId;
  import javax.faces.render.RenderKit;
  import javax.faces.render.RenderKitFactory;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletRequest;
  import javax.servlet.ServletResponse;
  
  import org.apache.myfaces.context.ReleaseableExternalContext;
  import org.apache.myfaces.context.ReleaseableFacesContextFactory;
  import org.apache.myfaces.shared.util.NullIterator;
  
  /**
   * @author Manfred Geiler (latest modification by $Author$)
   * @author Anton Koinov
   * @version $Revision$ $Date$
   */
  public class FacesContextImpl extends FacesContextImplBase
  {
  
      private static final String METHOD_RESPONSEWRITER = "responseWriter";
      static final String RE_SPLITTER = "[\\s\\t\\r\\n]*\\,[\\s\\t\\r\\n]*";
      
      // ~ Instance fields ----------------------------------------------------------------------------
      
      private Map<String, List<FacesMessage>> _messages = null;
      private List<FacesMessage> _orderedMessages = null;
      private PhaseId _currentPhaseId;
      private ResponseStream _responseStream = null;
      private ResponseWriter _responseWriter = null;
      private FacesMessage.Severity _maximumSeverity = null;
      private boolean _renderResponse = false;
      private boolean _responseComplete = false;
      private boolean _validationFailed = false;
      private PartialViewContext _partialViewContext = null;
      private ReleaseableFacesContextFactory _facesContextFactory = null;
      
      private PartialViewContextFactory _partialViewContextFactory = null;
      private RenderKitFactory _renderKitFactory = null;
  
      // ~ Constructors -------------------------------------------------------------------------------
      
      /**
       * Creates a FacesContextImpl with a ServletExternalContextImpl.
       */
      public FacesContextImpl(final ServletContext servletContext, final ServletRequest servletRequest,
                              final ServletResponse servletResponse)
      {
          this(new ServletExternalContextImpl(servletContext, servletRequest, servletResponse));
      }
      
      /**
       * Private constructor used in internal construtor chain.
       * @param externalContext
       */
      private FacesContextImpl(ServletExternalContextImpl externalContext)
      {
          this(externalContext, externalContext, null);
      }
      
      /**
       * Creates a FacesContextImpl with the given ExternalContext,
       * ReleaseableExternalContext and ReleaseableFacesContextFactory.
       * @param externalContext
      * @param defaultExternalContext
      * @param facesContextFactory
      */
     public FacesContextImpl(final ExternalContext externalContext,
             final ReleaseableExternalContext defaultExternalContext , 
             final ReleaseableFacesContextFactory facesContextFactory)
     {
         // setCurrentInstance is called in constructor of super class
         super(externalContext, defaultExternalContext);
         
         _facesContextFactory = facesContextFactory;
     }
     
     public FacesContextImpl(final ExternalContext externalContext,
             final ReleaseableExternalContext defaultExternalContext , 
             final ReleaseableFacesContextFactory facesContextFactory,
             final ApplicationFactory applicationFactory,
             final RenderKitFactory renderKitFactory,
             final PartialViewContextFactory partialViewContextFactory)
     {
         // setCurrentInstance is called in constructor of super class
         super(externalContext, defaultExternalContext, applicationFactory, 
                 renderKitFactory);
         
         _facesContextFactory = facesContextFactory;
         _renderKitFactory = renderKitFactory;
         _partialViewContextFactory = partialViewContextFactory;
     }
 
     // ~ Methods ------------------------------------------------------------------------------------
     
     @Override
     public final void release()
     {
         assertNotReleased();
 
         _messages = null;
         _orderedMessages = null;
         _currentPhaseId = null;
         _responseStream = null;
         _responseWriter = null;
         _maximumSeverity = null;
         _partialViewContext = null;
         _renderKitFactory = null;
         _partialViewContextFactory = null;
 
         if (_facesContextFactory != null)
         {
             _facesContextFactory.release();
             _facesContextFactory = null;
         }
 
         // release FacesContextImplBase (sets current instance to null)
         super.release();
     }
     
     @Override
     public final FacesMessage.Severity getMaximumSeverity()
     {
         assertNotReleased();
 
         return _maximumSeverity;
     }
     
     @Override
     public final void addMessage(final String clientId, final FacesMessage message)
     {
         assertNotReleased();
 
         if (message == null)
         {
             throw new NullPointerException("message");
         }
 
         if (_messages == null)
         {
             _messages = new LinkedHashMap<String, List<FacesMessage>>();
             _orderedMessages = new ArrayList<FacesMessage>();
         }
         
         List<FacesMessage> lst = _messages.get(clientId); 
         if (lst == null)
         {
             lst = new ArrayList<FacesMessage>();
             _messages.put(clientId, lst);
         }
         
         lst.add(message);
         _orderedMessages.add (message);
         
         FacesMessage.Severity serSeverity = message.getSeverity();
         if (serSeverity != null)
         {
             if (_maximumSeverity == null)
             {
                 _maximumSeverity = serSeverity;
             }
             else if (serSeverity.compareTo(_maximumSeverity) > 0)
             {
                 _maximumSeverity = serSeverity;
             }
         }
     }
 
     @Override
     public List<FacesMessage> getMessageList()
     {
         assertNotReleased();
         
         if (_messages == null)
         {
             return Collections.unmodifiableList(Collections.<FacesMessage>emptyList());
         }
         
         return Collections.unmodifiableList(_orderedMessages);
     }
 
     @Override
     public List<FacesMessage> getMessageList(String clientId)
     {
         assertNotReleased();
         
         if (_messages == null || !_messages.containsKey(clientId))
         {
             return Collections.unmodifiableList(Collections.<FacesMessage>emptyList());
         }
         
         return _messages.get(clientId);
     }
 
     @Override
     public final Iterator<FacesMessage> getMessages()
     {
         assertNotReleased();
 
         if (_messages == null)
         {
             return NullIterator.instance();
         }
         
         return _orderedMessages.iterator();
     }
 
     @Override
     public final Iterator<FacesMessage> getMessages(final String clientId)
     {
 
         assertNotReleased();
 
         if (_messages == null || !_messages.containsKey(clientId))
         {
             return NullIterator.instance();
         }
         
         return _messages.get(clientId).iterator();        
     }
     
     @Override
     public final Iterator<String> getClientIdsWithMessages()
     {
         assertNotReleased();
 
         if (_messages == null || _messages.isEmpty())
         {
             return NullIterator.instance();
         }
         
         return _messages.keySet().iterator();
     }
     
     @Override
     public PhaseId getCurrentPhaseId()
     {
         assertNotReleased();
 
         return _currentPhaseId;
     }
     
     @Override
     public void setCurrentPhaseId(PhaseId currentPhaseId)
     {
         assertNotReleased();
 
         _currentPhaseId = currentPhaseId;
     }
     
     @Override
     public PartialViewContext getPartialViewContext()
     {
         assertNotReleased();
 
         if (_partialViewContext == null)
         {
             //Get through factory finder
             if (_partialViewContextFactory == null)
             {
                 _partialViewContextFactory = (PartialViewContextFactory)
                     FactoryFinder.getFactory(FactoryFinder.PARTIAL_VIEW_CONTEXT_FACTORY);
             }
             // Put actual facesContext as param, not this - this can be wrapped
             _partialViewContext = _partialViewContextFactory.getPartialViewContext(getCurrentFacesContext());
         }
         return _partialViewContext;
     }
 
     @Override
     public final boolean getRenderResponse()
     {
         assertNotReleased();
 
         return _renderResponse;
     }
     
     @Override
     public final void renderResponse()
     {
         assertNotReleased();
 
         _renderResponse = true;
     }
 
     @Override
     public final boolean getResponseComplete()
     {
         assertNotReleased();
 
         return _responseComplete;
     }
     
     @Override
     public final void responseComplete()
     {
         assertNotReleased();
 
         _responseComplete = true;
     }
 
     @Override
     public final void setResponseStream(final ResponseStream responseStream)
     {
         assertNotReleased();
 
         if (responseStream == null)
         {
             throw new NullPointerException("responseStream");
         }
         _responseStream = responseStream;
     }
 
     @Override
     public final ResponseStream getResponseStream()
     {
         assertNotReleased();
 
         return _responseStream;
     }
 
     @Override
     public final void setResponseWriter(final ResponseWriter responseWriter)
     {
         assertNotReleased();
 
         if (responseWriter == null)
         {
             throw new NullPointerException(METHOD_RESPONSEWRITER);
         }
         _responseWriter = responseWriter;
     }
 
     @Override
     public final ResponseWriter getResponseWriter()
     {
         assertNotReleased();
 
         return _responseWriter;
     }
 
     @Override
     public boolean isPostback()
     {
         assertNotReleased();
 
         RenderKit renderKit = getRenderKit();
         FacesContext facesContext = getCurrentFacesContext();
         if (renderKit == null)
         {
             // NullPointerException with StateManager, because
             // to restore state it first restore structure,
             // then fill it and in the middle of the two previous
             // process there is many calls from _ComponentChildrenList.childAdded
             // to facesContext.isPostback, and getViewRoot is null.
             // 
             // Setting a "phantom" UIViewRoot calling facesContext.setViewRoot(viewRoot)
             // to avoid it is bad, because this is work of RestoreViewExecutor,
             // and theorically ViewHandler.restoreView must return an UIViewRoot
             // instance.
             //
             // The problem with this is if the user changes the renderkit directly
             // using f:view renderKitId param, the ResponseStateManager returned
             // will be the one tied to faces-config selected RenderKit. But the usual 
             // method to check if a request is a postback, is always detect the param
             // javax.faces.ViewState, so there is no problem after all.
             String renderKitId = facesContext.getApplication().getViewHandler().calculateRenderKitId(facesContext);
             if (_renderKitFactory == null)
             {
                 _renderKitFactory = (RenderKitFactory) 
                     FactoryFinder.getFactory(FactoryFinder.RENDER_KIT_FACTORY);
             }
             renderKit = _renderKitFactory.getRenderKit(facesContext, renderKitId);
         }
         return renderKit.getResponseStateManager().isPostback(facesContext);
     }
 
     @Override
     public void validationFailed()
     {
         assertNotReleased();
         
         _validationFailed=true;
     }
 
     @Override
     public boolean isValidationFailed()
     {
         assertNotReleased();
         
         return _validationFailed;
     }
     
 }