package de.fhdw.wtf.parser;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.List;
   import java.util.Vector;
   
   import de.fhdw.wtf.common.ast.Constructor;
   import de.fhdw.wtf.common.ast.ConstructorByTypeAndSignatureState;
  import de.fhdw.wtf.common.ast.ConstructorReference;
  import de.fhdw.wtf.common.ast.Name;
  import de.fhdw.wtf.common.ast.type.ByNameState;
  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.ast.type.TypeProxy;
  import de.fhdw.wtf.common.exception.parser.AbstractParserException;
  import de.fhdw.wtf.common.stream.TokenStream;
  import de.fhdw.wtf.common.token.Token;
  import de.fhdw.wtf.common.token.symbols.BracketCloseToken;
  import de.fhdw.wtf.common.token.symbols.SemicolonToken;
  
  /**
   * Parser to parse the given TokenStream to {@link Constructor}s.
   */
  final class ConstructorParser {
  	
  	/**
  	 * Token stream.
  	 */
  	private final TokenStream stream;
  	
  	/**
  	 * Collection for exceptions.
  	 */
  	private final Collection<AbstractParserException> exceptions;
  	
  	/**
  	 * Constructor of {@link ConstructorParser}.
  	 * 
  	 * @param stream
  	 *            token stream
  	 * @param exceptions
  	 *            collection for exceptions
  	 */
  	private ConstructorParser(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		this.stream = stream;
  		this.exceptions = exceptions;
  	}
  	
  	/**
  	 * Creates a {@link ConstructorParser}-Object.
  	 * 
  	 * @param stream
  	 *            token stream
  	 * @param exceptions
  	 *            collection for exceptions
  	 * @return the {@link ConstructorParser}-Object.
  	 */
  	protected static ConstructorParser create(final TokenStream stream,
  			final Collection<AbstractParserException> exceptions) {
  		return new ConstructorParser(stream, exceptions);
  	}
  	
  	/**
  	 * Parses a series of Tokens and creates an Constructor.
  	 * 
  	 * @param firstToken
  	 *            firstToken
  	 * @param owner
  	 *            the owner-class of the constructor
  	 * @return Attribute
  	 * @throws AbstractParserException
  	 *             AbstractParserException
  	 */
  	protected Constructor parse(final Token firstToken, final ClassType owner) throws AbstractParserException {
  		final Collection<ConstructorReference> superConstructors = new Vector<>();
  		final Token firstTokenProduct = this.stream.peek();
  		final ProductType params = ProductType.create(firstTokenProduct);
  		this.parseParameters(params);
  		this.parseConstructorReferences(superConstructors);
  		this.stream.removeFirst();
  		// To this time it is not possible in wtf to set the exceptions for the constructors, because it is not
  		// implemented
  		final Constructor newConstructor = Constructor.create(params, owner, superConstructors, firstToken);
  		return newConstructor;
  	}
  	
  	/**
  	 * Parses all constructor references until the {@link SemicolonToken} and adds them to superConstructors.
  	 * 
  	 * @param superConstructors
  	 *            the Collection to add the references to.
  	 * @throws AbstractParserException
  	 *             if the given tokens do not match the expected syntax.
  	 */
  	private void parseConstructorReferences(final Collection<ConstructorReference> superConstructors)
  			throws AbstractParserException {
  		if (!this.stream.peek().isSemicolonToken()) {
 			ParserUtils.requireAndRemoveEqualToken(this.stream);
 			while (this.stream.hasNext() && this.stream.peek().isIdentifierToken()) {
 				final Name typeForConstructorName = NameParser.createNameParser(this.stream).parse();
 				final ByNameState byName = ByNameState.create(typeForConstructorName);
 				final List<Type> parameters = new ArrayList<>();
 				this.parseParameters(parameters);
 				
 				final ConstructorByTypeAndSignatureState byTypeAndSignatureState =
 						ConstructorByTypeAndSignatureState.create(
 								TypeProxy.create(typeForConstructorName.getFirstToken(), byName),
 								parameters);
 				
 				superConstructors.add(ConstructorReference.create(byTypeAndSignatureState));
 				if (this.stream.peek().isPlusSymbolToken()) {
 					ParserUtils.requireAndRemovePlusSymbol(this.stream);
 				}
 			}
 		}
 		ParserUtils.requireSemicolonToken(this.stream);
 	}
 	
 	/**
 	 * Parses all parametersTypes from a ConstructorReference until the {@link BracketCloseToken} and adds them to
 	 * parameters.
 	 * 
 	 * @param parameters
 	 *            the Collection to add the parameters to.
 	 * @throws AbstractParserException
 	 *             if the given tokens do not match the expected syntax.
 	 */
 	private void parseParameters(final List<Type> parameters) throws AbstractParserException {
 		ParserUtils.requireAndRemoveBracketOpenToken(this.stream);
 		while (this.stream.hasNext() && this.stream.peek().isIdentifierToken()) {
 			parameters.add(TypeParser.create(this.stream, this.exceptions).parse());
 			if (this.stream.peek().isCommaToken()) {
 				this.stream.removeFirst();
 			}
 		}
 		ParserUtils.requireAndRemoveBracketCloseToken(this.stream);
 	}
 	
 	/**
 	 * Parses all parameters until the {@link BracketCloseToken} and adds them to parameters.
 	 * 
 	 * @param parameters
 	 *            the Collection to add the parameters to.
 	 * @throws AbstractParserException
 	 *             if the given tokens do not match the expected syntax.
 	 */
 	private void parseParameters(final ProductType parameters) throws AbstractParserException {
 		ParserUtils.requireAndRemoveBracketOpenToken(this.stream);
 		while (this.stream.hasNext() && this.stream.peek().isIdentifierToken()) {
 			parameters.addElement(ParameterParser.create(this.stream, this.exceptions).parse());
 			if (this.stream.peek().isCommaToken()) {
 				this.stream.removeFirst();
 			}
 		}
 		ParserUtils.requireAndRemoveBracketCloseToken(this.stream);
 		parameters.setLastToken(this.stream.peek());
 	}
 }