import static choco.Choco.*;
import choco.kernel.model.Model;
import choco.kernel.model.variables.integer.IntegerVariable;
import choco.kernel.model.constraints.automaton.DFA;
import java.util.*;

public class Skipper {

    int id;                          // a sequence number
    Match[] match;                   // matches skipper is in
    int firstFree;                   // for adding new matches
    IntegerVariable numberOfChanges; // number of times skipper changes boats
    IntegerVariable[] change;        // change[i] = 0 <-> skipper is in same boat in match i and match i+1
    IntegerVariable[] boat;          // boat[i] maybe {1..numberOfBoats} for allocation or {0,1} for orientation
    int numberOfMatches;             // number of matches for this skipper (must be n-1)
    int numberOfBoats;               // to compute position of match in a round/flight
    //
    // NOTE:  boat[i] is used in two different roles. 
    //
    //        In Phase1a, boat allocation, boat[i] is  the boat used by this skipper in his ith match. 
    //        See penalizeBoatChange below
    //
    //        In Phase1b boat[i] is 0 or 1, where 0 is port and 1 starboard. This then gives the 
    //        orientation of the skipper in his ith match. See portStarboard below
    //

    Skipper(int id,int numberOfMatches,int numberOfBoats){
	this.id              = id;
	this.numberOfMatches = numberOfMatches;
	match                = new Match[numberOfMatches];
	firstFree            = 0;
	numberOfChanges      = makeIntVar("totalChanges-"+ id,0,numberOfMatches-1);
	change               = makeIntVarArray("change-"+ id,numberOfMatches-1,0,1);
	boat                 = new IntegerVariable[numberOfMatches];
	this.numberOfBoats   = numberOfBoats;
    }
    //
    // as used in Phase1a, boat allocation
    //

    Skipper(int id,int numberOfMatches){
	this.id              = id;
	this.numberOfMatches = numberOfMatches;
	match                = new Match[numberOfMatches];
	firstFree            = 0;
	boat                 = new IntegerVariable[numberOfMatches];
    }
    //
    // as used in Phase1b, match orientation
    //

    void add(Match m){
	match[firstFree] = m;
	firstFree++;
    }
    //
    // add a new match m to this skipper, where skipper
    // is player1 or player2 in that match m
    //

    void penalizeBoatChange(Model model){
	Arrays.sort(match,new MatchComparator());
	int m = numberOfBoats/2; // number of matches in a round/flight
	for (int i=0;i<numberOfMatches;i++)
	    if (match[i].player1 == id) boat[i] = match[i].boat1; else boat[i] = match[i].boat2;
	//
	// build array of boat allocations for this skipper
	//
	for (int i=0;i<numberOfMatches-1;i++)
	    model.addConstraint(ifOnlyIf(eq(change[i],0),eq(boat[i],boat[i+1])));
	//
	// there is a change in the skipper's ith match there are different boats 
	// in his ith and ith+1 match
	//
	model.addConstraint(eq(numberOfChanges,sum(change)));
	//
	// sum up the number of changes made into constrained integer variable 
	// number of changes. This is, later, minimised
	//
	for (int i=0;i<numberOfMatches-1;i++)
	    if ((match[i].timeSlot % m) == m-1) // last match in round/flight
		model.addConstraint(eq(change[i],0));
	//
	// If match[i] is the last match in the flight 
	// Then stay in the boat (no change) in the next match
	//
	// NOTE: this is "Extra Criteria ... 11. Skippers in the last match of a flight 
	//       do not change boats."
	//
	for (int i=0;i<numberOfMatches-1;i++)
	    if (match[i+1].timeSlot % m == 0 && match[i+1].timeSlot/m - match[i].timeSlot/m == 1)
		model.addConstraint(eq(change[i],0));
	//
	// If match[i+1] is first match in flight h and match[i] is in flight g
	//    where h-g = 1 (i.e. g is the flight just before h) and match[i+1] is 
	//    first match in flight h
	// Then do not change boat
	// 
	// NOTE: this is "Extra Criteria ... 12. Skippers in new boats do not sail in the 
	//                first match of the next flight."
	//
    }
    //
    // NOTE: Phase1a, boat allocation every time the skipper changes boats he pays a penalty
    //       "Extra Criteria ... 11 and 12"
    // First, sort the matches in chronological order
    // Second, use this order to construct the ordered array of boats
    //         such that we take the boat with player matching the skipper's id
    // Third, post constraints to determine if a boat change take place at time i
    // Fourth, sum up the number of boat changes made
    // Finaly, restrict boat changes to meet "Extra Criterai ... 11 and 12"
    //
    // NOTE: it is assumed that boat[i] = k <-> boat k was used in the ith match by this skipper
    //

    void portStarboard(Model model,DFA auto){
	Arrays.sort(match,new MatchComparator());
	int m = numberOfBoats/2; // number of matches in a round/flight
	for (int i=0;i<numberOfMatches;i++)
	    if (match[i].player1 == id) boat[i] = match[i].boat1; else boat[i] = match[i].boat2;
	//
	// as above, create an array of boat orientations used by this skipper sorted chronologically
	//
	model.addConstraint(regular(auto,boat));
	//
	// using a DFA, disallow subsequences "000" and "111"
	//
	if (numberOfMatches%2 == 0) model.addConstraint(eq(sum(boat),numberOfMatches/2));
	else model.addConstraint(eq(sum(boat),makeIntVar("v",numberOfMatches/2,1+numberOfMatches/2)));
	//
	// If there are an even number of matches then skipper must have same number of port matches
	// as starboard. If an odd number of matches then the number of port and number of starboard
	// matches must differ by one
	//
    }
    //
    // NOTE: Phased1b, match orientation
    //       "Principal Criteria ... 2 and 5"
    // each match that a skipper is in must be oriented such that there
    // is an equitable time spent port and starboard and there are no 3
    // consecutive matches that the skipper spends on the same side (port (0)
    // or starboard (1))
    //

    public String toString(){
	String s = "skip_"+ id +": ";
	for (Match m : match) s = s + m +" ";
	return s;
    }
}