#include "contorno.h"

void ini_contorno (tContorno *contorno )
{
	int i;
	contorno->num_puntos_contorno=0;
	for (i=0;i<MAX_PUNTOS_CONTORNO;i++){
		contorno->contorno[i].latitud=0;
		contorno->contorno[i].longitud=0;
	}
}

void leer_contorno_teclado (tContorno *dibujo)
{
	int i;
	printf("Escriu el nombre de punts:\n");
	scanf("%d%*c",&dibujo->num_puntos_contorno);
	for(i=0;i<dibujo->num_puntos_contorno;i++){
		dibujo->contorno[i]=leer_coordenada_teclado();
		
	}
}

int buscar_coordenada_contorno (tContorno contorno, tCoordenada coordenada)
{	
	int i=0;
	while (!coordenadas_iguales(contorno.contorno[i],coordenada) &&
		i<contorno.num_puntos_contorno)
		i++;
	if ( i==contorno.num_puntos_contorno){
		return -1;
	}else{
		return i;
		}
	
}

int insertar_coordenada_contorno (tContorno *contorno , tCoordenada coordenada )
{	
	int i;
	i=contorno->num_puntos_contorno;
	
	
	if (contorno->num_puntos_contorno==MAX_PUNTOS_CONTORNO && buscar_coordenada_contorno (*contorno,coordenada)!= -1){
		printf ("La llista de coordenades esta plena!!o la coordenada ja existeix\n");
		return 0;
	}else{
		contorno->contorno[i].latitud=coordenada.latitud;
		contorno->contorno[i].longitud=coordenada.longitud;
		contorno->num_puntos_contorno++;
	return i;
	}

}

int eliminar_coordenada_contorno (tContorno *contorno, tCoordenada coordenada)
{
	int i;
	/*pos=buscar_coordenada_contorno (*contorno, coordenada);*/
	if (contorno->num_puntos_contorno==0 || buscar_coordenada_contorno (*contorno, coordenada) == -1){
		printf ("no s'ha pogut eliminar cap element perquè la llista està buida o la coordenada no hi es!!");
	return 0;
	}else{
		
		for (i=buscar_coordenada_contorno (*contorno, coordenada);i<contorno->num_puntos_contorno;i++){
			contorno->contorno[i].latitud = contorno->contorno[i+1].latitud;
			contorno->contorno[i].longitud = contorno->contorno[i+1].longitud;
			
		}
		contorno->num_puntos_contorno--;
		}
		return buscar_coordenada_contorno (*contorno, coordenada) ;
	


}

void dibujar_contorno_mapa (tContorno contorno)
{
	int i;
	for (i=0;i<contorno.num_puntos_contorno - 1;i++){
		dibujar_segmento (contorno.contorno[i],contorno.contorno[i+1]);
	}
		dibujar_segmento (contorno.contorno[contorno.num_puntos_contorno - 1],contorno.contorno[0]);
}

/* Muestra por pantalla el contenido de la 
estructura contorno que viene como parametro */
void escribir_contorno_pantalla (tContorno c)
{
	int i;

	printf("\n Contorno: %d puntos", c.num_puntos_contorno);
	for (i=0; (i<c.num_puntos_contorno); i++) {
		printf("\n %d: (%.2f, %.2f) ", i, c.contorno[i].latitud, c.contorno[i].longitud);
	}
}

int escribir_contorno_fichero (tContorno contorno, tNombre nombre_fichero)
{	
	int i;
	FILE *fp;
	fp = fopen (nombre_fichero,"w");
	if (fp==NULL){
		printf("Error, no s'ha pogut trobar el fitxer demanat.\n");
		return 0;
	}else{
		for (i=0;i<contorno.num_puntos_contorno;i++){
			fprintf (fp,"(%f,%f)\n", contorno.contorno[i].latitud,contorno.contorno[i].longitud);
		}
		return i+1;
	}
	fclose (fp);
	
}




int leer_contorno_fichero (tContorno *contorno, tNombre nombre_fichero)
{
	int i=0,ok;
	
	FILE *fpin;
	fpin = fopen (nombre_fichero,"r");
	if (fpin==NULL){
		printf("Error, no s'ha pogut trobar el fitxer demanat.\n");
		return 0;
	}else{
		while (!feof(fpin)){
			
			ok = fscanf (fpin, "(%f,%f)\n",&contorno->contorno[i].latitud,&contorno->contorno[i].longitud);
	
			i++;
		}
		contorno->num_puntos_contorno = i;
		return i;
		
	}
	
	fclose (fpin);
}

void rotar_contorno ( tContorno *contorno, float angulo, tCoordenada centro_rotacion)
{
	int i;
	for (i=0; i<contorno->num_puntos_contorno;i++){
		contorno->contorno[i] = rotar_coordenada (contorno->contorno[i], angulo, centro_rotacion);
	}
		dibujar_contorno_mapa (*contorno);
}

