/*

  * 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.shared.view;

 import java.beans.BeanInfo;

 import java.io.IOException;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import javax.faces.FactoryFinder;

 import javax.faces.application.Resource;

 import javax.faces.application.StateManager;

 import javax.faces.application.ViewHandler;

 import javax.faces.component.UIViewRoot;

 import javax.faces.context.ExternalContext;

 import javax.faces.context.FacesContext;

 import javax.faces.context.ResponseWriter;

 import javax.faces.render.RenderKit;

 import javax.faces.render.RenderKitFactory;

 import javax.faces.view.StateManagementStrategy;

 import javax.faces.view.ViewDeclarationLanguage;

 import javax.faces.view.ViewMetadata;

 import javax.servlet.ServletResponse;

 import javax.servlet.ServletResponseWrapper;

 import javax.servlet.http.HttpServletResponse;

 import org.apache.myfaces.shared.application.DefaultViewHandlerSupport;

 import org.apache.myfaces.shared.application.ViewHandlerSupport;

 import org.apache.myfaces.shared.config.MyfacesConfig;

 public abstract class JspViewDeclarationLanguageBase extends ViewDeclarationLanguageBase

 {

   private static final Logger log = Logger.getLogger(JspViewDeclarationLanguageBase.class.getName());

   private static final String FORM_STATE_MARKER = "<!--@@JSF_FORM_STATE_MARKER@@-->";

   private static final String AFTER_VIEW_TAG_CONTENT_PARAM = JspViewDeclarationLanguageBase.class

               + ".AFTER_VIEW_TAG_CONTENT";

   private static final int FORM_STATE_MARKER_LEN = FORM_STATE_MARKER.length();

   private ViewHandlerSupport _cachedViewHandlerSupport;

   @Override

   public String getId()

   {

       return ViewDeclarationLanguage.JSP_VIEW_DECLARATION_LANGUAGE_ID;

   }

   @Override

   public void buildView(FacesContext context, UIViewRoot view) throws IOException

   {

       // memorize that buildView() has been called for this view

       setViewBuilt(context, view);

       if (context.getPartialViewContext().isPartialRequest())

       {

           // try to get (or create) a ResponseSwitch and turn off the output

           Object origResponse = context.getExternalContext().getResponse();

           ResponseSwitch responseSwitch = getResponseSwitch(origResponse);

           if (responseSwitch == null)

           {

               // no ResponseSwitch installed yet - create one 

               responseSwitch = createResponseSwitch(origResponse);

               if (responseSwitch != null)

               {

                   // install the ResponseSwitch

                   context.getExternalContext().setResponse(responseSwitch);

               }

           }

           if (responseSwitch != null)

           {

               // turn the output off

               responseSwitch.setEnabled(false);

           }

       }

   }

   /**

    * {@inheritDoc}

    */

   @Override

   public BeanInfo getComponentMetadata(FacesContext context, Resource componentResource)

   {

       throw new UnsupportedOperationException();

   }

   /**

    * {@inheritDoc}

    */

   @Override

   public Resource getScriptComponentResource(FacesContext context, Resource componentResource)

   {

       throw new UnsupportedOperationException();

   }

   /**

    * {@inheritDoc}

    */

   @Override

   public void renderView(FacesContext context, UIViewRoot view) throws IOException

   {

       //Try not to use native objects in this class.  Both MyFaces and the bridge

       //provide implementations of buildView but they do not override this class.

       checkNull(context, "context");

       checkNull(view, "view");

       // do not render the view if the rendered attribute for the view is false

       if (!view.isRendered())

       {

           if (log.isLoggable(Level.FINEST))

           {

               log.finest("View is not rendered");

           }

           return;

       }

       // Check if the current view has already been built via VDL.buildView()

       // and if not, build it from here. This is necessary because legacy ViewHandler

       // implementations return null on getViewDeclarationLanguage() and thus

       // VDL.buildView() is never called. Furthermore, before JSF 2.0 introduced 

       // the VDLs, the code that built the view was in ViewHandler.renderView().

       if (!isViewBuilt(context, view))

       {

           buildView(context, view);

       }

       ExternalContext externalContext = context.getExternalContext();

       String viewId = context.getViewRoot().getViewId();

       if (log.isLoggable(Level.FINEST))

       {

           log.finest("Rendering JSP view: " + viewId);

       }

       // handle character encoding as of section 2.5.2.2 of JSF 1.1

       if(null != externalContext.getSession(false))

       {

         externalContext.getSessionMap().put(ViewHandler.CHARACTER_ENCODING_KEY, 

                 externalContext.getResponseCharacterEncoding());

       }

       // render the view in this method (since JSF 1.2)

       RenderKitFactory renderFactory = (RenderKitFactory) FactoryFinder.getFactory(FactoryFinder.RENDER_KIT_FACTORY);

       RenderKit renderKit = renderFactory.getRenderKit(context, view.getRenderKitId());

       ResponseWriter responseWriter = context.getResponseWriter();

       if (responseWriter == null)

       {

           responseWriter = renderKit.createResponseWriter(externalContext.getResponseOutputWriter(), 

                   null, externalContext.getRequestCharacterEncoding());

           context.setResponseWriter(responseWriter);

       }

       // try to enable the ResponseSwitch again (disabled in buildView())

       Object response = context.getExternalContext().getResponse();

       ResponseSwitch responseSwitch = getResponseSwitch(response);

       if (responseSwitch != null)

       {

           responseSwitch.setEnabled(true);

       }

       ResponseWriter oldResponseWriter = responseWriter;

       StringWriter stateAwareWriter = null;

       StateManager stateManager = context.getApplication().getStateManager();

       boolean viewStateAlreadyEncoded = isViewStateAlreadyEncoded(context);

       if (!viewStateAlreadyEncoded)

       {

         // we will need to parse the reponse and replace the view_state token with the actual state

         stateAwareWriter = new StringWriter();

         // Create a new response-writer using as an underlying writer the stateAwareWriter

         // Effectively, all output will be buffered in the stateAwareWriter so that later

         // this writer can replace the state-markers with the actual state.

         responseWriter = oldResponseWriter.cloneWithWriter(stateAwareWriter);

         context.setResponseWriter(responseWriter);

       }

       try

       {

         if (!actuallyRenderView(context, view))

         {

           return;

         }

       }

       finally

       {

         if(oldResponseWriter != null)

         {

             context.setResponseWriter(oldResponseWriter);    

         }

       }

       if (!viewStateAlreadyEncoded)

       {

         // parse the response and replace the token wit the state

         flushBufferToWriter(stateAwareWriter.getBuffer(), externalContext.getResponseOutputWriter());

       }

       else

       {

         stateManager.saveView(context);

       }

       // now disable the ResponseSwitch again

       if (responseSwitch != null)

       {

           responseSwitch.setEnabled(false);

       }

       // Final step - we output any content in the wrappedResponse response from above to the response,

       // removing the wrappedResponse response from the request, we don't need it anymore

       ViewResponseWrapper afterViewTagResponse = (ViewResponseWrapper) externalContext.getRequestMap()

               .get(AFTER_VIEW_TAG_CONTENT_PARAM);

       externalContext.getRequestMap().remove(AFTER_VIEW_TAG_CONTENT_PARAM);

       // afterViewTagResponse is null if the current request is a partial request

       if (afterViewTagResponse != null)

       {

           afterViewTagResponse.flushToWriter(externalContext.getResponseOutputWriter(), 

                   externalContext.getResponseCharacterEncoding());

       }

       //TODO sobryan: Is this right?

       context.getResponseWriter().flush();

   }

   /**

    * {@inheritDoc}

    */

   @Override

   public ViewMetadata getViewMetadata(FacesContext context, String viewId)

   {

       // Not necessary given that this method always returns null, but staying true to

       // the spec.

       checkNull(context, "context");

       //checkNull(viewId, "viewId");

       // JSP impl must return null.

       return null;

   }

   protected boolean isViewStateAlreadyEncoded(FacesContext context)

   {

     if (MyfacesConfig.getCurrentInstance(context.getExternalContext()).isMyfacesImplAvailable())

     {

       // In MyFaces the viewState key is already encoded is server side state saving is being used

       return !context.getApplication().getStateManager().isSavingStateInClient(context);

     }

     else

     {

       return false;

     }

   }

   protected void setAfterViewTagResponseWrapper(ExternalContext ec, ViewResponseWrapper wrapper)

   {

     ec.getRequestMap().put(AFTER_VIEW_TAG_CONTENT_PARAM, wrapper);

   }

   protected void flushBufferToWriter(StringBuffer buff, Writer writer) throws IOException

   {

     FacesContext facesContext = FacesContext.getCurrentInstance();

     StateManager stateManager = facesContext.getApplication().getStateManager();

     StringWriter stateWriter = new StringWriter();

     ResponseWriter realWriter = facesContext.getResponseWriter();

     facesContext.setResponseWriter(realWriter.cloneWithWriter(stateWriter));

     Object serializedView = stateManager.saveView(facesContext);

     stateManager.writeState(facesContext, serializedView);

     facesContext.setResponseWriter(realWriter);

     String state = stateWriter.getBuffer().toString();

     // State markers must be replaced

     int lastFormMarkerPos = 0;

     int formMarkerPos = 0;

     // Find all state markers and write out actual state instead

     while ((formMarkerPos = buff.indexOf(JspViewDeclarationLanguageBase.FORM_STATE_MARKER, formMarkerPos)) > -1)

     {

       // Write content before state marker

       writePartialBuffer(buff, lastFormMarkerPos, formMarkerPos, writer);

       // Write state and move position in buffer after marker

       writer.write(state);

       formMarkerPos += JspViewDeclarationLanguageBase.FORM_STATE_MARKER_LEN;

       lastFormMarkerPos = formMarkerPos;

     }

     // Write content after last state marker

     if (lastFormMarkerPos < buff.length())

     {

       writePartialBuffer(buff, lastFormMarkerPos, buff.length(), writer);

     }

   }

   protected void writePartialBuffer(StringBuffer contentBuffer, int beginIndex, 

           int endIndex, Writer writer) throws IOException

   {

     int index = beginIndex;

     int bufferSize = 2048;

     char[] bufToWrite = new char[bufferSize];

     while (index < endIndex)

     {

       int maxSize = Math.min(bufferSize, endIndex - index);

       contentBuffer.getChars(index, index + maxSize, bufToWrite, 0);

       writer.write(bufToWrite, 0, maxSize);

       index += bufferSize;

     }

   }

   /**

    * Render the view now - properly setting and resetting the response writer

    * [MF] Modified to return a boolean so subclass that delegates can determine

    * whether the rendering succeeded or not. TRUE means success.

    */

   protected boolean actuallyRenderView(FacesContext facesContext, UIViewRoot viewToRender)

       throws IOException

   {

       // Set the new ResponseWriter into the FacesContext, saving the old one aside.

       ResponseWriter responseWriter = facesContext.getResponseWriter();

       // Now we actually render the document

       // Call startDocument() on the ResponseWriter.

       responseWriter.startDocument();

       // Call encodeAll() on the UIViewRoot

       viewToRender.encodeAll(facesContext);

       // Call endDocument() on the ResponseWriter

       responseWriter.endDocument();

       responseWriter.flush();

       // rendered successfully -- forge ahead

       return true;

   }

   @Override

   public StateManagementStrategy getStateManagementStrategy(FacesContext context, String viewId)

   {

       return null;

   }

   @Override

   protected String calculateViewId(FacesContext context, String viewId)

   {

       if (_cachedViewHandlerSupport == null)

       {

           _cachedViewHandlerSupport = new DefaultViewHandlerSupport();

       }

       return _cachedViewHandlerSupport.calculateViewId(context, viewId);

   }

   /**

    * Returns true if the given UIViewRoot has already been built via VDL.buildView().

    * This is necessary because legacy ViewHandler implementations return null on 

    * getViewDeclarationLanguage() and thus VDL.buildView() is never called. 

    * So we have to check this in renderView() and, if it is false, we have to

    * call buildView() manually before the rendering.

    *  

    * @param facesContext

    * @param view

    * @return

    */

   protected boolean isViewBuilt(FacesContext facesContext, UIViewRoot view)

   {

       return Boolean.TRUE.equals(facesContext.getAttributes().get(view));

   }

   /**

    * Saves a flag in the attribute map of the FacesContext to indicate

    * that the given UIViewRoot was already built with VDL.buildView().

    * 

    * @param facesContext

    * @param view

    */

   protected void setViewBuilt(FacesContext facesContext, UIViewRoot view)

   {

       facesContext.getAttributes().put(view, Boolean.TRUE);

   }

   /**

    * Trys to obtain a ResponseSwitch from the Response.

    * @param response

    * @return if found, the ResponseSwitch, null otherwise

    */

   private static ResponseSwitch getResponseSwitch(Object response)

   {

       // unwrap the response until we find a ResponseSwitch

       while (response != null)

       {

           if (response instanceof ResponseSwitch)

           {

               // found

               return (ResponseSwitch) response;

           }

           if (response instanceof ServletResponseWrapper)

           {

               // unwrap

               response = ((ServletResponseWrapper) response).getResponse();

           }

           // no more possibilities to find a ResponseSwitch

           break; 

       }

       return null; // not found

   }

   /**

    * Try to create a ResponseSwitch for this response.

    * @param response

    * @return the created ResponseSwitch, if there is a ResponseSwitch 

    *         implementation for the given response, null otherwise

    */

   private static ResponseSwitch createResponseSwitch(Object response)

   {

       if (response instanceof HttpServletResponse)

       {

           return new HttpServletResponseSwitch((HttpServletResponse) response);

       }

       else if (response instanceof ServletResponse)

       {

           return new ServletResponseSwitch((ServletResponse) response);

       }

       return null;

   }

   /**

    * Writes the response and replaces the state marker tags with the state information for the current context

    */

 /*  private static class StateMarkerAwareWriter extends Writer

   {

     private StringBuilder buf;

     public StateMarkerAwareWriter()

     {

         this.buf = new StringBuilder();

     }

     @Override

     public void close() throws IOException

     {

     }

     @Override

     public void flush() throws IOException

     {

     }

     @Override

     public void write(char[] cbuf, int off, int len) throws IOException

     {

       if ((off < 0) || (off > cbuf.length) || (len < 0) || ((off + len) > cbuf.length) || ((off + len) < 0))

       {

         throw new IndexOutOfBoundsException();

       }

       else if (len == 0)

       {

         return;

       }

       buf.append(cbuf, off, len);

     }

     public StringBuilder getStringBuilder()

     {

       return buf;

     }

   }*/

 }