/*

  * 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 javax.faces.context;

 import java.io.IOException;

 import java.util.Iterator;

 import java.util.Map;

 /**

  * @since 2.0

  */

 public class PartialResponseWriter extends ResponseWriterWrapper

 {

     public static final String RENDER_ALL_MARKER = "javax.faces.ViewRoot";

     public static final String VIEW_STATE_MARKER = "javax.faces.ViewState";

     private ResponseWriter _wrapped;

     private boolean hasChanges;

     private String insertType;

     /**

      * 

      */

     public PartialResponseWriter(ResponseWriter writer)

     {

         _wrapped = writer;

     }

     public void delete(String targetId) throws IOException

     {

         startChanges();

         _wrapped.startElement ("delete", null);

         _wrapped.writeAttribute ("id", targetId, null);

         _wrapped.endElement ("delete");

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public void endDocument() throws IOException

     {

         if (hasChanges)

         {

             // Close the <insert> element, if any.

             //error close the last op if any

             endInsert();

             _wrapped.endElement ("changes");

             hasChanges = false;

         }

         _wrapped.endElement ("partial-response");

     }

     public void endError() throws IOException

     {

         // Close open <error-message> element.

         _wrapped.endCDATA();

         _wrapped.endElement ("error-message");

         _wrapped.endElement ("error");

     }

     public void endEval() throws IOException

     {

         // Close open <eval> element.

         _wrapped.endCDATA();

         _wrapped.endElement ("eval");

     }

     public void endExtension() throws IOException

     {

         _wrapped.endElement ("extension");

     }

     public void endInsert() throws IOException

     {

         if (insertType == null)

         {

             // No insert started; ignore.

             return;

         }

         // Close open <insert> element.

         _wrapped.endCDATA();

         _wrapped.endElement (insertType);

         _wrapped.endElement ("insert");

         insertType = null;

     }

     public void endUpdate() throws IOException

     {

         _wrapped.endCDATA();

         _wrapped.endElement ("update");

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public ResponseWriter getWrapped()

     {

         return _wrapped;

     }

     public void redirect(String url) throws IOException

     {

         _wrapped.startElement ("redirect", null);

         _wrapped.writeAttribute ("url", url, null);

         _wrapped.endElement ("redirect");

     }

     /**

      * {@inheritDoc}

      */

     @Override

     public void startDocument() throws IOException

     {

         // JSF 2.2 section 2.2.6.1 Render Response Partial Processing

         // use writePreamble(...)

         //_wrapped.write ("<?xml version=\"1.0\" encoding=\"utf-8\"?>");

         _wrapped.startElement ("partial-response", null);

         // If by some reason the response has been reset, and the same

         // PartialResponseWriter is used, it is necessary to ensure any 

         // variable is initialized in a consistent state. To do that,

         // the best point is when the document is started.

         hasChanges = false;

         insertType = null;

     }

     public void startError(String errorName) throws IOException

     {

         _wrapped.startElement ("error", null);

         _wrapped.startElement ("error-name", null);

         _wrapped.write (errorName);

         _wrapped.endElement ("error-name");

         _wrapped.startElement ("error-message", null);

         startCDATA();

         // Leave open; caller will write message.

     }

     @Override

     public void startCDATA() throws IOException

     {

         _wrapped.startCDATA();

     }

     @Override

     public void endCDATA() throws IOException

     {

         _wrapped.endCDATA();    

     }

     public void startEval() throws IOException

     {

         startChanges();

         _wrapped.startElement ("eval", null);

         startCDATA();

         // Leave open; caller will write statements.

     }

     public void startExtension(Map<String, String> attributes) throws IOException

     {

         Iterator<String> attrNames;

         startChanges();

         _wrapped.startElement ("extension", null);

         // Write out extension attributes.

         // TODO: schema mentions "id" attribute; not used?

         attrNames = attributes.keySet().iterator();

         while (attrNames.hasNext())

         {

             String attrName = attrNames.next();

             _wrapped.writeAttribute (attrName, attributes.get (attrName), null);

         }

         // Leave open; caller will write extension elements.

     }

     public void startInsertAfter(String targetId) throws IOException

     {

         startInsertCommon ("after", targetId);

     }

     public void startInsertBefore(String targetId) throws IOException

     {

         startInsertCommon ("before", targetId);

     }

     public void startUpdate(String targetId) throws IOException

     {

         startChanges();

         _wrapped.startElement ("update", null);

         _wrapped.writeAttribute ("id", targetId, null);

         startCDATA();

         // Leave open; caller will write content.

     }

     public void updateAttributes(String targetId, Map<String, String> attributes) throws IOException

     {

         Iterator<String> attrNames;

         startChanges();

         _wrapped.startElement ("attributes", null);

         _wrapped.writeAttribute ("id", targetId, null);

         attrNames = attributes.keySet().iterator();

         while (attrNames.hasNext())

         {

             String attrName = attrNames.next();

             _wrapped.startElement ("attribute", null);

             _wrapped.writeAttribute ("name", attrName, null);

             _wrapped.writeAttribute ("value", attributes.get (attrName), null);

             _wrapped.endElement ("attribute");

         }

         _wrapped.endElement ("attributes");

     }

     private void startChanges () throws IOException

     {

         if (!hasChanges)

         {

             _wrapped.startElement ("changes", null);

             hasChanges = true;

         }

     }

     private void startInsertCommon (String type, String targetId) throws IOException

     {

         if (insertType != null)

         {

             // An insert has already been started; ignore.

             return;

         }

         insertType = type;

         startChanges();

         _wrapped.startElement ("insert", null);

         _wrapped.startElement (insertType, null);

         _wrapped.writeAttribute ("id", targetId, null);

         startCDATA();

         // Leave open; caller will write content.

     }

 }