/*
 * Parser.java
 */
package org.ngbw.utils;


import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.util.regex.Pattern;


/**
 * 
 * @author Paul Hoover
 *
 */
abstract class Parser {

	private final BufferedReader m_reader;
	private final Pattern m_filter;
	private StringBuilder m_completeSource;
	private StringBuilder m_filteredSource;
	private boolean m_filtering;

	protected String m_line;


	/**
	 * 
	 * @param input
	 */
	protected Parser(String input, Pattern filter)
	{
		this(new StringReader(input), filter);
	}

	/**
	 * 
	 * @param input
	 */
	protected Parser(byte[] input, Pattern filter)
	{
		this(new ByteArrayInputStream(input), filter);
	}

	/**
	 * 
	 * @param input
	 */
	protected Parser(InputStream input, Pattern filter)
	{
		this(new InputStreamReader(input), filter);
	}

	/**
	 * 
	 * @param input
	 */
	protected Parser(Reader input, Pattern filter)
	{
		m_reader = new BufferedReader(input);
		m_filter = filter;
	}


	/**
	 * 
	 * @throws IOException
	 */
	protected void readAndStoreLine() throws IOException
	{
		readLine();
		storeLine();
	}

	/**
	 * 
	 * @return
	 */
	protected String getCompleteSource()
	{
		return m_completeSource.toString();
	}

	/**
	 * 
	 * @return
	 */
	protected String getFilteredSource()
	{
		return m_filteredSource.toString();
	}

	/**
	 * 
	 * @param pattern
	 * @return
	 * @throws IOException
	 */
	protected boolean findFirstLine(Pattern pattern) throws IOException
	{
		m_completeSource = new StringBuilder();
		m_filteredSource = new StringBuilder();
		m_filtering = true;

		while (true) {
			readLine();

			if (m_line == null)
				return false;

			if (pattern.matcher(m_line).matches()) {
				storeLine();

				break;
			}
		}

		return true;
	}


	/**
	 * 
	 * @throws IOException
	 */
	private void readLine() throws IOException
	{
		m_line = m_reader.readLine();
	}

	/**
	 * 
	 */
	private void storeLine()
	{
		m_completeSource.append(m_line);
		m_completeSource.append('\n');

		if (m_filtering) {
			if (m_filter.matcher(m_line).matches())
				m_filtering = false;
			else {
				m_filteredSource.append(m_line);
				m_filteredSource.append('\n');
			}
		}
	}
}