/* Reference :
Tiihonen, J., Soininen, T., Niemela, I., Sulonen, R.:
 Empirical testing of a weight constraint rule based configurator.
In ECAI 2002 Configuration Workshop. (2002) 17--22
http://www.soberit.hut.fi/pdmg/Empirical/index.html

*/

///////////////////////////////////////////////////////////////
// File: fx.cpp
// Desc:  ILOG instance for FX Benchmark
// Auth: Sathi
// Date: Mon July 12 2004
//////////////////////////////////////////////////////////////

#include <ilsolver/ilosolverany.h>
#include <stdlib.h>
#include <fstream.h>
#include <time.h>
clock_t worst;


ILOSTLBEGIN


struct assignment_pair{
	int varid;
	int value;
};




int main(int argc, char** argv) {
  if (argc < 2)
    {
      cerr << "Usage: machine? <in trace .ti file>\n ";
      exit(1);
    }

  IloEnv env;
  try {
    IloModel mdl(env);





  ////////////////////////////////////////////////////////////
  // Make aux. data structures for interactive configuration
  ///////////////////////////////////////////////////////////

  vector<int> varDom;
  vector<IloIntVar*> varPtr;


//Control_type                                                 3
IloIntVar Control_type(env, 0, 2);
varPtr.push_back(&Control_type);
varDom.push_back(3);

mdl.add(
   ( Control_type== 0)
|| ( Control_type== 1)
|| ( Control_type== 2)
);

//Supply_voltage_and_frequency								   6
IloIntVar Supply_voltage_and_frequency(env, 0, 5);
varPtr.push_back(&Supply_voltage_and_frequency);
varDom.push_back(6);

mdl.add(
   (Supply_voltage_and_frequency == 0)
|| (Supply_voltage_and_frequency == 1)
|| (Supply_voltage_and_frequency == 2)
|| (Supply_voltage_and_frequency == 3)
|| (Supply_voltage_and_frequency == 4)
|| (Supply_voltage_and_frequency == 5)
);


//Control_type_and_Nominal_Power							   5
IloIntVar Control_type_and_Nominal_Power(env, 0, 4);
varPtr.push_back(&Control_type_and_Nominal_Power);
varDom.push_back(5);

mdl.add(
   ( Control_type_and_Nominal_Power== 0)
|| ( Control_type_and_Nominal_Power== 1)
|| ( Control_type_and_Nominal_Power== 2)
|| ( Control_type_and_Nominal_Power== 3)
|| ( Control_type_and_Nominal_Power== 4)
);

//Supply_voltage											   4
IloIntVar Supply_voltage(env, 0, 3);
varPtr.push_back(&Supply_voltage);
varDom.push_back(4);

mdl.add(
   ( Supply_voltage== 0)
|| ( Supply_voltage== 1)
|| ( Supply_voltage== 2)
|| ( Supply_voltage== 3)
);

//Supply_frequency											   2
IloIntVar Supply_frequency(env, 0, 1);
varPtr.push_back(&Supply_frequency);
varDom.push_back(2);

mdl.add(
   (Supply_frequency == 0)
|| (Supply_frequency == 1)
);

//Pressure													   4
IloIntVar Pressure(env, 0, 3);
varPtr.push_back(&Pressure);
varDom.push_back(4);

mdl.add(
   ( Pressure== 0)
|| ( Pressure== 1)
|| ( Pressure== 2)
|| ( Pressure== 3)
);

//Nominal_power												   4
IloIntVar Nominal_power(env, 0, 3);
varPtr.push_back(&Nominal_power);
varDom.push_back(4);

mdl.add(
   ( Nominal_power== 0)
|| ( Nominal_power== 1)
|| ( Nominal_power== 2)
|| ( Nominal_power== 3)
);

//Maximum_capacity											   44
IloIntVar Maximum_capacity(env, 0, 43);
varPtr.push_back(&Maximum_capacity);
varDom.push_back(44);

mdl.add(
   ( Maximum_capacity== 0)
|| ( Maximum_capacity== 1)
|| ( Maximum_capacity== 2)
|| ( Maximum_capacity== 3)
|| ( Maximum_capacity== 4)
|| ( Maximum_capacity== 5)
|| ( Maximum_capacity== 6)
|| ( Maximum_capacity== 7)
|| ( Maximum_capacity== 8)
|| ( Maximum_capacity== 9)
|| ( Maximum_capacity== 10)
|| ( Maximum_capacity== 11)
|| ( Maximum_capacity== 12)
|| ( Maximum_capacity== 13)
|| ( Maximum_capacity== 14)
|| ( Maximum_capacity== 15)
|| ( Maximum_capacity== 16)
|| ( Maximum_capacity== 17)
|| ( Maximum_capacity== 18)
|| ( Maximum_capacity== 19)
|| ( Maximum_capacity== 20)
|| ( Maximum_capacity== 21)
|| ( Maximum_capacity== 22)
|| ( Maximum_capacity== 23)
|| ( Maximum_capacity== 24)
|| ( Maximum_capacity== 25)
|| ( Maximum_capacity== 26)
|| ( Maximum_capacity== 27)
|| ( Maximum_capacity== 28)
|| ( Maximum_capacity== 29)
|| ( Maximum_capacity== 20)
|| ( Maximum_capacity== 31)
|| ( Maximum_capacity== 32)
|| ( Maximum_capacity== 33)
|| ( Maximum_capacity== 34)
|| ( Maximum_capacity== 35)
|| ( Maximum_capacity== 36)
|| ( Maximum_capacity== 37)
|| ( Maximum_capacity== 38)
|| ( Maximum_capacity== 39)
|| ( Maximum_capacity== 30)
|| ( Maximum_capacity== 41)
|| ( Maximum_capacity== 42)
|| ( Maximum_capacity== 43)
);

//Document_language											   9
IloIntVar Document_language(env, 0, 8);
varPtr.push_back(&Document_language);
varDom.push_back(9);

mdl.add(
   ( Document_language== 0)
|| ( Document_language== 1)
|| ( Document_language== 2)
|| ( Document_language== 3)
|| ( Document_language== 4)
|| ( Document_language== 5)
|| ( Document_language== 6)
|| ( Document_language== 7)
|| ( Document_language== 8)
);

//Week_timer												   2
IloIntVar Week_timer(env, 0, 1);
varPtr.push_back(&Week_timer);
varDom.push_back(2);

mdl.add(
   ( Week_timer== 0)
|| ( Week_timer== 1)
);

//Communication_bus_RS485									   2
IloIntVar Communication_bus_RS485(env, 0, 1);
varPtr.push_back(&Communication_bus_RS485);
varDom.push_back(2);

mdl.add(
   ( Communication_bus_RS485== 0)
|| ( Communication_bus_RS485== 1)
);

//Canopy_filter												   2
IloIntVar Canopy_filter(env, 0, 1);
varPtr.push_back(&Canopy_filter);
varDom.push_back(2);

mdl.add(
   (Canopy_filter == 0)
|| (Canopy_filter == 1)
);

//Integrated_refridgeration_air_dryer						   2
IloIntVar Integrated_refridgeration_air_dryer(env, 0, 1);
varPtr.push_back(&Integrated_refridgeration_air_dryer);
varDom.push_back(2);

mdl.add(
   ( Integrated_refridgeration_air_dryer== 0)
|| ( Integrated_refridgeration_air_dryer== 1)
);

//Oil_water_separator										   2
IloIntVar Oil_water_separator(env, 0, 1);
varPtr.push_back(&Oil_water_separator);
varDom.push_back(2);

mdl.add(
   ( Oil_water_separator== 0)
|| ( Oil_water_separator== 1)
);

//Water_draining_system										   3
IloIntVar Water_draining_system(env, 0, 2);
varPtr.push_back(&Water_draining_system);
varDom.push_back(3);

mdl.add(
   ( Water_draining_system== 0)
|| ( Water_draining_system== 1)
|| ( Water_draining_system== 2)
);

//Maximum_ambient_temperature								   3
IloIntVar Maximum_ambient_temperature(env, 0, 2);
varPtr.push_back(&Maximum_ambient_temperature);
varDom.push_back(3);

mdl.add(
   ( Maximum_ambient_temperature== 0)
|| ( Maximum_ambient_temperature== 1)
|| ( Maximum_ambient_temperature== 2)
);

//Altitude													   2
IloIntVar Altitude(env, 0, 1);
varPtr.push_back(&Altitude);
varDom.push_back(2);

mdl.add(
   ( Altitude== 0)
|| ( Altitude== 1)
);

//Packaging													   5
IloIntVar Packaging(env, 0, 4);
varPtr.push_back(&Packaging);
varDom.push_back(5);

mdl.add(
   ( Packaging== 0)
|| (Packaging == 1)
|| (Packaging == 2)
|| (Packaging == 3)
|| (Packaging == 4)
);




  //  keep track of interaction
  int**  var_isvalid = new int*[varPtr.size()];
  int*  is_assigned = new int[varPtr.size()];
  for(int i=0;i< varPtr.size();i++)
    {
      var_isvalid[i] = new int[varDom[i]];
      is_assigned[i] = 0;
      for(int j=0; j < varDom[i]; j++)
        var_isvalid[i][j] = 1;
    }

  int**  var_shownValidThisStep = new int*[varPtr.size()];
  for(int i=0;i< varPtr.size();i++)
    {
      var_shownValidThisStep[i] = new int[varDom[i]];
      for(int j=0; j < varDom[i]; j++)
        var_shownValidThisStep[i][j] = 0;
    }

  assignment_pair* assignments = new assignment_pair[varPtr.size()];
  assignment_pair* old_assignments = new assignment_pair[varPtr.size()];
  int old_num_assigns = 0;
  int start_from_scratch = 1;

  ifstream ti(argv[1]);
  if (!ti) { cerr << argv[1] << " cannot be opened\n"; exit(1); }
  int num_assigns = 0;
  int varid;
  int value;
  int inp;
  int inp2;
  int itr_count=0;
  ti >> inp; ti >> inp2;
  int start_assign = 0;



   // mdl.add(    );


mdl.add(!(Control_type_and_Nominal_Power == 0)||(((Control_type == 1) and (Nominal_power == 0))));
mdl.add(!(Control_type_and_Nominal_Power == 1)||(((Control_type == 1) and (Nominal_power == 1))));
mdl.add(!(Control_type_and_Nominal_Power == 2)||(((Control_type == 1) and (Nominal_power == 2))));
mdl.add(!(Control_type_and_Nominal_Power == 3)||(((Control_type == 2) and (Nominal_power == 0))));
mdl.add(!(Control_type_and_Nominal_Power == 4)||(((Control_type == 0) and (Nominal_power == 3))));


mdl.add(!(Control_type == 2) || (Nominal_power == 0)) ;
mdl.add(!(Control_type == 0) || (Nominal_power == 3)) ;
mdl.add(!(Nominal_power == 3) || (Control_type == 0))  ;


mdl.add(!(Supply_voltage_and_frequency == 0)||(( Supply_voltage == 1) && ( Supply_frequency == 0)));
mdl.add(!(Supply_voltage_and_frequency == 1)||(( Supply_voltage == 0) && ( Supply_frequency == 0)));
mdl.add(!(Supply_voltage_and_frequency == 2)||(( Supply_voltage == 0) && ( Supply_frequency == 1)));
mdl.add(!(Supply_voltage_and_frequency == 3)||(( Supply_voltage == 1) && ( Supply_frequency == 1)));
mdl.add(!(Supply_voltage_and_frequency == 4)||(( Supply_voltage == 2) && ( Supply_frequency == 1)));
mdl.add(!(Supply_voltage_and_frequency == 5)||(( Supply_voltage == 3) && ( Supply_frequency == 1)));


mdl.add(

(
   ((Maximum_capacity == 0) && (Nominal_power == 0) && ( Pressure == 2) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 2) && (Nominal_power == 0) && ( Pressure == 1) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 10) && (Nominal_power == 0) && ( Pressure == 0) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 1) && (Nominal_power == 1) && ( Pressure == 3) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 4) && (Nominal_power == 1) && ( Pressure == 2) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 6) && (Nominal_power == 1) && ( Pressure == 1) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 11) && (Nominal_power == 1) && ( Pressure == 0) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 5) && (Nominal_power == 2) && ( Pressure == 3) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 7) && (Nominal_power == 2) && ( Pressure == 2) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 9) && (Nominal_power == 2) && ( Pressure == 1) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 9) && (Nominal_power == 2) && ( Pressure == 0) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 12) && (Nominal_power == 3) && ( Pressure == 3) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 13) && (Nominal_power == 3) && ( Pressure == 2) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 14) && (Nominal_power == 3) && ( Pressure == 1) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 15) && (Nominal_power == 3) && ( Pressure == 0) && ( Supply_frequency == 0))
