int charToInt(char num[]) {
	int i, res = 0, len = strlen(num);
	for (i = 0; i < len; i++)
		res = (res * 10) + (int)num[i] - 48;
	return res;
}
char* intToChar(int num, int digits) {
	int i = 0, tempnum = num, tempdigits = 0;
	while (tempnum) { tempdigits++; tempnum /= 10; }
	char* numstr = (char*)malloc(sizeof(char) * digits + 1);
	if (numstr) {
		while (num) {
			numstr[i++] = (int)(num % 10) + 48;
			num /= 10;
		}
		for (; i < digits; i++)
			numstr[i] = ' ';
		numstr[i] = 0;
		numstr = _strrev(numstr);
		if (tempdigits < digits)
			for (i = 0; i < digits - tempdigits; i++)
				numstr[i] = '0';
	}
	return numstr;
}
int openMapsFile() { // Gil Sorek
	FILE* mapfile;
	fopen_s(&mapfile, MAP, "rt"); // trys to read MAP file
	if (mapfile) { // if read succeeded, return 1;
		fclose(mapfile);
		return 1;
	}
	return 0; // when fails to read maps, returns 0
}
int openLetsPlay() { // Gil Sorek
	FILE* file;
	fopen_s(&file, LETSPLAY, "rt"); // trys to read letsplay file
	if (file) { // if read succeeded, return 1;
		fclose(file);
		return 1;
	}
	return 0; // when fails to read, returns 0
}
void option4PrintsPathes() { // Gilad Wolf
	store* stores;//pointer struct of stores
	char routes[34] = { 0 };//array for saving the routes for printing
	stores = (store*)malloc(sizeof(store) * 11);//creating an array of stores (struct store)
	if (!openMapsFile()) printf_s("file map.txt not found\n");
	if (stores) {
		resetingStores(stores);//reseting details
		mapArrayCreator(stores);//creating stores array with the details
		if (stores[0].exists) generatingPaths(stores, routes, 0, NULL);//generating the routes with recurtion
		else printf_s("\n");
		free(stores);
	}
}
void resetingStores(store* stores) { // Gilad Wolf
	//and empty array of stores
	int i = 0;
	for (i = 0; i < 11; i++) {
		stores[i].c1 = stores[i].c2 = stores[i].c3 = NULL;//putting null in the next stores
		stores[i].exists = stores[i].r1 = stores[i].r2 = stores[i].r3 = 0;//putting 0 in exist (no one exist)
		stores[i].num = i;//ordering the numbers of the stores to the orgins of the array
	}
}
void mapArrayCreator(store* stores) { // Gilad Wolf
	//accepting an empty array and reading from the map the relative details
	FILE* maps;//the map file
	int result = 1, i, length, from, to;//result - fgets return value. length - length of the word. from - word in 1column. row - word in 2column
	char line[9], *token;//line - word, token - rest of the line
	fopen_s(&maps, MAP, "rt");//open the map
	//if (!maps) printf_s("file map.txt not found\n");//checking if it exist
	if (maps) {
		while (result) { // while fgets get new line
			result = (int)fgets(line, 9, maps);
			if ((strcmp(line, "\n") != 0) && result) {//if its not '\n' and exist
				token = NULL;//putting null at token
				for (i = 0, length = strlen(line); i < length; i++) {//run all the line
					if (line[i] == '\t') line[i] = ' ';//if the char is '\t' put " "
					if (line[i - 1] == '\n') line[i - 1] = 0;//if the char is '\n' finish the line.
				}
				from = charToInt(strtok_s(line, " ", &token));//copying the word to from
				to = charToInt(strtok_s(token, " ", &token));//copying the word to to
				if (!stores[from].exists)//if the stores is exist
					stores[from].exists = 1;//put 1
				if (!stores[from].r1) {//if there isn't next stores from this store
					stores[from].c1 = &stores[to];//put the next store on c1
					stores[from].r1 = 1;
				}//sign that there is 1 next store
				else if (stores[from].r1 && !stores[from].r2) {//if there is only 1 next store
					stores[from].c2 = &stores[to];//put the next store on c2
					stores[from].r2 = 1;
				}//sign that there is 2 next stores
				else if (stores[from].r1 && stores[from].r2) {//if there is 2 stores
					stores[from].c3 = &stores[to];//put the next store on c3
					stores[from].r3 = 1;
				}//sign that there is 3 stores
			}
		}fclose(maps);//closing the file
	}
}
char updateRouteStr(char routes[], int num) { // Gilad Wolf
	//accepting the routes array for saving the printing lines and the number of the store
	int i, len = strlen(routes), lenNum; //len - length of the line in routes array. lenNum - how many digits
	char number[3] = { 0 };//an empty array of chars all origins is '\0'
	(num == 10) ? strncpy_s(number, 3, intToChar(num, 2), 3) : strncpy_s(number, 3, intToChar(num, 1), 3);//if number is 10 copying 3 digits, else copying 2 digits include '\0'
	lenNum = strlen(number);//length of the number
	for (i = 0; i < lenNum; i++)
		routes[len++] = number[i];//put the number in the correct location in the array
	routes[len] = '-';//put '-' next
	routes[len + 1] = '>';//put '>' next
	routes[len + 2] = 0;//put '\0'(closing line till now)
	return *routes;//returning the updateRouteStrd routes
}
int checkIfWas(char routes[], int num) // Gilad Wolf
	////////////////////////////////////////////////////////////
{
	int i = 0, length = strlen(routes);
	for (i = 0; i < length; i += 3) {
		if (num == 10) {
			if (1 == ((routes[i] + 48)) && 0 == routes[i + 1])
				return(1);
		}
		else {
			if ((num + 48) == routes[i])
				return(1);
		}
	}return(0);
}
void printPaths(store* store, char routes[], char* temproute, int flag, FILE* routesfile) { // Gilad Wolf
//accepting  the stores array, the routes array (the printing lines),a pointer with the correct line for printing. flag and file for creating file to func5
	if (store->num == 0) {//if store is store number 0
		routes[strlen(temproute)] = 48;//putting 0 in the printing line
		routes[strlen(temproute) + 1] = 0;//closing the line
		strncpy_s(temproute, 34, routes, 34);//copying line from routes to the temp route
		(!flag) ? printf_s("%s\n", temproute) : fprintf_s(routesfile, "%s\n", temproute);//if flag is 0 printing the route
		routes[strlen(temproute) - 1] = 0;//closing the routes instead of the 0 number;
		free(temproute);//free the temp route
	}
	else {
		routes[strlen(temproute) - 2] = 0;//if we've been in the this store
		strncpy_s(temproute, 34, routes, 34);//copying to the temp route the line from routes
		if (!flag) printf_s("%s\n", temproute);//printing the route
		routes[strlen(temproute)] = '-';//put '-' next
		routes[strlen(temproute) + 1] = '>';//put '>' next
		free(temproute);//free the temp route
	}
}
void generatingPaths(store* store, char routes[], int flag, FILE* routesfile) { // Gilad Wolf
	//accepting the stores, sevivon(reality reminder), routes, flag and file for func5
	char* temproute = calloc(34, 1);//creating a dinamic line
	strncpy_s(temproute, 34, routes, 34);//copying routes to temproute
	if (!checkIfWas(routes, store->num)) {//if we have never been in this store
		updateRouteStr(temproute, store->num);//updating the temproute where we are now
		if (store->r1)generatingPaths(store->c1, temproute, flag, routesfile);//if there is next store, go there.
		if (store->r2 && checkIfWas(routes, store->c2->num) == 0) generatingPaths(store->c2, temproute, flag, routesfile);// if there is next second store and we never been there, go there.
		if (store->r3 && checkIfWas(routes, store->c3->num) == 0) generatingPaths(store->c3, temproute, flag, routesfile);// if there is next third store, go there.
		if (!store->r1) {// if there isn't next stores
			strncpy_s(routes, 34, temproute, 34);//copying temproute line to routes array for saving it
			routes[strlen(temproute) - 2] = 0;//closing the line in routes
			strncpy_s(temproute, 34, routes, 34);//copying routes line to temproute
			if (!flag) printf_s("%s\n", temproute);//if flag is 0 printing the route
			routes[strlen(temproute)] = '-';//put '-' next
			routes[strlen(temproute) + 1] = '>';//put '>' next
			free(temproute);//free the temproute
		}
	}
	else
		printPaths(store, routes, temproute, flag, routesfile);//if we have been in this store. printing the route
}
// Option 5 functions
void option5DriverPath(int mode) {		// Gil Sorek
	FILE* routes = NULL;
	path_t* paths;				// paths array for routes starting and ending in the factory
	int maxroutelen = 0, numOfRoutes = 0, routesflag = 1;	// variables for calculating how many routes are and the longest route length
	char* routestr = NULL;					// string for saving routes from routes.txt
	routes = readRoutesFromMaps(routes, &routesflag, mode);	// trying to read routes.txt to check if there are any relevant routes
	if (!routes) {
		if (routesflag) printf_s("Read error.\n");		// if cant read routes.txt
		else if ((!routesflag) && (mode != 2)) printf_s("No path from factory 0\n\n");	// if there are no roads going out from the factory
		else if ((!routesflag) && (mode == 2) && openMapsFile()) printf_s("\n");
	}
	else {
		routestr = genRouteStr(routes, &maxroutelen, &numOfRoutes); // generating longest route string
		paths = (path_t*)malloc(sizeof(path_t)*(numOfRoutes + 1));	// allocating memory for routes array (1 extra to work with coordinated indexes)
		if (paths && routestr) {	// if memory allocated good and routestr string was created
			if (numOfRoutes) {		// if there is at least one complete route (going out and back to factory)
				if (genPathNodes(paths, routestr, maxroutelen, numOfRoutes, routes))	// generates all routes nodes
					chooseBestPath(paths, numOfRoutes + 1, mode);	// chooses best route
				freePaths(paths, numOfRoutes);	// free all nodes
			}
			else {
				if (openLetsPlay()) printf_s("can't find file letsPlay.txt\n");
				printf_s("No best path found\n\n"); free(paths); free(routestr); }
		}
	}
}
FILE* readRoutesFromMaps(FILE* routes, int* routesflag, int mode) { // Gil Sorek
	store* stores;
	char routesStr[34] = { 0 }; //route string with longest possible route length
	fopen_s(&routes, ROUTE, "w+");
	if (!routes) return NULL;	// if cant read file, return NULL
	stores = (store*)malloc(sizeof(store) * 11); // allocating memory for all stores(and factory)
	if (mode == 1) {
		if (!openLetsPlay()) printf_s("can't find file letsPlay.txt\n");
		if (!openMapsFile()) printf_s("file map.txt not found\n");
	}
	else
		if (!openMapsFile()) printf_s("file map.txt not found\n\n");
	if (stores) {
		resetingStores(stores); // resetting stores list
		mapArrayCreator(stores); // creating stores array with info from map.txt
		if (stores[0].exists) generatingPaths(stores, routesStr, 1, routes); // generating all routes (run-mode 1 for function 5 mode)
		else { fclose(routes); free(stores); *routesflag = 0; return NULL; }  // if no roads going out from factory, return NULL with routesflag=0 for error printing
		fseek(routes, 0, SEEK_SET);
		return routes; // if successful read, return routes FILE
	}
	fclose(routes);
	return NULL;
}
char* genRouteStr(FILE* routes, int* routemax, int* numOfRoutes) {	// Gil Sorek
	int res = 0, routelen = 1;			// res is fscanf_s result variable, routelen is the longest route length
	char ch = '\n', lastch, *routestr=NULL;	// ch&lastch for chars comparison
	while (res != EOF) {
		if (ch) lastch = ch;			// save last char before getting new
		res = fscanf_s(routes, "%c", &ch, 1);
		if ((ch != '\n') && (res != EOF)) routelen++;		// counting chars in each line
		else {	 // end of line
			if (routelen > *routemax) *routemax = routelen; // if current line is the longest, save length
			routelen = 1;
			if (lastch != '\n') (*numOfRoutes)++;			// saving total number of routes
		}
	}
	fseek(routes, 0, SEEK_SET);
	routestr = calloc(*routemax + 1, 1);	// allocating memory for longest route length string
	return routestr; // returning routestr string address if calloc succeeded, else returning NULL
}
void create_PathNode(path_t* head, path_t* path, char route[]) {	// Gil Sorek
	path_t *store = NULL;	// creating new store variable for the node list
	removeLastStore(route, path->store);	// removing last store from route string
	if (route[0] != '0') {					// if current store is not the last one (factory)
		store = malloc(sizeof(path_t));		// allocating memory for the new store
		store->store = (route[1] == '-') ? (int)route[0] - 48 : 10;	// saving store number from route string
		store->packCount = packagesForStore(store->store);			// saving number of packages appointed for the current store
		store->distTotal = path->distTotal + distanceBetweenStores(path->store, store->store);	// summing of the total distance of the route
		store->packTotal = path->packTotal + store->packCount;	// summing the total packages for the route
		store->next = path;
		path->next = store; // adding store to node list
		if (strcmp(route, "0") != 0) create_PathNode(head, path->next, route); // sending new node list again to continue list building
	}
	else {	// if this is the last store (arrived back to factory)
		head->distTotal = path->distTotal + distanceBetweenStores(path->store, 0); // save total distance in the head of the list including way back to factory
		head->packTotal = path->packTotal; // save total packages in the head of the list
		path->next = NULL;
	}
}
void removeLastStore(char route[], int store) {	// Gil Sorek
	int i, len; // len is variable for how many chars needed to be removed (depends on store number)
	for (i = 0, len = (store == 10) ? strlen(route) - 2 : strlen(route) - 3; i < len; i++)
		route[i] = (store == 10) ? route[i + 4] : route[i + 3]; // over-writing the store wanting to remove
	route[i] = 0; // setting last char as '\0'
}
int genPathNodes(path_t* paths, char routestr[], int maxroutelen, int numOfRoutes, FILE* routes) {	// Gil Sorek
	// paths=routes array, routestr=longest route string, maxroutelen=longest route length, numOfRoutes=total number of routes, routes=FILE*
	int i;
	char** routesArr = genRoutesArr(routes, maxroutelen, numOfRoutes); // generates arr with all complete routs (going from and back to factory)
	if (routesArr) {
		for (i = 1; i < numOfRoutes + 1; i++) {			// running on all routes
			paths[i].distTotal = paths[i].packCount = paths[i].packTotal = paths[i].store = 0;	// defining the head of each route
			paths[i].path = malloc(sizeof(char)*strlen(routesArr[i]) + 1);							// allocating memory for route string
			strncpy_s(paths[i].path, maxroutelen, routesArr[i], strlen(routesArr[i]) + 1);		// saving route string in each head
			strncpy_s(routestr, maxroutelen, routesArr[i], strlen(routesArr[i]) + 1);			// saving copy of route for recurtion function
			create_PathNode(&paths[i], &paths[i], routestr);	// Creating path node for every route
		}
		for (int i = 1; i < numOfRoutes + 1; i++) // free memory
			free(routesArr[i]);
		free(routesArr);
		//freopen_s(routes, ROUTE, "wt", routes);
		fclose(routes);
		if (paths[1].next != NULL)	// if at least 1 node exists
			return 1;
	}
	return 0;
}
char** genRoutesArr(FILE* routes, int maxRoutelen, int numOfRoutes) { // Gil Sorek
	int i, res = 1; // res for fgets return value
	char* tempstr = calloc(maxRoutelen, 1);	// temp string for saving every route
	char** routesArr=NULL;	// char** array for all complete routs (going from and back to factory)
	routesArr = (char**)malloc(sizeof(char*) * (numOfRoutes + 1)); // allocating memory for array
	for (i = 0; i < numOfRoutes + 1; i++) //allocating string for every route
		routesArr[i] = (char*)malloc(sizeof(char)*maxRoutelen);
	if (tempstr && routesArr) { // if mallocs succeded, creates array
		fseek(routes, 0, SEEK_SET);
		i = 1;
		while (res) { // while getting routes from file
			res = (int)fgets(tempstr, maxRoutelen, routes); // save route in tempstr
			if (res && strcmp(tempstr, "\n")) {
				strncpy_s(routesArr[i], maxRoutelen, tempstr, strlen(tempstr)); //saving route in array
				if (routesArr[i][strlen(routesArr[i])-1] == '\n') // removes '\n' at the end of every line
					routesArr[i][strlen(routesArr[i])-1] = 0;
				i++; // promotes i for next route
			}
		}
		free(tempstr); //free tempstr memory
	}
	fclose(routes);
	return routesArr; // return arr
}
int packagesForStore(int store) {	// Gil Sorek
	int res = 1, packages = 0;		// res is fgets return value, packages for counting how many packages appointed to store
	char package[13];				// package string to save from file
	FILE* file;
	fopen_s(&file, LETSPLAY, "rt");
	if (!file) return 0;			// if cant read file, return 0 packages
	while (res) {
		res = (int)fgets(package, 13, file);
		if ((getPackageStore(package) == store) && res) packages++;	// if store of package from file matches to store variable
		fseek(file, 2, SEEK_CUR);	// skip '\n' at the end of each line
	}
	fclose(file);
	return packages;
}
int distanceBetweenStores(int store1, int store2) { // Gil Sorek
	FILE* maps;
	int res = 1, i, len, from, to;	// res for fgets return value, from&to for store numbers in map.txt
	char line[9], *token;			// line string for saving every line from file
	fopen_s(&maps, MAP, "rt");
	while (res) {	// while getting new lines
		res = (int)fgets(line, 9, maps);
		if ((strcmp(line, "\n") != 0) && res) { // if line is not '\n'
			token = NULL;
			for (i = 0, len = strlen(line); i < len; i++)
				if (line[i] == '\t') line[i] = ' ';		// replace tabs with spaces
			if (line[i - 1] == '\n') line[i - 1] = 0;	// set end of line in '\0'
			from = charToInt(strtok_s(line, " ", &token));	// extract from city
			to = charToInt(strtok_s(token, " ", &token));	// extract to city
			if (((from == store1) && (to == store2)) || ((from == store2) && (to == store1))) {	// if cities is a match, return distance (whats left in token str)
				fclose(maps);
				return charToInt(token);
			}
		}
	}
	fclose(maps);
	return 0; // return 0 if no match
}
void chooseBestPath(path_t* paths, int numOfRoutes, int mode) { // Gil Sorek
	int i, bestroute = 1; //setting first route as best route at the starting
	for (i = 2; i < numOfRoutes; i++) { // running on all other routes
		if (paths[i].packTotal > paths[bestroute].packTotal) // if total packs of current route is bigger than current best route, replace indexes
			bestroute = i;
		else if (paths[i].packTotal == paths[bestroute].packTotal) // in case total packages are equal
			if (paths[i].distTotal < paths[bestroute].distTotal) // if total distance is lower, replace indexes
				bestroute = i;
	}
	if (mode == 2)
		fuelConsumption(paths[bestroute]); // if run-mode is 2, send best route to function 6 (fuel report)
	printRouteFile(paths[bestroute], mode); // else print best route
}
void printRouteFile(path_t bestpath, int mode) { // Gil Sorek
	FILE* route;
	path_t* ptr = bestpath.next; // creates path_t ptr for running on all stores
	fopen_s(&route, ROUTE, "wt");// creates route file
	if (!route)
		printf_s("problem writing to route.txt\n");
	else {
		fprintf_s(route, "Driver Route:\n%s\nStore\tPackages Distance so far[km]\n----	-------- -------------------\n", bestpath.path); // prints headlines
		if (mode == 1) printf_s("Driver Route:\n%s\n", bestpath.path);
		if (mode == 1) printf_s("The total packages available for this route is %d\nThe total suggested route distance is %d\n\n", bestpath.packTotal, bestpath.distTotal); // prints to screen total packages and distance
		while (ptr->next) { // for every store in node list
			fprintf_s(route, "%d\t%d\t %d\n", ptr->store, ptr->packCount, ptr->distTotal); // prints to file every store's number, pack count and distance
			ptr = ptr->next; // promotes ptr to next store
		}
		fprintf_s(route, "%d\t%d\t %d\n%d\t%d\t %d\n", ptr->store, ptr->packCount, ptr->distTotal, bestpath.store, bestpath.packCount, bestpath.distTotal); // prints last store's number, pack count and distance
		fprintf_s(route, "The total packages available for this route is %d\nThe total suggested route distance is %d\n", bestpath.packTotal, bestpath.distTotal); // prints total packages for route and total distance
	}
	fclose(route); // closes file
}
void freePaths(path_t* paths, int routes) { // Gil Sorek
	path_t* ptr1, *ptr2; // creates 2 path_t pointers for running on node list and free memory
	int i;
	for (i = 1; i < routes + 1; i++) { // for every store (starting from first store, not includes factory(head) )
		ptr1 = paths[i].next; // at the start of every route, ptr1 first equals to the first store (after factory)
		while (ptr1) { // while ptr1 exists (doesnt equals NULL)
			ptr2 = ptr1->next; // stores next store after ptr1
			free(ptr1); // free memory of first store
			ptr1 = ptr2;// promotes first ptr to what was ptr1->next
		}
		ptr1 = ptr2 = NULL; // resets pointers
	}
	free(paths); // free all factory heads for all routes
}