// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.xml;

import java.io.*;

import org.litesoft.commonfoundation.typeutils.*;
import org.xmlpull.v1.*;

public class PullParserProxy
{
    /**
     * Signal that parser has just read (and is at) a start tag.
     * See getAttribute* methods to retrieve element attribute.
     */
    public static final int START_TAG = XmlPullParser.START_TAG;

    /**
     * Signal that parser has just read (and is at) an end tag.
     */
    public static final int END_TAG = XmlPullParser.END_TAG;

    /**
     * Signal that parser has just read (and is at) a TEXT event,
     * skipping IGNORABLE_WHITESPACE, PROCESSING_INSTRUCTION and COMMENT events,
     * the text value will be normalized. For high level applications the text is
     * normalized apropriately.
     */
    public static final int TEXT = XmlPullParser.TEXT;

    public static final String[] TYPES = XmlPullParser.TYPES;

    private XmlPullParser mPullparser;

    public PullParserProxy()
            throws XML_RuntimeException
    {
        try
        {
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
//        //factory.setNamespaceAware(true);
            factory.setFeature( XmlPullParser.FEATURE_PROCESS_NAMESPACES, true );

            mPullparser = factory.newPullParser();
        }
        catch ( XmlPullParserException e )
        {
            throw new XML_RuntimeException( e );
        }
    }

    public PullParserProxy setInput( String pXML_NoN )
            throws XML_RuntimeException
    {
        return initializeForInput( new StringReader( pXML_NoN ) );
    }

    public PullParserProxy setInput( Reader pReaderNoN )
            throws XML_RuntimeException
    {
        if ( !(pReaderNoN instanceof BufferedReader) )
        {
            pReaderNoN = new BufferedReader( pReaderNoN );
        }

        return initializeForInput( pReaderNoN );
    }

    private PullParserProxy initializeForInput( Reader pReader )
            throws XML_RuntimeException
    {
        try
        {
            mPullparser.setInput( pReader );
            //parser.setInput( new FileReader( args[i] ) );
            //parser.setInput ( new InputStreamReader( new FileInputStream ( args [i] ) ) );
            //parser.setInput ( new FileInputStream ( args [i] ), "UTF-8"  );
        }
        catch ( XmlPullParserException e )
        {
            throw new XML_RuntimeException( e );
        }

        require( XmlPullParser.START_DOCUMENT );

        return this;
    }

    /**
     * Find the next Appropriate Event Tag Type
     *
     * @param pEndName - Name of EndTag that is Acceptable
     *
     * @return Event Type (ONLY one of the following): START_TAG, END_TAG
     */
    public int getNextTag( String pEndName )
            throws XML_RuntimeException
    {
        return checkTagStartOrEnd( nextTag(), pEndName );
    }

    /**
     * Find the next Appropriate Event Type
     *
     * @param pEndName - Name of EndTag that is Acceptable
     *
     * @return Event Type (ONLY one of the following): TEXT, START_TAG, END_TAG
     */
    public int getNextTextOrTag( String pEndName )
            throws XML_RuntimeException
    {
        int eventType = getNextNonWhiteSpace();

        if ( TEXT == eventType )
        {
            return eventType;
        }
        return checkTagStartOrEnd( eventType, pEndName );
    }

    public boolean isStartTag()
            throws XML_RuntimeException
    {
        return START_TAG == getEventType();
    }

    public boolean isText()
            throws XML_RuntimeException
    {
        return TEXT == getEventType();
    }

    public void checkNextIsEndOfDocument()
            throws XML_RuntimeException
    {
        next();

        require( XmlPullParser.END_DOCUMENT );
    }

    public String getNextStartTag()
    {
        nextTag();
        try
        {
            mPullparser.require( START_TAG, null, null );
        }
        catch ( XmlPullParserException e )
        {
            throw new XML_RuntimeException( e );
        }
        catch ( IOException e )
        {
            throw new XML_RuntimeException( e );
        }
        return getTagName();
    }

    public String validateNextIsStartTag( String pStartTagName )
            throws XML_RuntimeException
    {
        nextTag();

        validateIsStartTag( pStartTagName );

        return pStartTagName;
    }

    public void validateNextIsEndTag( String pEndName )
            throws XML_RuntimeException
    {
        nextTag();

        validateIsEndTag( pEndName );
    }

    public String getTagName()
            throws XML_RuntimeException
    {
        return mPullparser.getName();
    }

    public void validateIsStartTag( String pStartTagName )
            throws XML_RuntimeException
    {
        require( START_TAG, pStartTagName );
    }

    public void validateIsEndTag( String pEndName )
            throws XML_RuntimeException
    {
        require( END_TAG, pEndName );
    }

    public String getTextFromTextElement( String pTagName )
            throws XML_RuntimeException
    {
        String rv = mPullparser.getText();

        validateNextIsEndTag( pTagName );

        return rv;
    }

    public String getTextFromTextElement()
            throws XML_RuntimeException
    {
        String endName = getTagName();

        String rv = nextText();

        validateIsEndTag( endName );

        return rv;
    }

    private int getNextNonWhiteSpace()
            throws XML_RuntimeException
    {
        int eventType;
        do
        {
            eventType = next();
        }
        while ( (eventType == TEXT) && isWhiteSpace() );

        return eventType;
    }

