package de.fhdw.wtf.walker.tasks;
   
   import de.fhdw.wtf.common.ast.Attribute;
   import de.fhdw.wtf.common.ast.AttributeModifier;
   import de.fhdw.wtf.common.ast.AttributeModifierFindable;
   import de.fhdw.wtf.common.ast.AttributeModifierMutable;
   import de.fhdw.wtf.common.ast.AttributeModifierPrior;
   import de.fhdw.wtf.common.ast.AttributeModifierSymmetric;
   import de.fhdw.wtf.common.ast.AttributeModifierTransient;
  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.ListType;
  import de.fhdw.wtf.common.ast.type.MapType;
  import de.fhdw.wtf.common.ast.type.ProductElementType;
  import de.fhdw.wtf.common.ast.type.ProductType;
  import de.fhdw.wtf.common.ast.type.SumType;
  import de.fhdw.wtf.common.ast.type.ThrownType;
  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.AttributeModifierVisitorReturnException;
  import de.fhdw.wtf.common.ast.visitor.CompositeTypeVisitorException;
  import de.fhdw.wtf.common.ast.visitor.TypeVisitorException;
  import de.fhdw.wtf.common.constants.walker.ExceptionConstants;
  import de.fhdw.wtf.common.exception.walker.InvalidAttributeModifierException;
  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 checked the {@link AttributeModifier}s in the model. For example: symmetric is not allowed with BaseTypes,
   * because BaseTypes can´t have reverse getters.
   * 
   * This Checker must run after the {@link TypeReferencer}.
   */
  public final class InvalidAttributeModifierCheck extends SimpleWalkerTask {
  	
  	/**
  	 * Constructor of {@link InvalidAttributeModifierCheck}.
  	 * 
  	 * @param m
  	 *            model
  	 * @param taskmanager
  	 *            taskmanager
  	 */
  	private InvalidAttributeModifierCheck(final Model m, final TaskExecutor taskmanager) {
  		super(m, taskmanager);
  	}
  	
  	/**
  	 * Creates a {@link InvalidAttributeModifierCheck}-Object.
  	 * 
  	 * @param model
  	 *            model
  	 * @param taskmanager
  	 *            taskmanager
  	 * @return The {@link InvalidAttributeModifierCheck}-Object.
  	 */
  	public static InvalidAttributeModifierCheck create(final Model model, final TaskExecutor taskmanager) {
  		return new InvalidAttributeModifierCheck(model, taskmanager);
  	}
  	
  	@Override
  	public void handleClass(final ClassType c) throws TaskException {
  		// Nothing
  	}
  	
  	@Override
  	public void handleGroup(final Group g) throws TaskException {
  		// Nothing
  	}
  	
  	@Override
  	public void handleAttribute(final Attribute a, final ClassType owner) throws TaskException {
  		// TODO: Check attribute modifiers besides symmetric. (Bug #770)
  		for (final AttributeModifier modifier : a.getModifiers()) {
  			modifier.accept(new AttributeModifierVisitorReturnException<Boolean, TaskException>() {
  				
  				@Override
  				public Boolean handle(final AttributeModifierFindable modFindable) throws TaskException {
  					return false;
  				}
  				
  				@Override
  				public Boolean handle(final AttributeModifierPrior modPrior) throws TaskException {
  					return false;
  				}
  				
  				@Override
  				public Boolean handle(final AttributeModifierTransient modTransient) throws TaskException {
  					return false;
  				}
  				
 				@Override
 				public Boolean handle(final AttributeModifierMutable modMutable) throws TaskException {
 					return false;
 				}
 				
 				@Override
 				public Boolean handle(final AttributeModifierSymmetric modSymmetric) throws TaskException {
 					final Type attrType = a.getAttrType();
 					InvalidAttributeModifierCheck.this.checkSymmetricType(a, modSymmetric, attrType);
 					return false;
 				}
 			});
 		}
 	}
 	
 	/**
 	 * Check the symmetric modifier.
 	 * 
 	 * @param attribute
 	 *            attribute
 	 * @param symmetricModifier
 	 *            symmetricModifier
 	 * @param attrType
 	 *            attrType
 	 * @throws TaskException
 	 *             possible Exception
 	 */
 	void checkSymmetricType(final Attribute attribute,
 			final AttributeModifierSymmetric symmetricModifier,
 			final Type attrType) throws TaskException {
 		attrType.accept(new TypeVisitorException<TaskException>() {
 			
 			@Override
 			public void handle(final AtomicType s) throws TaskException {
 				s.accept(new AtomicTypeVisitorException<TaskException>() {
 					
 					@Override
 					public void handle(final BaseType baseType) throws TaskException {
 						throw InvalidAttributeModifierException.create(
 								symmetricModifier,
 								ExceptionConstants.INVALID_SYMMETRIC_ATTRIBUTE_REASON);
 					}
 					
 					@Override
 					public void handle(final ClassType clazz) throws TaskException {
 						// Nothing: everything right
 					}
 				});
 			}
 			
 			@Override
 			public void handle(final CompositeType c) throws TaskException {
 				c.accept(new CompositeTypeVisitorException<TaskException>() {
 					
 					@Override
 					public void handle(final MapType map) throws TaskException {
 						InvalidAttributeModifierCheck.this.checkSymmetricType(attribute, symmetricModifier, map.getOf());
 					}
 					
 					@Override
 					public void handle(final ListType list) throws TaskException {
 						InvalidAttributeModifierCheck.this.checkSymmetricType(
 								attribute,
 								symmetricModifier,
 								list.getOf());
 					}
 					
 					@Override
 					public void handle(final ProductType product) throws TaskException {
 						for (final ProductElementType element : product.getElements()) {
 							InvalidAttributeModifierCheck.this.checkSymmetricType(
 									attribute,
 									symmetricModifier,
 									element.getType());
 						}
 					}
 					
 					@Override
 					public void handle(final SumType sum) throws TaskException {
 						for (final Type element : sum.getElements()) {
 							InvalidAttributeModifierCheck.this
 									.checkSymmetricType(attribute, symmetricModifier, element);
 						}
 					}
 					
 					@Override
 					public void handle(final ThrownType thrownType) throws TaskException {
 						// Nothing
 					}
 				});
 			}
 			
 			@Override
 			public void handle(final TypeProxy s) throws TaskException {
 				final AtomicType targetType = HelperUtils.getTargetAtomicType(s);
 				InvalidAttributeModifierCheck.this.checkSymmetricType(attribute, symmetricModifier, targetType);
 			}
 		});
 	}
 	
 	@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
 	}
 }