package wox.serial;

import java.io.*;
import org.litesoft.core.typeutils.Objects;
import java.util.*;

import org.jdom.Document;
import org.jdom.Element;
import org.jdom.*;
import org.jdom.input.*;
import org.w3c.dom.*;

/**
 * Version: 1.0
 * Author: Carlos R. Jaimez Gonzalez
 * Author: Simon M. Lucas
 * Site: http://woxserializer.sourceforge.net/
 *
 * Version: 1.5
 * Author: Steven M Lewis
 *
 * Version: 2.0
 * Author: George Smith
 * SVN: http://svn.xp-dev.com/svn/WOX2/
 * Note: XML form for vs 2 is more compact and therefor incompatible with vs 1
 */

public class XMLreaderImpl implements XMLreader
{
    private DomIterator mDomIterator;
    private int mNextBase;
    private Element mCurrentElement = null;

    private XMLreaderImpl( DomIterator pDomIterator )
    {
        if ( null != (mDomIterator = pDomIterator) )
        {
            mNextBase = mDomIterator.getCurrentDepth();
        }
    }

    public XMLreaderImpl( Reader pReader )
            throws DOMException, IOException
    {
        this( new DomIterator( pReader ) );
    }

    public boolean readStartElement()
    {
        if ( mDomIterator != null )
        {
            if ( null != (mCurrentElement = (mCurrentElement == null) ? mDomIterator.first() : mDomIterator.next( mNextBase )) )
            {
                return true;
            }
            mDomIterator = null;
        }
        return false;
    }

    public boolean hasAttributesOrElementText()
    {
        List zAttributes = mCurrentElement.getAttributes();
        return ((zAttributes != null) && !zAttributes.isEmpty()) || (null != readElementText());
    }

    public String getAttribute( String pName )
    {
        assertIsCurrentElement();
        return XMLutils.decodeText( mCurrentElement.getAttributeValue( pName ) );
    }

    public String readElementText()
    {
        assertIsCurrentElement();
        String s = mCurrentElement.getText();
        return XMLutils.decodeText( (s != null) ? s : "" );
    }

    public XMLreader createSubtreeReader()
    {
        assertIsCurrentElement();
        return new XMLreaderImpl( mDomIterator );
    }

    public void dispose()
    {
        mDomIterator = null;
        mCurrentElement = null;
    }

    private void assertIsCurrentElement()
    {
        if ( mCurrentElement == null )
        {
            throw new IllegalStateException( "No Current Element" );
        }
    }

    @Override
    protected void finalize()
            throws Throwable
    {
        dispose();
        super.finalize();
    }

    public static class DomIterator
    {
        /**
         * The Top is returned with first(), otherwise the Top is what WAS returned and is used by next() to determine what to return
         */
        private Stack<Entry> mElements = new Stack<Entry>();

        public DomIterator( Reader pReader )
                throws DOMException, IOException
        {
            try
            {
                SAXBuilder builder = new SAXBuilder();
                Document doc = builder.build( pReader );
                mElements.push( new Entry( doc.getRootElement(), 0 ) );
            }
            catch ( JDOMException e )
            {
                throw new OurDOMException( e );
            }
        }

        public int getCurrentDepth()
        {
            return mElements.size();
        }

        public Element first()
        {
            return !mElements.isEmpty() ? mElements.peek().getElement() : null;
        }

        public Element next( int pCurrentDepthLimit )
        {
            while ( !mElements.isEmpty() )
            {
                // First try to return my next (first?) Child
                Entry zEntry = mElements.peek();
                int zNextChild = zEntry.getAndIncNextChild();
                Element zElement = zEntry.getElement();
                List zChildren = zElement.getChildren();
                if ( (zChildren != null) && (zNextChild < zChildren.size()) )
                {
                    zElement = (Element) zChildren.get( zNextChild );
                    mElements.push( new Entry( zElement, 0 ) );
                    return zElement;
                }
                // Next Get My Sibling
                if ( mElements.size() <= pCurrentDepthLimit ) // No more at this level
                {
                    return null;
                }
                mElements.pop(); // loop using Parent
            }
            return null;
        }

        private static class Entry
        {
            private Element mElement;
            private int mNextChild;

            private Entry( Element pElement, int pNextChild )
            {
                mElement = pElement;
                mNextChild = pNextChild;
            }

            public Element getElement()
            {
                return mElement;
            }

            public int getAndIncNextChild()
            {
                return mNextChild++;
            }
        }
    }

    public static class OurDOMException extends DOMException
    {
        public OurDOMException( JDOMException pCause )
        {
            super( (short) 0, pCause.getMessage() );
            initCause( pCause );
        }
    }
}