|| ((Maximum_capacity == 16) && (Nominal_power == 0) && ( Pressure == 2) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 17) && (Nominal_power == 0) && ( Pressure == 1) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 18) && (Nominal_power == 0) && ( Pressure == 0) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 19) && (Nominal_power == 0) && ( Pressure == 2) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 20) && (Nominal_power == 0) && ( Pressure == 1) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 21) && (Nominal_power == 0) && ( Pressure == 0) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 22) && (Nominal_power == 1) && ( Pressure == 3) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 3) && (Nominal_power == 1) && ( Pressure == 2) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 23) && (Nominal_power == 1) && ( Pressure == 1) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 24) && (Nominal_power == 1) && ( Pressure == 0) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 25) && (Nominal_power == 1) && ( Pressure == 3) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 26) && (Nominal_power == 1) && ( Pressure == 2) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 27) && (Nominal_power == 1) && ( Pressure == 1) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 28) && (Nominal_power == 1) && ( Pressure == 0) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 29) && (Nominal_power == 2) && ( Pressure == 3) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 30) && (Nominal_power == 2) && ( Pressure == 2) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 8) && (Nominal_power == 2) && ( Pressure == 1) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 31) && (Nominal_power == 2) && ( Pressure == 0) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 32) && (Nominal_power == 2) && ( Pressure == 3) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 33) && (Nominal_power == 2) && ( Pressure == 2) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 34) && (Nominal_power == 2) && ( Pressure == 1) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 35) && (Nominal_power == 2) && ( Pressure == 0) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 36) && (Nominal_power == 3) && ( Pressure == 3) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 37) && (Nominal_power == 3) && ( Pressure == 2) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 38) && (Nominal_power == 3) && ( Pressure == 1) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 39) && (Nominal_power == 3) && ( Pressure == 0) && ( Supply_frequency == 1) && ((Supply_voltage == 0) || (Supply_voltage == 1) ))
|| ((Maximum_capacity == 40) && (Nominal_power == 3) && ( Pressure == 3) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 41) && (Nominal_power == 3) && ( Pressure == 2) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 42) && (Nominal_power == 3) && ( Pressure == 1) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))
|| ((Maximum_capacity == 43) && (Nominal_power == 3) && ( Pressure == 0) && ( Supply_frequency == 1) && ((Supply_voltage == 2) || (Supply_voltage == 3) ))

));


