/*
 * Jednoduchy konverzni a rezaci programek pro GPSku  
 * Petr Krejci										  
 * Pouziti: ot2gps <soubor bez pripony> <sirka rezu> <vyskaorezu> <prekryvani> [sirka] [vyska] 
 * 1. otevreni souboru s priponou .map a .cal
 * 2. podle prvniho radku urci typ souboru
 * 3. nacteni okrajovych poloch
 * 4. podle sirky a vysky vyrezu provede vypocet 
 * okrajovych poloch jednotlich vyrezu a vytvori jednotlive
 * soubory odpovidajici rezum. Nazvy souboru obsahuje pocizi vyrezu
 * 
*/


#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <complex.h>

// Struktura popisujici polohu a pozici v obrazku
typedef struct tPoloha {
    int x;
    int y;
    double px;
    double py;
} tPoloha;

// Nacteni radky ze souboru
int getRow(FILE * a_f, char * a_row) {
    int l_znak;


    while (! feof(a_f)) {
	l_znak = fgetc(a_f);
	if (l_znak == -1) {
		*a_row = 0;
		return 1;
	}
	if (l_znak == '\n') {
		*a_row = 0;
		return 0;
	}
	if (l_znak == '\r') {
		continue;
	}
	* a_row = l_znak;
	a_row++;
    }
    *a_row = 0;
    return 1;
}

// Rozdeli retezec podle oddelovace
int strseg(char * a_row, char a_del, int *a_pocet, char *a_pozice[] ) {
    char l_retezec[1024];
    char *l_aktualni;
    
    *a_pocet = 1;
    l_aktualni = & l_retezec[0];
    while (*a_row != 0) {
		if (* a_row == a_del) {
			*l_aktualni = 0;
			a_pozice[(*a_pocet)-1] = (char *) strdup(l_retezec);
			l_aktualni = & l_retezec[0];
			(*a_pocet)++;
			a_row++;
			continue;
		}
		*l_aktualni = * a_row;
		l_aktualni++;
		a_row++;
    }
	*l_aktualni = 0;
	a_pozice[(*a_pocet)-1] = (char *) strdup(l_retezec);
    return 1;
}

// Nacteni pozic ze souboru ve formatu OZI
int ozi(FILE *l_ozimap, int *l_pocet, tPoloha l_rozmer[], int *l_width, int *l_height) {
	int l_konec;
	char l_row[1024];
	char *l_segmenty[20];
	int l_pocetx, l_idx;
	
	l_konec = 0;
	*l_pocet = 0;
	while (! l_konec) {
		l_konec = getRow(l_ozimap, l_row);
		if (l_row[0] == 0) {
			continue;
		}

		if (strncmp("MMPXY", l_row, 5) == 0 ) {
	   	   strseg(l_row,',', & l_pocetx, l_segmenty);
		   l_idx = atoi(l_segmenty[1]) - 1 ;

		   l_rozmer[l_idx].x = atoi(l_segmenty[2]); 
		   l_rozmer[l_idx].y = atoi(l_segmenty[3]); 

		   *l_pocet = (*l_pocet < l_idx+1) ? l_idx + 1 : *l_pocet;
		}

		if (strncmp("MMPLL", l_row, 5) == 0 ) {
	           strseg(l_row,',', & l_pocetx, l_segmenty);
               l_idx = atoi(l_segmenty[1]) - 1;

               l_rozmer[l_idx].px = atof(l_segmenty[2]);
               l_rozmer[l_idx].py = atof(l_segmenty[3]);

			   *l_pocet = (*l_pocet < l_idx+1) ? l_idx + 1 : *l_pocet;
		}
		
		// IWH,Map Image Width/Height,1186,1741
		if (strncmp("IWH", l_row, 3) == 0 ) {
	           strseg(l_row,',', & l_pocetx, l_segmenty);

               *l_width = atoi(l_segmenty[2]);
               *l_height = atoi(l_segmenty[3]);
		}

	}
	return 1;
}

