import org.chocosolver.solver.Model;
import org.chocosolver.solver.Solver;
import org.chocosolver.solver.Solution;
import org.chocosolver.solver.variables.IntVar;
import org.chocosolver.solver.constraints.IIntConstraintFactory.*;
import org.chocosolver.solver.search.strategy.Search;
import org.chocosolver.solver.search.strategy.strategy.IntStrategy;
import org.chocosolver.solver.search.strategy.selectors.values.IntDomainMax;
import org.chocosolver.solver.exception.ContradictionException;

public class OperationTest {

    private static int slack(IntVar op_i,int d_i,IntVar op_j,int d_j){
	return op_j.getUB() - Math.max(op_i.getLB() + d_i,op_j.getLB());
    }
    //
    // slack if op_i before op_j 
    // i.e. slack(op_i -> op_j) in S&C AAAI-93 parlance
    //
    // NOTE: we consider earliest and latest start times whereas S&C
    //       consider earliest start and latest finish, but our calculations
    //       are exactly the same
    //

    public static void main(String args[]) throws ContradictionException {

	Model model   = new Model("Operation Test");
	Solver solver = model.getSolver();
	Operation op1 = new Operation("op1","test",2,1,10,model);
	Operation op2 = new Operation("op2","test",3,1,10,model);
	
	IntVar decision = model.intVar("decision",0,1);
	
	model.ifThen(model.arithm(decision,"=",0),op1.before(op2)); // decision = 0 -> op_i before op
	model.ifThen(model.arithm(decision,"=",1),op2.before(op1)); // decision = 1 -> op before op_i
	
	//
	// initial state
	//
	System.out.println();
	System.out.println(decision);
	System.out.println(op1);
	System.out.println(op2);
	System.out.println();

	//
	// propagate
	//
	System.out.println();
	solver.propagate();
	System.out.println(decision);
	System.out.println(op1);
	System.out.println(op2);
	System.out.println("nothing happens");
	//
	// make decision op1 -> op2
	//
	System.out.println();
	solver.getEnvironment().worldPush();
	decision.instantiateTo(0,null);
	solver.propagate();
	System.out.println(decision);
	System.out.println(op1);
	System.out.println(op2);
	System.out.println("op1 before op2");
	solver.getEnvironment().worldPop();

	//
	// make decision op2 -> op1
	//
	System.out.println();
	solver.getEnvironment().worldPush();
	decision.instantiateTo(1,null);
	solver.propagate();
	System.out.println(decision);
	System.out.println(op1);
	System.out.println(op2);
	System.out.println("op2 before op1");
	solver.getEnvironment().worldPop();

	//
	// compute slack on the decision
	//
	System.out.println();
	System.out.println("slack(op1 -> op2) : "+ slack(op1.start,2,op2.start,3));
	System.out.println("slack(op2 -> op1) : "+ slack(op2.start,3,op1.start,2));
	System.out.println("slack(op1,op2) : "+  Math.max(slack(op1.start,2,op2.start,3),slack(op2.start,3,op1.start,2)));

    }
}
//
// questions:
// should we be taking the maximum of the two slacks?
// what if one of these is negative?
// when make a decisiion should it be to minimise maximum slack
// are there other measures
//