package de.fhdw.wtf.parser;
   
   import java.util.ArrayList;
   import java.util.Collection;
   
   import de.fhdw.wtf.common.ast.Model;
   import de.fhdw.wtf.common.exception.parser.AbstractParserException;
   import de.fhdw.wtf.common.exception.parser.NoValidTokenStreamException;
   import de.fhdw.wtf.common.stream.TokenStream;
  
  /**
   * <h1>Parser</h1> The {@link Parser} transforms a given TokenStream of <i>WTF-Tokens</i> into an abstract syntax tree.
   * See documentations for further information about the abstract syntax tree.
   */
  public final class Parser {
  	
  	/**
  	 * TokenStream.
  	 */
  	private final TokenStream stream;
  	
  	/**
  	 * Collection of exceptions.
  	 */
  	private final Collection<AbstractParserException> exceptions;
  	
  	/**
  	 * Constructor for a Parser. <code>stream</code> is the TokenStream which will be parsed.
  	 * 
  	 * @param stream
  	 *            tokenStream
  	 */
  	private Parser(final TokenStream stream) {
  		this.stream = stream;
  		this.exceptions = new ArrayList<>();
  	}
  	
  	/**
  	 * Factory Method for a {@link Parser}. <code>stream</code> is the TokenStream which will be parsed.
  	 * 
  	 * @param stream
  	 *            tokenStream
  	 * @return The {@link Parser}-Object.
  	 */
  	public static Parser create(final TokenStream stream) {
  		return new Parser(stream);
  	}
  	
  	/**
  	 * Starts the parsing process. A Model will be returned which represents the root node of an abstract syntax tree.
  	 * This tree will be the result of the processed stream.
  	 * 
  	 * @return The parsed Model
  	 * @throws NoValidTokenStreamException
  	 *             NoValidTokenStreamException
  	 */
  	public Model parse() throws NoValidTokenStreamException {
  		final Model result = ModelParser.create(this.stream, this.exceptions).parse();
  		if (this.exceptions.size() > 0) {
  			throw NoValidTokenStreamException.create();
  		}
  		return result;
  	}
  	
  	/**
  	 * Returns all exceptions.
  	 * 
  	 * @return all exceptions
  	 */
  	public Collection<AbstractParserException> getExceptions() {
  		return this.exceptions;
  	}
  }