package ca.uhn.hl7v2.util;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PushbackReader;
import java.io.Reader;
import java.util.Iterator;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>
 * Reads from an {@link InputStream} containing a stream of encoded HL7 messages
 * and iterates over those messages. This class is geared towards reading from
 * files, and tries to be very lenient about the format of the stream,
 * specifically concerning control characters and line endings. It should be
 * safe to provide a stream containing Windows or Unix line endings (which will
 * be treated as segment delimiters). It is also safe to provide a stream
 * containing MLLP control blocks before and after each message (although these
 * will not be validated! Do not use this class to read MLLP messages from a
 * socket stream!)
 * </p>
 * <p>
 * The input stream could, for example, be a FileInputStream reading from a text
 * file containing a number of HL7 messages in plain text format.
 * </p>
 * <p>
 * Usage note: If an IOException occurs while reading from the stream or a
 * message parsing exception occurs, it will be thrown as an unchecked
 * {@link ParseFailureError}
 * </p>
 */
public class Hl7InputStreamMessageStringIterator implements Iterator<String> {

        @SuppressWarnings("unused")
        private static final Logger ourLog = LoggerFactory.getLogger(Hl7InputStreamMessageStringIterator.class);
        
        private StringBuilder myBuffer = new StringBuilder();
        private boolean myFoundMessageInBuffer = false;
        private Boolean myHasNext;
        private boolean myIgnoreComments;
        private String myNext;
        private Reader myReader;

        /**
         * Constructor
         * 
         * @param theInputStream
         *            The input stream to read from
         */
        public Hl7InputStreamMessageStringIterator(InputStream theInputStream) {
                this(new InputStreamReader(theInputStream));
        }

        /**
         * Constructor
         * 
         * @param theReader
         *            The reader to read from
         */
        public Hl7InputStreamMessageStringIterator(Reader theReader) {
                myReader = new PushbackReader(theReader);
        }

        /**
         * {@inheritDoc}
         */
        public boolean hasNext() {
                if (myHasNext == null) {

                        int next;
                        int prev = -1;
                        int endOfBuffer = -1;
                        boolean inComment = false;
                        
                        while (true) {
                                try {
                                        next = myReader.read();
                                } catch (IOException e) {
                                        throw new ParseFailureError("IOException reading from input", e);
                                }

                                if (next == -1) {
                                        break;
                                }

                                char nextChar = (char) next;
                                if (nextChar == '#' && myIgnoreComments && (prev == -1 || prev == '\n' || prev == '\r')) {
                                        inComment = true;
                                        continue;
                                }
                                
                                // Convert '\n' or "\r\n" to '\r'
                                if (nextChar == 10) {
                                        if (myBuffer.length() > 0) {
                                                if (myBuffer.charAt(myBuffer.length() - 1) == 13) {
                                                        // don't append
                                                } else {
                                                        myBuffer.append((char) 13);
                                                }
                                        }
                                } else if (inComment) {
                                        if (nextChar == 10 || nextChar == 13) {
                                                inComment = false;
                                        }
                                } else {
                                        myBuffer.append(nextChar);
                                }
                                
                                prev = next;
                                
                                int bLength = myBuffer.length();
                                if (nextChar == 'H' && bLength >= 3) {
                                        if (myBuffer.charAt(bLength - 2) == 'S') {
                                                if (myBuffer.charAt(bLength - 3) == 'M') {
                                                        if (myFoundMessageInBuffer) {
                                                                if (myBuffer.charAt(bLength - 4) < 32) {
                                                                        endOfBuffer = bLength - 3;
                                                                        break;
                                                                }
                                                        } else {
                                                                // Delete any whitespace or other stuff before
                                                                // the first message
                                                                myBuffer.delete(0, bLength - 3);
                                                                myFoundMessageInBuffer = true;
                                                        }
                                                }
                                        }
                                }

                        } // while(true)

                        if (!myFoundMessageInBuffer) {
                                myHasNext = false;
                                return myHasNext;
                        }

                        String msgString;
                        if (endOfBuffer > -1) {
                                msgString = myBuffer.substring(0, endOfBuffer);
                                myBuffer.delete(0, endOfBuffer);
                        } else {
                                msgString = myBuffer.toString();
                                myBuffer.setLength(0);
                        }

                        if (!msgString.startsWith("MSH")) {
                                myHasNext = Boolean.FALSE;
                                return myHasNext;
                        }

                        myNext = msgString;
                        myHasNext = Boolean.TRUE;

                }
                return myHasNext;
        }

        /**
         * {@inheritDoc}
         */
        public String next() {
                if (!hasNext()) {
                        throw new IllegalStateException();
                }
                String retVal = myNext;
                myNext = null;
                myHasNext = null;
                return retVal;
        }

        /**
         * Unsupported method!
         * 
         * @throws UnsupportedOperationException
         *             If called
         */
        public void remove() {
                throw new UnsupportedOperationException();
        }

        /**
         * If set to true, any lines beginning with a hash (#) will be ignored. This
         * allows you to place comments in a file to be read if needed.
         */
        public void setIgnoreComments(boolean theIgnoreComments) {
                myIgnoreComments = theIgnoreComments;
        }

        public static class ParseFailureError extends RuntimeException {

                private static final long serialVersionUID = 1L;

                public ParseFailureError(String theMessage, Exception theCause) {
                        super(theMessage, theCause);
                }

        }

}