package com.hfg.xml;

import java.io.*;
import java.util.*;

import org.xml.sax.InputSource;

import com.hfg.util.Case;
import com.hfg.util.CompareUtil;
import com.hfg.util.collection.OrderedMap;
import com.hfg.util.io.GZIP;
import com.hfg.util.io.NoClosePrintWriter;
import com.hfg.util.StringUtil;
import com.hfg.util.collection.CollectionUtil;
import com.hfg.xml.parser.XMLTagReader;

//------------------------------------------------------------------------------
/**
 XMLTag is a generic container for XML. It can be used both to construct XML or
 to deconstruct XML into a DOM-like structure.

 @author J. Alex Taylor, hairyfatguy.com
 */
//------------------------------------------------------------------------------
// com.hfg XML/HTML Coding Library
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// J. Alex Taylor, President, Founder, CEO, COO, CFO, OOPS hairyfatguy.com
// jataylor@hairyfatguy.com
//------------------------------------------------------------------------------
   
public class XMLTag extends XMLContainerImpl implements XMLNode, Comparable
{

   //###########################################################################
   // PRIVATE FIELDS
   //###########################################################################

   private String mName;
   private Map<String, XMLAttribute> mAttributes;
   private XMLNamespace mNamespace;
   // Attribute sorting is preferred for the consistency of attribute order
   private boolean mSortAttributesBeforeWriting = true;

   private static char sQuoteChar = '\''; // Not final since it can be changed
   private static final String  NL = System.getProperty("line.separator");

   //###########################################################################
   // CONSTRUCTORS
   //###########################################################################
   
   //---------------------------------------------------------------------------
   /**
    @param inName the tag name
    */
   public XMLTag(String inName)
   {
      setTagName(inName);
   }

   //---------------------------------------------------------------------------
   /**
    @param inName the tag name
    */
   public XMLTag(XMLName inName)
   {
      if (inName != null)
      {
         setTagName(inName.getLocalName());
         setNamespace(inName.getNamespace());
      }
   }

   //---------------------------------------------------------------------------
   /**
    @param inName the tag name
    @param inAttributes a Collection of XMLAttribute objects
    */
   public XMLTag(String inName, Collection<XMLAttribute> inAttributes)
   {
      setTagName(inName);
      setAttributes(inAttributes);
   }
  
   //---------------------------------------------------------------------------
   /**
    @param inName the tag name
    @param inAttributes a Map of attribute (names and values as String objects)
    */
   public XMLTag(String inName, Map<String,String> inAttributes)
   {
      if (CollectionUtil.hasValues(inAttributes))
      {
         List<XMLAttribute> attributes = new ArrayList<>();

         for (String name : inAttributes.keySet())
         {
            attributes.add(new XMLAttribute(name, inAttributes.get(name)));
         }

         setAttributes(attributes);
      }
      setTagName(inName);
   }
   
   //---------------------------------------------------------------------------
   /**
    @param inName the tag name
    @param inAttributes a Collection of XMLAttribute objects
    @param inContent the tag's content
    */
   public XMLTag(String inName, Collection inAttributes, String inContent)
   {
      this(inName, inAttributes);
      setContent(inContent);
   }
   
   //---------------------------------------------------------------------------
   /**
    @param inName the tag name
    @param inAttributes a ImageMap of attribute (names and values as String objects)
    @param inContent the tag's content
    */
   public XMLTag(String inName, Map inAttributes, String inContent)
   {
      this(inName, inAttributes);
      setContent(inContent);
   }
   
   //----------------------------------------------------------------------
   /**
    @param inXML an InputStream containing XML text
    */
   public XMLTag(InputStream inXML)
         throws XMLException, IOException
   {
      construct(inXML);
   }

   //----------------------------------------------------------------------
   /**
    @param inXML a Reader containing XML text
    */
   public XMLTag(Reader inXML)
         throws XMLException, IOException
   {
      construct(inXML);
   }

   //---------------------------------------------------------------------------
   /**
    @param inXMLFile a File containing XML text
    */
   public XMLTag(File inXMLFile)
         throws XMLException, IOException
   {
      if (null == inXMLFile)
      {
         throw new XMLException("null File passed to XMLTag()!");
      }

      construct(new FileReader(inXMLFile));
   }
 
   
   //###########################################################################
   // PUBLIC METHODS
   //###########################################################################