    private int checkTagStartOrEnd( int pEventType, String pEndName )
            throws XML_RuntimeException
    {
        if ( START_TAG == pEventType )
        {
            return pEventType;
        }
        validateIsEndTag( pEndName );
        return END_TAG;
    }

    public String ignoreRestOfCurrentElement( String pTagName )
            throws XML_RuntimeException
    {
        if ( (XmlPullParser.END_TAG == getEventType()) && (pTagName.equals( mPullparser.getName() )) )
        {
            return pTagName;
        }

        for ( int eventType; XmlPullParser.END_TAG != (eventType = next()); )
        {
            if ( eventType == XmlPullParser.START_TAG )
            {
                ignoreRestOfCurrentElement( mPullparser.getName() );
            }
        }

        validateIsEndTag( pTagName );

        return pTagName;
    }

    /**
     * Returns the number of attributes of the current start tag, or
     * -1 if the current event type is not START_TAG
     */
    public int getAttributeCount()
    {
        return mPullparser.getAttributeCount();
    }

    /**
     * Returns the local name of the specified attribute
     * if namespaces are enabled or just attribute name if namespaces are disabled.
     * Throws an IndexOutOfBoundsException if the index is out of range
     * or current event type is not START_TAG.
     *
     * @param index zero based index of attribute
     *
     * @return attribute name (null is never returned)
     */
    public String getAttributeName( int index )
            throws IndexOutOfBoundsException
    {
        return mPullparser.getAttributeName( index );
    }

    /**
     * Returns the given attribute value.
     * Throws an IndexOutOfBoundsException if the index is out of range
     * or current event type is not START_TAG.
     * <p/>
     * <p><strong>NOTE:</strong> attribute value must be normalized
     * (including entity replacement text if PROCESS_DOCDECL is false) as described in
     * <a href="http://www.w3.org/TR/REC-xml#AVNormalize">XML 1.0 section
     * 3.3.3 Attribute-Value Normalization</a>
     *
     * @param index zero based index of attribute
     *
     * @return value of attribute (null is never returned)
     */
    public String getAttributeValue( int index )
            throws IndexOutOfBoundsException
    {
        return mPullparser.getAttributeValue( index );
    }

    public String getAttributeValue( String pAttributeName )
    {
        if ( pAttributeName != null )
        {
            for ( int i = getAttributeCount(); --i >= 0; )
            {
                if ( pAttributeName.equals( getAttributeName( i ) ) )
                {
                    return getAttributeValue( i );
                }
            }
        }
        return null;
    }

    public String getUnderlyingEventType()
            throws XML_RuntimeException
    {
        return TYPES[getEventType()];
    }

    public String walkEventType()
            throws XML_RuntimeException
    {
        int eventType = next();
        String type = XmlPullParser.TYPES[eventType];
        switch ( eventType )
        {
            case XmlPullParser.START_TAG:
                return type + ": " + mPullparser.getName() + " - " + mPullparser.getAttributeCount();
            case XmlPullParser.END_TAG:
                return type + ": " + mPullparser.getName();
            case XmlPullParser.TEXT:
                return type + ": \"" + Strings.cvtTextForDisplay( mPullparser.getText() ) + "\"";
            case XmlPullParser.START_DOCUMENT:
            case XmlPullParser.END_DOCUMENT:
            default:
                return type;
        }
    }

    public boolean walkHasMore()
            throws XML_RuntimeException
    {
        return (getEventType() != XmlPullParser.END_DOCUMENT);
    }

    // Start Of: simple Exception Converting Vectoring methods to Real Pull Parser...

    private void require( int pEventType )
            throws XML_RuntimeException
    {
        require( pEventType, null );
    }

    private void require( int pEventType, String pName )
            throws XML_RuntimeException
    {
        try
        {
            mPullparser.require( pEventType, null, pName );
        }
        catch ( XmlPullParserException e )
        {
            throw new XML_RuntimeException( e );
        }
        catch ( IOException e )
        {
            throw new XML_RuntimeException( e );
        }
    }

    private boolean isWhiteSpace()
            throws XML_RuntimeException
    {
        try
        {
            return mPullparser.isWhitespace();
        }
        catch ( XmlPullParserException e )
        {
            throw new XML_RuntimeException( e );
        }
    }

    private String nextText()
            throws XML_RuntimeException
    {
        try
        {
            return mPullparser.nextText();
        }
        catch ( XmlPullParserException e )
        {
            throw new XML_RuntimeException( e );
        }
        catch ( IOException e )
        {
            throw new XML_RuntimeException( e );
        }
    }

    private int nextTag()
            throws XML_RuntimeException
    {
        try
        {
            return mPullparser.nextTag();
        }
        catch ( XmlPullParserException e )
        {
            throw new XML_RuntimeException( e );
        }
        catch ( IOException e )
        {
            throw new XML_RuntimeException( e );
        }
    }

    private int next()
            throws XML_RuntimeException
    {
        try
        {
            return mPullparser.next();
        }
        catch ( XmlPullParserException e )
        {
            throw new XML_RuntimeException( e );
        }
        catch ( IOException e )
        {
            throw new XML_RuntimeException( e );
        }
    }

    private int getEventType()
            throws XML_RuntimeException
    {
        try
        {
            return mPullparser.getEventType();
        }
        catch ( XmlPullParserException e )
        {
            throw new XML_RuntimeException( e );
        }
    }
}