package de.fhdw.wtf.parser;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.List;
   
   import de.fhdw.wtf.common.ast.Group;
   import de.fhdw.wtf.common.ast.GroupElement;
   import de.fhdw.wtf.common.ast.Name;
  import de.fhdw.wtf.common.exception.parser.AbstractParserException;
  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 a group from a given tokenstream.
   */
  final class GroupParser {
  	/**
  	 * TokenStream.
  	 */
  	private final TokenStream stream;
  	
  	/**
  	 * Collection of exceptions.
  	 */
  	private final Collection<AbstractParserException> exceptions;
  	
  	/**
  	 * Constructor of {@link GroupParser}.
  	 * 
  	 * @param stream
  	 *            tokenStream
  	 * @param exceptions
  	 *            collection of exceptions
  	 */
  	private GroupParser(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		this.stream = stream;
  		this.exceptions = exceptions;
  	}
  	
  	/**
  	 * FactoryMethod for {@link GroupParser}.
  	 * 
  	 * @param stream
  	 *            tokenStream
  	 * @param exceptions
  	 *            collection of exceptions
  	 * @return The {@link GroupParser}-Object.
  	 */
  	static GroupParser create(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		return new GroupParser(stream, exceptions);
  	}
  	
  	/**
  	 * Parses a Group with <code>groupName</code> as the group name from this.stream. This method expects the first
  	 * Token in the stream to be an EqualToken and the second to be an SquareBracketOpenToken. This method calls an
  	 * operation to parse the Elements of the group. If one of the Tokens in the stream is unexpected, an
  	 * AbstractParserException will be thrown.
  	 * 
  	 * @param groupName
  	 *            groupName
  	 * @param firstToken
  	 *            firstToken
  	 * @return parsed Group
  	 */
  	Group parse(final Name groupName, final Token firstToken) {
  		final List<GroupElement> groups = new ArrayList<>();
  		final Group group = Group.create(groupName, groups, firstToken);
  		try {
  			ParserUtils.requireAndRemoveEqualToken(this.stream);
  			ParserUtils.requireAndRemoveSquareBracketOpenToken(this.stream);
  		} catch (final AbstractParserException e) {
  			if (this.stream.hasNext() && this.stream.peek().isSquareBracketOpenToken()) {
  				this.stream.next();
  			}
  			this.exceptions.add(e);
  		}
  		while (this.stream.hasNext() && !(this.stream.peek().isEndToken()) && !this.checkGroupEnd()) {
  			try {
  				final IdentifierToken idtoken = ParserUtils.requireAndRemoveIdentifier(this.stream);
  				final Token nextToken = this.stream.peek();
  				ParserUtils.requireAndRemoveColonToken(this.stream);
  				ParserUtils.requireGroupElement(this.stream);
  				final Name newName = groupName.addName(idtoken, nextToken);
  				newName.setFirstToken(idtoken); // Don't reuse the group tokens!
  												// -> safe if reusing the
  												// tokens.
  				groups.add(this.parseGroupElement(newName));
  			} catch (final AbstractParserException e) {
  				this.exceptions.add(e);
  				ParserUtils.skipToSemicolonToken(this.stream);
  				// if the next token is an EndToken, we can stop here.
  				// If we don't stop here, we always get a NoSemicolonException.
  				if (this.stream.peek().isEndToken()) {
  					return group;
  				} else {
  					continue;
 				}
 			}
 		}
 		try {
 			ParserUtils.requireSemicolonToken(this.stream);
 			this.stream.next();
 			group.setLastToken(this.stream.peek());
 		} catch (final NoSemicolonException e) {
 			this.exceptions.add(e);
 		}
 		return group;
 	}
 	
 	/**
 	 * This method parses a GroupElement into a syntax tree structure. Be careful to call this method only in the case
 	 * that the next token is a GroupElement.
 	 * 
 	 * @param name
 	 *            : Name of the GroupElement.
 	 * @return : GroupElement.
 	 * @throws AbstractParserException
 	 *             If neither .parseClass or .parseGroup throws an exception.
 	 */
 	private GroupElement parseGroupElement(final Name name) throws AbstractParserException {
 		final Token nextToken = this.stream.next();
 		if (nextToken.isClassToken()) {
 			return RegularClassParser.create(this.stream, this.exceptions).parse(name, name.getFirstToken());
 		} else if (nextToken.isExceptionToken()) {
 			return ExceptionClassParser.create(this.stream, this.exceptions).parse(name, name.getFirstToken());
 		} else {
 			return this.parse(name, name.getFirstToken());
 		}
 	}
 	
 	/**
 	 * Returns true if the next Token of this.stream is a SquareBracketCloseToken, otherwise false.
 	 * 
 	 * @return Boolean
 	 */
 	private boolean checkGroupEnd() {
 		if (!this.stream.peek().isSquareBracketCloseToken()) {
 			return false;
 		}
 		this.stream.removeFirst();
 		return true;
 	}
 }