package de.fhdw.wtf.parser;
   
   import java.util.Collection;
   import java.util.List;
   import java.util.Vector;
   
   import de.fhdw.wtf.common.ast.Attribute;
   import de.fhdw.wtf.common.ast.Constructor;
   import de.fhdw.wtf.common.ast.Name;
  import de.fhdw.wtf.common.ast.Operation;
  import de.fhdw.wtf.common.ast.type.ByNameState;
  import de.fhdw.wtf.common.ast.type.ClassModifier;
  import de.fhdw.wtf.common.ast.type.ClassType;
  import de.fhdw.wtf.common.ast.type.ExceptionClassType;
  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.exception.parser.NoCurlyBracketOpenException;
  import de.fhdw.wtf.common.exception.parser.NoEqualException;
  import de.fhdw.wtf.common.exception.parser.NoPlusSymbolException;
  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 given {@link TokenStream}.
   * 
   * * TODO -> Duplicate code. See RegularClassParser. As a first try just copied ClassParser to ExceptionClassParser and
   * RegularClassParser. Think about how to split them.
   */
  public final class ExceptionClassParser {
  	
  	/**
  	 * Tokenstream.
  	 */
  	private final TokenStream stream;
  	
  	/**
  	 * Collection for exceptions.
  	 */
  	private final Collection<AbstractParserException> exceptions;
  	
  	/**
  	 * Constructor of {@link ExceptionClassParser}.
  	 * 
  	 * @param stream
  	 *            tokenstream
  	 * @param exceptions
  	 *            collection for exceptions
  	 */
  	private ExceptionClassParser(final TokenStream stream, final Collection<AbstractParserException> exceptions) {
  		this.stream = stream;
  		this.exceptions = exceptions;
  	}
  	
  	/**
  	 * Creates a {@link ExceptionClassParser}-Object.
  	 * 
  	 * @param stream
  	 *            tokenstream
  	 * @param exceptions
  	 *            collection for exceptions
  	 * @return the {@link ExceptionClassParser}-Object.
  	 */
  	protected static ExceptionClassParser create(final TokenStream stream,
  			final Collection<AbstractParserException> exceptions) {
  		return new ExceptionClassParser(stream, exceptions);
  	}
  	
  	/**
  	 * Parses a Class with <code>name</code> as the class name from this.stream. This method expects the first Token in
  	 * the stream to be an EqualToken. This method calls an operation to parse the Attributes and ClassModifiers. If one
  	 * of the Tokens in the stream is unexpected, an AbstractParserException will be thrown.
  	 * 
  	 * @param name
  	 *            : Name of Class.
  	 * @param firstToken
  	 *            : First token of class.
  	 * @throws AbstractParserException
  	 *             AbstractParserException
  	 * @return ClassType
  	 */
  	protected ClassType parse(final Name name, final Token firstToken) throws AbstractParserException {
  		try {
  			ParserUtils.requireAndRemoveEqualToken(this.stream);
  		} catch (final NoEqualException e) {
  			throw e;
  		}
  		
  		final Collection<Attribute> attributes = new Vector<>();
  		final Collection<ClassModifier> modifiers = new Vector<>();
  		final Collection<ClassType> subTypes = new Vector<>();
  		final Collection<Operation> operations = new Vector<>();
  		final List<Type> superTypes = new Vector<>();
  		final Collection<Constructor> constructors = new Vector<>();
  		final ClassType classResult =
  				ExceptionClassType.create(
  						name,
 						modifiers,
 						attributes,
 						superTypes,
 						operations,
 						constructors,
 						firstToken,
 						subTypes);
 		try {
 			classResult.getSuperTypes().addAll(this.parseSuperTypes());
 			ParserUtils.requireAndRemoveCurlyBracketOpenToken(this.stream);
 		} catch (final NoCurlyBracketOpenException e) {
 			this.exceptions.add(e);
 			// Don't skip to next semicolon because you may find it behind the class so that
 			// you produce more exceptions as necessary.
 		}
 		while (this.stream.hasNext() && !this.checkClassEnd() && !(this.stream.peek().isEndToken())) {
 			final Token currentToken = this.stream.peek();
 			if (currentToken.isIdentifierToken()) {
 				try {
 					final IdentifierToken token = ParserUtils.requireAndRemoveIdentifier(this.stream);
 					this.parseClassElement(
 							classResult,
 							constructors,
 							attributes,
 							operations,
 							token.stringRepresentation(),
 							classResult,
 							token);
 				} catch (final NoSemicolonException e) {
 					throw e;
 				} catch (final AbstractParserException e) {
 					this.exceptions.add(e);
 					ParserUtils.skipToSemicolonToken(this.stream);
 					continue;
 				}
 			} else if (currentToken.isBracketOpenToken()) {
 				this.parseConstructor(currentToken, constructors, classResult);
 			} else {
 				ParserUtils.requireAndRemoveCurlyBracketCloseToken(this.stream);
 			}
 		}
 		modifiers.addAll(ClassModifierParser.create(this.stream, this.exceptions).parse(classResult));
 		classResult.setLastToken(this.stream.peek());
 		return classResult;
 	}
 	
 	/**
 	 * Parses a constructor.
 	 * 
 	 * @param firstToken
 	 *            firstToken.
 	 * @param constructors
 	 *            the list of constructors for classResult.
 	 * @param owner
 	 *            the owner class of the constructor.
 	 * @throws AbstractParserException
 	 *             if the syntax is not correct.
 	 */
 	private void parseConstructor(final Token firstToken,
 			final Collection<Constructor> constructors,
 			final ClassType owner) throws AbstractParserException {
 		constructors.add(ConstructorParser.create(this.stream, this.exceptions).parse(firstToken, owner));
 	}
 	
 	/**
 	 * Parses a series of tokens and returns the a list of {@link TypeProxy} . If the series of tokens does not match
 	 * the grammar an Exception will be thrown.
 	 * 
 	 * @return super types
 	 * @throws AbstractParserException
 	 *             {@link NoPlusSymbolException}: if there are some {@link IdentifierToken}s or an
 	 *             {@link IdentifierToken} followed by an {@link de.fhdw.wtf.common.token.symbols.CurlyBracketOpenToken}
 	 *             with no symbol between, than there is a PlusSymbol missing. {@link NoCurlyBracketOpenException}: If
 	 *             it ist not a {@link NoPlusSymbolException} it must be a {@link NoCurlyBracketOpenException}.
 	 * 
 	 */
 	private Collection<TypeProxy> parseSuperTypes() throws AbstractParserException {
 		final Collection<TypeProxy> superTypes = new Vector<>();
 		
 		tryPossibleExceptions(this.stream.copy());
 		
 		while (this.stream.hasNext() && this.stream.peek().isIdentifierToken()) {
 			final NameParser nameParser = NameParser.createNameParser(this.stream);
 			final Name currentSuperTypeName = nameParser.parse();
 			
 			ParserUtils.requireAndRemovePlusSymbol(this.stream);
 			final ByNameState byName = ByNameState.create(currentSuperTypeName);
 			final TypeProxy typeProxy = TypeProxy.create(currentSuperTypeName.getFirstToken(), byName);
 			typeProxy.setLastToken(currentSuperTypeName.getLastToken());
 			superTypes.add(typeProxy);
 		}
 		return superTypes;
 	}
 	
 	/**
 	 * Trys if there are any excpetions with missing + or {. In the case of missing { it is necessary to start the
 	 * parsing again from the first identifier. For example: Class:class=attribute:String;};
 	 * 
 	 * @param copy
 	 *            - a copy of the origin tokenStream
 	 * @throws AbstractParserException
 	 *             {@link NoPlusSymbolException} and {@link NoCurlyBracketOpenException}.
 	 */
 	private static void tryPossibleExceptions(final TokenStream copy) throws AbstractParserException {
 		final Token firstPosition = copy.peek();
 		
 		try {
 			while (copy.hasNext() && copy.peek().isIdentifierToken()) {
 				final NameParser nameParser = NameParser.createNameParser(copy);
 				nameParser.parse();
 				ParserUtils.requireAndRemovePlusSymbol(copy);
 			}
 		} catch (final NoPlusSymbolException e) {
 			if (copy.hasNext() && (copy.peek().isIdentifierToken() || copy.peek().isCurlyBracketOpenToken())) {
 				throw e;
 			} else {
 				throw NoCurlyBracketOpenException.create(firstPosition);
 			}
 		}
 	}
 	
 	/**
 	 * Parses a series of Tokens and creates attribute or operation. The name it is <code>name</code>. The result will
 	 * be add to <code>attributes</code> or <code>operations</code>. The first {@link Token} is <code>firstToken</code>.
 	 * be <code>attributeName</code>.
 	 * 
 	 * @param classResult
 	 *            the class that is being parsed at the moment.
 	 * 
 	 * @param attributes
 	 *            attributes
 	 * @param operations
 	 *            operations
 	 * @param constructors
 	 *            constructors
 	 * @param name
 	 *            name of attribute or operation
 	 * @param firstToken
 	 *            firstToken
 	 * @throws AbstractParserException
 	 *             AbstractParserException
 	 */
 	private void parseClassElement(final ClassType classResult,
 			final Collection<Constructor> constructors,
 			final Collection<Attribute> attributes,
 			final Collection<Operation> operations,
 			final String name,
 			final ClassType containingType,
 			final IdentifierToken firstToken) throws AbstractParserException {
 		ParserUtils.requireAndRemoveColonToken(this.stream);
 		final Token nextToken = this.stream.peek();
 		if (nextToken.isDoubleSquareBracketOpenToken()) {
 			this.stream.removeFirst();
 			operations
 					.add(OperationParser.create(this.stream, this.exceptions).parse(name, containingType, firstToken));
 		} else {
 			attributes.add(AttributeParser.create(this.stream, this.exceptions).parse(name, firstToken));
 		}
 		
 	}
 	
 	/**
 	 * Returns true if the next Token of this.stream is a CurlyBracketCloseToken, otherwise false.
 	 * 
 	 * @return Boolean
 	 */
 	private boolean checkClassEnd() {
 		if (!(this.stream.peek().isCurlyBracketCloseToken())) {
 			return false;
 		}
 		this.stream.removeFirst();
 		return true;
 	}
 }