/*

 * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.xml.internal.stream;

import com.sun.xml.internal.stream.events.XMLEventAllocatorImpl;

import java.util.NoSuchElementException;

import javax.xml.stream.XMLInputFactory;

import javax.xml.stream.XMLStreamConstants;

import javax.xml.stream.XMLStreamException;

import javax.xml.stream.XMLStreamReader;

import javax.xml.stream.events.EntityReference;

import javax.xml.stream.events.XMLEvent;

import javax.xml.stream.util.XMLEventAllocator;

/**

 * @author  @author  Neeraj Bajaj Sun Microsystems

 *

 */

public class XMLEventReaderImpl implements javax.xml.stream.XMLEventReader{

    protected XMLStreamReader fXMLReader ;

    protected XMLEventAllocator fXMLEventAllocator;

    //only constructor will do because we delegate everything to underlying XMLStreamReader

    public XMLEventReaderImpl(XMLStreamReader reader) throws  XMLStreamException {

        fXMLReader = reader ;

        fXMLEventAllocator = (XMLEventAllocator)reader.getProperty(XMLInputFactory.ALLOCATOR);

        if(fXMLEventAllocator == null){

            fXMLEventAllocator = new XMLEventAllocatorImpl();

        }

        fPeekedEvent = fXMLEventAllocator.allocate(fXMLReader);

    }

    public boolean hasNext() {

        //if we have the peeked event return 'true'

        if(fPeekedEvent != null)return true;

        //this is strange XMLStreamReader throws XMLStreamException

        //XMLEventReader doesn't throw XMLStreamException

        boolean next = false ;

        try{

            next = fXMLReader.hasNext();

        }catch(XMLStreamException ex){

            return false;

        }

        return next ;

    }

    public XMLEvent nextEvent() throws XMLStreamException {

        //if application peeked return the peeked event

        if(fPeekedEvent != null){

            fLastEvent = fPeekedEvent ;

            fPeekedEvent = null;

            return fLastEvent ;

        }

        else if(fXMLReader.hasNext()){

            //advance the reader to next state.

            fXMLReader.next();

            return fLastEvent = fXMLEventAllocator.allocate(fXMLReader);

        }

        else{

            fLastEvent = null;

            throw new NoSuchElementException();

        }

    }

    public void remove(){

        //remove of the event is not supported.

        throw new java.lang.UnsupportedOperationException();

    }

    public void close() throws XMLStreamException {

        fXMLReader.close();

    }

    /** Reads the content of a text-only element. Precondition:

     * the current event is START_ELEMENT. Postcondition:

     * The current event is the corresponding END_ELEMENT.

     * @throws XMLStreamException if the current event is not a START_ELEMENT

     * or if a non text element is encountered

     */

    public String getElementText() throws XMLStreamException {

        //we have to keep reference to the 'last event' of the stream to be able

        //to make this check - is there another way ? - nb.

        if(fLastEvent.getEventType() != XMLEvent.START_ELEMENT){

            throw new XMLStreamException(

            "parser must be on START_ELEMENT to read next text", fLastEvent.getLocation());

        }

        // STag content ETag

        //[43]   content   ::=   CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*

        //<foo>....some long text say in KB and underlying parser reports multiple character

        // but getElementText() events....</foo>

        String data = null;

        //having a peeked event makes things really worse -- we have to test the first event

        if(fPeekedEvent != null){

            XMLEvent event = fPeekedEvent ;

            fPeekedEvent = null;

            int type = event.getEventType();

            if(  type == XMLEvent.CHARACTERS || type == XMLEvent.SPACE ||

            type == XMLEvent.CDATA){

                data = event.asCharacters().getData();

            }

            else if(type == XMLEvent.ENTITY_REFERENCE){

                data = ((EntityReference)event).getDeclaration().getReplacementText();

            }

            else if(type == XMLEvent.COMMENT || type == XMLEvent.PROCESSING_INSTRUCTION){

                //ignore

            } else if(type == XMLEvent.START_ELEMENT) {

                throw new XMLStreamException(

                "elementGetText() function expects text only elment but START_ELEMENT was encountered.", event.getLocation());

            }else if(type == XMLEvent.END_ELEMENT){

                return "";

            }

            //create the string buffer and add initial data

            StringBuffer buffer = new StringBuffer();

            if(data != null && data.length() > 0 ) {

                buffer.append(data);

            }

            //get the next event -- we should stop at END_ELEMENT but it can be any thing

            //things are worse when implementing this function in XMLEventReader because

            //there isn't any function called getText() which can get values for

            //space, cdata, characters and entity reference

            //nextEvent() would also set the last event.

            event = nextEvent();

            while(event.getEventType() != XMLEvent.END_ELEMENT){

                if(  type == XMLEvent.CHARACTERS || type == XMLEvent.SPACE ||

                type == XMLEvent.CDATA){

                    data = event.asCharacters().getData();

                }

                else if(type == XMLEvent.ENTITY_REFERENCE){

                    data = ((EntityReference)event).getDeclaration().getReplacementText();

                }

                else if(type == XMLEvent.COMMENT || type == XMLEvent.PROCESSING_INSTRUCTION){

                    //ignore

                } else if(type == XMLEvent.END_DOCUMENT) {

                    throw new XMLStreamException("unexpected end of document when reading element text content");

                } else if(type == XMLEvent.START_ELEMENT) {

                    throw new XMLStreamException(

                    "elementGetText() function expects text only elment but START_ELEMENT was encountered.", event.getLocation());

                } else {

                    throw new XMLStreamException(

                    "Unexpected event type "+ type, event.getLocation());

                }

                //add the data to the buffer

                if(data != null && data.length() > 0 ) {

                    buffer.append(data);

                }

                event = nextEvent();

            }

            return buffer.toString();

        }//if (fPeekedEvent != null)

        //if there was no peeked, delegate everything to fXMLReader

        //update the last event before returning the text

        data = fXMLReader.getElementText();

        fLastEvent = fXMLEventAllocator.allocate(fXMLReader);

        return data;

    }

