package typinferenz;

import java.util.Iterator;
import java.util.Vector;

import mycompiler.mytype.Pair;
import mycompiler.mytype.Type;
import mycompiler.mytype.TypePlaceholder;

/**
 * Im Grunde Sammlung von Pair s mit Equal-Operatoren.
 * 
 * @author Andreas Stadelmeier, a10023
 *
 */
public class ResultSet implements Iterable<Pair> {

	Vector<Pair> resultPairs;
	
	public ResultSet(Vector<Pair> resultSet){
		resultPairs = resultSet;
	}
	
	/**
	 * Erstellt ein leeres ResultSet
	 */
	public ResultSet() {
		this(new Vector<Pair>());
	}

	public Vector<Pair> getResultSet(){
		return resultPairs;
	}

	/**
	 * Löst den übergebenen Typ auf. Rückgabetyp ist ein Reftype oder Void
	 * @param type
	 * @return
	 */
	public Type getTypeEqualTo(Type type) {
		Type res = type;
		Vector<Pair> modifiedResultPairs = (Vector<Pair>) resultPairs.clone();
		int i = findPairWithTypeEqualTo(type, modifiedResultPairs);
		while(i != -1){
			res = modifiedResultPairs.get(i).TA2;
			modifiedResultPairs.remove(i);
			i = findPairWithTypeEqualTo(res, modifiedResultPairs);
		}
		return res;
	}
	
	private int findPairWithTypeEqualTo(Type type, Vector<Pair> inResultPairs){
		for(int i = 0; i<inResultPairs.size();i++){
			Pair p = inResultPairs.elementAt(i);
			if((p.OperatorEqual() || p.OperatorSmallerExtends()) && p.TA1.equals(type))return i;
		}
		return -1;
	}

	public Iterator<Pair> iterator() {
		return this.getResultSet().iterator();
	}

	/**
	 * Durchsucht das ResultSet (die unifizierten Constraints des ResultSets) nach diesem Typ. Der Typ wird nicht aufgelöst.
	 * Es spielt keine Rolle in welchem Kontext der Typ im ResultSet auftaucht.
	 * @param tA1
	 * @return true, falls der gesuchte Typ enthalten ist.
	 */
	public boolean contains(Type tA1) {
		for(Pair p : this){
			if(p.TA1.equals(tA1)||p.TA2.equals(tA1))return true;
		}
		return false;
	}
	
	@Override
	public String toString(){
		return this.getResultSet().toString();
	}
	
	@Override
	public boolean equals(Object obj){
		return true;
	}

	
	/**
	 * Sammelt alle Constraints, welche mit den übergebenen TPH's in Verbindung stehen.
	 * Auch alle Constraints, welche wiederum mit den gesammelten Constraints in Verbindung stehen werden gesammelt.
	 * @return
	 */
	public Vector<Pair> getConstraintsFor(Vector<TypePlaceholder> typePlaceholders) {
		Vector<Pair> ret = new Vector<Pair>();
		Vector<TypePlaceholder> tphs = (Vector<TypePlaceholder>) typePlaceholders.clone();
		for(int i = 0;i<tphs.size();i++){
			TypePlaceholder tph = tphs.get(i);
			for(Pair p : this.resultPairs){
				if(p.TA1.equals(tph)){
					ret.add(p);
					if(p.TA2 instanceof TypePlaceholder && !tphs.contains(p.TA2))tphs.add((TypePlaceholder)p.TA2);
				}else if(p.TA2.equals(tph)){
					ret.add(p);
					if(p.TA1 instanceof TypePlaceholder && !tphs.contains(p.TA1))tphs.add((TypePlaceholder)p.TA1);
				}
			}
		}
		
		return ret;
	}

	/**
	 * Durchsucht das ResultSet nach Typen, die die übergebenen unresolvedTPHs als generische Variablen einbinden.
	 * @param unresolvedTPH
	 * @return
	 */
	public Vector<Type> getTypesInvolving(Vector<TypePlaceholder> unresolvedTPH) {
		Vector<Type> ret = new Vector<Type>();
		for(Pair p : this.resultPairs){
			for(TypePlaceholder tph : unresolvedTPH){
				if(p.TA1.involves(tph))ret.add(p.TA1);
				if(p.TA2.involves(tph))ret.add(p.TA2);
			}
		}
		return ret;
	}
}