   //---------------------------------------------------------------------------
   public static void useDoubleQuotes(boolean inValue)
   {
      if (inValue)
      {
         sQuoteChar = '\"';
      }
      else
      {
         sQuoteChar = '\'';
      }
   }

   //---------------------------------------------------------------------------
   public XMLTag setSortAttributesBeforeWriting(boolean inValue)
   {
      mSortAttributesBeforeWriting = inValue;
      return this;
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLTag clone()
   {
      XMLTag cloneObj = super.clone();

      if (mAttributes != null)
      {
         cloneObj.mAttributes = new OrderedMap<>();
         for (String key : mAttributes.keySet())
         {
            cloneObj.mAttributes.put(key, mAttributes.get(key).clone());
         }
      }

      return cloneObj;
   }

   //---------------------------------------------------------------------------
   @Override
   public boolean equals(Object inObj2)
   {
      return (0 == compareTo(inObj2));
   }

   //--------------------------------------------------------------------------
   @Override
   public int compareTo(Object inObj2)
   {
      int result = -1;

      if (inObj2 instanceof XMLTag)
      {
         XMLTag tag2 = (XMLTag) inObj2;

         result = CompareUtil.compare(getTagName(), tag2.getTagName());

         if (0 == result)
         {
            // Compare attributes
            result = CompareUtil.compare(getAttributes(), tag2.getAttributes());

            if (0 == result)
            {
               // Compare content & subtags
               result = CompareUtil.compare(getContentPlusSubtagList(), tag2.getContentPlusSubtagList());
            }
         }
      }

      return result;
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLNode setContent(CharSequence inContent)
   {
      return (XMLNode) super.setContent(inContent);
   }


   //--------------------------------------------------------------------------
   public XMLTag addSubtag(String inTagName)
   {
      XMLTag subtag = new XMLTag(inTagName);
      addSubtag(subtag);

      return subtag;
   }

   //--------------------------------------------------------------------------
   public XMLTag addSubtag(XMLName inTagName)
   {
      XMLTag subtag = new XMLTag(inTagName);
      addSubtag(subtag);

      return subtag;
   }

   //--------------------------------------------------------------------------
   public String getStartTag()
   {
      Collection attributes = null;
      if (mAttributes != null) attributes = mAttributes.values();

      return XMLUtil.composeStartTag(getTagName(), attributes, false);
   }

   //--------------------------------------------------------------------------
   public String getEndTag()
   {
      return XMLUtil.composeEndTag(getTagName());
   }

   //--------------------------------------------------------------------------
   @Override
   public boolean isEmptyTag()
   {
      boolean returnValue = false;

      if (null == mContentAndSubtagList
            || 0 == mContentAndSubtagList.size())
      {
         returnValue = true;
      }

      return returnValue;
   }


   //---------------------------------------------------------------------------
   @Override
   public XMLTag setTagName(XMLName inName)
   {
      // Check the name for XML validity.
      XMLUtil.checkXMLNameValidity(inName.getLocalName());

      mName = inName.getLocalName();
      setNamespace(inName.getNamespace());

      return this;
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLTag setTagName(String inName)
   {
      // Check the name for XML validity.
      XMLUtil.checkXMLNameValidity(inName);

      mName = inName;

      return this;
   }

   //---------------------------------------------------------------------------
   @Override
   public String getTagName()
   {
      return mName;
   }

   //---------------------------------------------------------------------------
   public String getQualifiedTagName()
   {
      return (mNamespace != null && mNamespace.getPrefix() != null ? mNamespace.getPrefix() + ":" : "") + mName;
   }

   //---------------------------------------------------------------------------
   @Override
   public void verifyTagName(XMLName inTagName)
   {
      verifyTagName(inTagName, Case.SENSITIVE);
   }

   //---------------------------------------------------------------------------
   @Override
   public void verifyTagName(XMLName inTagName, Case inCaseSensitivity)
   {
      try
      {
         verifyTagName(inTagName.getLocalName(), inCaseSensitivity);
      }
      catch (XMLException e)
      {
         // Try the qualified tag name
         verifyTagName(inTagName.getQualifiedName(), inCaseSensitivity);
      }
   }

   //---------------------------------------------------------------------------
   @Override
   public void verifyTagName(String inTagName)
   {
      verifyTagName(inTagName, Case.SENSITIVE);
   }

   //---------------------------------------------------------------------------
   @Override
  public void verifyTagName(String inTagName, Case inCaseSensitivity)
   {
      boolean verified = false;
      if (Case.INSENSITIVE.equals(inCaseSensitivity))
      {
         if (getTagName().equalsIgnoreCase(inTagName))
         {
            verified = true;
         }
      }
      else if (getTagName().equals(inTagName))
      {
         verified = true;
      }

      if (! verified)
      {
         throw new XMLException("Expected a tag name of " + StringUtil.singleQuote(inTagName)
                                + " but was given a tag with name " + StringUtil.singleQuote(getTagName()) + "!");
      }
   }


   //---------------------------------------------------------------------------
   @Override
   public XMLTag setAttribute(String inAttributeName, Object inValue)
   {
      String stringValue = (inValue != null ? inValue.toString() : "");
      XMLAttribute attribute = new XMLAttribute(inAttributeName, stringValue);
      setAttribute(attribute);

      return this;
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLTag setAttribute(XMLName inAttributeName, Object inValue)
   {
      String stringValue = (inValue != null ? inValue.toString() : "");
      XMLAttribute attribute = new XMLAttribute(inAttributeName, stringValue);
      setAttribute(attribute);

      return this;
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLTag setAttribute(XMLAttribute inAttribute)
   {
      if (inAttribute != null)
      {
         if (null == mAttributes) mAttributes = new OrderedMap<>(4);

         // Avoid overstriking the attribute's element when the attribute was
         // reused without cloning. 
         if (inAttribute.getElement() != null)
         {
            inAttribute = inAttribute.clone();
         }

         mAttributes.put(inAttribute.getName(), inAttribute);

         inAttribute.setElement(this);
      }

      return this;
   }

   //---------------------------------------------------------------------------
   /**
    Takes a Collection of XMLAttribute objects as input.
    */
   @Override
   public void setAttributes(Collection<XMLAttribute> inAttributes)
   {
      if (inAttributes != null)
      {
         for (XMLAttribute attribute : inAttributes)
         {
            setAttribute(attribute);
         }
      }
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLAttribute getAttribute(XMLName inAttributeName)
   {
      return getAttribute(inAttributeName.getLocalName());
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLAttribute getAttribute(String inAttributeName)
   {
      XMLAttribute attribute = null;

      if (mAttributes != null)
      {
         attribute = mAttributes.get(inAttributeName);
      }

      return attribute;
   }

   //---------------------------------------------------------------------------
   @Override
   public boolean hasAttributes()
   {
      return (CollectionUtil.hasValues(mAttributes));
   }

   //---------------------------------------------------------------------------
   @Override
   public boolean hasAttribute(XMLName inAttributeName)
   {
      return (getAttribute(inAttributeName) != null);
   }

   //---------------------------------------------------------------------------
   @Override
   public boolean hasAttribute(String inAttributeName)
   {
      return (getAttribute(inAttributeName) != null);
   }

   //---------------------------------------------------------------------------
   @Override
   public String getAttributeValue(XMLName inAttributeName)
   {
      return getAttributeValue(inAttributeName.getLocalName());
   }

   //---------------------------------------------------------------------------
   @Override
   public String getAttributeValue(String inAttributeName)
   {
      XMLAttribute attribute = getAttribute(inAttributeName);

      String value = null;

      if (attribute != null)
      {
         value = attribute.getUnscapedValue();
      }

      return value;
   }
   
   //---------------------------------------------------------------------------
   /**
    Returns a Collection of XMLAttribute objects.
    */
   @Override
   public Collection<XMLAttribute> getAttributes()
   {
      Collection<XMLAttribute> attributes = null;

      if (mAttributes != null)
      {
         attributes = mAttributes.values();
      }

      return attributes;
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLAttribute removeAttribute(String inAttributeName)
   {
      XMLAttribute attribute = null;

      if (mAttributes != null)
      {
         attribute = mAttributes.remove(inAttributeName);
      }

      return attribute;
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLAttribute removeAttribute(XMLName inAttributeName)
   {
      return removeAttribute(inAttributeName.getLocalName());
   }



   //---------------------------------------------------------------------------
   @Override
   public XMLNamespace getNamespace()
   {
      return mNamespace;
   }

   //---------------------------------------------------------------------------
   @Override
   public XMLTag setNamespace(XMLNamespace inValue)
   {
      mNamespace = inValue;

      return this;
   }

   //---------------------------------------------------------------------------
   public XMLTag setDefaultXMLNamespaceDeclaration(XMLNamespace inValue)
   {
      return setAttribute("xmlns", inValue.getURI());
   }

   //---------------------------------------------------------------------------
   public XMLTag addXMLNamespaceDeclaration(XMLNamespace inValue)
   {
      return setAttribute("xmlns" + (StringUtil.isSet(inValue.getPrefix()) ? ":" + inValue.getPrefix() : ""), inValue.getURI());
   }

   //---------------------------------------------------------------------------
   /**
    Returns a List of all nodes with the specified attribute name and specified attribute value.
    */
   @Override
   public List<? extends XMLNode> findNodesByAttributeValue(XMLName inAttribute, String inValue)
   {
      return findNodesByAttributeValue(inAttribute.getLocalName(), inValue);
   }

   //---------------------------------------------------------------------------
   /**
    Returns a List of all nodes with the specified attribute name and specified attribute value.
    */
   @Override
   public List<? extends XMLNode> findNodesByAttributeValue(String inAttribute, String inValue)
   {
      List<XMLNode> outList = new ArrayList<>();

      recursiveFindNodesByAttributeValue(inAttribute, inValue, outList);

      return outList;
   }

   //---------------------------------------------------------------------------
   @Override
   public String toString()
   {
      return "<" + mName + ">";
   }

   //---------------------------------------------------------------------------
   @Override
   public String toXML()
   {
      ByteArrayOutputStream outStream = null;
      try
      {
         outStream = new ByteArrayOutputStream(2048);
         toXML(outStream);
         outStream.close();
      }
      catch (Exception e)
      {
         throw new XMLException(e);
      }

      return outStream.toString();
   }

   //---------------------------------------------------------------------------
   @Override
   public void toXML(OutputStream inStream)
   {
      PrintWriter writer = new PrintWriter(inStream);

      toXML(writer);
      
      writer.flush();
   }

   //---------------------------------------------------------------------------
   @Override
   public synchronized void toXML(Writer inWriter)
   {
      toXML(inWriter, null);
   }

   //---------------------------------------------------------------------------
   protected void toXML(Writer inWriter, XMLNamespaceSet inDeclaredNamespaces)
   {
      try
      {
         XMLNamespaceSet declaredNamespaces = updateDeclaredNamespaces(inDeclaredNamespaces);

         String tagName = getTagName();
         if (tagName != null)
         {
            String nsPrefix = null;
            boolean addedNamespaceAttr = false;
            if (mNamespace != null)
            {
               // Namespace already declared?
               if (declaredNamespaces != null
                   && declaredNamespaces.contains(mNamespace)
                   && !mNamespace.equals(declaredNamespaces.getDefault()))
               {
                  nsPrefix = mNamespace.getPrefix();
               }
               else if (null == declaredNamespaces
                        || ! declaredNamespaces.contains(mNamespace))
               {
                  // Need to declare the namespace
                  setDefaultXMLNamespaceDeclaration(mNamespace);
                  addedNamespaceAttr = true;

                  if (null == declaredNamespaces)
                  {
                     declaredNamespaces = new XMLNamespaceSet(4);
                  }

                  declaredNamespaces.setDefault(mNamespace);
               }
            }

            if (nsPrefix != null)
            {
               tagName = nsPrefix + ":" + tagName;
            }

            writeStartTag(inWriter, declaredNamespaces, tagName);

            if (addedNamespaceAttr)
            {
               // We shouldn't permanently alter the tag.
               removeAttribute("xmlns");
            }
         }

         if (mContentAndSubtagList != null)
         {
            for (Object content : mContentAndSubtagList)
            {
               if (content instanceof String)
               {
                  inWriter.write(content.toString());
               }
               else if (content instanceof byte[])
               {
                  inWriter.write(GZIP.uncompressToString((byte[]) content));
               }
               else
               {
                  XMLizable subtag = (XMLizable) content;
                  if (subtag instanceof XMLTag)
                  {
                     ((XMLTag)subtag).toXML(inWriter, declaredNamespaces);
                  }
                  else
                  {
                     subtag.toXML(inWriter);
                  }
               }
            }
         }

         if (tagName != null)
         {
            // Closing tag?
            if (!isEmptyTag())
            {
               inWriter.write(XMLUtil.composeEndTag(tagName));
            }
         }
      }
      catch (IOException e)
      {
         throw new RuntimeException(e);
      }
   }

   //---------------------------------------------------------------------------
   @Override
   public String toIndentedXML(int inInitialIndentLevel, int inIndentSize)
   {
      ByteArrayOutputStream outStream;
      try
      {
         outStream = new ByteArrayOutputStream();
         PrintWriter writer = new PrintWriter(outStream);
         toIndentedXML(writer, inInitialIndentLevel, inIndentSize);
         writer.close();
      }
      catch (Exception e)
      {
         throw new XMLException(e);
      }

      return outStream.toString();
   }
   
   //---------------------------------------------------------------------------
   /**
    Writes out the tag (and any subtags) to te specified OutputStream. Note that
    the OutputStream is not closed by this method.
    * @param inOutputStream OutputStream to which the XML is written.
    */
   @Override
   public void toIndentedXML(OutputStream inOutputStream, int inInitialIndentLevel, int inIndentSize)
   {
       PrintWriter writer = null;
       try
       {
           writer = new NoClosePrintWriter(inOutputStream);
           toIndentedXML(writer, inInitialIndentLevel, inIndentSize);
       }
       finally
       {
           if (writer != null) writer.close();
       }
   }

   //--------------------------------------------------------------------------
   @Override
   public synchronized void toIndentedXML(Writer inWriter, int inInitialIndentLevel, int inIndentSize)
   {
      toIndentedXML(inWriter, inInitialIndentLevel, inIndentSize, null);
   }

   //--------------------------------------------------------------------------
   @Override
   public synchronized void toIndentedXML(Writer inWriter, int inInitialIndentLevel, int inIndentSize,
                                          XMLNamespaceSet inDeclaredNamespaces)
   {
      try
      {
         boolean emptyTag = isEmptyTag();
         boolean contentPresent = false;
         String indent = StringUtil.polyChar(' ', inInitialIndentLevel * inIndentSize);

         if (inInitialIndentLevel > 0)
         {
            inWriter.write(NL);
            inWriter.write(indent);
         }

         XMLNamespaceSet declaredNamespaces = updateDeclaredNamespaces(inDeclaredNamespaces);

         String tagName = getTagName();
         if (tagName != null)
         {
            String nsPrefix = null;
            boolean addedNamespaceAttr = false;
            if (mNamespace != null)
            {
               // Namespace already declared?
               if (declaredNamespaces != null
                   && ! mNamespace.equals(declaredNamespaces.getDefault()))
               {
                  nsPrefix = mNamespace.getPrefix();
               }
               else if (null == declaredNamespaces
                        || ! declaredNamespaces.contains(mNamespace))
               {
                  // Need to declare the namespace
                  setDefaultXMLNamespaceDeclaration(mNamespace);
                  addedNamespaceAttr = true;

                  if (null == declaredNamespaces)
                  {
                     declaredNamespaces = new XMLNamespaceSet(4);
                  }

                  declaredNamespaces.setDefault(mNamespace);
               }
            }

            if (nsPrefix != null)
            {
               tagName = nsPrefix + ":" + tagName;
            }

            writeStartTag(inWriter, declaredNamespaces, tagName);

            if (addedNamespaceAttr)
            {
               // We shouldn't permanently alter the tag.
               removeAttribute("xmlns");
            }
         }

         if (mContentAndSubtagList != null)
         {
            for (int i = 0; i < mContentAndSubtagList.size(); i++)
            {
               Object content = mContentAndSubtagList.get(i);

               if (content instanceof XMLNode)
               {
                  ((XMLNode) content).toIndentedXML(inWriter, (contentPresent ? 0 : inInitialIndentLevel + 1), inIndentSize,
                                                    declaredNamespaces);
               }
               else if (content instanceof String)
               {
                  inWriter.write(content.toString());
                  contentPresent = true;
               }
               else if (content instanceof byte[])
               {
                  byte[] bytes = (byte[]) content;
                  String contentValue = GZIP.uncompressToString(bytes);
                  contentPresent = true;

                  inWriter.write(contentValue);
               }
               else if (content instanceof XMLComment)
               {
                  if (!contentPresent)
                  {
                     inWriter.write(NL);
                     inWriter.write(StringUtil.polyChar(' ', (inInitialIndentLevel + 1) * inIndentSize));
                  }
                  inWriter.write(((XMLComment) content).toXML());
//               if (!contentPresent)
//               {
//                  inWriter.println();
//               }
               }
               else if (content instanceof XMLizable)
               {
                  inWriter.write(((XMLizable) content).toXML());
               }
            }
         }

         if (tagName != null)
         {
            if (!emptyTag)
            {
               if (!contentPresent)
               {
                  inWriter.write(NL);
                  inWriter.write(indent);
               }
               inWriter.write(XMLUtil.composeEndTag(tagName));
            }
         }

         if (inInitialIndentLevel == 0) inWriter.flush();
      }
      catch (IOException e)
      {
         throw new RuntimeException(e);
      }
   }

   //--------------------------------------------------------------------------
   @Override
   public void replaceCharacterEntities()
   {
      // Check the attribute values
      if (mAttributes != null
          && mAttributes.size() > 0)
      {
         for (XMLAttribute attr : mAttributes.values())
         {
            String newValue = XMLUtil.convertCharacterEntitiesToNumeric(attr.getValue());
            if (! newValue.equals(attr.getValue()))
            {
               attr.setValue(newValue);
            }
         }
      }

      if (mContentAndSubtagList != null)
      {
         for (int i = 0; i < mContentAndSubtagList.size(); i++)
         {
            Object content = mContentAndSubtagList.get(i);

            if (content instanceof XMLNode)
            {
               ((XMLNode)content).replaceCharacterEntities();
            }
            else if (content instanceof String)
            {
               String newValue = XMLUtil.convertCharacterEntitiesToNumeric((String)content);
               if (! newValue.equals(content))
               {
                  mContentAndSubtagList.set(i, newValue);
               }
            }
            else if (content instanceof byte[])
            {
               byte[] bytes = (byte[]) content;
               String contentValue = GZIP.uncompressToString(bytes);

               String newValue = XMLUtil.convertCharacterEntitiesToNumeric(contentValue);
               if (! newValue.equals(contentValue))
               {
                  mContentAndSubtagList.set(i, GZIP.compress(newValue));
               }
            }
         }
      }
   }

   //##########################################################################
   // PROTECTED METHODS
   //##########################################################################

   //---------------------------------------------------------------------------
   protected void sortAttributes(List<XMLAttribute> inAttributes)
   {
      if (inAttributes != null)
      {
         Collections.sort(inAttributes);
      }
   }

   //##########################################################################
   // PRIVATE METHODS
   //##########################################################################

   //----------------------------------------------------------------------
   private void construct(InputStream inXML)
         throws XMLException, IOException
   {
      construct(new InputStreamReader(inXML));
   }

   //----------------------------------------------------------------------
   private void construct(Reader inXML)
         throws XMLException, IOException
   {
      XMLTag rootTag = createFromInputSource(new InputSource(inXML));
      setTagName(rootTag.getTagName());
      setAttributes(rootTag.getAttributes());
      mNamespace = rootTag.mNamespace;
      mContentAndSubtagList = rootTag.mContentAndSubtagList;
   }

   //----------------------------------------------------------------------
   private static synchronized XMLTag createFromInputSource(InputSource inXML)
         throws XMLException, IOException
   {
      XMLTagReader tagReader = new XMLTagReader();
      tagReader.parse(inXML);
      return tagReader.getRootNode();

/*      try
      {
         XMLReader parser = getParser();
         parser.setContentHandler(getDocHandler());
         parser.setProperty("http://xml.org/sax/properties/lexical-handler", getDocHandler());
         parser.parse(inXML);
      }
      catch (Exception e)
      {
         throw new XMLException(e);
      }

      return getDocHandler().getRootTag();
*/
   }


   //---------------------------------------------------------------------------
   private void recursiveFindNodesByAttributeValue(String inAttribute, String inValue, List<XMLNode> inList)
   {
      if (inAttribute != null)
      {
         if (hasAttribute(inAttribute)
             && (null == inValue
                 || getAttributeValue(inAttribute).equals(inValue)))
         {
            inList.add(this);
         }
      }
      else
      {
         for (XMLAttribute attr : getAttributes())
         {
            if (null == inValue
                || attr.getValue().equals(inValue))
            {
               inList.add(this);
            }
         }
      }

      if (mContentAndSubtagList != null)
      {
         for (Object content : mContentAndSubtagList)
         {
            if (content instanceof XMLTag)
            {
               ((XMLTag)content).recursiveFindNodesByAttributeValue(inAttribute, inValue, inList);
            }
         }
      }
   }

   //---------------------------------------------------------------------------
   /**
    Composes an xml start tag (ex: "&lt;inName att1='value1' att2='value2'>").
    If the isEmptyTag parameter is true, the output tag will end with "/>".
    ex: "&lt;inName att1='value1' att2='value2'/>". Attributes appear in
    alphabetical order for consistency.
    */
   private void writeStartTag(Writer inWriter, XMLNamespaceSet inDeclaredNamespaces, String inTagName)
      throws IOException
   {
      inWriter.write("<");
      inWriter.write(inTagName);


      // Write attributes.
      if (mAttributes != null
          && mAttributes.size() > 0)
      {
         List<XMLAttribute> sordidAttributes = new ArrayList<>(mAttributes.values());
         if (mSortAttributesBeforeWriting)
         {
            sortAttributes(sordidAttributes);
         }

         for (XMLAttribute attribute : sordidAttributes)
         {
            inWriter.write(" ");

            XMLNamespace namespace = attribute.getNamespace();
            if (namespace != null
                  && namespace.getPrefix() != null
                  && (null == inDeclaredNamespaces
                      || null == inDeclaredNamespaces.getDefault()
                      || ! namespace.equals(inDeclaredNamespaces.getDefault())))
            {
               inWriter.write(namespace.getPrefix());
               inWriter.write(":");
            }
            inWriter.write(attribute.getName());

            String value = attribute.getValue();
            if (null == value) value = "";
            inWriter.write("=");

            String safeValue = "''";
            if (value != null)
            {
               if (sQuoteChar == '\'')
               {
                  safeValue =  "'" + XMLUtil.escapeAttributeValue(value) + "'";
               }
               else
               {
                  safeValue = "\"" + XMLUtil.escapeDoubleQuotedAttributeValue(value) + "\"";
               }
            }
            inWriter.write(safeValue);
         }
      }

      if (isEmptyTag()) inWriter.write(" /");
      inWriter.write(">");
   }

   //---------------------------------------------------------------------------
   private XMLNamespaceSet updateDeclaredNamespaces(XMLNamespaceSet inDeclaredNamespaces)
   {
      XMLNamespaceSet expandedNamespaceSet = inDeclaredNamespaces;
      if (getAttributes() != null)
      {
         boolean cloned = false;
         for (XMLAttribute attr : getAttributes())
         {
            String qualifiedAttrName = attr.getQualifiedName();
            if (qualifiedAttrName.startsWith("xmlns"))
            {
               if (! cloned)
               {
                  expandedNamespaceSet = new XMLNamespaceSet((inDeclaredNamespaces != null ? inDeclaredNamespaces.size() : 0) + 5);
                  if (CollectionUtil.hasValues(inDeclaredNamespaces))
                  {
                     expandedNamespaceSet.addAll(inDeclaredNamespaces);
                  }
                  cloned = true;
               }

               if (qualifiedAttrName.equals("xmlns"))
               {
                  expandedNamespaceSet.setDefault(XMLNamespace.getNamespace(attr.getValue()).clone());
               }
               else if (qualifiedAttrName.startsWith("xmlns:"))
               {
                  expandedNamespaceSet.add(XMLNamespace.getNamespace(qualifiedAttrName.substring(6), attr.getValue()).clone());
                  if (inDeclaredNamespaces != null)
                  {
                     // Propagate the previous default
                     expandedNamespaceSet.setDefault(inDeclaredNamespaces.getDefault());
                  }
               }
            }
         }
      }

      return expandedNamespaceSet;
   }

   //###########################################################################
   // INNER CLASS
   //###########################################################################

   private class ProducerThread extends Thread
   {
      OutputStream mOutputStream;

      //----------------------------------------------------------------------
      public ProducerThread(OutputStream inOutputStream)
      {
         mOutputStream = inOutputStream;
      }

      //----------------------------------------------------------------------
      public void run()
      {
         toXML(mOutputStream);
         try
         {
            mOutputStream.close();
         }
         catch (IOException e)
         {
            e.printStackTrace();
         }
      }


   }

}