    /** Get the value of a feature/property from the underlying implementation

     * @param name The name of the property

     * @return The value of the property

     * @throws IllegalArgumentException if the property is not supported

     */

    public Object getProperty(java.lang.String name) throws java.lang.IllegalArgumentException {

        return fXMLReader.getProperty(name) ;

    }

    /** Skips any insignificant space events until a START_ELEMENT or

     * END_ELEMENT is reached. If anything other than space characters are

     * encountered, an exception is thrown. This method should

     * be used when processing element-only content because

     * the parser is not able to recognize ignorable whitespace if

     * the DTD is missing or not interpreted.

     * @throws XMLStreamException if anything other than space characters are encountered

     */

    public XMLEvent nextTag() throws XMLStreamException {

        //its really a pain if there is peeked event before calling nextTag()

        if(fPeekedEvent != null){

            //check the peeked event first.

            XMLEvent event = fPeekedEvent;

            fPeekedEvent = null ;

            int eventType = event.getEventType();

            //if peeked event is whitespace move to the next event

            //if peeked event is PI or COMMENT move to the next event

            if( (event.isCharacters() && event.asCharacters().isWhiteSpace())

            || eventType == XMLStreamConstants.PROCESSING_INSTRUCTION

            || eventType == XMLStreamConstants.COMMENT

            || eventType == XMLStreamConstants.START_DOCUMENT){

                event = nextEvent();

                eventType = event.getEventType();

            }

            //we have to have the while loop because there can be many PI or comment event in sucession

            while((event.isCharacters() && event.asCharacters().isWhiteSpace())

            || eventType == XMLStreamConstants.PROCESSING_INSTRUCTION

            || eventType == XMLStreamConstants.COMMENT){

                event = nextEvent();

                eventType = event.getEventType();

            }

            if (eventType != XMLStreamConstants.START_ELEMENT && eventType != XMLStreamConstants.END_ELEMENT) {

                throw new XMLStreamException("expected start or end tag", event.getLocation());

            }

            return event;

        }

        //if there is no peeked event -- delegate the work of getting next event to fXMLReader

        fXMLReader.nextTag();

        return (fLastEvent = fXMLEventAllocator.allocate(fXMLReader));

    }

    public Object next() {

        Object object = null;

        try{

            object = nextEvent();

        }catch(XMLStreamException streamException){

            fLastEvent = null ;

            //don't swallow the cause

            NoSuchElementException e = new NoSuchElementException(streamException.getMessage());

            e.initCause(streamException.getCause());

            throw e;

        }

        return object;

    }

    public XMLEvent peek() throws XMLStreamException{

        //if someone call peek() two times we should just return the peeked event

        //this is reset if we call next() or nextEvent()

        if(fPeekedEvent != null) return fPeekedEvent;

        if(hasNext()){

            //revisit: we can implement peek() by calling underlying reader to advance

            // the stream and returning the event without the knowledge of the user

            // that the stream was advanced but the point is we are advancing the stream

            //here. -- nb.

            // Is there any application that relies on this behavior ?

            //Can it be an application knows that there is particularly very large 'comment' section

            //or character data which it doesn't want to read or to be returned as event

            //But as of now we are creating every event but it can be optimized not to create

            // the event.

            fXMLReader.next();

            fPeekedEvent = fXMLEventAllocator.allocate(fXMLReader);

            return fPeekedEvent;

        }else{

            return null;

        }

    }//peek()

    private XMLEvent fPeekedEvent;

    private XMLEvent fLastEvent;

}//XMLEventReaderImpl