float calcular_perimetro (tContorno dibujo)
{
	int i;
	float res,perim;
	perim = 0;
	res = 0;

	if(dibujo.num_puntos_contorno == 2){
		res = calcular_distancia (dibujo.contorno[0],dibujo.contorno[1]);
	}else{

	for (i=0;i<dibujo.num_puntos_contorno - 2;i++){
		res = res + calcular_distancia (dibujo.contorno[i],dibujo.contorno[i+1]);
	}
	perim = res + calcular_distancia (dibujo.contorno[dibujo.num_puntos_contorno-1],dibujo.contorno[0]);
	}
	return res;
}







#include "tortuga.h"
#include "coordenada.h"


/* Crea e inicializa una estructura de tipo tCoordenada
con las coordenadas (0,0) */
tCoordenada ini_coordenada ()
{
tCoordenada aux;
	aux.latitud= 0;
	aux.longitud= 0;
	return aux;
}


/* Lee desde teclado los campos latitud y longitud de la estructura coordenada 
y retorna una estructura de tipo tCoordenada cargada con éstos valores */
tCoordenada leer_coordenada_teclado ()
{
tCoordenada coord;

	coord = ini_coordenada();

	printf("\n                Latitud? ");
	scanf("%f%*c", &coord.latitud);
	printf("\n                Longitud? ");
	scanf("%f%*c", &coord.longitud);

	return coord;
}

void escribir_coordenada_pantalla (tCoordenada coord)
{
	printf("\n Coordenada: latitud=%.2f  longitud=%.2f \n", coord.latitud, coord.longitud);
}

void posicionar_tortuga (tCoordenada coordenada)
{
	posicion_inicial (coordenada.latitud,coordenada.longitud);
}

void  dibujar_segmento ( tCoordenada cinicio, tCoordenada cfinal )
{
	float x,z;
	posicionar_tortuga (cinicio);
	angulo_inicial(0);
	x=angulo_segmento_abcisas (cinicio,cfinal);
	girar(x);
	z=calcular_distancia(cinicio,cfinal);
	avanzar(z);
	girar (-x);
	

}

float calcular_distancia (tCoordenada coord1, tCoordenada coord2)
{
	float x,y,z;
		x=(coord2.latitud)-(coord1.latitud);
	    y=(coord2.longitud)-(coord1.longitud);
        z=(float)sqrt(pow(x,2)+pow(y,2));

	return z;
}

int escribir_coordenada_fichero(FILE *fp, tCoordenada coordenada)
{

	char nombre_fichero [30];
	fp = fopen (nombre_fichero,"w");
	if (fp==NULL){
		printf("Error, no s'ha pogut trobar el fitxer demanat.\n");
		return 0;
	}else{
		fprintf (fp,"(%f,%f)\n)",coordenada.latitud,coordenada.longitud);
	}
	
	return 1;
	fclose (fp);
}

int leer_coordenada_fichero(FILE *fp, tCoordenada *coordenada)
{
	

	char nombre_fichero [30];
	fp = fopen (nombre_fichero,"w");
	if (fp==NULL){
		printf("Error, no s'ha pogut trobar el fitxer demanat.\n");
		return 0;
	}else{
			
			fscanf (fp, "(%f,%f)\n",&coordenada->latitud,&coordenada->longitud);
		}
	return 1;
	
	fclose (fp);
	

}

tCoordenada rotar_coordenada (tCoordenada origen, float angulo, tCoordenada centro_rotacion)
{
	tCoordenada coordenada;
	float alpha,dist,x,y;

	coordenada = ini_coordenada();

	alpha=angulo_segmento_abcisas (centro_rotacion,origen );
	dist=calcular_distancia (centro_rotacion,origen );

	girar (angulo);

	y=dist*sin((alpha+angulo)/180*PI);
	x=dist*cos((alpha+angulo)/180*PI);

	coordenada.latitud=centro_rotacion.latitud+x;
	coordenada.longitud=centro_rotacion.longitud+y;

	return coordenada;
}


int coordenadas_iguales ( tCoordenada coordA,tCoordenada coordB)
{
	return (coordA.latitud==coordB.latitud) && (coordA.longitud==coordB.longitud);
}



float angulo_segmento_abcisas ( tCoordenada cinicio , tCoordenada cfinal )
{
double x,y,alpha;

	x= cfinal.latitud - cinicio.latitud;
	y= cfinal.longitud  - cinicio.longitud;

	if ( x>=0  && y>=0  )
	{
		alpha	=	atan(y/x)*180/PI;
	}
	else if ( x>=0 && y<0 )
	{
		y=-y;
		alpha	=	360 - atan(y/x)*180/PI;
	}
	else if ( x<0 && y>=0 )
	{
		x=-x;
		alpha	=	180- atan(y/x)*180/PI;
	}
	else if ( x<0 && y<0)
	{
		x=-x;
		y=-y;
		alpha	=	180 + atan(y/x)*180/PI;
	}

	return (float) alpha;
}