package de.fhdw.wtf.walker.tasks;
   
   import java.util.HashSet;
   import java.util.Set;
   
   import de.fhdw.wtf.common.ast.Attribute;
   import de.fhdw.wtf.common.ast.ConstructorOrOperation;
   import de.fhdw.wtf.common.ast.Group;
   import de.fhdw.wtf.common.ast.Model;
  import de.fhdw.wtf.common.ast.type.AtomicType;
  import de.fhdw.wtf.common.ast.type.BaseType;
  import de.fhdw.wtf.common.ast.type.ClassType;
  import de.fhdw.wtf.common.ast.type.CompositeType;
  import de.fhdw.wtf.common.ast.type.Type;
  import de.fhdw.wtf.common.ast.type.TypeProxy;
  import de.fhdw.wtf.common.ast.visitor.AtomicTypeVisitorException;
  import de.fhdw.wtf.common.ast.visitor.TypeVisitorException;
  import de.fhdw.wtf.common.exception.ast.ASTException;
  import de.fhdw.wtf.common.exception.walker.DoubleAttributenameException;
  import de.fhdw.wtf.common.exception.walker.TaskException;
  import de.fhdw.wtf.common.task.TaskExecutor;
  import de.fhdw.wtf.walker.walker.HelperUtils;
  import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
  
  /**
   * This Task check the Attributenames in every Class and the superclasses. If there are duplicate Name of Attributes,
   * this Checker will thrown an {@link DoubleAttributenameException}.
   * 
   * This Checker must after the {@link CyclicInheritanceCheck} and the {@link BaseTypeInheritanceCheck}.
   */
  public final class DoubleAttributenameCheck extends SimpleWalkerTask {
  	
  	/**
  	 * Constructor of {@link DoubleAttributenameCheck}.
  	 * 
  	 * @param m
  	 *            model
  	 * @param taskmanager
  	 *            taskmanager
  	 */
  	private DoubleAttributenameCheck(final Model m, final TaskExecutor taskmanager) {
  		super(m, taskmanager);
  	}
  	
  	/**
  	 * Creates a {@link DoubleAttributenameCheck}-Object.
  	 * 
  	 * @param model
  	 *            model
  	 * @param taskmanager
  	 *            taskmanager
  	 * @return The {@link DoubleAttributenameCheck}-Object.
  	 */
  	public static DoubleAttributenameCheck create(final Model model, final TaskExecutor taskmanager) {
  		return new DoubleAttributenameCheck(model, taskmanager);
  	}
  	
  	@Override
  	public void handleClass(final ClassType c) throws TaskException {
  		this.checkAttributeNames(c);
  	}
  	
  	@Override
  	public void handleGroup(final Group g) throws TaskException {
  		// Nothing
  	}
  	
  	@Override
  	public void handleAttribute(final Attribute a, final ClassType owner) throws TaskException {
  		// Nothing
  	}
  	
  	/**
  	 * Check the attribute-Names of the class and the superclasses for double attributenames.
  	 * 
  	 * @param clss
  	 *            clss
  	 * @throws DoubleAttributenameException
  	 *             DoubleAttributenameException
  	 */
  	private void checkAttributeNames(final ClassType clss) throws DoubleAttributenameException {
  		this.checkAttributeNames(clss, new HashSet<String>());
  	}
  	
  	/**
  	 * Check the attribute-Names of the class and the superclasses for double attributenames.
  	 * 
  	 * @param clss
  	 *            clss
  	 * @param attrNamen
  	 *            already found attributenames
  	 * @throws DoubleAttributenameException
  	 *             DoubleAttributenameException
  	 */
  	void checkAttributeNames(final ClassType clss, final Set<String> attrNamen) throws DoubleAttributenameException {
  		for (final Attribute currentAttr : clss.getAttributes()) {
  			if (!attrNamen.add(currentAttr.getName())) {
  				throw DoubleAttributenameException.create(currentAttr);
  			}
 		}
 		
 		/*for (final Type currentSupertype : clss.getSuperTypes()) {
 			currentSupertype.accept(new TypeVisitorException<DoubleAttributenameException>() {
 				
 				@Override
 				public void handle(final TypeProxy typeProxy) throws DoubleAttributenameException {
 					final Type targetType = HelperUtils.getTargetType(typeProxy);
 					targetType.accept(new TypeVisitorException<DoubleAttributenameException>() {
 						
 						@Override
 						public void handle(final TypeProxy tP) {
 							throw new ASTException("It could not be a typeProxy in a typeProxy");
 						}
 						
 						@Override
 						public void handle(final CompositeType compositeType) {
 							// Nothing
 						}
 						
 						@Override
 						public void handle(final AtomicType atomicType) throws DoubleAttributenameException {
 							atomicType.accept(new AtomicTypeVisitorException<DoubleAttributenameException>() {
 								
 								@Override
 								public void handle(final ClassType clazz) throws DoubleAttributenameException {
 									DoubleAttributenameCheck.this.checkAttributeNames(clazz, attrNamen);
 								}
 								
 								@Override
 								public void handle(final BaseType baseType) {
 									// Nothing
 								}
 							});
 						}
 					});
 				}
 				
 				@Override
 				public void handle(final CompositeType compositeType) {
 					// Nothing
 				}
 				
 				@Override
 				public void handle(final AtomicType atomicType) {
 					throw new ASTException("It´s could not be an atomic type direct");
 				}
 			});
 		}*/
 	}
 	
 	@Override
 	public void finalizeTask() throws TaskException {
 		// Nothing
 	}
 	
 	@Override
 	public void beginTask() throws TaskException {
 		// Nothing to do here
 	}
 	
 	@Override
 	public void handleConstructorOrOperation(final ConstructorOrOperation coo, final ClassType owner)
 			throws TaskException {
 		// Nothing to do here
 		
 	}
 }