package de.fhdw.wtf.parser;
   
   import java.util.ArrayList;
   import java.util.Collection;
   
   import de.fhdw.wtf.common.ast.Operation;
   import de.fhdw.wtf.common.ast.OperationModifier;
   import de.fhdw.wtf.common.ast.type.ClassType;
   import de.fhdw.wtf.common.ast.type.ProductType;
  import de.fhdw.wtf.common.ast.type.Type;
  import de.fhdw.wtf.common.exception.parser.AbstractParserException;
  import de.fhdw.wtf.common.stream.TokenStream;
  import de.fhdw.wtf.common.token.IdentifierToken;
  import de.fhdw.wtf.common.token.Token;
  
  /**
   * Parser to parse the given TokenStream to {@link Operation}s.
   */
  final class OperationParser {
  	/**
  	 * TokenStream.
  	 */
  	private final TokenStream stream;
  	
  	/**
  	 * Collection of exceptions.
  	 */
  	private final Collection<AbstractParserException> exceptions;
  	
  	/**
  	 * Constructor of {@link OperationParser}.
  	 * 
  	 * @param stream
  	 *            tokenStream
  	 * @param exceptions
  	 *            collection of exceptions
  	 */
  	private OperationParser(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		this.stream = stream;
  		this.exceptions = exceptions;
  	}
  	
  	/**
  	 * FactoryMethod for {@link OperationParser}.
  	 * 
  	 * @param stream
  	 *            tokenStream
  	 * @param exceptions
  	 *            collection of exceptions
  	 * @return The {@link OperationParser}-Object.
  	 */
  	static OperationParser create(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		return new OperationParser(stream, exceptions);
  	}
  	
  	/**
  	 * Parses a series of Tokens and creates an {@link Operation}. The name of the operation will be <code>name</code>.
  	 * 
  	 * @param name
  	 *            name
  	 * @param firstToken
  	 *            firstToken
  	 * @return Operation
  	 * @throws AbstractParserException
  	 *             AbstractParserException
  	 */
  	Operation parse(final String name, final ClassType containingType, final IdentifierToken firstToken)
  			throws AbstractParserException {
  		final Collection<OperationModifier> modifiers = new ArrayList<>();
  		final Token firstTokenProduct = this.stream.peek();
  		final ProductType params = ProductType.create(firstTokenProduct);
  		ParserUtils.requireAndRemoveBracketOpenToken(this.stream);
  		while (this.stream.hasNext() && this.stream.peek().isIdentifierToken()) {
  			params.addElement(ParameterParser.create(this.stream, this.exceptions).parse());
  			if (this.stream.peek().isCommaToken()) {
  				this.stream.removeFirst();
  			}
  		}
  		ParserUtils.requireAndRemoveBracketCloseToken(this.stream);
  		params.setLastToken(this.stream.peek());
  		ParserUtils.requireAndRemoveArrowToken(this.stream);
  		final Type type = TypeParser.create(this.stream, this.exceptions).parse();
  		// TODO anpassen
  		final Operation result =
  				Operation.create(name, modifiers, params, containingType, type, firstToken, type.getLastToken());
  		ParserUtils.requireAndRemoveDoubleSquareBracketCloseToken(this.stream);
  		modifiers.addAll(OperationModifierParser.create(this.stream, this.exceptions).parse(result));
  		return result;
  	}
  }