/*
    * 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.renderkit.html;
  
  import java.io.IOException;
  import java.util.Map;
  import java.util.logging.Logger;
  
  import javax.faces.context.ExternalContext;
  import javax.faces.context.FacesContext;
  import javax.faces.context.ResponseWriter;
  import javax.faces.lifecycle.ClientWindow;
  import javax.faces.render.RenderKitFactory;
  import javax.faces.render.ResponseStateManager;
  
  import org.apache.myfaces.application.StateCache;
  import org.apache.myfaces.application.StateCacheFactory;
  import org.apache.myfaces.application.viewstate.StateCacheFactoryImpl;
  import org.apache.myfaces.buildtools.maven2.plugin.builder.annotation.JSFWebConfigParam;
  import org.apache.myfaces.renderkit.MyfacesResponseStateManager;
  import org.apache.myfaces.renderkit.StateTokenProcessor;
  import org.apache.myfaces.shared.config.MyfacesConfig;
  import org.apache.myfaces.shared.renderkit.html.HTML;
  import org.apache.myfaces.shared.util.StateUtils;
  import org.apache.myfaces.shared.util.WebConfigParamUtils;
  
  /**
   * @author Manfred Geiler (latest modification by $Author$)
   * @version $Revision$ $Date$
   */
  public class HtmlResponseStateManager extends MyfacesResponseStateManager
  {
      private static final Logger log = Logger.getLogger(HtmlResponseStateManager.class.getName());
  
      public static final String STANDARD_STATE_SAVING_PARAM = "javax.faces.ViewState";
      
      private static final String VIEW_STATE_COUNTER = "oam.partial.VIEW_STATE_COUNTER";
      private static final String CLIENT_WINDOW_COUNTER = "oam.partial.CLIENT_WINDOW_COUNTER";
      
      private static final String SESSION_TOKEN = "oam.rsm.SESSION_TOKEN";
  
      /**
       * Define if the state caching code should be handled by the ResponseStateManager or by the StateManager used.
       * <p>
       * This param is used to keep compatibility with previous state managers implementations depending from old myfaces
       * way to deal with this. For example, JspStateManagerImpl requires this param set to false, but by default 
       * it is set to true, to keep aligned with the Reference Implementation (RI). Note also the default StateManagerImpl
       * requires this property set to true in order to work correctly, so if you set this param to false, please
       * remember to add an entry into your faces-config.xml setting up JspStateManagerImpl as the state manager to use.
       * </p> 
       * @deprecated 
       */
      @Deprecated
      @JSFWebConfigParam(since="2.0.6", expectedValues="true, false", defaultValue="true", group="state",
          deprecated=true)
      public static final String INIT_PARAM_HANDLE_STATE_CACHING_MECHANICS
              = "org.apache.myfaces.HANDLE_STATE_CACHING_MECHANICS";
      
      /**
       * Add autocomplete="off" to the view state hidden field. Enabled by default.
       */
      @JSFWebConfigParam(since="2.2.8, 2.1.18, 2.0.24", expectedValues="true, false", 
             defaultValue="true", group="state")
      public static final String INIT_PARAM_AUTOCOMPLETE_OFF_VIEW_STATE = 
              "org.apache.myfaces.AUTOCOMPLETE_OFF_VIEW_STATE";
              
      private StateCacheFactory _stateCacheFactory;
      
      private StateTokenProcessor _stateTokenProcessor;
      
      private Boolean _autoCompleteOffViewState;
      
      public HtmlResponseStateManager()
      {
          _stateCacheFactory = new StateCacheFactoryImpl();
          _stateTokenProcessor = new DefaultStateTokenProcessor();
          _autoCompleteOffViewState = null;
      }
      
      @Override
      public void writeState(FacesContext facesContext, Object state) throws IOException
      {
          ResponseWriter responseWriter = facesContext.getResponseWriter();
 
         Object savedStateObject = null;
         
         if (!facesContext.getViewRoot().isTransient())
         {
             // Only if the view is not transient needs to be saved
             savedStateObject = getStateCache(facesContext).encodeSerializedState(facesContext, state);
         }
 
         // write the view state field
         writeViewStateField(facesContext, responseWriter, savedStateObject);
 
         // renderKitId field
         writeRenderKitIdField(facesContext, responseWriter);
         
         // windowId field
         writeWindowIdField(facesContext, responseWriter);
     }
     
     private void writeWindowIdField(FacesContext facesContext, ResponseWriter responseWriter) throws IOException
     {
         ClientWindow clientWindow = facesContext.getExternalContext().getClientWindow();
         if (clientWindow != null)
         {
             responseWriter.startElement(HTML.INPUT_ELEM, null);
             responseWriter.writeAttribute(HTML.TYPE_ATTR, HTML.INPUT_TYPE_HIDDEN, null);
             responseWriter.writeAttribute(HTML.ID_ATTR, generateUpdateClientWindowId(facesContext), null);
             responseWriter.writeAttribute(HTML.NAME_ATTR, ResponseStateManager.CLIENT_WINDOW_PARAM, null);
             responseWriter.writeAttribute(HTML.VALUE_ATTR, clientWindow.getId(), null);
             responseWriter.endElement(HTML.INPUT_ELEM);
         }
     }
     
     @Override
     public void saveState(FacesContext facesContext, Object state)
     {
         if (!facesContext.getViewRoot().isTransient())
         {
             getStateCache(facesContext).saveSerializedView(facesContext, state);
         }
     }
 
     private void writeViewStateField(FacesContext facesContext, ResponseWriter responseWriter, Object savedState)
         throws IOException
     {
         String serializedState = _stateTokenProcessor.encode(facesContext, savedState);
         ExternalContext extContext = facesContext.getExternalContext();
         MyfacesConfig myfacesConfig = MyfacesConfig.getCurrentInstance(extContext);
 
         responseWriter.startElement(HTML.INPUT_ELEM, null);
         responseWriter.writeAttribute(HTML.TYPE_ATTR, HTML.INPUT_TYPE_HIDDEN, null);
         responseWriter.writeAttribute(HTML.NAME_ATTR, STANDARD_STATE_SAVING_PARAM, null);
         if (myfacesConfig.isRenderViewStateId())
         {
             // responseWriter.writeAttribute(HTML.ID_ATTR, STANDARD_STATE_SAVING_PARAM, null);
             // JSF 2.2 if javax.faces.ViewState is used as the id, in portlet
             // case it will be duplicate ids and that not xml friendly.
             responseWriter.writeAttribute(HTML.ID_ATTR,
                 HtmlResponseStateManager.generateUpdateViewStateId(
                     facesContext), null);
         }
         responseWriter.writeAttribute(HTML.VALUE_ATTR, serializedState, null);
         if (this.isAutocompleteOffViewState(facesContext))
         {
             responseWriter.writeAttribute(HTML.AUTOCOMPLETE_ATTR, "off", null);
         }
         responseWriter.endElement(HTML.INPUT_ELEM);
     }
 
     private void writeRenderKitIdField(FacesContext facesContext, ResponseWriter responseWriter) throws IOException
     {
 
         String defaultRenderKitId = facesContext.getApplication().getDefaultRenderKitId();
         if (defaultRenderKitId != null && !RenderKitFactory.HTML_BASIC_RENDER_KIT.equals(defaultRenderKitId))
         {
             responseWriter.startElement(HTML.INPUT_ELEM, null);
             responseWriter.writeAttribute(HTML.TYPE_ATTR, HTML.INPUT_TYPE_HIDDEN, null);
             responseWriter.writeAttribute(HTML.NAME_ATTR, ResponseStateManager.RENDER_KIT_ID_PARAM, null);
             responseWriter.writeAttribute(HTML.VALUE_ATTR, defaultRenderKitId, null);
             responseWriter.endElement(HTML.INPUT_ELEM);
         }
     }
 
     @Override
     public Object getState(FacesContext facesContext, String viewId)
     {
         Object savedState = getSavedState(facesContext);
         if (savedState == null)
         {
             return null;
         }
 
         return getStateCache(facesContext).restoreSerializedView(facesContext, viewId, savedState);
     }
 
     /**
      * Reconstructs the state from the "javax.faces.ViewState" request parameter.
      * 
      * @param facesContext
      *            the current FacesContext
      * 
      * @return the reconstructed state, or <code>null</code> if there was no saved state
      */
     private Object getSavedState(FacesContext facesContext)
     {
         Object encodedState = 
             facesContext.getExternalContext().getRequestParameterMap().get(STANDARD_STATE_SAVING_PARAM);
         if(encodedState==null || (((String) encodedState).length() == 0))
         {
             return null;
         }
 
         Object savedStateObject = _stateTokenProcessor.decode(facesContext, (String)encodedState);
         
         return savedStateObject;
     }
 
     /**
      * Checks if the current request is a postback
      * 
      * @since 1.2
      */
     @Override
     public boolean isPostback(FacesContext context)
     {
         return context.getExternalContext().getRequestParameterMap().containsKey(ResponseStateManager.VIEW_STATE_PARAM);
     }
 
     @Override
     public String getViewState(FacesContext facesContext, Object baseState)
     {
         // If the view is transient, baseState is null, so it should return null.
         // In this way, PartialViewContext will skip <update ...> section related
         // to view state (stateless view does not have state, so it does not need
         // to update the view state section). 
         if (baseState == null)
         {
             return null;
         }
         if (facesContext.getViewRoot().isTransient())
         {
             return null;
         }
         
         Object state = getStateCache(facesContext).saveSerializedView(facesContext, baseState);
 
         return _stateTokenProcessor.encode(facesContext, state);
     }
 
     @Override
     public boolean isStateless(FacesContext context, String viewId)
     {
         if (context.isPostback())
         {
             String encodedState = 
                 context.getExternalContext().getRequestParameterMap().get(STANDARD_STATE_SAVING_PARAM);
             if(encodedState==null || (((String) encodedState).length() == 0))
             {
                 return false;
             }
 
             return _stateTokenProcessor.isStateless(context, encodedState);
         }
         else 
         {
             // "... java.lang.IllegalStateException - if this method is invoked 
             // and the statefulness of the preceding call to writeState(
             // javax.faces.context.FacesContext, java.lang.Object) cannot be determined.
             throw new IllegalStateException(
                 "Cannot decide if the view is stateless or not, since the request is "
                 + "not postback (no preceding writeState(...)).");
         }
     }
 
     @Override
     public String getCryptographicallyStrongTokenFromSession(FacesContext context)
     {
         Map<String, Object> sessionMap = context.getExternalContext().getSessionMap();
         String savedToken = (String) sessionMap.get(SESSION_TOKEN);
         if (savedToken == null)
         {
             savedToken = getStateCache(context).createCryptographicallyStrongTokenFromSession(context);
             sessionMap.put(SESSION_TOKEN, savedToken);
         }
         return savedToken;
     }
     
     @Override
     public boolean isWriteStateAfterRenderViewRequired(FacesContext facesContext)
     {
         return getStateCache(facesContext).isWriteStateAfterRenderViewRequired(facesContext);
     }
 
     protected StateCache getStateCache(FacesContext facesContext)
     {
         return _stateCacheFactory.getStateCache(facesContext);
     }
 
     public static String generateUpdateClientWindowId(FacesContext facesContext)
     {
         // JSF 2.2 section 2.2.6.1 Partial State Rendering
         // According to the javascript doc of jsf.ajax.response,
         //
         // The new syntax looks like this:
         // <update id="<VIEW_ROOT_CONTAINER_CLIENT_ID><SEP>javax.faces.ClientWindow<SEP><UNIQUE_PER_VIEW_NUMBER>">
         //    <![CDATA[...]]>
         // </update>
         //
         // UNIQUE_PER_VIEW_NUMBER aim for portlet case. In that case it is possible to have
         // multiple sections for update. In servlet case there is only one update section per
         // ajax request.
         
         String id;
         char separator = facesContext.getNamingContainerSeparatorChar();
         Integer count = (Integer) facesContext.getAttributes().get(CLIENT_WINDOW_COUNTER);
         if (count == null)
         {
             count = Integer.valueOf(0);
         }
         count += 1;
         id = facesContext.getViewRoot().getContainerClientId(facesContext) + 
             separator + ResponseStateManager.CLIENT_WINDOW_PARAM + separator + count;
         facesContext.getAttributes().put(CLIENT_WINDOW_COUNTER, count);
         return id;
     }
     
     public static String generateUpdateViewStateId(FacesContext facesContext)
     {
         // JSF 2.2 section 2.2.6.1 Partial State Rendering
         // According to the javascript doc of jsf.ajax.response,
         //
         // The new syntax looks like this:
         // <update id="<VIEW_ROOT_CONTAINER_CLIENT_ID><SEP>javax.faces.ViewState<SEP><UNIQUE_PER_VIEW_NUMBER>">
         //    <![CDATA[...]]>
         // </update>
         //
         // UNIQUE_PER_VIEW_NUMBER aim for portlet case. In that case it is possible to have
         // multiple sections for update. In servlet case there is only one update section per
         // ajax request.
         
         String id;
         char separator = facesContext.getNamingContainerSeparatorChar();
         Integer count = (Integer) facesContext.getAttributes().get(VIEW_STATE_COUNTER);
         if (count == null)
         {
             count = Integer.valueOf(0);
         }
         count += 1;
         id = facesContext.getViewRoot().getContainerClientId(facesContext) + 
             separator + ResponseStateManager.VIEW_STATE_PARAM + separator + count;
         facesContext.getAttributes().put(VIEW_STATE_COUNTER, count);
         return id;
     }
 
     private static class DefaultStateTokenProcessor extends StateTokenProcessor
     {
         private static final String STATELESS_TOKEN = "stateless";
 
         @Override
         public Object decode(FacesContext facesContext, String token)
         {
             if (STATELESS_TOKEN.equals(token))
             {
                 // Should not happen, because ResponseStateManager.isStateless(context,viewId) should
                 // catch it first
                 return null;
             }
             Object savedStateObject = StateUtils.reconstruct((String)token, facesContext.getExternalContext());
             return savedStateObject;
         }
 
         @Override
         public String encode(FacesContext facesContext, Object savedStateObject)
         {
             if (facesContext.getViewRoot().isTransient())
             {
                 return STATELESS_TOKEN;
             }
             String serializedState = StateUtils.construct(savedStateObject, facesContext.getExternalContext());
             return serializedState;
         }
 
         @Override
         public boolean isStateless(FacesContext facesContext, String token)
         {
             return STATELESS_TOKEN.equals(token);
         }
     }
     
     private boolean isAutocompleteOffViewState(FacesContext facesContext)
     {
         if (_autoCompleteOffViewState == null)
         {
             _autoCompleteOffViewState = WebConfigParamUtils.getBooleanInitParameter(facesContext.getExternalContext(),
                     INIT_PARAM_AUTOCOMPLETE_OFF_VIEW_STATE, true);
         }
         return _autoCompleteOffViewState;
     }
 }