// Nacteni polohy ze souboru ve formatu TOMTOM
int tomtom(FILE *l_ozimap, int *l_pocet, tPoloha l_rozmer[], int *l_width, int *l_height) {
	int l_konec;
	char l_row[1024];
	char *l_segmenty[20];
	int l_pocetx;
	int l_idx;
	
	l_konec = 0;
	*l_pocet = 0;
	while (! l_konec) {
		l_konec = getRow(l_ozimap, l_row);
		if (l_row[0] == 0) {
			continue;
		}
   	    strseg(l_row,'=', & l_pocetx, l_segmenty);

/*		if (strstr(l_row, "nord =") != NULL ) {
		   l_rozmer[0].py = atof(l_segmenty[2]); 
		   l_rozmer[1].py = atof(l_segmenty[2]); 
		   l_rozmer[0].y = 0; 
		   l_rozmer[1].y = 0; 
		}
		if (strstr(l_row, "sued =") != NULL ) {
		   l_rozmer[2].py = atof(l_segmenty[2]); 
		   l_rozmer[3].py = atof(l_segmenty[2]); 
		   l_rozmer[2].y = *l_height; 
		   l_rozmer[3].y = *l_height; 
		}
		if (strstr(l_row, "ost =") != NULL ) {
		   l_rozmer[1].px = atof(l_segmenty[2]); 
		   l_rozmer[2].px = atof(l_segmenty[2]); 
		   l_rozmer[1].x = *l_width; 
		   l_rozmer[2].x = *l_width; 
		}
		if (strstr(l_row, "west =") != NULL ) {
		   l_rozmer[3].px = atof(l_segmenty[2]); 
		   l_rozmer[0].px = atof(l_segmenty[2]); 
		   l_rozmer[3].x = 0; 
		   l_rozmer[0].x = 0; 
		}*/
		
		if (strstr(l_row, "_x =") != NULL ) {
			sscanf(l_row, "c%d_x", & l_idx);
			
			l_rozmer[l_idx-1].x = atoi(l_segmenty[2]);
			
		   *l_pocet = (*l_pocet < l_idx+1) ? l_idx + 1 : *l_pocet;
		}
		
		if (strstr(l_row, "_y =") != NULL ) {
			sscanf(l_row, "c%d_y", & l_idx);
			
			l_rozmer[l_idx-1].y = atoi(l_segmenty[2]);
			
		   *l_pocet = (*l_pocet < l_idx+1) ? l_idx + 1 : *l_pocet;
		}
		
		if (strstr(l_row, "_lat =") != NULL ) {
			sscanf(l_row, "c%d_lat", & l_idx);
			
			l_rozmer[l_idx-1].py = atof(l_segmenty[2]);
			
		   *l_pocet = (*l_pocet < l_idx+1) ? l_idx + 1 : *l_pocet;
		}
		
		if (strstr(l_row, "_lon =") != NULL ) {
			sscanf(l_row, "c%d_lon", & l_idx);
			
			l_rozmer[l_idx-1].px = atof(l_segmenty[2]);
			
		   *l_pocet = (*l_pocet < l_idx+1) ? l_idx + 1 : *l_pocet;
		}
	}
	/**l_pocet = 4;*/
	// Zjisti, ktere jsou prazdne ty vyrad
	for(l_idx = 0; l_idx < *l_pocet; l_idx++) {
		if (l_rozmer[l_idx].px == 0 && l_rozmer[l_idx].py == 0) {
			memcpy(& l_rozmer[l_idx], & l_rozmer[l_idx+1], sizeof(tPoloha) * ((*l_pocet)-l_idx-1));
			l_idx--;
			(*l_pocet)--;
		}
	}
	
	
	return 1;
}

// Vypocita polohu podle calibracnich bodu
int getXY(tPoloha a_polohy[], int a_pocet, int a_x, int a_y, double * a_px, double * a_py) {
	int l_idx;
	int l_rozdil1, l_rozdil2;
	int l_rozdil;
	int l_polozka1, l_polozka2;
	// Vyhledej 2 neblizsi body
	// X
	l_rozdil1 = 10000;	l_polozka1 = -1;
	l_rozdil2 = 10000;	l_polozka2 = -1;
	for(l_idx = 0; l_idx < a_pocet ; l_idx++) {
		l_rozdil =   hypot(a_polohy[l_idx].x - a_x, a_polohy[l_idx].y - a_y);
		if ( l_rozdil < l_rozdil1 ) {
			l_rozdil1 = l_rozdil;
			l_polozka1 = l_idx;
			continue;
		}
	}
	for(l_idx = 0; l_idx < a_pocet ; l_idx++) {
		l_rozdil =   hypot(a_polohy[l_idx].x - a_x, a_polohy[l_idx].y - a_y);
		if (l_rozdil < l_rozdil2 && l_rozdil > l_rozdil1 && a_polohy[l_idx].x != a_polohy[l_polozka1].x && a_polohy[l_idx].y != a_polohy[l_polozka1].y) {
			l_rozdil2 = l_rozdil;
			l_polozka2 = l_idx;
			continue;
		}
	}
	// X
	*a_px = a_polohy[l_polozka1].px + 
	(a_polohy[l_polozka2].px - a_polohy[l_polozka1].px) / 
	(a_polohy[l_polozka2].x - a_polohy[l_polozka1].x) * 
	( a_x - a_polohy[l_polozka1].x);
	
	// Y
	*a_py = a_polohy[l_polozka1].py + 
		(a_polohy[l_polozka2].py - a_polohy[l_polozka1].py) / 
		(a_polohy[l_polozka2].y - a_polohy[l_polozka1].y) * 
		( a_y - a_polohy[l_polozka1].y);
	return 1;
}


