package net.sf.logdistiller.xml;

/*
 * Licensed 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.
 */

import java.util.Iterator;
import java.util.NoSuchElementException;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * Miscellaneous utilities for DOM.
 */
public class DOMUtils
{
    private DOMUtils()
    {
    }

    public static String getPCDATAByTagName( Element elmt, String tagName )
    {
        return getPCDATAByTagName( elmt, tagName, false );
    }

    public static String getPCDATAByTagName( Element elmt, String tagName, boolean normalize )
    {
        Iterator<Element> iter = getChildElementsByTagName( elmt, tagName );
        if ( !iter.hasNext() )
        {
            return null;
        }
        return getPCDATA( (Element) iter.next(), normalize );
    }

    /**
     * Computes the resulting string of a <code>#PCDATA</code> element: it can consist in the XML document of a
     * combination of nodes Text, EntityReference and CDATASection, with Comment.
     *
     * @param normalize normalize the element before computing?
     */
    public static String getPCDATA( Element element, boolean normalize )
    {
        if ( normalize )
        {
            element.normalize();
        }
        StringBuffer buff = new StringBuffer();
        NodeList list = element.getChildNodes();
        int len = list.getLength();
        for ( int i = 0; i < len; i++ )
        {
            Node n = list.item( i );
            switch ( n.getNodeType() )
            {
                case Node.TEXT_NODE:
                case Node.CDATA_SECTION_NODE:
                    buff.append( n.getNodeValue() );
                    break;
                case Node.ENTITY_REFERENCE_NODE:
                    buff.append( n.getFirstChild().getNodeValue() );
                    break;
                case Node.COMMENT_NODE:
                    break; // ignore comments
                default: // should not occur if really #PCDATA
                    throw new IllegalArgumentException( "element '" + element.getNodeName()
                        + "' is not #PCDATA because it " + "contains a " + getNodeTypeAsString( n ) + " node" );
            }
        }
        return buff.toString();
    }

    public static String getPCDATA( Element elmt )
    {
        return getPCDATA( elmt, false );
    }

    public static Iterator<Element> getChildElementsByTagName( Element element, String tagName )
    {
        return new ElementIterator( element.getChildNodes(), tagName );
    }

    public static String getNodeTypeAsString( Node node )
    {
        int type = node.getNodeType();
        switch ( type )
        {
            case Node.ELEMENT_NODE:
                return "Element";
            case Node.ATTRIBUTE_NODE:
                return "Attribute";
            case Node.TEXT_NODE:
                return "Text";
            case Node.CDATA_SECTION_NODE:
                return "CDATASection";
            case Node.ENTITY_REFERENCE_NODE:
                return "EntityReference";
            case Node.ENTITY_NODE:
                return "Entity";
            case Node.PROCESSING_INSTRUCTION_NODE:
                return "ProcessingInstruction";
            case Node.COMMENT_NODE:
                return "Comment";
            case Node.DOCUMENT_NODE:
                return "Document";
            case Node.DOCUMENT_TYPE_NODE:
                return "DocumentType";
            case Node.DOCUMENT_FRAGMENT_NODE:
                return "DocumentFragment";
            case Node.NOTATION_NODE:
                return "Notation";
            default:
        }
        return "Unknown node type: " + type;
    }

    private static class ElementIterator
        implements Iterator<Element>
    {
        private final NodeList nodeList;

        private final String tagName;

        private int index;

        private Element next;

        public ElementIterator( NodeList nodeList, String tagName )
        {
            this.nodeList = nodeList;
            this.tagName = tagName;
            findNext();
        }

        public boolean hasNext()
        {
            return ( next != null );
        }

        private void findNext()
        {
            while ( index < nodeList.getLength() )
            {
                Node node = nodeList.item( index );
                index++;
                if ( ( node.getNodeType() == Node.ELEMENT_NODE )
                    && ( ( tagName == null ) || node.getNodeName().equals( tagName ) ) )
                {
                    // next element found
                    next = (Element) node;
                    return;
                }
            }
            // no element available any more
            next = null;
        }

        public Element next()
        {
            if ( next == null )
            {
                throw new NoSuchElementException();
            }
            Element returnValue = next;
            findNext();
            return returnValue;
        }

        public void remove()
        {
            throw new UnsupportedOperationException();
        }
    }
}