/*
	This problem generator should generate a problme(s) which contains:
	typed packages, trucks, and airplanes.
*/

/* generator for translog domain */

#include <iostream.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define NUM_CITY 5
#define NUM_LOC 15
#define NUM_AIRPORT 5

#define NUM_T 8
#define NUM_P 20
#define NUM_K 20

#define NUM_TYPE_T 4
#define NUM_TYPE_P 4
#define NUM_TYPE_K 4

typedef struct package {
    char *origin, *destination, *origin_city, *destination_city, *type, *name;
} package;

//add struct for trucks and airplanes
typedef struct truck {
	char *origin, *origin_city, *type, *name; // origin is a location or an airport	
} truck;

typedef struct plane {
	char *origin, *origin_city, *type, *name; // origin is an airport 	
} plane;

// 5 cities
char * cityList[NUM_CITY]={"CITY1", "CITY2", "CITY3", "CITY4", "CITY5"};

// 3 locations in each city
char * locationList[NUM_LOC]={"CITY1-CL1", "CITY1-CL2", "CITY1-CL3",
        "CITY2-CL1", "CITY2-CL2", "CITY2-CL3",
        "CITY3-CL1", "CITY3-CL2", "CITY3-CL3",
        "CITY4-CL1", "CITY4-CL2", "CITY4-CL3",
        "CITY5-CL1", "CITY5-CL2", "CITY5-CL3"};

// 1 airport in each city
char * airportList[NUM_AIRPORT]={"CITY1-AP1", "CITY2-AP2", "CITY3-AP3", "CITY4-AP4", "CITY5-AP5"};

// 8 trucks in each city
char * truckList[NUM_CITY * NUM_T] = {"TRUCK1-1", "TRUCK2-1", "TRUCK3-1", "TRUCK4-1", "TRUCK5-1", "TRUCK6-1", "TRUCK7-1", "TRUCK8-1",
									  "TRUCK1-2", "TRUCK2-2", "TRUCK3-2", "TRUCK4-2", "TRUCK5-2", "TRUCK6-2", "TRUCK7-2", "TRUCK8-2",
									  "TRUCK1-3", "TRUCK2-3", "TRUCK3-3", "TRUCK4-3", "TRUCK5-3", "TRUCK6-3", "TRUCK7-3", "TRUCK8-3",
									  "TRUCK1-4", "TRUCK2-4", "TRUCK3-4", "TRUCK4-4", "TRUCK5-4", "TRUCK6-4", "TRUCK7-4", "TRUCK8-4",
									  "TRUCK1-5", "TRUCK2-5", "TRUCK3-5", "TRUCK4-5", "TRUCK5-5", "TRUCK6-5", "TRUCK7-5", "TRUCK8-5"};

// 20 planes
char * planeList[NUM_P] = {"PLANE1", "PLANE2", "PLANE3", "PLANE4", "PLANE5", "PLANE6", "PLANE7", "PLANE8", "PLANE9", "PLANE10",
						   "PLANE11", "PLANE12", "PLANE13", "PLANE14", "PLANE15", "PLANE16", "PLANE17", "PLANE18", "PLANE19", "PLANE20"};

// 20 packages
char * packageList[NUM_K] = {"PACKAGE1", "PACKAGE2", "PACKAGE3", "PACKAGE4", "PACKAGE5", "PACKAGE6", "PACKAGE7", "PACKAGE8", "PACKAGE9", "PACKAGE10",
						 "PACKAGE11", "PACKAGE12", "PACKAGE13", "PACKAGE14", "PACKAGE15", "PACKAGE16", "PACKAGE17", "PACKAGE18", "PACKAGE19", "PACKAGE20"};

/* 
a package can be defined as: genPackage, bigPackage, medPackage, or smlPackage 
*/
char * packagetype[NUM_TYPE_K]={"PACKAGE", "BIGPACKAGE", "MEDIUMPACKAGE", "SMALLPACKAGE"};
char * trucktype[NUM_TYPE_T]={"TRUCK", "BIGTRUCK", "MEDIUMTRUCK", "SMALLTRUCK"};
char * planetype[NUM_TYPE_P]={"PLANE", "BIGPLANE", "MEDIUMPLANE", "SMALLPLANE"};

