import choco.Problem;
import choco.integer.*;
import choco.ContradictionException;

public class Triple {

    Node a,b,c;
    Tree tree;
    int type;
    IntDomainVar v;
    
    public Triple(Node a, Node b, Node c,int x,UMatrix um){
	Problem pb = um.getProblem();
	IntDomainVar [][] M = um.getM();
	int i = a.getSpeciesNo();
	int j = b.getSpeciesNo();
	int k = c.getSpeciesNo();
	this.a = a;
	this.b = b;
	this.c = c;
	type = x;
	tree = a.getTree();
	v = pb.makeBoundIntVar("<" + a.getSpeciesNo() + "," + 
			       b.getSpeciesNo() + "," +
			       c.getSpeciesNo() + ">",0,1);
	if (type == 1){
	    //System.out.println("triple");
	     pb.post(pb.or(pb.and (pb.eq(v,1),
				   pb.and(pb.eq(M[i][k],M[j][k]),
					  pb.and(pb.gt(M[i][j],M[j][k]),pb.gt(M[i][j],M[i][k])))),
			   (pb.and(pb.eq(v,0),
				   pb.or(pb.neq(M[i][k],M[j][k]),
					 pb.or(pb.leq(M[i][j],M[j][k]),pb.leq(M[i][j],M[i][k])))))));
	    /*
	    pb.post(pb.implies(pb.eq(v,1),
			       pb.and(pb.eq(M[i][k],M[j][k]),
				      pb.and(pb.gt(M[i][j],M[j][k]),pb.gt(M[i][j],M[i][k])))));
	    pb.post(pb.implies(pb.eq(v,0),
			       pb.or(pb.neq(M[i][k],M[j][k]),
				     pb.or(pb.leq(M[i][j],M[j][k]),pb.leq(M[i][j],M[i][k])))));
	    */
	}
	else {
	    //System.out.println("fan");
	    pb.post(pb.implies(pb.eq(v,1),
			       pb.and(pb.eq(M[i][j],M[i][k]),
				      pb.and(pb.eq(M[i][k],M[j][k]),pb.eq(M[i][j],M[j][k])))));
	    pb.post(pb.implies(pb.eq(v,0),
			       pb.or(pb.neq(M[i][j],M[i][k]),
				     pb.or(pb.neq(M[i][k],M[j][k]),pb.neq(M[i][j],M[j][k])))));
	}
    }

    public void post() throws ContradictionException {v.setVal(1);}
    public void retract() throws ContradictionException {v.setVal(0);}
    public boolean isPosted() throws ContradictionException {return v.isInstantiated() && v.getVal() == 1;}
    public IntDomainVar getVar(){return v;}

    public static boolean sameSpecies(Triple X,Triple Y){
	return ((X.a.getSpeciesNo() == Y.a.getSpeciesNo() 
		 || X.a.getSpeciesNo() == Y.b.getSpeciesNo() 
		 || X.a.getSpeciesNo() == Y.c.getSpeciesNo()) &&
		(X.b.getSpeciesNo() == Y.a.getSpeciesNo() 
		 || X.b.getSpeciesNo() == Y.b.getSpeciesNo() 
		 || X.b.getSpeciesNo() == Y.c.getSpeciesNo()) &&
		(X.c.getSpeciesNo() == Y.a.getSpeciesNo() 
		 || X.c.getSpeciesNo() == Y.b.getSpeciesNo() 
		 || X.c.getSpeciesNo() == Y.c.getSpeciesNo()));
    }

    public static boolean incompatibe(Triple X,Triple Y){
	return ((sameSpecies(X,Y) && X.type != Y.type) ||
		(sameSpecies(X,Y) && X.type == 1 && Y.type == 1 && X.c != Y.c));
    }

    public boolean equalFans(Triple Y){
	return sameSpecies(this,Y) && type == 2 && Y.type == 2;
    }

    public boolean equalTriples(Triple Y){
	return sameSpecies(this,Y) && c.getSpeciesNo() == Y.c.getSpeciesNo() && type == 1 && Y.type == 1;
    }

    public boolean isTriple(){return type == 1;}

    public boolean isFan(){return type == 2;}

    public String toString(){
	return "type: " + type + " <" + v + " ((" + a.getSpecies() + "," + b.getSpecies() + ")," + c.getSpecies() + 
	        ")" + tree.getName();
    }

    public String look(){
	return "((" + a.getSpecies() + "," + b.getSpecies() + ")," + c.getSpecies()+ ");";
    }

    public Tree getTree(){return tree;}
}