int main(int argc, const char *argv[] ) {
	FILE *l_ozimap;
	char l_row[1024];
	int l_pocet=0;
	tPoloha l_body[256];
	int l_konec;
	char l_filename[128] = {0};
	
	int sizeX, sizeY,overlap;
	int l_x, l_y, imX, imY, imH, imW;
	int l_width = 0, l_height = 0;
	double l_pozx1, l_pozy1;
	double l_pozx2, l_pozy2;
	double l_pozx3, l_pozy3;
	double l_pozx4, l_pozy4;
	
	if (argc < 5) {
		fprintf(stderr,"ot2gps <soubor bez pripony> <sirka rezu> <vyskaorezu> <prekryvani> [sirka] [vyska]");
		exit(1);
	}
	sizeX = atoi(argv[2]);
	sizeY = atoi(argv[3]);
	overlap = atoi(argv[4]);
	if (argc >  5) {
		l_width = atoi(argv[5]);
	}
	if (argc > 6) {
		l_height = atoi(argv[6]);
	}
	
	// Nacti souradnice ze souboru, MMPXY, MMPLL
   	strcpy(l_filename, argv[1]);
	strcat(l_filename, ".map");
	l_ozimap = fopen(l_filename, "rt");
	if (l_ozimap == NULL) {
	   	strcpy(l_filename, argv[1]);
		strcat(l_filename, ".cal");
		l_ozimap = fopen(l_filename, "rt");
	}
	if (l_ozimap == NULL) {
		fprintf(stderr,"Soubor se nepodarilo otevrit");
		exit(1);
	}
	
	
	// Urceni typu souboru OZI nebo TOMTOM ?
	l_konec = getRow(l_ozimap, l_row);
	if (strncmp("OziExplorer",l_row, 11) == 0) {
		ozi(l_ozimap, & l_pocet, l_body, & l_width, &l_height);
	}	
	if (strncmp("; Calibration File for QV Map",l_row, 29) == 0) {
		tomtom(l_ozimap, & l_pocet, l_body, & l_width, &l_height);
	}	
	fclose(l_ozimap);
	
	if (l_pocet == 0) {
		fprintf(stderr,"Nenalezen zadny kalibracni bod.\n");
		exit(1);
	}
	if (l_width == 0) {
		fprintf(stderr,"Neni nastavena sirka.\n");
		exit(1);
	}
	if (l_height == 0) {
		fprintf(stderr,"Neni nastavena vyska.\n");
		exit(1);
	}
	
	/******************************/
	/* Vlastni vytvoreni souboru  */
	/******************************/

	
	l_y = 0;
	while (l_y < l_height) {
		l_x = 0;
		while (l_x < l_width) {
			
			imX = l_x - overlap; imY = l_y - overlap;
			if (imX < 0) imX = 0; if (imY < 0) imY = 0;
			imW = sizeX + 2 * overlap;
			imH = sizeY + 2 * overlap;
			if (imX + imW > l_width) imW = l_width - imX;
			if (imY + imH > l_height) imH = l_height - imY;

			getXY(l_body, l_pocet, imX, imY, &l_pozx1, &l_pozy1);
			getXY(l_body, l_pocet, imX + imW, imY, &l_pozx2, &l_pozy2);
			getXY(l_body, l_pocet, imX + imW, imY+imH, &l_pozx3, &l_pozy3);
			getXY(l_body, l_pocet, imX, imY+imH, &l_pozx4, &l_pozy4);
			
			sprintf(l_filename, "%s_%d_%d.xml", argv[1], l_x, l_y);
			l_ozimap = fopen(l_filename, "wt");
			fprintf(l_ozimap, "<?xml version=\"1.0\"?>\n");
			fprintf(l_ozimap, "<map>\n");
			fprintf(l_ozimap, "<name>%s_%d_%d</name>\n",argv[1], l_x, l_y);
			fprintf(l_ozimap,"<description>%s</description>\n", argv[1]);
			fprintf(l_ozimap,"<position x=\"%d\" y=\"%d\"><latitude>%f</latitude><longitude>%f</longitude></position>\n", 0, 0, l_pozy1 , l_pozx1); 
			fprintf(l_ozimap,"<position x=\"%d\" y=\"%d\"><latitude>%f</latitude><longitude>%f</longitude></position>\n", imW, 0, l_pozy2, l_pozx2); 
			fprintf(l_ozimap,"<position x=\"%d\" y=\"%d\"><latitude>%f</latitude><longitude>%f</longitude></position>\n", 0, imH, l_pozy4, l_pozx4 );
			fprintf(l_ozimap,"<position x=\"%d\" y=\"%d\"><latitude>%f</latitude><longitude>%f</longitude></position>\n", imW, imH, l_pozy3, l_pozx3); 
			fprintf(l_ozimap, "<imageWidth>%d</imageWidth>\n", imW);
			fprintf(l_ozimap, "<imageHeight>%d</imageHeight>\n", imH);
			fprintf(l_ozimap, "</map>\n");
			
			printf("%s_%d_%d\n\t%d,\t%d\t%f,%f\n", argv[1], l_x, l_y, 0, 0, l_pozy1 , l_pozx1);
			printf("\t%d,\t%d\t%f,%f\n", imW, 0, l_pozy2 , l_pozx2);
			printf("\t%d,\t%d\t%f,%f\n", imW, imH, l_pozy3 , l_pozx3);
			printf("\t%d,\t%d\t%f,%f\n", 0, imH, l_pozy4 , l_pozx4);
			
			fclose(l_ozimap);
			
			l_x += sizeX;	
				
		}
		
		l_y += sizeY;	
	}
	

	return 0;
}