package de.fhdw.wtf.walker.tasks;
   
   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.Map;
   
  import de.fhdw.wtf.common.ast.Attribute;
  import de.fhdw.wtf.common.ast.Constructor;
  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.Name;
  import de.fhdw.wtf.common.ast.Operation;
  import de.fhdw.wtf.common.ast.type.ClassType;
  import de.fhdw.wtf.common.ast.type.ProductElementType;
  import de.fhdw.wtf.common.ast.visitor.ConstructorOrOperationExceptionVisitor;
  import de.fhdw.wtf.common.exception.walker.DuplicateConstructorException;
  import de.fhdw.wtf.common.exception.walker.InvalidOverloadingException;
  import de.fhdw.wtf.common.exception.walker.TaskException;
  import de.fhdw.wtf.common.task.TaskExecutor;
  import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
  
  /**
   * This Task check that operations, which have the same name, are different in their parametertypes! So it only allowes
   * correct overloading.
   * 
   * This Checker must run after the {@link PrototypesTask}.
   */
  public final class OverloadingCheck extends SimpleWalkerTask {
  	
  	/**
  	 * Map from Name of a class to their already found list of operation.
  	 */
  	private final Map<Name, Collection<Operation>> classOperationMap;
  	
  	/**
  	 * This list contains {@link ClassType} instances and those {@link Constructor} instances that have already been
  	 * found.
  	 */
  	private final Map<ClassType, Collection<Constructor>> previouslyFoundConstructors;
  	
  	/**
  	 * Constructor of {@link OverloadingCheck}.
  	 * 
  	 * @param m
  	 *            model
  	 * @param taskmanager
  	 *            taskmanager
  	 */
  	private OverloadingCheck(final Model m, final TaskExecutor taskmanager) {
  		super(m, taskmanager);
  		this.classOperationMap = new HashMap<>();
  		this.previouslyFoundConstructors = new HashMap<>();
  	}
  	
  	/**
  	 * Creates a {@link OverloadingCheck}-Object.
  	 * 
  	 * @param m
  	 *            model
  	 * @param taskmanager
  	 *            taskmanager
  	 * @return The {@link OverloadingCheck}-Object.
  	 */
  	public static OverloadingCheck create(final Model m, final TaskExecutor taskmanager) {
  		return new OverloadingCheck(m, taskmanager);
  	}
  	
  	@Override
  	public void handleGroup(final Group g) throws TaskException {
  		// Nothing to do here
  	}
  	
  	@Override
  	public void handleClass(final ClassType c) throws TaskException {
  		// Nothing to do here
  	}
  	
  	@Override
  	public void handleAttribute(final Attribute a, final ClassType owner) throws TaskException {
  		// Nothing to do here
  	}
  	
  	@Override
  	public void handleConstructorOrOperation(final ConstructorOrOperation coo, final ClassType owner)
  			throws TaskException {
  		coo.accept(new ConstructorOrOperationExceptionVisitor<TaskException>() {
  			
  			@Override
  			public void handleOperation(final Operation operation) throws TaskException {
  				Collection<Operation> operations = OverloadingCheck.this.classOperationMap.get(owner.getName());
  				if (operations == null) {
  					operations = new ArrayList<>();
  					OverloadingCheck.this.classOperationMap.put(owner.getName(), operations);
  				}
  				for (final Operation current : operations) {
 					if (current.getName().equals(operation.getName())) {
 						if (current.getParameters().getElements().size() == operation.getParameters().getElements()
 								.size()) {
 							boolean isEqual = true;
 							final Iterator<ProductElementType> iteratorCurrent =
 									current.getParameters().getPrototype().getElements().iterator();
 							final Iterator<ProductElementType> iteratorO =
 									operation.getParameters().getPrototype().getElements().iterator();
 							while (isEqual && iteratorCurrent.hasNext()) {
 								isEqual = iteratorCurrent.next().getType().equals(iteratorO.next().getType());
 							}
 							if (isEqual) {
 								throw InvalidOverloadingException.create(
 										operation.getFirstToken(),
 										operation.getLastToken());
 							}
 						}
 					}
 				}
 				operations.add(operation);
 				
 			}
 			
 			@Override
 			public void handleConstructor(final Constructor constructor) throws TaskException {
 				OverloadingCheck.this.throwDuplicateConstructorExceptionIfExistsAlready(constructor, owner);
 				OverloadingCheck.this.addConstructorToPreviouslyFoundConstructors(constructor, owner);
 				
 			}
 		});
 		
 	}
 	
 	@Override
 	public void finalizeTask() throws TaskException {
 		// Nothing to do here
 	}
 	
 	@Override
 	public void beginTask() throws TaskException {
 		// Nothing to do here
 	}
 	
 	/**
 	 * Throws a {@link DuplicateConstructorException} exception if a {@link Constructor} instance for the same type and
 	 * with the same type as constructor exists in the previouslyFoundConstructors map.
 	 * 
 	 * @param constructor
 	 *            the {@link Constructor} instance to check against.
 	 * @param owner
 	 *            the {@link ClassType} instance for constructor.
 	 * @throws DuplicateConstructorException
 	 *             if the above applies.
 	 */
 	private void throwDuplicateConstructorExceptionIfExistsAlready(final Constructor constructor, final ClassType owner)
 			throws DuplicateConstructorException {
 		if (this.previouslyFoundConstructors.containsKey(owner)) {
 			final Iterator<Constructor> previouslyFoundConstructorsIterator =
 					this.previouslyFoundConstructors.get(owner).iterator();
 			while (previouslyFoundConstructorsIterator.hasNext()) {
 				final Constructor current = previouslyFoundConstructorsIterator.next();
 				if (current.getParameters().equals(constructor.getParameters())) {
 					throw DuplicateConstructorException.create(constructor);
 				}
 			}
 		}
 		
 	}
 	
 	/**
 	 * Adds a new entry for constructor in the collection behind the key owner of the previouslyFoundConstructors map.
 	 * Adds a new key entry with owner before in case that no key entry for owner has been found.
 	 * 
 	 * @param constructor
 	 *            The new entry for the collection behind owner.
 	 * @param owner
 	 *            The type for constructor.
 	 */
 	private void addConstructorToPreviouslyFoundConstructors(final Constructor constructor, final ClassType owner) {
 		if (this.previouslyFoundConstructors.containsKey(owner)) {
 			this.previouslyFoundConstructors.get(owner).add(constructor);
 		} else {
 			final Collection<Constructor> list = new LinkedList<>();
 			list.add(constructor);
 			this.previouslyFoundConstructors.put(owner, list);
 		}
 		
 	}
 	
 }