package de.fhdw.wtf.walker.tasks;
   
   import java.util.ArrayList;
   import java.util.Iterator;
   
   import de.fhdw.wtf.common.ast.Attribute;
   import de.fhdw.wtf.common.ast.AttributeModifier;
   import de.fhdw.wtf.common.ast.AttributeModifierSymmetric;
   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.ClassType;
  import de.fhdw.wtf.common.ast.type.Type;
  import de.fhdw.wtf.common.exception.walker.SymmetricCheckException;
  import de.fhdw.wtf.common.exception.walker.TaskException;
  import de.fhdw.wtf.common.task.TaskExecutor;
  import de.fhdw.wtf.common.task.TaskExecutorFixed;
  import de.fhdw.wtf.walker.walker.SimpleWalkerTask;
  
  /**
   * @author hfw413hy
   *
   */
  public class SymmetricCheck extends SimpleWalkerTask {
  	
  	private final ArrayList<SymmetricCheckPart> parts = new ArrayList<>();
  	
  	private final void addPart(final Attribute a, final ClassType owner) {
  		this.parts.add(new SymmetricCheckPart(owner, a));
  	}
  	
  	/**
  	 * Erzeugt ein Check-Objekt zum Prüfen, ob symmetrische Beziehungen auf beiden Seiten der Klasse angegeben wurden.
  	 * 
  	 * @param model
  	 *            Das zugrunde liegende Modell, welches geprüft werden soll.
  	 * @param taskmanager
  	 *            Der Manager.
  	 * @return Das Check-Objekt.
  	 */
  	public static SymmetricCheck create(final Model model, final TaskExecutorFixed taskmanager) {
  		return new SymmetricCheck(model, taskmanager);
  	}
  	
  	private SymmetricCheck(final Model m, final TaskExecutor taskmanager) {
  		super(m, taskmanager);
  	}
  	
  	@Override
  	public void handleClass(final ClassType c) throws TaskException {
  		// Nichts
  	}
  	
  	@Override
  	public void handleGroup(final Group g) throws TaskException {
  		// Nichts
  	}
  	
  	@Override
  	public void handleAttribute(final Attribute a, final ClassType owner) throws TaskException {
  		if (a.isSymmetric()) {
  			this.addPart(a, owner);
  		}
  	}
  	
  	@Override
  	public void handleConstructorOrOperation(final ConstructorOrOperation coo, final ClassType owner)
  			throws TaskException {
  		// Nichts...
  	}
  	
  	/**
  	 * Prüft ob es in der Liste aller symmetrischen Attribute ein Gegenstück gibt.
  	 * 
  	 * @param g
  	 *            Die Gruppe in der wir symmetrische Beziehungen testen.
  	 * @param current
  	 *            Das Ausgangs-Attribut.
  	 * @throws SymmetricCheckException
  	 */
  	private void findCorrespondingAttribute(final SymmetricCheckPart current) throws SymmetricCheckException {
  		final boolean debug = true;
  		final Iterator<SymmetricCheckPart> itemIt = this.parts.iterator();
  		while (itemIt.hasNext()) {
  			final SymmetricCheckPart cur = itemIt.next();
  			
  			// Überspringe Vergleich mit sich selbst
  			if (current.equals(cur)) {
  				continue;
  			}
  			
  			// Klasse A: idA : B symmetric(idB);
  			// Klasse B: idB : A symmetric(idA);
  			
  			// Überprüfen der Attributnamen-Referenzierung
  			// Prüft ob "idA" (in A) so als Identifier in B (in symmetric(idA)) hinterlegt ist...
  			if (!cur.getAttributeName().equals(current.getSymmetricIdentifier())) {
  				if (debug) {
  					System.out.println("1 : " + cur.getAttributeName() + " vs " + current.getSymmetricIdentifier());
 				}
 				continue;
 			}
 			// ...und umgekehrt
 			if (!current.getAttributeName().equals(cur.getSymmetricIdentifier())) {
 				if (debug) {
 					System.out.println("2 : " + current.getAttributeName() + " vs " + cur.getSymmetricIdentifier());
 				}
 				continue;
 			}
 			
 			// Prüft ob die Typen übereinstimmen
 			if (!cur.getAttributeTypeString().equals(current.getClassTypeString())) {
 				if (debug) {
 					System.out.println("3 : " + cur.getAttributeTypeString() + " vs " + current.getClassTypeString());
 				}
 				continue;
 			}
 			if (!current.getAttributeTypeString().equals(cur.getClassTypeString())) {
 				if (debug) {
 					System.out.println("4 : " + current.getAttributeTypeString() + " vs " + cur.getClassTypeString());
 				}
 				continue;
 			}
 			
 			// Wir haben den passenden Typ gefunden der zu "current" passt
 			return;
 		}
 		
 		throw SymmetricCheckException.create("Kein passendes Attribut in der Klasse "
 				+ current.getAttributeType().getTypeString() + " gefunden!", current.getAttribute());
 	}
 	
 	@Override
 	public void finalizeTask() throws TaskException {
 		final Iterator<SymmetricCheckPart> groupIt = this.parts.iterator();
 		while (groupIt.hasNext()) {
 			this.findCorrespondingAttribute(groupIt.next());
 		}
 	}
 	
 	@Override
 	public void beginTask() throws TaskException {
 		// Nichts...
 	}
 	
 }
 
 /**
  * 
  * @author hfw413hy
  *
  */
 class SymmetricCheckPart {
 	private final ClassType Owner;
 	private final Attribute OwnerAttribute;
 	
 	public SymmetricCheckPart(final ClassType owner, final Attribute a) {
 		this.Owner = owner;
 		this.OwnerAttribute = a;
 	}
 	
 	public Type getClassType() {
 		return this.Owner;
 	}
 	
 	public Type getAttributeType() {
 		return this.OwnerAttribute.getAttrType();
 	}
 	
 	public String getAttributeTypeString() {
 		String tmp = this.OwnerAttribute.getAttrType().getTypeString();
 		final int idx = tmp.indexOf("*");
 		if (idx > -1) {
 			tmp = tmp.substring(0, idx) + tmp.substring(idx + 1);
 		}
 		return tmp;
 	}
 	
 	public Attribute getAttribute() {
 		return this.OwnerAttribute;
 	}
 	
 	/**
 	 * Liefert den Identifier eines Symmetrischen Attributes zurück, Bsp.: "a : A symmetric(myA)" -> "myA".
 	 * 
 	 * @return Der Identifier eines Symmetrischen Attributes, Bsp.: "a : A symmetric(myA)" -> "myA".
 	 */
 	public String getSymmetricIdentifier() {
 		final Iterator<AttributeModifier> i = this.OwnerAttribute.getModifiers().iterator();
 		while (i.hasNext()) {
 			final AttributeModifier m = i.next();
 			if (m instanceof AttributeModifierSymmetric) {
 				final AttributeModifierSymmetric cur = (AttributeModifierSymmetric) m;
 				return cur.getIdentifierToken().getIdentifier();
 			}
 		}
 		return "";
 	}
 	
 	public String getAttributeName() {
 		return this.OwnerAttribute.getName();
 	}
 	
 	/**
 	 * Liefert bei einem qualifizierten Namen (Bsp.: "de>fhdw>test>a") den Klassennamen "a".
 	 * 
 	 * @return Liefert bei einem qualifizierten Namen (Bsp.: "de>fhdw>test>a") den Klassennamen "a".
 	 */
 	public String getClassTypeString() {
 		final String[] arr = this.getClassType().getTypeString().split(">");
 		return arr[arr.length - 1];
 	}
 }