package de.fhdw.wtf.parser;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   
   import de.fhdw.wtf.common.ast.type.ClassModifier;
   import de.fhdw.wtf.common.ast.type.ClassModifierAbstract;
   import de.fhdw.wtf.common.ast.type.ClassModifierService;
  import de.fhdw.wtf.common.ast.type.ClassModifierTransient;
  import de.fhdw.wtf.common.ast.type.ClassModifierVisitable;
  import de.fhdw.wtf.common.ast.type.ClassType;
  import de.fhdw.wtf.common.ast.visitor.ClassModifierVisitor;
  import de.fhdw.wtf.common.exception.parser.AbstractParserException;
  import de.fhdw.wtf.common.exception.parser.ClassModifierAlreadyAddedException;
  import de.fhdw.wtf.common.exception.parser.NoSemicolonException;
  import de.fhdw.wtf.common.stream.TokenStream;
  import de.fhdw.wtf.common.token.Token;
  
  /**
   * Parses a given Tokenstream to {@link ClassModifier}s ( {@link ClassModifierAbstract}, {@link ClassModifierTransient},
   * {@link ClassModifierService}).
   */
  public final class ClassModifierParser {
  	/**
  	 * Tokenstream.
  	 */
  	private final TokenStream stream;
  	/**
  	 * Collection for exceptions.
  	 */
  	private final Collection<AbstractParserException> exceptions;
  	
  	/**
  	 * Constrcutor of {@link ClassModifierParser}.
  	 * 
  	 * @param stream
  	 *            tokenstream
  	 * @param exceptions
  	 *            collection for exceptions
  	 */
  	private ClassModifierParser(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		this.stream = stream;
  		this.exceptions = exceptions;
  	}
  	
  	/**
  	 * Creates a {@link ClassModifierParser}-Object.
  	 * 
  	 * @param stream
  	 *            tokenstream
  	 * @param exceptions
  	 *            collection for exceptions
  	 * @return the {@link ClassModifierParser}-Object.
  	 */
  	static ClassModifierParser create(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		return new ClassModifierParser(stream, exceptions);
  	}
  	
  	/**
  	 * Parses the next series of Tokens of this.stream to ClassModifiers 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
  	 * ClassModifierToken, a {@link NoSemicolonException} will be thrown.
  	 * 
  	 * @param currentClass
  	 *            class
  	 * @throws AbstractParserException
  	 *             {@link NoSemicolonException}
  	 * @return modifiers
  	 */
  	Collection<ClassModifier> parse(final ClassType currentClass) throws AbstractParserException {
  		final Collection<ClassModifier> result = new ArrayList<>();
  		while (this.stream.hasNext()) {
  			if (this.stream.peek().isSemicolonToken()) {
  				this.stream.next();
  				currentClass.setLastToken(this.stream.peek());
  				break;
  			} else {
  				try {
  					result.add(this.parseClassModifier(result));
  				} catch (final ClassModifierAlreadyAddedException e3) {
  					this.stream.removeFirst();
  					this.exceptions.add(e3);
  				}
  			}
  		}
  		return result;
  	}
  	
  	/**
  	 * Checks if the next Token of this.stream is a ClassModifierToken and returns it, if it is. Otherwise a
  	 * NoClassModifierException will be returned.
  	 * 
  	 * @param modifiers
  	 *            list of modifiers
  	 * @throws ClassModifierAlreadyAddedException
  	 *             ClassModifierAlreadyAddedException
  	 * @throws NoSemicolonException
  	 *             NoSemicolonException
 	 * @return ClassModifier
 	 */
 	private ClassModifier parseClassModifier(final Collection<ClassModifier> modifiers) throws NoSemicolonException,
 			ClassModifierAlreadyAddedException {
 		final Token nextToken = this.stream.peek();
 		if (nextToken.isClassModifierToken()) {
 			if (containsClassModifier(modifiers, nextToken)) {
 				throw ClassModifierAlreadyAddedException.create(nextToken);
 			}
 			if (nextToken.isAbstractModifierToken()) {
 				this.stream.removeFirst();
 				return ClassModifierAbstract.create(nextToken, this.stream.peek());
 			}
 			if (nextToken.isServiceToken()) {
 				this.stream.removeFirst();
 				return ClassModifierService.create(nextToken, this.stream.peek());
 			}
 			if (nextToken.isTransientToken()) {
 				this.stream.removeFirst();
 				return ClassModifierTransient.create(nextToken, this.stream.peek());
 			}
 			if (nextToken.isVisitableToken()) {
 				this.stream.removeFirst();
 				return ClassModifierVisitable.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
 	 *            : Collection to be searched in
 	 * 
 	 * @param modifier
 	 *            : Modifiers of {@link ClassModifier} to search for
 	 * @return : <true> if <code>modifiers</code> contains <code>modifier</code> , <false> otherwise
 	 */
 	private static boolean containsClassModifier(final Collection<ClassModifier> modifiers, final Token modifier) {
 		final Iterator<ClassModifier> i = modifiers.iterator();
 		while (i.hasNext()) {
 			final ClassModifier current = i.next();
 			if (current.accept(new ClassModifierVisitor() {
 				@Override
 				public boolean handle(final ClassModifierAbstract abstract1) {
 					return modifier.isAbstractModifierToken();
 				}
 				
 				@Override
 				public boolean handle(final ClassModifierTransient tranzient) {
 					return modifier.isTransientToken();
 				}
 				
 				@Override
 				public boolean handle(final ClassModifierService service) {
 					return modifier.isServiceToken();
 				}
 				
 				@Override
 				public boolean handle(final ClassModifierVisitable visitable) {
 					return modifier.isVisitableToken();
 				}
 			})) {
 				return true;
 			}
 		}
 		return false;
 	}
 }