package de.fhdw.wtf.parser;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   
   import de.fhdw.wtf.common.ast.Operation;
   import de.fhdw.wtf.common.ast.OperationModifier;
   import de.fhdw.wtf.common.ast.OperationModifierAbstract;
  import de.fhdw.wtf.common.ast.visitor.OperationModifierVisitor;
  import de.fhdw.wtf.common.exception.parser.AbstractParserException;
  import de.fhdw.wtf.common.exception.parser.NoSemicolonException;
  import de.fhdw.wtf.common.exception.parser.OperationModifierAlreadyAddedException;
  import de.fhdw.wtf.common.stream.TokenStream;
  import de.fhdw.wtf.common.token.Token;
  
  /**
   * Parser to parse the given TokenStream to {@link OperationModifier}s.
   */
  public final class OperationModifierParser {
  	
  	/**
  	 * TokenStream.
  	 */
  	private final TokenStream stream;
  	
  	/**
  	 * Collection of exceptions.
  	 */
  	private final Collection<AbstractParserException> exceptions;
  	
  	/**
  	 * Constructor of {@link OperationModifierParser}.
  	 * 
  	 * @param stream
  	 *            tokenStream
  	 * @param exceptions
  	 *            collection of exceptions
  	 */
  	private OperationModifierParser(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		this.stream = stream;
  		this.exceptions = exceptions;
  	}
  	
  	/**
  	 * FactoryMethod for {@link OperationModifierParser}.
  	 * 
  	 * @param stream
  	 *            tokenStream
  	 * @param exceptions
  	 *            collection of exceptions
  	 * @return The {@link OperationModifierParser}-Object.
  	 */
  	static OperationModifierParser create(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		return new OperationModifierParser(stream, exceptions);
  	}
  	
  	/**
  	 * Parses the next series of Tokens of this.stream to {@link OperationModifier}s until a SemicolonToken occurs. If
  	 * one of the Tokens between the first element of this.stream and the next SemicolonToken is not a subtype of
  	 * {@link OperationModifier}, a {@link NoSemicolonException} will be thrown.
  	 * 
  	 * @param currentOperation
  	 *            currentOperation
  	 * @return all OperationModifier
  	 * @throws AbstractParserException
  	 *             AbstractParserException
  	 */
  	Collection<OperationModifier> parse(final Operation currentOperation) throws AbstractParserException {
  		final Collection<OperationModifier> result = new ArrayList<>();
  		while (this.stream.hasNext()) {
  			if (this.stream.peek().isSemicolonToken()) {
  				this.stream.next();
  				currentOperation.setLastToken(this.stream.peek());
  				break;
  			} else {
  				try {
  					result.add(this.parseOperationModifier(result));
  				} catch (final OperationModifierAlreadyAddedException e) {
  					this.exceptions.add(e);
  					ParserUtils.skipToSemicolonToken(this.stream);
  					break;
  				}
  			}
  		}
  		return result;
  	}
  	
  	/**
  	 * Checks if the next Token of this.stream is a OperationModifierToken and returns it, if it is. Otherwise a
  	 * NoOperationModifierException will be returned.
  	 * 
  	 * @param modifiers
  	 *            already found modifiers
  	 * @return OperationModifier
  	 * @throws AbstractParserException
  	 *             AbstractParserException
  	 */
  	private OperationModifier parseOperationModifier(final Collection<OperationModifier> modifiers)
 			throws AbstractParserException {
 		final Token nextToken = this.stream.peek();
 		if (nextToken.isOperationModifierToken()) {
 			if (this.containsOperationModifier(modifiers, nextToken)) {
 				throw OperationModifierAlreadyAddedException.create(nextToken);
 			}
 			if (nextToken.isAbstractOperationToken()) {
 				this.stream.removeFirst();
 				return OperationModifierAbstract.create(nextToken, this.stream.peek());
 			}
 		}
 		throw NoSemicolonException.create(nextToken);
 	}
 	
 	/**
 	 * Checks if <code>modifiers</code> contains a modifier of the type of <code>modifier</code>.
 	 * 
 	 * @param modifiers
 	 *            : Modifiers of {@link OperationModifier}
 	 * @param modifier
 	 *            : modifier to search for
 	 * @return Boolean
 	 */
 	private boolean containsOperationModifier(final Collection<OperationModifier> modifiers, final Token modifier) {
 		final Iterator<OperationModifier> i = modifiers.iterator();
 		while (i.hasNext()) {
 			final OperationModifier current = i.next();
 			if (current.accept(new OperationModifierVisitor() {
 				
 				@Override
 				public boolean handle(final OperationModifier abstract1) {
 					return modifier.isAbstractOperationToken();
 				}
 				
 			})) {
 				return true;
 			}
 		}
 		return false;
 	}
 }