/*
    * 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.renderkit.html;
  
  import java.io.IOException;
  import java.io.Writer;
  import java.nio.charset.Charset;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  import javax.el.ValueExpression;
  
  import javax.faces.FacesException;
  import javax.faces.component.UIComponent;
  import javax.faces.context.FacesContext;
  import javax.faces.context.ResponseWriter;
  import javax.faces.render.Renderer;
  
  import org.apache.myfaces.shared.config.MyfacesConfig;
  import org.apache.myfaces.shared.renderkit.ContentTypeUtils;
  import org.apache.myfaces.shared.renderkit.RendererUtils;
  import org.apache.myfaces.shared.renderkit.html.util.UnicodeEncoder;
  import org.apache.myfaces.shared.util.CommentUtils;
  import org.apache.myfaces.shared.util.StreamCharBuffer;
  
  public class HtmlResponseWriterImpl
          extends ResponseWriter
  {
      //private static final Log log = LogFactory.getLog(HtmlResponseWriterImpl.class);
      private static final Logger log = Logger.getLogger(HtmlResponseWriterImpl.class.getName());
  
      private static final String DEFAULT_CONTENT_TYPE = "text/html";
      private static final String DEFAULT_CHARACTER_ENCODING = "ISO-8859-1";
      private static final String UTF8 = "UTF-8";
  
      private static final String APPLICATION_XML_CONTENT_TYPE = "application/xml";
      private static final String TEXT_XML_CONTENT_TYPE = "text/xml";
      
      //private boolean _writeDummyForm = false;
      //private Set _dummyFormParams = null;
  
      /**
       * The writer used as output, or in other words, the one passed on the constructor
       */
      private Writer _outputWriter;
      
      /**
       * The writer we are using to store data.
       */
      private Writer _currentWriter;
      
      /**
       * The writer used to buffer script and style content
       */
      private StreamCharBuffer _buffer;
      
      private String _contentType;
      
      private String _writerContentTypeMode;
      
      /**
       * This var prevents check if the contentType is for xhtml multiple times.
       */
      private boolean _isXhtmlContentType;
      
      /**
       * Indicate the current response writer should not close automatically html elements
       * and let the writer close them.
       */
      private boolean _useStraightXml;
      
      private String _characterEncoding;
      private boolean _wrapScriptContentWithXmlCommentTag;
      private boolean _isUTF8;
      
      private String _startElementName;
      private boolean _isInsideScript = false;
      private boolean _isStyle = false;
      private Boolean _isTextArea;
      private UIComponent _startElementUIComponent;
      private boolean _startTagOpen;
     private Map<String, Object> _passThroughAttributesMap;
     private FacesContext _facesContext;
 
     private boolean _cdataOpen;
     
     private List<String> _startedChangedElements;
     private List<Integer> _startedElementsCount;
 
     private static final String CDATA_START = "<![CDATA[ \n";
     private static final String CDATA_START_NO_LINE_RETURN = "<![CDATA[";
     private static final String COMMENT_START = "<!--\n";
     private static final String CDATA_COMMENT_START = "//<![CDATA[ \n";
     private static final String CDATA_COMMENT_END = "\n//]]>";
     private static final String CDATA_END = "\n]]>";
     private static final String CDATA_END_NO_LINE_RETURN = "]]>";
     private static final String COMMENT_COMMENT_END = "\n//-->";
     private static final String COMMENT_END = "\n-->";
 
     static private final String[][] EMPTY_ELEMENT_ARR = new String[256][];
 
     static private final String[] A_NAMES = new String[]
     {
       "area",
     };
 
     static private final String[] B_NAMES = new String[]
     {
       "br",
       "base",
       "basefont",
     };
 
     static private final String[] C_NAMES = new String[]
     {
       "col",
     };
 
     static private final String[] E_NAMES = new String[]
     {
       "embed",
     };
 
     static private final String[] F_NAMES = new String[]
     {
       "frame",
     };
 
     static private final String[] H_NAMES = new String[]
     {
       "hr",
     };
 
     static private final String[] I_NAMES = new String[]
     {
       "img",
       "input",
       "isindex",
     };
 
     static private final String[] L_NAMES = new String[]
     {
       "link",
     };
 
     static private final String[] M_NAMES = new String[]
     {
       "meta",
     };
 
     static private final String[] P_NAMES = new String[]
     {
       "param",
     };
 
     static
     {
       EMPTY_ELEMENT_ARR['a'] = A_NAMES;
       EMPTY_ELEMENT_ARR['A'] = A_NAMES;
       EMPTY_ELEMENT_ARR['b'] = B_NAMES;
       EMPTY_ELEMENT_ARR['B'] = B_NAMES;
       EMPTY_ELEMENT_ARR['c'] = C_NAMES;
       EMPTY_ELEMENT_ARR['C'] = C_NAMES;
       EMPTY_ELEMENT_ARR['e'] = E_NAMES;
       EMPTY_ELEMENT_ARR['E'] = E_NAMES;
       EMPTY_ELEMENT_ARR['f'] = F_NAMES;
       EMPTY_ELEMENT_ARR['F'] = F_NAMES;
       EMPTY_ELEMENT_ARR['h'] = H_NAMES;
       EMPTY_ELEMENT_ARR['H'] = H_NAMES;
       EMPTY_ELEMENT_ARR['i'] = I_NAMES;
       EMPTY_ELEMENT_ARR['I'] = I_NAMES;
       EMPTY_ELEMENT_ARR['l'] = L_NAMES;
       EMPTY_ELEMENT_ARR['L'] = L_NAMES;
       EMPTY_ELEMENT_ARR['m'] = M_NAMES;
       EMPTY_ELEMENT_ARR['M'] = M_NAMES;
       EMPTY_ELEMENT_ARR['p'] = P_NAMES;
       EMPTY_ELEMENT_ARR['P'] = P_NAMES;
     }    
     
     public HtmlResponseWriterImpl(Writer writer, String contentType, String characterEncoding)
     {
         this(writer,contentType,characterEncoding,true);
     }
 
     public HtmlResponseWriterImpl(Writer writer, String contentType, String characterEncoding,
             boolean wrapScriptContentWithXmlCommentTag)
     {
         this(writer,contentType, characterEncoding, wrapScriptContentWithXmlCommentTag, 
                 contentType != null && HtmlRendererUtils.isXHTMLContentType(contentType) ? 
                     ContentTypeUtils.XHTML_CONTENT_TYPE : ContentTypeUtils.HTML_CONTENT_TYPE);
     }
     
     public HtmlResponseWriterImpl(Writer writer, String contentType, String characterEncoding,
              boolean wrapScriptContentWithXmlCommentTag, String writerContentTypeMode)
     throws FacesException
     {
         _outputWriter = writer;
         //The current writer to be used is the one used as output 
         _currentWriter = _outputWriter;
         _wrapScriptContentWithXmlCommentTag = wrapScriptContentWithXmlCommentTag;
         
         _contentType = contentType;
         if (_contentType == null)
         {
             if (log.isLoggable(Level.FINE))
             {
                 log.fine("No content type given, using default content type " + DEFAULT_CONTENT_TYPE);
             }
             _contentType = DEFAULT_CONTENT_TYPE;
         }
         _writerContentTypeMode = writerContentTypeMode;
         _isXhtmlContentType = writerContentTypeMode.indexOf(ContentTypeUtils.XHTML_CONTENT_TYPE) != -1;
         
         _useStraightXml = _isXhtmlContentType && (_contentType.indexOf(APPLICATION_XML_CONTENT_TYPE) != -1 ||
                           _contentType.indexOf(TEXT_XML_CONTENT_TYPE) != -1);
 
         if (characterEncoding == null)
         {
             if (log.isLoggable(Level.FINE))
             {
                 log.fine("No character encoding given, using default character encoding " +
                         DEFAULT_CHARACTER_ENCODING);
             }
             _characterEncoding = DEFAULT_CHARACTER_ENCODING;
         }
         else
         {
             // canonize to uppercase, that's the standard format
             _characterEncoding = characterEncoding.toUpperCase();
             
             // Check if encoding is valid by javadoc of RenderKit.createResponseWriter()
             if (!Charset.isSupported(_characterEncoding))
             {
                 throw new IllegalArgumentException("Encoding "+_characterEncoding
                         +" not supported by HtmlResponseWriterImpl");
             }
         }
         _isUTF8 = UTF8.equals(_characterEncoding);
         _startedChangedElements = new ArrayList<String>();
         _startedElementsCount = new ArrayList<Integer>();
     }
 
     public static boolean supportsContentType(String contentType)
     {
         String[] supportedContentTypes = HtmlRendererUtils.getSupportedContentTypes();
 
         for (int i = 0; i < supportedContentTypes.length; i++)
         {
             String supportedContentType = supportedContentTypes[i];
 
             if(supportedContentType.indexOf(contentType)!=-1)
             {
                 return true;
             }
         }
         return false;
     }
 
     public String getContentType()
     {
         return _contentType;
     }
     
     public String getWriterContentTypeMode()
     {
         return _writerContentTypeMode;
     }
 
     public String getCharacterEncoding()
     {
         return _characterEncoding;
     }
 
     public void flush() throws IOException
     {
         // API doc says we should not flush the underlying writer
         //_writer.flush();
         // but rather clear any values buffered by this ResponseWriter:
         closeStartTagIfNecessary();
     }
 
     public void startDocument()
     {
         // do nothing
     }
 
     public void endDocument() throws IOException
     {
         MyfacesConfig myfacesConfig = MyfacesConfig.getCurrentInstance(
             FacesContext.getCurrentInstance().getExternalContext());
         if (myfacesConfig.isEarlyFlushEnabled())
         {
             _currentWriter.flush();
         }
         _facesContext = null;
     }
 
     public void startElement(String name, UIComponent uiComponent) throws IOException
     {
         if (name == null)
         {
             throw new NullPointerException("elementName name must not be null");
         }
 
         closeStartTagIfNecessary();
         _currentWriter.write('<');
 
         resetStartedElement();
 
         _startElementName = name;
         _startElementUIComponent = uiComponent;
         _startTagOpen = true;
         _passThroughAttributesMap = (_startElementUIComponent != null) ?
             _startElementUIComponent.getPassThroughAttributes(false) : null;
 
         if (_passThroughAttributesMap != null)
         {
             Object value = _passThroughAttributesMap.get(
                 Renderer.PASSTHROUGH_RENDERER_LOCALNAME_KEY);
             if (value != null)
             {
                 if (value instanceof ValueExpression)
                 {
                     value = ((ValueExpression)value).getValue(
                         getFacesContext().getELContext());
                 }
                 String elementName = value.toString().trim();
                 
                 if (!name.equals(elementName))
                 {
                     _startElementName = elementName;
                     _startedChangedElements.add(elementName);
                     _startedElementsCount.add(0);
                 }
                 _currentWriter.write((String) elementName);
             }
             else
             {
                 _currentWriter.write(name);
             }
         }
         else
         {
             _currentWriter.write(name);
         }
 
         if (!_startedElementsCount.isEmpty())
         {
             int i = _startedElementsCount.size()-1;
             _startedElementsCount.set(i, _startedElementsCount.get(i)+1);
         }
         
         // Each time we start a element, it is necessary to check <script> or <style>,
         // because we need to buffer all content to post process it later when it reach its end
         // according to the initialization properties used.
         if(isScript(_startElementName))
         {
             // handle a <script> start
             _isInsideScript = true;
             _isStyle = false;
             _isTextArea = Boolean.FALSE;
         }
         else if (isStyle(_startElementName))
         {
             _isInsideScript = false;
             _isStyle = true;
             _isTextArea = Boolean.FALSE;
         }
     }
 
     @Override
     public void startCDATA() throws IOException
     {
         if (!_cdataOpen)
         {
             write(CDATA_START_NO_LINE_RETURN);
             _cdataOpen = true;
         }
     }
 
     @Override
     public void endCDATA() throws IOException
     {
         if (_cdataOpen)
         {
             write(CDATA_END_NO_LINE_RETURN);
             _cdataOpen = false;
         }
     }
 
     private void closeStartTagIfNecessary() throws IOException
     {
         if (_startTagOpen)
         {
             if (_passThroughAttributesMap != null)
             {
                 for (Map.Entry<String, Object> entry : _passThroughAttributesMap.entrySet())
                 {
                     String key = entry.getKey();
                     Object value = entry.getValue();
                     if (Renderer.PASSTHROUGH_RENDERER_LOCALNAME_KEY.equals(key))
                     {
                         // Special attribute stored in passthrough attribute map,
                         // skip rendering
                         continue;
                     }
                     if (value instanceof ValueExpression)
                     {
                         value = ((ValueExpression)value).getValue(getFacesContext().getELContext());
                     }
                     // encodeAndWriteURIAttribute(key, value, key);
                     // JSF 2.2 In the renderkit javadoc of jsf 2.2 spec says this 
                     // (Rendering Pass Through Attributes):
                     // "... The ResponseWriter must ensure that any pass through attributes are 
                     // rendered on the outer-most markup element for the component. If there is 
                     // a pass through attribute with the same name as a renderer specific 
                     // attribute, the pass through attribute takes precedence. Pass through 
                     // attributes are rendered as if they were passed to 
                     // ResponseWriter.writeURIAttribute(). ..."
                     // Note here it says "as if they were passed", instead say "... attributes are
                     // encoded and rendered as if ...". Black box testing against RI shows that there
                     // is no URI encoding at all in this part, so in this case the best is do the
                     // same here. After all, it is resposibility of the one who set the passthrough
                     // attribute to do the proper encoding in cases when a URI is provided. However,
                     // that does not means the attribute should not be encoded as other attributes.
                     // According to tests done, if passthrough attribute is null, the attribute must not
                     // be rendered.
                     if (value != null)
                     {
                         encodeAndWriteAttribute(key, value);
                     }
                 }
             }
 
             if (!_useStraightXml && isEmptyElement(_startElementName))
             {
                 _currentWriter.write(" />");
                 // make null, this will cause NullPointer in some invalid element nestings
                 // (better than doing nothing)
                 resetStartedElement();
             }
             else
             {
                 _currentWriter.write('>');
                 /*
                 if(isScript(_startElementName))
                 {
                     if(HtmlRendererUtils.isXHTMLContentType(_contentType))
                     {
                         if(HtmlRendererUtils.isAllowedCdataSection(FacesContext.getCurrentInstance()))
                         {
                             _currentWriter.write(CDATA_START);
                         }
                     }
                     else
                     {
                         _currentWriter.write(COMMENT_START);
                     }
                 }*/
                 if (isScript(_startElementName) && (_isXhtmlContentType || _wrapScriptContentWithXmlCommentTag))
                 {
                     //_bufferedWriter.reset();
                     //_currentWriter = _bufferedWriter;
                     getInternalBuffer(true);
                     _currentWriter = getInternalBuffer().getWriter();
                 }                
                 if (isStyle(_startElementName) && _isXhtmlContentType)
                 {
                     //_bufferedWriter.reset();
                     //_currentWriter = _bufferedWriter;
                     getInternalBuffer(true);
                     _currentWriter = getInternalBuffer().getWriter();
                 }
             }
             _startTagOpen = false;
         }
     }
     
     private boolean isEmptyElement(String elem)
     {
         // Code taken from trinidad
         // =-=AEW Performance?  Certainly slower to use a hashtable,
         // at least if we can't assume the input name is lowercased.
         // -= Leonardo Uribe =- elem.toLowerCase() internally creates an array,
         // and the contains() force a call to hashCode(). The array uses simple
         // char comparison, which at the end is faster and use less memory.
         // Note this call is very frequent, so at the end it is worth to do it.
         String[] array = EMPTY_ELEMENT_ARR[elem.charAt(0)];
         if (array != null)
         {
             for (int i = array.length - 1; i >= 0; i--)
             {
                 if (elem.equalsIgnoreCase(array[i]))
                 {
                     return true;
                 }
             }
         }
         return false;
     }
 
     private void resetStartedElement()
     {
         _startElementName = null;
         _startElementUIComponent = null;
         _passThroughAttributesMap = null;
         _isStyle = false;
         _isTextArea = null;
     }
 
     public void endElement(String name) throws IOException
     {
         if (name == null)
         {
             throw new NullPointerException("elementName name must not be null");
         }
 
         String elementName = name;
 
         if (!_startedElementsCount.isEmpty())
         {
             int i = _startedElementsCount.size()-1;
             _startedElementsCount.set(i, _startedElementsCount.get(i)-1);
             if (_startedElementsCount.get(i) == 0)
             {
                 elementName = _startedChangedElements.get(i);
                 _startedChangedElements.remove(i);
                 _startedElementsCount.remove(i);
             }
         }
 
         if (log.isLoggable(Level.WARNING))
         {
             if (_startElementName != null &&
                 !elementName.equals(_startElementName))
             {
                 log.warning("HTML nesting warning on closing " + elementName + ": element " + _startElementName +
                         (_startElementUIComponent==null?"":(" rendered by component : "+
                         RendererUtils.getPathToComponent(_startElementUIComponent)))+" not explicitly closed");
             }
         }
 
         if(_startTagOpen)
         {
 
             // we will get here only if no text or attribute was written after the start element was opened
             // now we close out the started tag - if it is an empty tag, this is then fully closed
             closeStartTagIfNecessary();
 
             //tag was no empty tag - it has no accompanying end tag now.
             if(_startElementName!=null)
             {                
                 if (isScript() && (_isXhtmlContentType || _wrapScriptContentWithXmlCommentTag))
                 {
                     writeScriptContent();
                     _currentWriter = _outputWriter;
                 }
                 else if (isStyle() && _isXhtmlContentType)
                 {
                     writeStyleContent();
                     _currentWriter = _outputWriter;
                 }
 
                 //write closing tag
                 writeEndTag(elementName);
             }
         }
         else
         {
             if (!_useStraightXml && isEmptyElement(elementName))
             {
            /*
            Should this be here?  It warns even when you have an x:htmlTag value="br", it should just close.
 
                 if (log.isWarnEnabled())
                     log.warn("HTML nesting warning on closing " + name + 
                         ": This element must not contain nested elements or text in HTML");
                     */
             }
             else
             {
                 if (isScript() && (_isXhtmlContentType || _wrapScriptContentWithXmlCommentTag))
                 {
                     writeScriptContent();
                     _currentWriter = _outputWriter;
                 }
                 else if (isStyle() && _isXhtmlContentType)
                 {
                     writeStyleContent();
                     _currentWriter = _outputWriter;
                 }
                 writeEndTag(elementName);
             }
         }
 
         resetStartedElement();
     }
 
 
     
     private void writeStyleContent() throws IOException
     {
         String content = getInternalBuffer().toString();
         
         if(_isXhtmlContentType)
         {
             // In xhtml, the content inside <style> tag is PCDATA, but
             // in html the content is CDATA, so in order to preserve 
             // compatibility we need to wrap the content inside proper
             // CDATA tags.
             // Since the response content type is xhtml, we can use
             // simple CDATA without comments, but note we need to check
             // when we are using any valid notation (simple CDATA, commented CDATA, xml comment) 
             String trimmedContent = content.trim();
             if (trimmedContent.startsWith(CommentUtils.CDATA_SIMPLE_START) && trimmedContent.endsWith(
                     CommentUtils.CDATA_SIMPLE_END))
             {
                 _outputWriter.write(content);
                 return;
             }
             else if (CommentUtils.isStartMatchWithCommentedCDATA(trimmedContent) && 
                     CommentUtils.isEndMatchWithCommentedCDATA(trimmedContent))
             {
                 _outputWriter.write(content);
                 return;
             }
             else if (trimmedContent.startsWith(CommentUtils.COMMENT_SIMPLE_START) && 
                     trimmedContent.endsWith(CommentUtils.COMMENT_SIMPLE_END))
             {
                 //Use comment wrap is valid, but for xhtml it is preferred to use CDATA
                 _outputWriter.write(CDATA_START);
                 _outputWriter.write(trimmedContent.substring(4,trimmedContent.length()-3));
                 _outputWriter.write(CDATA_END);
                 return;
             }
             else
             {
                 _outputWriter.write(CDATA_START);
                 _outputWriter.write(content);
                 _outputWriter.write(CDATA_END);
                 return;                
             }
         }
         // If the response is handled as text/html, 
         // it is not necessary to wrap with xml comment tag,
         // so we can just write the content as is.
         _outputWriter.write(content);
     }
     
     private void writeScriptContent() throws IOException
     {
         String content = getInternalBuffer().toString();
         String trimmedContent = null;
         
         if(_isXhtmlContentType)
         {
             trimmedContent = content.trim();
             
             if ( trimmedContent.startsWith(CommentUtils.COMMENT_SIMPLE_START) && 
                     CommentUtils.isEndMatchtWithInlineCommentedXmlCommentTag(trimmedContent))
             {
                 // In xhtml use xml comment to wrap is invalid, so it is only required to remove the <!--
                 // the ending //--> will be parsed as a comment, so it will not be a problem. Let it on the content.
                 if (_cdataOpen)
                 {
                     _outputWriter.write("//\n");
                 }
                 else
                 {
                    _outputWriter.write(CDATA_COMMENT_START);
                 }
 
                 _outputWriter.write(trimmedContent.substring(4));
 
                 if (_cdataOpen)
                 {
                     _outputWriter.write("\n");
                 }
                 else
                 {
                     _outputWriter.write(CDATA_COMMENT_END);
                 }
                 
                 return;
             }
             else if (CommentUtils.isStartMatchWithCommentedCDATA(trimmedContent) && 
                     CommentUtils.isEndMatchWithCommentedCDATA(trimmedContent))
             {
                 _outputWriter.write(content);
                 return;
             }
             else if (CommentUtils.isStartMatchWithInlineCommentedCDATA(trimmedContent) && 
                     CommentUtils.isEndMatchWithInlineCommentedCDATA(trimmedContent))
             {
                 _outputWriter.write(content);
                 return;
             }
             else
             {
                 // <script> in xhtml has as content type PCDATA, but in html it is CDATA,
                 // so we need to wrap here to prevent problems.
                 if (_cdataOpen)
                 {
                     _outputWriter.write("//\n");
                 }
                 else
                 {
                    _outputWriter.write(CDATA_COMMENT_START);
                 }
 
                 _outputWriter.write(content);
 
                 if (_cdataOpen)
                 {
                     _outputWriter.write("\n");
                 }
                 else
                 {
                     _outputWriter.write(CDATA_COMMENT_END);
                 }
 
                 return;
             }
         }
         else
         {
             if (_wrapScriptContentWithXmlCommentTag)
             {
                 trimmedContent = content.trim();
                 
                 if ( trimmedContent.startsWith(CommentUtils.COMMENT_SIMPLE_START) && 
                         CommentUtils.isEndMatchtWithInlineCommentedXmlCommentTag(trimmedContent))
                 {
                     _outputWriter.write(content);
                     return;
                 }
                 else if (CommentUtils.isStartMatchWithCommentedCDATA(trimmedContent) && 
                         CommentUtils.isEndMatchWithCommentedCDATA(trimmedContent))
                 {
                     _outputWriter.write(content);
                     return;
                 }
                 else if (CommentUtils.isStartMatchWithInlineCommentedCDATA(trimmedContent) && 
                         CommentUtils.isEndMatchWithInlineCommentedCDATA(trimmedContent))
                 {
                     _outputWriter.write(content);
                     return;
                 }
                 else
                 {
                     _outputWriter.write(COMMENT_START);
                     _outputWriter.write(content);
                     _outputWriter.write(COMMENT_COMMENT_END);
                     return;
                 }
             }
         }
         
         //If no return, just write everything
         _outputWriter.write(content);
     }
     
 
     private void writeEndTag(String name)
         throws IOException
     {
         /*
         if(isScript(name)) 
         {
             if(HtmlRendererUtils.isXHTMLContentType(_contentType))
             {
                 if(HtmlRendererUtils.isAllowedCdataSection(FacesContext.getCurrentInstance()))
                 {
                     _currentWriter.write(CDATA_COMMENT_END);
                 }
             }
             else
             {
                 _currentWriter.write(COMMENT_COMMENT_END);
             }
             
             // reset _isInsideScript
             _isInsideScript = Boolean.FALSE;
         }*/
         
         if (isScript(name))
         {
             // reset _isInsideScript
             _isInsideScript = false;
         }
         else if (isStyle(name))
         {
             _isStyle = false;
         }
 
         _currentWriter.write("</");
         _currentWriter.write(name);
         _currentWriter.write('>');
     }
 
     public void writeAttribute(String name, Object value, String componentPropertyName) throws IOException
     {
         if (name == null)
         {
             throw new NullPointerException("attributeName name must not be null");
         }
         if (!_startTagOpen)
         {
             throw new IllegalStateException("Must be called before the start element is closed (attribute '"
                     + name + "')");
         }
         // From JSF 2.2 RenderKit javadoc: "... If there is a pass through attribute with the same 
         // name as a renderer specific attribute, the pass through attribute takes precedence. ..."
         if (_passThroughAttributesMap != null && _passThroughAttributesMap.containsKey(name))
         {
             return;
         }
 
         if (value instanceof Boolean)
         {
             if (((Boolean)value).booleanValue())
             {
                 // name as value for XHTML compatibility
                 _currentWriter.write(' ');
                 _currentWriter.write(name);
                 _currentWriter.write("=\"");
                 _currentWriter.write(name);
                 _currentWriter.write('"');
             }
         }
         else
         {
             String strValue = (value==null)?"":value.toString();
             _currentWriter.write(' ');
             _currentWriter.write(name);
             _currentWriter.write("=\"");
             org.apache.myfaces.shared.renderkit.html.util.HTMLEncoder.encode(_currentWriter,
                     strValue, false, false, !_isUTF8);
             _currentWriter.write('"');
         }
     }
     
     private void encodeAndWriteAttribute(String name, Object value) throws IOException
     {
         String strValue = (value==null)?"":value.toString();
         _currentWriter.write(' ');
         _currentWriter.write(name);
         _currentWriter.write("=\"");
         org.apache.myfaces.shared.renderkit.html.util.HTMLEncoder.encode(_currentWriter,
                 strValue, false, false, !_isUTF8);
         _currentWriter.write('"');
     }
 
     public void writeURIAttribute(String name, Object value, String componentPropertyName) throws IOException
     {
         if (name == null)
         {
             throw new NullPointerException("attributeName name must not be null");
         }
         if (!_startTagOpen)
         {
             throw new IllegalStateException("Must be called before the start element is closed (attribute '"
                     + name + "')");
         }
         // From JSF 2.2 RenderKit javadoc: "... If there is a pass through attribute with the same 
         // name as a renderer specific attribute, the pass through attribute takes precedence. ..."
         if (_passThroughAttributesMap != null && _passThroughAttributesMap.containsKey(name))
         {
             return;
         }
         
         encodeAndWriteURIAttribute(name, value);
     }
     
     private void encodeAndWriteURIAttribute(String name, Object value) throws IOException
     {
         String strValue = value.toString();
         _currentWriter.write(' ');
         _currentWriter.write(name);
         _currentWriter.write("=\"");
         if (strValue.toLowerCase().startsWith("javascript:"))
         {
             org.apache.myfaces.shared.renderkit.html.util.HTMLEncoder.encode(_currentWriter,
                     strValue, false, false, !_isUTF8);
         }
         else
         {
             /*
             Todo: what is this section about? still needed?
             client side state saving is now done via javascript...
 
             if (_startElementName.equalsIgnoreCase(HTML.ANCHOR_ELEM) && //Also support image and button urls?
                 name.equalsIgnoreCase(HTML.HREF_ATTR) &&
                 !strValue.startsWith("#"))
             {
                 FacesContext facesContext = FacesContext.getCurrentInstance();
                 if (facesContext.getApplication().getStateManager().isSavingStateInClient(facesContext))
                 {
                     // saving state in url depends on the work together
                     // of 3 (theoretically) pluggable components:
                     // ViewHandler, ResponseWriter and ViewTag
                     // We should try to make this HtmlResponseWriterImpl able
                     // to handle this alone!
                     if (strValue.indexOf('?') < 0)
                     {
                         strValue = strValue + '?' + JspViewHandlerImpl.URL_STATE_MARKER;
                     }
                     else
                     {
                         strValue = strValue + '&' + JspViewHandlerImpl.URL_STATE_MARKER;
                     }
                 }
             }
             */
             //_writer.write(strValue);
             org.apache.myfaces.shared.renderkit.html.util.HTMLEncoder.encodeURIAttribute(_currentWriter,
                             strValue, _characterEncoding);
         }
         _currentWriter.write('"');
     }
 
     public void writeComment(Object value) throws IOException
     {
         if (value == null)
         {
             throw new NullPointerException("comment name must not be null");
         }
 
         closeStartTagIfNecessary();
         _currentWriter.write("<!--");
         _currentWriter.write(value.toString());    //TODO: Escaping: must not have "-->" inside!
         _currentWriter.write("-->");
     }
 
     public void writeText(Object value, String componentPropertyName) throws IOException
     {
         if (value == null)
         {
             throw new NullPointerException("Text must not be null.");
         }
 
         closeStartTagIfNecessary();
 
         String strValue = value.toString();
 
         if (isScriptOrStyle())
         {
             // Don't bother encoding anything if chosen character encoding is UTF-8
             if (_isUTF8)
             {
                 _currentWriter.write(strValue);
             }
             else
             {
                 UnicodeEncoder.encode(_currentWriter, strValue);
             }
         }
         else
         {
             org.apache.myfaces.shared.renderkit.html.util.HTMLEncoder.encode(_currentWriter,
                       strValue, false, false, !_isUTF8);
         }
     }
 
     public void writeText(char cbuf[], int off, int len) throws IOException
     {
         if (cbuf == null)
         {
             throw new NullPointerException("cbuf name must not be null");
         }
         if (cbuf.length < off + len)
         {
             throw new IndexOutOfBoundsException((off + len) + " > " + cbuf.length);
         }
 
         closeStartTagIfNecessary();
 
         if (isScriptOrStyle())
         {
             String strValue = new String(cbuf, off, len);
             // Don't bother encoding anything if chosen character encoding is UTF-8
             if (_isUTF8)
             {
                 _currentWriter.write(strValue);
             }
             else
             {
                 UnicodeEncoder.encode(_currentWriter, strValue);
             }
         }
         else if (isTextarea())
         {
             // For textareas we must *not* map successive spaces to &nbsp or Newlines to <br/>
             org.apache.myfaces.shared.renderkit.html.util.HTMLEncoder.encode(
                     cbuf, off, len, false, false, !_isUTF8, _currentWriter);
         }
         else
         {
             // We map successive spaces to &nbsp; and Newlines to <br/>
             org.apache.myfaces.shared.renderkit.html.util.HTMLEncoder.encode(
                     cbuf, off, len, true, true, !_isUTF8, _currentWriter);
         }
     }
 
     private boolean isScriptOrStyle()
     {
         //initializeStartedTagInfo();
 
         return _isStyle || _isInsideScript;
     }
     
     /**
      * Is the given element a script tag?
      * @param element
      * @return
      */
     private boolean isScript(String element)
     {
         return (HTML.SCRIPT_ELEM.equalsIgnoreCase(element));
     }
     
     private boolean isScript()
     {
         return _isInsideScript;
     }
     
     private boolean isStyle(String element)
     {
         return (HTML.STYLE_ELEM.equalsIgnoreCase(element));
     }
     
     private boolean isStyle()
     {
         return _isStyle;
     }
 
     private boolean isTextarea()
     {
         initializeStartedTagInfo();
 
         return _isTextArea != null && _isTextArea.booleanValue();
     }
 
     private void initializeStartedTagInfo()
     {
         if(_startElementName != null)
         {
             /*
             if(_isStyle == null)
             {
                 if(_startElementName.equalsIgnoreCase(org.apache.myfaces.shared.renderkit.html.HTML.STYLE_ELEM))
                 {
                     _isStyle = Boolean.TRUE;
                     _isTextArea = Boolean.FALSE;
                 }
                 else
                 {
                     _isStyle = Boolean.FALSE;
                 }
             }*/
 
             if(_isTextArea == null)
             {
                 if(_startElementName.equalsIgnoreCase(HTML.TEXTAREA_ELEM))
                 {
                     _isTextArea = Boolean.TRUE;
                 }
                 else
                 {
                     _isTextArea = Boolean.FALSE;
                 }
             }
         }
     }
 
     public ResponseWriter cloneWithWriter(Writer writer)
     {
         HtmlResponseWriterImpl newWriter
                 = new HtmlResponseWriterImpl(writer, getContentType(), getCharacterEncoding(), 
                         _wrapScriptContentWithXmlCommentTag, _writerContentTypeMode);
         //newWriter._writeDummyForm = _writeDummyForm;
         //newWriter._dummyFormParams = _dummyFormParams;
         return newWriter;
     }
 
 
     // Writer methods
 
     public void close() throws IOException
     {
         closeStartTagIfNecessary();
         _currentWriter.close();
         _facesContext = null;
     }
 
     public void write(char cbuf[], int off, int len) throws IOException
     {
         closeStartTagIfNecessary();
         // Don't bother encoding anything if chosen character encoding is UTF-8
         if (_isUTF8)
         {
             _currentWriter.write(cbuf, off, len);
         }
         else
         {
             UnicodeEncoder.encode(_currentWriter, cbuf, off, len);
         }
     }
 
     public void write(int c) throws IOException
     {
         closeStartTagIfNecessary();
         _currentWriter.write(c);
     }
 
     public void write(char cbuf[]) throws IOException
     {
         closeStartTagIfNecessary();
         // Don't bother encoding anything if chosen character encoding is UTF-8
         if (_isUTF8)
         {
             _currentWriter.write(cbuf);
         }
         else
         {
             UnicodeEncoder.encode(_currentWriter, cbuf, 0, cbuf.length);
         }
     }
 
     public void write(String str) throws IOException
     {
         closeStartTagIfNecessary();
         // empty string commonly used to force the start tag to be closed.
         // in such case, do not call down the writer chain
         if (str != null && str.length() > 0)
         {
             // Don't bother encoding anything if chosen character encoding is UTF-8
             if (_isUTF8)
             {
                 _currentWriter.write(str);
             }
             else
             {
                 UnicodeEncoder.encode(_currentWriter, str);
             }
         }
     }
 
     public void write(String str, int off, int len) throws IOException
     {
         closeStartTagIfNecessary();
         // Don't bother encoding anything if chosen character encoding is UTF-8
         if (_isUTF8)
         {
             _currentWriter.write(str, off, len);
         }
         else
         {
             UnicodeEncoder.encode(_currentWriter, str, off, len);
         }
     }
     
     /**
      * This method ignores the <code>UIComponent</code> provided and simply calls
      * <code>writeText(Object,String)</code>
      * @since 1.2
      */
     public void writeText(Object object, UIComponent component, String string) throws IOException
     {
         writeText(object,string);
     }
     
     protected StreamCharBuffer getInternalBuffer()
     {
         return getInternalBuffer(false);
     }
     
     protected StreamCharBuffer getInternalBuffer(boolean reset)
     {
         if (_buffer == null)
         {
             _buffer = new StreamCharBuffer(256, 100);
         }
         else if (reset)
         {
             _buffer.reset();
         }
         return _buffer;
     }
     
     protected FacesContext getFacesContext()
     {
         if (_facesContext == null)
         {
             _facesContext = FacesContext.getCurrentInstance();
         }
         return _facesContext;
     }
     
     protected boolean getWrapScriptContentWithXmlCommentTag()
     {
         return _wrapScriptContentWithXmlCommentTag;
     }
     
     protected void forceFlush() throws IOException
     {
         _currentWriter.flush();
     }
 }