package de.fhdw.wtf.common.ast;
   
   import java.util.Collection;
   import java.util.HashSet;
   import java.util.Iterator;
   
   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.visitor.ConstructorOrOperationExceptionVisitor;
  import de.fhdw.wtf.common.ast.visitor.OperationModifierVisitorReturn;
  import de.fhdw.wtf.common.constants.parser.AstDescriptionConstants;
  import de.fhdw.wtf.common.exception.walker.TaskException;
  import de.fhdw.wtf.common.token.Token;
  
  /**
   * This class represents a operation of a class. It is held by a <ClassType>, can contain multiple
   * {@link OperationModifier}, has a name, returnType and parameters.
   */
  public final class Operation extends ConstructorOrOperation {
  	
  	/**
  	 * generated.
  	 */
  	private static final long serialVersionUID = 8835914994800497991L;
  	
  	/**
  	 * The modifiers of the operation.
  	 * 
  	 */
  	private final Collection<OperationModifier> modifiers;
  	
  	/**
  	 * Overriding Operations in the Model
  	 * 
  	 */
  	private final Collection<Operation> overridingOperations;
  	
  	/**
  	 * Private-Constructor of {@link Operation}.
  	 * 
  	 * @param name
  	 *            name
  	 * @param modifiers
  	 *            The modifiers of the operation.
  	 * @param parameters
  	 *            The parameters of the operation.
  	 * @param containingType
  	 *            The classType of the class, that contains the operation.
  	 * @param returnType
  	 *            The return-type of the Operation.
  	 * @param firstToken
  	 *            firstToken
  	 * @param lastToken
  	 *            lastToken
  	 */
  	private Operation(final String name,
  			final Collection<OperationModifier> modifiers,
  			final ProductType parameters,
  			final ClassType containingType,
  			final Type returnType,
  			final Token firstToken,
  			final Token lastToken) {
  		super(name, parameters, containingType, returnType, firstToken, lastToken);
  		this.modifiers = modifiers;
  		this.overridingOperations = new HashSet<Operation>();
  	}
  	
  	/**
  	 * Creates a {@link Operation}-Object.
  	 * 
  	 * @param name
  	 *            name
  	 * @param modifiers
  	 *            The modifiers of the operation.
  	 * @param parameters
  	 *            The params of the operation.
  	 * @param containingType
  	 *            The classType of the class, that contains the constructor or operation.
  	 * @param returnType
  	 *            The Returntype of the Operation.
  	 * @param firstToken
  	 *            firstToken
  	 * @param lastToken
  	 *            lastToken
  	 * @return The Operation-Object
  	 */
  	public static Operation create(final String name,
  			final Collection<OperationModifier> modifiers,
  			final ProductType parameters,
  			final ClassType containingType,
  			final Type returnType,
  			final Token firstToken,
  			final Token lastToken) {
  		return new Operation(name, modifiers, parameters, containingType, returnType, firstToken, lastToken);
  	}
  	
  	/**
  	 * Creates a {@link Operation}-Object.
 	 * 
 	 * @param name
 	 *            name
 	 * @param modifiers
 	 *            The modifiers of the operation.
 	 * @param parameters
 	 *            The params of the operation.
 	 * @param containingType
 	 *            The classType of the class, that contains the constructor or operation.
 	 * @param returnType
 	 *            The Returntype of the Operation.
 	 * @param firstToken
 	 *            firstToken
 	 * @return The Operation-Object
 	 */
 	public static Operation create(final String name,
 			final Collection<OperationModifier> modifiers,
 			final ProductType parameters,
 			final ClassType containingType,
 			final Type returnType,
 			final Token firstToken) {
 		return new Operation(name, modifiers, parameters, containingType, returnType, firstToken, null);
 	}
 	
 	/**
 	 * Returns true if <code>this</code> is an abstract operation. False otherwise.
 	 * 
 	 * @return boolean.
 	 */
 	public boolean isAbstract() {
 		final OperationModifierVisitorReturn<Boolean> visitor = new OperationModifierVisitorReturn<Boolean>() {
 			@Override
 			public Boolean handle(final OperationModifierAbstract v) {
 				return true;
 			}
 		};
 		return this.processModifierVisitor(visitor);
 	}
 	
 	/**
 	 * Processes a Returnvisitor with Return-Type Boolean and returns the result.
 	 * 
 	 * @param visitor
 	 *            visitor.
 	 * @return boolean.
 	 */
 	private boolean processModifierVisitor(final OperationModifierVisitorReturn<Boolean> visitor) {
 		for (final OperationModifier current : this.getModifiers()) {
 			if (current.accept(visitor)) {
 				return true;
 			}
 		}
 		return false;
 	}
 	
 	@Override
 	public boolean equals(final Object o) {
 		if (o instanceof Operation) {
 			final Operation other = (Operation) o;
 			boolean result = true;
 			result = result && this.getName().equals(other.getName());
 			result = result && this.getReturnType().equals(other.getReturnType());
 			final Iterator<OperationModifier> i = this.getModifiers().iterator();
 			while (i.hasNext()) {
 				final OperationModifier current = i.next();
 				result = result && other.getModifiers().contains(current);
 			}
 			// there is no use hitting a dead body
 			if (!result) {
 				return result;
 			}
 			return this.getParameters().equals(other.getParameters());
 		}
 		return false;
 	}
 	
 	@Override
 	public int hashCode() {
 		int result = this.getName().hashCode() ^ this.getReturnType().hashCode() ^ this.getParameters().hashCode();
 		for (final OperationModifier modifier : this.getModifiers()) {
 			result ^= modifier.hashCode();
 		}
 		return result;
 	}
 	
 	@Override
 	public String toString() {
 		final StringBuilder result = new StringBuilder();
 		result.append(this.getName()).append(AstDescriptionConstants.COLON_TOKEN)
 				.append(AstDescriptionConstants.DOUBLE_SQUARE_BRACKET_OPEN_TOKEN).append(this.getParameters())
 				.append(AstDescriptionConstants.ARROW_TOKEN).append(this.getReturnType())
 				.append(AstDescriptionConstants.DOUBLE_SQUARE_BRACKET_CLOSE_TOKEN);
 		if (!this.getModifiers().isEmpty()) {
 			final Iterator<OperationModifier> i = this.getModifiers().iterator();
 			while (i.hasNext()) {
 				result.append(' ').append(i.next());
 			}
 		}
 		result.append(AstDescriptionConstants.SEMICOLON_TOKEN);
 		return result.toString();
 	}
 	
 	/**
 	 * The modifiers of the operation.
 	 * 
 	 * @return modifiers
 	 */
 	public Collection<OperationModifier> getModifiers() {
 		return this.modifiers;
 	}
 	
 	/**
 	 * The name of the operation.
 	 * 
 	 * @return name
 	 */
 	@Override
 	public String getName() {
 		return this.getSignature().getName();
 	}
 	
 	@Override
 	public void accept(final ConstructorOrOperationExceptionVisitor<TaskException> constructorAndOperationVisitor)
 			throws TaskException {
 		constructorAndOperationVisitor.handleOperation(this);
 		
 	}
 	
 	/**
 	 * @returns the Operations, which override this operation!
 	 */
 	public Collection<Operation> getOverridingOperations() {
 		return this.overridingOperations;
 	}
 }