mdl.add((! ((Nominal_power == 0 ) && ( Pressure == 3))));

mdl.add(!(Control_type == 0)||((Week_timer == 1) && (Communication_bus_RS485 == 1)));
mdl.add(!(Control_type == 2)|| (Communication_bus_RS485 == 0));
mdl.add(!(Control_type == 2)|| (Integrated_refridgeration_air_dryer == 0));

mdl.add(!(Integrated_refridgeration_air_dryer == 1) || (( Water_draining_system == 0) || (Water_draining_system == 1)));
mdl.add(!(Oil_water_separator == 1) || (Water_draining_system == 1));




  ////////////////////////////////
  // Do interactive configuration
  // from trace file
  ///////////////////////////////

  IloExtractableArray iloextractablearray(env,varPtr.size());

  IloSolver solver(mdl);

  do{

          clock_t t1=clock();


      	for(int k = 0; k < old_num_assigns; k++)
      		old_assignments[k] = assignments[k];
      	ti >> inp; ti >> inp2;
      	while(inp != -1 && inp != -2){
      		varid = inp;
      		value = inp2;
      		assignments[num_assigns].varid = varid;
      		assignments[num_assigns].value = value;
      		//cerr<<"varid "<<varid<<"    "<<"value "<<value<<endl;
      		num_assigns++;
      		ti >> inp; ti >> inp2;
      	}

      	// make the assignments
      	// check for each valid value in previous request.
      	if(num_assigns == old_num_assigns + 1){
      		int i;
      		for(i = 0; i < old_num_assigns; i++){
      			if(assignments[i].varid != old_assignments[i].varid ||
                             assignments[i].value != old_assignments[i].value)
      				break;
      		}
      		if(i == old_num_assigns)
      			start_from_scratch = 0;
      		else
      			start_from_scratch = 1;

      	}
      	else
      		start_from_scratch=1;

      	if(start_from_scratch){
      		//remove old_num_assigns of iloextractable array constraints from the model
      		//valid all values are valid values
      		for(int i = 0; i < old_num_assigns; i++){
      			mdl.remove(iloextractablearray[i]);
      		}
      		for(int i = 0; i < varPtr.size(); i++)
      			for(int j = 0; j < varDom[i];j++)
      				var_isvalid[i][j] = 1;
      		for(int i = 0; i < varPtr.size(); i++)
      			is_assigned[i]=0;

      		start_assign = 0;
      	}
      	else
      	  start_assign = old_num_assigns;

      	for(int i = start_assign; i < num_assigns; i++){
      		iloextractablearray[i] = mdl.add(*varPtr[assignments[i].varid] == assignments[i].value);
                  // debug: I want to know what is assigned
                 // cout << "Assigned: " << varName[assignments[i].varid] << " = " << assignments[i].value << endl;
                  // cout.flush();
      		is_assigned[assignments[i].varid] = 1;
      	}

      	for(int i = 0; i < varPtr.size(); i++)
      		for(int j = 0; j < varDom[i];j++)
      			var_shownValidThisStep[i][j] = 0;
      	for(int i = 0; i < varPtr.size(); i++){

      		if (is_assigned[i]) continue;

      		for(int j = 0; j < varDom[i]; j++) {

      			if (!var_isvalid[i][j]) continue;
      			if (var_shownValidThisStep[i][j]) continue;

                         //cout << "i=" << i << " j=" << j << endl;
                         //cout.flush();

      			IloExtractable current = mdl.add(*varPtr[i] == j);

      			solver.startNewSearch();

      			if( solver.next() )
      			   for (int g = 0; g < varPtr.size(); g++) {
      			      var_shownValidThisStep[g][int(solver.getValue(*varPtr[g]))] = 1;
      			      // cout << " fi=" << g << " fj=" << int(solver.getValue(*varPtr[g]));
      			      }
                          else
                             var_isvalid[i][j] = 0;

                          // cout << endl;
      			solver.endSearch();

      			mdl.remove(current);
      		}

      	}

           // debug: print possible remaining values for each variable
           // cout << "\nRemaing values of variable domains\n";
           // for (int i = 0; i < varPtr.size(); i++)
           //   {
           //     cout << varName[i] << "(" << i << ") ";
           //         if (is_assigned[i])
           //           cout << " is assigned";
           //         else
           //           for (int j = 0; j < varDom[i]; j++)
           //   	   if (var_isvalid[i][j])
           //   	   cout << " " << j;
           //     cout << endl;
           //   }
           // cout << "\n\n";
           // cout.flush();


      	itr_count++;
      	old_num_assigns = num_assigns;
      	num_assigns = 0;

	clock_t t2=clock();

	if(itr_count==0)  worst = (t2-t1);

	if(worst < (t2-t1)) worst = (t2-t1);


      } while (inp != -2);

  solver.out() << "End Simulation of " << itr_count << " Requests" << endl;
  solver.out()<<"Worst Time is "<<(worst/(double)CLOCKS_PER_SEC) << endl;



      }
catch (IloException& ex) {
  cerr << "Error: " << ex << endl;
}
env.end();
return 0;
}