package de.fhdw.wtf.parser;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   import java.util.List;
   
   import de.fhdw.wtf.common.ast.AttributeModifier;
   import de.fhdw.wtf.common.ast.AttributeModifierFindable;
  import de.fhdw.wtf.common.ast.AttributeModifierMutable;
  import de.fhdw.wtf.common.ast.AttributeModifierPrior;
  import de.fhdw.wtf.common.ast.AttributeModifierSymmetric;
  import de.fhdw.wtf.common.ast.AttributeModifierTransient;
  import de.fhdw.wtf.common.ast.visitor.AttributModifierVisitor;
  import de.fhdw.wtf.common.exception.parser.AbstractParserException;
  import de.fhdw.wtf.common.exception.parser.AttributeModifierAlreadyAddedException;
  import de.fhdw.wtf.common.exception.parser.NoSemicolonException;
  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 AttributeModifier}s.
   */
  public final class AttributeModifierParser {
  	
  	/**
  	 * Tokenstream.
  	 */
  	private final TokenStream stream;
  	
  	/**
  	 * Collection for exceptions.
  	 */
  	private final Collection<AbstractParserException> exceptions;
  	
  	/**
  	 * Constrcutor of {@link AttributeModifierParser}.
  	 * 
  	 * @param stream
  	 *            tokenstream
  	 * @param exceptions
  	 *            collection for exceptions
  	 */
  	private AttributeModifierParser(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		this.stream = stream;
  		this.exceptions = exceptions;
  	}
  	
  	/**
  	 * Creates a {@link AttributeModifierParser}-Object.
  	 * 
  	 * @param stream
  	 *            tokenstream
  	 * @param exceptions
  	 *            collection for exceptions
  	 * @return the {@link AttributeModifierParser}-Object.
  	 */
  	static AttributeModifierParser create(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		return new AttributeModifierParser(stream, exceptions);
  	}
  	
  	/**
  	 * Parses the next series of Tokens of this.stream to AttributeModifiers until a SemicolonToken occurs. If one of
  	 * the Tokens between the first element of this.stream and the next SemicolonToken is not a AttributeModifierToken,
  	 * a NoAttributeModifierException will be thrown.
  	 * 
  	 * @return found attribute modifiers
  	 * @throws AbstractParserException
  	 *             possible Exceptions
  	 */
  	List<AttributeModifier> parse() throws AbstractParserException {
  		final List<AttributeModifier> modifiers = new ArrayList<>();
  		while (this.stream.hasNext()) {
  			if (this.stream.peek().isSemicolonToken()) {
  				break;
  			} else {
  				try {
  					final AttributeModifier modifier = this.parseAttributeModifier(modifiers);
  					modifiers.add(modifier);
  				} catch (final AttributeModifierAlreadyAddedException e) {
  					this.stream.removeFirst();
  					this.exceptions.add(e);
  				}
  			}
  		}
  		return modifiers;
  	}
  	
  	/**
  	 * Checks if the next Token of this.stream is a AttributeModifierToken and returns it, if it is. Otherwise a
  	 * {@link NoSemicolonException} will be returned.
  	 * 
  	 * @param modifiers
  	 *            already found modfiers
  	 * @return attribute Modifier
  	 * @throws AbstractParserException
  	 *             possible Exception
  	 */
 	private AttributeModifier parseAttributeModifier(final Collection<AttributeModifier> modifiers)
 			throws AbstractParserException {
 		
 		final Token nextToken = this.stream.peek();
 		if (nextToken.isAttributeModifierToken()) {
 			if (containsAttributeModifier(modifiers, nextToken)) {
 				throw AttributeModifierAlreadyAddedException.create(nextToken);
 			}
 			if (nextToken.isPriorModifierToken()) {
 				this.stream.removeFirst();
 				return AttributeModifierPrior.create(nextToken, this.stream.peek());
 			}
 			if (nextToken.isTransientToken()) {
 				this.stream.removeFirst();
 				return AttributeModifierTransient.create(nextToken, this.stream.peek());
 			}
 			if (nextToken.isFindableToken()) {
 				this.stream.removeFirst();
 				return AttributeModifierFindable.create(nextToken, this.stream.peek());
 			}
 			if (nextToken.isMutableToken()) {
 				this.stream.removeFirst();
 				return AttributeModifierMutable.create(nextToken, this.stream.peek());
 			}
 			if (nextToken.isSymmetricToken()) {
 				this.stream.removeFirst();
 				ParserUtils.requireAndRemoveBracketOpenToken(this.stream);
 				final IdentifierToken symmetricIdentifier = ParserUtils.requireAndRemoveIdentifier(this.stream);
 				final Token lastToken = ParserUtils.requireAndRemoveBracketCloseToken(this.stream);
 				final AttributeModifierSymmetric symmetricModifier =
 						AttributeModifierSymmetric.create(nextToken, symmetricIdentifier, this.stream.peek());
 				symmetricModifier.setLastToken(lastToken);
 				return symmetricModifier;
 			}
 		}
 		throw NoSemicolonException.create(nextToken);
 	}
 	
 	/**
 	 * Returns true if <code>modifiers</code> contains a modifier of the type of <code>modifier</code>, otherwise false.
 	 * 
 	 * @param modifiers
 	 *            : Modifiers of {@link AttributeModifier}.
 	 * @param modifier
 	 *            : modifier to search for.
 	 * @return Boolean
 	 */
 	private static boolean containsAttributeModifier(final Collection<AttributeModifier> modifiers, final Token modifier) {
 		final Iterator<AttributeModifier> i = modifiers.iterator();
 		while (i.hasNext()) {
 			final AttributeModifier current = i.next();
 			if (current.accept(new AttributModifierVisitor() {
 				
 				@Override
 				public boolean handle(final AttributeModifierPrior prior) {
 					return modifier.isPriorModifierToken();
 				}
 				
 				@Override
 				public boolean handle(final AttributeModifierTransient tranzient) {
 					return modifier.isTransientToken();
 				}
 				
 				@Override
 				public boolean handle(final AttributeModifierFindable findable) {
 					return modifier.isFindableToken();
 				}
 				
 				@Override
 				public boolean handle(final AttributeModifierMutable mutable) {
 					return modifier.isMutableToken();
 				}
 				
 				@Override
 				public boolean handle(final AttributeModifierSymmetric symmetric) {
 					return modifier.isSymmetricToken();
 				}
 			})) {
 				return true;
 			}
 		}
 		return false;
 	}
 }