truck *trk;
package *pkg;
plane *pln;

void print_constants();
void print_package(const package p);
void print_truck(const truck t);
void print_plane(const plane p);

void main(int argc, char *argv[]) {

    int cur_city, cur_truck, cur_plane, cur_package, cur_location, des_city, des_location;
	int i, j, k;    
	int randomList[4];
	int done, duplicate;

	// Initialize packages
    pkg = new package[NUM_K];
	for ( cur_package = 0; cur_package < NUM_K; cur_package++ ) {
		pkg[cur_package].name = packageList[cur_package];
		pkg[cur_package].type = packagetype[cur_package % NUM_TYPE_K];
	}

	// Initialize trucks
	trk = new truck[NUM_CITY * NUM_T];
	for ( cur_city = 0; cur_city < NUM_CITY; cur_city++ ) {
		for ( cur_truck = 0; cur_truck < NUM_T; cur_truck++ ) {
			trk[cur_city * NUM_T + cur_truck].name = truckList[cur_city * NUM_T + cur_truck];
			trk[cur_city * NUM_T + cur_truck].type = trucktype[cur_truck % NUM_TYPE_T];
		}
	}

	// Initialize planes
	pln = new plane[NUM_P];
	for ( cur_plane = 0; cur_plane < NUM_P; cur_plane++ ) {
		pln[cur_plane].name = planeList[cur_plane];
		pln[cur_plane].type = planetype[cur_plane % NUM_TYPE_P];
	}

    srandom(time(NULL));

	/* write the problem file for SHOP */
	cout<<"(defproblem UMtranslog"<<endl;
    cout<<"   ("<<endl;
    
	/*
		Pick a package randomly from the list P1, P2, ..., P20
		Select a city Ci randomly
		Select a location Lj-i in Ci randomly
		Place the package in Lj-i (starting location of package)
		Select a city Ci randomly
		Select a location Lj-i in Ci randomly (destination location in the package)
	*/
		
	cur_package = random() % NUM_K;
	cur_city = random() % NUM_CITY;	
	cur_location = random() % 3;
	des_city = random() % NUM_CITY;
	des_location = random() % 3;

	pkg[cur_package].origin_city = cityList[cur_city];
	//if ( cur_location == 3 ) {
	//	pkg[cur_package].origin = airportList[cur_city];
	//}
	//else {
    pkg[cur_package].origin = locationList[cur_city*3 + cur_location];		
	//}
	
	pkg[cur_package].destination_city = cityList[des_city];
	//if ( des_location == 3 ) {
	//	pkg[cur_package].destination = airportList[des_city];
	//}
	//else {
	pkg[cur_package].destination = locationList[des_city*3 + des_location];
	//}
    
	// print the package
	print_package(pkg[cur_package]);

	/*
	For every city Ci do
       2.1 Pick 4 trucks randomly from the list T1-i, T2-i,
           T3-i, T4-i, T5-i, T6-i, T7-i, T8-i
       2.2 For every selected truck in 2.1 select randomly a 
           location from: L1-i, L2-i, L3-i, A-i and put 
           the truck there
	*/
	
	for ( cur_city = 0; cur_city < NUM_CITY; cur_city++ ) {
		
		// initialize randomList
		for ( i = 0; i < 4; i++) {
			randomList[ i ] = -1;
		}
				
		// get 4 randomly
		for ( i = 0; i < 4; i++ ) {						
			done = 0;   			
			while ( done == 0 ) {
				duplicate = 0;
				cur_truck = random() % NUM_T;
				// check for duplicate values in the randomList
				for ( j = 0; j < 4; j++ ) {
					if ( randomList[ j ] == cur_truck ) {
						duplicate = 1;
					} 
				}				
				// if there is no duplicate, insert truck number in array
				if ( duplicate != 1 ) {
					randomList[ i ] = cur_truck;
					done = 1;
				}
			}
		}

		// assign origin location, origin city to each truck, print
		for ( i = 0; i < 4; i++ ) {
			trk[cur_city * NUM_T + randomList[ i ]].origin_city = cityList[cur_city];			
			cur_location = random() % 4;
			if ( cur_location == 3 ) {
				trk[cur_city * NUM_T + randomList[ i ]].origin = airportList[cur_city];
			}
			else {
				trk[cur_city * NUM_T + randomList[ i ]].origin = locationList[cur_city * 3 + cur_location];
			}			

			// print the truck
			print_truck( trk[cur_city * NUM_T + randomList[ i ]] );
		}		
	}

	/*
		Pick 4 airplanes randomly from the list A1, A2, ..., A20
		For each airplane randomly assign an airport
	*/

		
	// initialize randomList
	for ( j = 0; j < 4; j++ ) {
		randomList[ j ] = -1;
	}
	
	// get 4 randomly
	for ( j = 0; j < 4; j++ ) {
		done = 0;
		while ( done == 0 ) {
			duplicate = 0;
			cur_plane = random() % NUM_P;
			for ( k = 0; k < 4; k++ ) {
				if ( randomList[ k ] == cur_plane ) {
					duplicate = 1;
				}
			}
			if ( duplicate != 1 ) {
				randomList[ j ] = cur_plane;
				done = 1;
			}
		}
	}

	// assign origin location, origin city, print
	for ( j = 0; j < 4; j++ ) {
		cur_city = random() % NUM_CITY;
		pln[randomList[ j ]].origin = airportList[cur_city];
		pln[randomList[ j ]].origin_city = cityList[cur_city];
		
		// print the plane
		print_plane( pln[randomList[ j ]] );
	}
	
	/* write the information that is the same in any problem instance */
    print_constants();

	//write the tasks
    cout<<")"<<endl<<"((achieve-goals (  list"<<endl;
    cout<<"  (obj-at "<<pkg[cur_package].name<<" "<<pkg[cur_package].destination<<")"<<endl;
    cout<<"))))"<<endl;    
}


void print_package(const package p) {
    cout<<" (obj-at "<<p.name<<" "<<p.origin<<")"<<endl;
    cout<<" (type "<<p.name<<" "<<p.type<<")"<<endl;
}

/*
	format: 
	(type truck1 smallTruck) 
	(truck-at truck1 city1-cl2 )
	(truck truck1 city1 )
*/
void print_truck(const truck t) {	
	cout<<" (type "<<t.name<<" "<<t.type<<")"<<endl;
	cout<<" (truck-at "<<t.name<<" "<<t.origin<<")"<<endl;	
	cout<<" (truck "<<t.name<<" "<<t.origin_city<<")"<<endl;	
}

/*
	format: 
	(type plane1 smallPlane)
	(airplane-at plane1 city1-ap1 )
	(airplane plane1 city1)	
*/
void print_plane(const plane p) {
	cout<<" (type "<<p.name<<" "<<p.type<<")"<<endl;
	cout<<" (airplane-at "<<p.name<<" "<<p.origin<<")"<<endl;
	cout<<" (airplane "<<p.name<<" "<<p.origin_city<<")"<<endl;	
}

void print_constants() {
	cout<<" (in-city CITY1-CL1 CITY1 ) 	
 (in-city CITY1-CL2 CITY1 ) 	
 (in-city CITY1-CL3 CITY1 )
 (in-city CITY2-CL1 CITY2 ) 	
 (in-city CITY2-CL2 CITY2 ) 	
 (in-city CITY2-CL3 CITY2 )
 (in-city CITY3-CL1 CITY3 ) 	
 (in-city CITY3-CL2 CITY3 ) 	
 (in-city CITY3-CL3 CITY3 )
 (in-city CITY4-CL1 CITY4 ) 	
 (in-city CITY4-CL2 CITY4 ) 	
 (in-city CITY4-CL3 CITY4 )
 (in-city CITY5-CL1 CITY5 ) 	
 (in-city CITY5-CL2 CITY5 ) 	
 (in-city CITY5-CL3 CITY5 )
 (in-city CITY1-AP1 CITY1 )
 (in-city CITY2-AP2 CITY2 )
 (in-city CITY3-AP3 CITY3 )	
 (in-city CITY4-AP4 CITY4 )
 (in-city CITY5-AP5 CITY5 )
 (airport CITY1-AP1 )
 (airport CITY2-AP2 )
 (airport CITY3-AP3 )
 (airport CITY4-AP4 )
 (airport CITY5-AP5)"<<endl;

}