/**
 *Declaracion de la clase MapConfig
 *@author Romanuel Ramon Antunez
**/
var acronimo = new Ext.data.Store({
	      				autoLoad:true,
	      				baseParams:{
						accion:'cargarAcronimo',
						opcion:1,
					},
	      				proxy: new Ext.data.HttpProxy({ url:"geoweb/configurar/sConfigurar.php" }),
	     				reader: new Ext.data.JsonReader([{name:'nombre'},{name:'acronimo'}])
		});	


function Config(){
		
		/**
		  *medidas del mapa
		 */
		 //coordenadas
		this.coord = "degree";
		
		//distancia
		this.dist = "m";
		this.distAnt = "m";
		
		//areas
		this.supf = "sq m";
		this.supfAnt = "sq m"; 
		
		//azimutes
		this.azim = "GG.DD";
		
		/**
		  *formatos de medidas
		**/
		//formato de coordenadas
		this.fCoord = 0;
		
		//tipo de distancia a calcular
		this.tDist = 1;
		
		/**
		  *Otras config
		**/
		//proyeccion del mapa 
		/*this.Proj = new Array();
		this.Proj['name'] = 'NAD27';
		this.Proj['id'] = 4267;*/
		if(document.getElementById('valProyeccion'))
			this.Proj = document.getElementById('valProyeccion').value; 
		
		//Datum para conversiones
		//this.Datum = "algo";
		
};

Config.prototype.Configurar = function(){
	var projArray = this.Proj.split('+');
	for(k=0; k<projArray.length; k++)
		projArray[k] = projArray[k].replace(' ','');	
	
	var proj = projArray[1].split('=');
            //proj = proj.replace(' ','');
 
	if(proj[1] != "longlat"){
		for(h = 2; h < projArray.length; h++){
			var val = projArray[h].split('=')
			if(val[0] == "units"){
				this.coord = val[1];
				break;
			}else if(val[0] == "to_meter"){
				var valor = parseFloat(val[1]);
				if(valor > 0.304800){
					this.coord = "survey ft";
					break;
				}else{
					this.coord = "ft";
					break;
				}
			}
		}
	}else{
		this.coord = "degree";
	}

	if(this.coord != "degree"){
		this.tDist = 0;
	}else
		this.tDist = 1;

	if(this.coord != "degree" && this.coord != "m"){
		this.dist = this.coord;
		acrotemp = "sq "+this.coord;
		this.supf = acrotemp;
	}else{
		this.dist = "m";
		this.supf = "sq m";
	}
		
}

Config.prototype.CalculoDist = function(punto, punto2){
	switch(this.tDist){
		case 0:
			return this.CalcularDistCartesiana(punto, punto2);
		case 1:
			return this.CalculoDistEsferica(punto,punto2);
	}
}

/**
 *Funcion para calcular distancia teniendo en cuenta
 *la curvatura de la tierra
 *@param punto
 *@param punto2 
 *http://franchu.net/2007/11/16/gis-calculo-de-distancias-sobre-la-tierra/
**/
Config.prototype.CalculoDistEsferica = function(punto,punto2){
	//Radio(ecuatorial) de la tierra metros  
	var Radi = 6378400;
	
	//Calculo de diferencia de lat y lon
	var lon1 = punto.x * Math.PI/180; 
	var lat1 = punto.y * Math.PI/180;
	var lon2 = punto2.x * Math.PI/180;
	var lat2 = punto2.y * Math.PI/180;
	var dlon = (lon2 - lon1);
	var dlat = (lat2 - lat1);
	
	//Calculos intermedios
	var intcal = Math.pow((Math.sin(dlat/2)),2) + Math.cos(lat1) * Math.cos(lat2) * Math.pow(Math.sin(dlon/2),2);
	var intd = 2 * Math.atan2(Math.sqrt(intcal),Math.sqrt(1-intcal));
	
	 //Calculo Final
	var dist = Radi * intd;
      
	return dist;
	
}

/**
 *Funcion para calcular distancia en el plano 
 *@param punto
 *@param punto2 
 *http://franchu.net/2007/11/16/gis-calculo-de-distancias-sobre-la-tierra/
**/
Config.prototype.CalcularDistCartesiana = function(punto, punto2){
	/*p1 = GD2UTM(punto.x,punto.y);
	p2 = GD2UTM(punto2.x,punto2.y);*/

	var dist = Math.sqrt(Math.pow((punto2.x-punto.x),2)+Math.pow((punto2.y-punto.y),2));
	
	return dist;
}

Config.prototype.CalcularArea = function(aPolilinea){
	area = 0;
	for(i=1; i<=aPolilinea.vertices.length-2; i++){
		area += this.AreaTriangulo(aPolilinea.vertices[0],aPolilinea.vertices[i],aPolilinea.vertices[i+1]);
	}

	area = (area < 0) ? (area *= -1) : area;
	return area;
}

Config.prototype.AreaTriangulo = function(p1, p2, p3){
	a = this.CalculoDist(p1, p2);
	b = this.CalculoDist(p2, p3);
	c = this.CalculoDist(p1, p3);
	s = (a + b + c)/2;

	are = Math.sqrt(s*(s-a)*(s-b)*(s-c));
	if(GiroIzquierda(p1,p2,p3))
		are *= -1;

	return are;	
}

function GiroIzquierda(p1,p2,p3){
	val = (p1.x * p2.y) - (p1.y * p2.x) +
	      (p2.x * p3.y) - (p2.y * p3.x) +
	      (p3.x * p1.y) - (p3.y * p1.x);

	return (val > 0) ?  true :  false;
}
/**
 *Funcion para calcular el azimuth (modelo con coord polares)
 *@param punto
 *@param punto2 
**/

Config.prototype.CalcularAzimuth = function(ptoO, ptoR){
	var ptoN = new Point();
	
	  ptoN.x = ptoO.x;
	  ptoN.y = ptoR.y;

	  //calculo de los lados del triangulo para hallar el angulo
	  /*switch(this.tDist){
		case 0:
			var distON = this.CalcularDistCartesiana(ptoO, ptoN);
			var distOR = this.CalcularDistCartesiana(ptoO, ptoR);
			break;
		case 1:
			var distON = this.CalculoDistEsferica(ptoO, ptoN);
			var distOR = this.CalculoDistEsferica(ptoO, ptoR);
			break;
	  }*/

	var distON = this.CalculoDist(ptoO, ptoN);
	var distOR = this.CalculoDist(ptoO, ptoR);
	  
	  //calculo del angulo del azimuth
	  if(distOR > 0){
		var az = Math.acos(distON/distOR);
		var az = az * 180/Math.PI;
	  }
	  else
	    az = 0;
	
	  //verificar cuadrante del angulo
	  if((ptoO.x <= ptoR.x) && (ptoO.y <= ptoR.y)){
	  		
		az = az;
	
	  }else if((ptoO.x > ptoR.x) && (ptoO.y <= ptoR.y)){
		
		az = 360 - az;
		
	  }else if((ptoO.x >= ptoR.x) && (ptoO.y > ptoR.y)){
		
		az = 180 + az;
		
	  }else{

		az = 180 - az;
	  }

	  return az;
} 

Config.prototype.CalculoAzimuth = function(ptoO, ptoR){
	  //variable para guardar el punto del norte geografico
	  
	  az = this.CalcularAzimuth(ptoO, ptoR);

	  //escoger formato a mostrar
	  switch(this.coord){
			case "degree":
				this.printPAG(ptoO, ptoR);
				break;
			default : 
				this.printPAM(ptoO, ptoR);
				break;
			/*case "m":
				this.printPAM(ptoO, ptoR);
				break;
			case "mi":
				this.printPAMI(ptoO, ptoR);
				break;*/
		}
	  
	  switch(this.azim){
		case "GG.DD":
			{
			 az = Redondear(az,6);
			 document.getElementById('azimuth').innerHTML='Acimut:'+ az+"&deg;"+this.azim;
			}
			 break;
		case "GG.MM":
			document.getElementById('azimuth').innerHTML='Acimut:'+ GD2GM(az)+this.azim;
			break;
		case "GG.MM.SS":
			document.getElementById('azimuth').innerHTML='Acimut:'+ GD2GMS(az)+this.azim;
			break;
	  }
	  
	  	 	   
}


Config.prototype.CalcularPoliAzimuth = function(aFeature){
	var resultado = new Array();
		
	for(p = 0; p < aFeature.vertices.length - 1; p++){
			tupla = new Array();
			tupla[0] = p+1;
			tupla[1] = 'Punto'+(p+1);
			tupla[2] = 'Punto'+(p+2);
			switch(this.coord){
				case 'degree':
					switch(this.fCoord){
						case 0:
							tupla[3] = Redondear(aFeature.vertices[p].x,3);
							tupla[4] = Redondear(aFeature.vertices[p].y,3);
						        break;
						case 1:
							tupla[3] = GD2GM(aFeature.vertices[p].x);
							tupla[4] = GD2GM(aFeature.vertices[p].y);
							break;
						case 2:
							tupla[3] = GD2GMS(aFeature.vertices[p].x);
							tupla[4] = GD2GMS(aFeature.vertices[p].y);
							break 							
					}
					break;
				case 'm' :
					puntou = GD2UTM(aFeature.vertices[p].x, aFeature.vertices[p].y);
					utmX = puntou.x;
					utmY = puntou.y;
					tupla[3] = Redondear(utmX,2);
					tupla[4] = Redondear(utmY,2);
					break;
				case 'mi' :
					puntou = GD2UTM(aFeature.vertices[p].x, aFeature.vertices[p].y);
					millX = puntou.x/1609.34;
					millY = puntou.y/1609.34;
					tupla[3] = Redondear(millX,2);
					tupla[4] = Redondear(millY,2);
					break;
			}
			switch(this.azim){
				case "GG.DD":
					tupla[5] = Redondear(this.CalcularAzimuth(aFeature.vertices[p], aFeature.vertices[p+1]),3);
					break;
				case "GG.MM":
					tupla[5] = GD2GM(this.CalcularAzimuth(aFeature.vertices[p], aFeature.vertices[p+1]));
					break;
				case "GG.MM.SS":
					tupla[5] = GD2GMS(this.CalcularAzimuth(aFeature.vertices[p], aFeature.vertices[p+1]));
					break;
			}
			medi = this.CalculoDist(aFeature.vertices[p], aFeature.vertices[p+1]);
			medi = ConvUnidLon(medi); 
			tupla[6] = Redondear(medi,2);
			
			tupla[7] = Redondear(ConvUnidLon(DistAcumPor(aFeature, p+1)),2);
			
			resultado[p] = tupla;
	}
	 		
	return resultado;
	 //en el grrid store = resultado;
}

Config.prototype.printPAG = function(ptoO, ptoR){
	//var str;
	
	switch(this.fCoord){
		case 0:
			document.getElementById('OAsimuth').innerHTML = Redondear(ptoO.x,3)+"&deg;"+'/'+Redondear(ptoO.y,3)+"&deg;";
			document.getElementById('DAsimuth').innerHTML = Redondear(ptoR.x,3)+"&deg;"+'/'+Redondear(ptoR.y,3)+"&deg;";
			break;
		case 1:
			coordx = GD2GM(ptoO.x);
			coordy = GD2GM(ptoO.y);
			coord1x = GD2GM(ptoR.x);
			coord1y = GD2GM(ptoR.y);
			document.getElementById('OAsimuth').innerHTML = coordx+'/'+coordy;
			document.getElementById('DAsimuth').innerHTML = coord1x+'/'+coord1y;
			break;
		case 2:
			coordx = GD2GMS(ptoO.x);
			coordy = GD2GMS(ptoO.y);
			coord1x = GD2GMS(ptoR.x);
			coord1y = GD2GMS(ptoR.y)
			document.getElementById('OAsimuth').innerHTML = coordx+'/'+coordy;
			document.getElementById('DAsimuth').innerHTML = coord1x+'/'+coord1y;
			//str = sprintf(mainmap.geoUnits, coordx, coordy);  
			break;
	}
}

Config.prototype.printPAM = function(ptoO,ptoR){
	/*puntou = GD2UTM(ptoO.x, ptoO.y);
	utmX = puntou.x;
	utmY = puntou.y;
	puntou1 = GD2UTM(ptoR.x, ptoR.y);
	utm1X = puntou1.x;
	utm1Y = puntou1.y;*/
	
	document.getElementById('OAsimuth').innerHTML = Redondear(ptoO.x,2)+'/'+Redondear(ptoO.y,2);
	document.getElementById('DAsimuth').innerHTML = +Redondear(ptoR.x,2)+'/'+Redondear(ptoR.y,2);
} 

Config.prototype.printPAMI = function(ptoO,ptoR){
	/*puntou = GD2UTM(ptoO.x, ptoO.y);
	puntou1 = GD2UTM(ptoR.x, ptoR.y);*/
		
	millX = ptoO.x/1609.34;
	millY = ptoO.y/1609.34;
	mill1X = ptoR.x/1609.34;
	mill1Y = ptoR.y/1609.34;
	
	document.getElementById('OAsimuth').innerHTML = Redondear(millX,2)+'/'+Redondear(millY,2);
	document.getElementById('DAsimuth').innerHTML = Redondear(mill1X,2)+'/'+Redondear(mill1X,2);
} 

/**
 * Funcion para imprimir coordenadas
 *@param x valor de la longitud
 *@param y valor de la latitud
**/
Config.prototype.printCoord = function(x,y){
	var acronimo;
	/*if(this.acronimo.reader.jsonData)
	{
		for(i = 0; i<this.acronimo.reader.jsonData.length; i++){
			if(this.acronimo.reader.jsonData[i].nombre == this.coord){
				acronimo = this.acronimo.reader.jsonData[i].acronimo;	
			}
		}*/

		mainmap.geoUnits = '<span>Coordenadas('+ this.coord +'): %s / %s</span>'	
	
		switch(this.coord){
			case "degree":
				return printCG(this.fCoord, x, y);
			/*case "m":
				return printCM(x, y);
			case "mi":
				return printCMI(x, y);*/
			default : 
				return printCP(x, y);
		}
	//}
}

/**
 * Funcion para imprimir la distancia acumulada
 *@param distancia
**/
Config.prototype.printDistanciaA = function(distance){   //esta funcion debe cambiar cuando este lista la consulta
  	var acronimo; 
	/*if(this.acronimo.reader.jsonData)
	{
		for(i = 0; i<this.acronimo.reader.jsonData.length; i++){
			if(this.acronimo.reader.jsonData[i].nombre == this.coord){
				acronimo = this.acronimo.reader.jsonData[i].acronimo;	
			}
		}*/
	
	distance = Redondear(distance,2);	
	document.getElementById('distacumulada').innerHTML= distance +'('+ this.dist +')';
}

/**
 * Funcion para imprimir la distancia
 *@param distancia
**/
Config.prototype.printDistancia = function(distance){
  	/*if(this.acronimo.reader.jsonData)
	{
		for(i = 0; i<this.acronimo.reader.jsonData.length; i++){
			if(this.acronimo.reader.jsonData[i].nombre == this.coord){
				acronimo = this.acronimo.reader.jsonData[i].acronimo;	
			}
		}*/
   
	distance = Redondear(distance,2);
	document.getElementById('distancia').innerHTML= distance +'('+ this.dist +')';

}

/**
 * Funcion para imprimir el perimetro
 *@param perimetro
**/
Config.prototype.printPerimetro = function(perimetro){
	var acronimo; 
	/*if(this.acronimo.reader.jsonData)
	{
		for(i = 0; i<this.acronimo.reader.jsonData.length; i++){
			if(this.acronimo.reader.jsonData[i].nombre == this.coord){
				acronimo = this.acronimo.reader.jsonData[i].acronimo;	
			}
		}*/
      	
	perimetro = Redondear(perimetro,2);
	document.getElementById('perimetro').innerHTML= perimetro +'('+ this.dist +')';
    
}

/**
 * Funcion para imprimir el Area
 *@param area
**/
Config.prototype.printArea = function(surface){
	var acronimo;
	/*if(this.acronimo.reader.jsonData)
	{
		for(i = 0; i<this.acronimo.reader.jsonData.length; i++){
			if(this.acronimo.reader.jsonData[i].nombre == this.coord){
				acronimo = this.acronimo.reader.jsonData[i].acronimo;	
			}
		}*/ 
       
      surface = Redondear(surface,2);	
      document.getElementById('superficie').innerHTML= surface +'('+ this.supf +')';

}

Config.prototype.printZoom = function(){
	var punto = new Point();
	var punto2 = new Point();
	punto.x = mainmap.extent.xmin;
	punto.y = mainmap.extent.ymax/2;
	punto2.x = mainmap.extent.xmax;
	punto2.y = mainmap.extent.ymax/2;
	var dist;

	/*if(this.tDist == 0){
		dist = this.CalcularDistCartesiana(punto, punto2);
	}else{
		dist = this.CalculoDistEsferica(punto, punto2);
	}*/
	dist = this.CalculoDist(punto, punto2);
	
	dist = Redondear(ConvUnidLon(dist),2);
	if(document.getElementById("geozoom"))
		document.getElementById("geozoom").innerHTML = 'Zoom: '+ dist + this.dist;
}

/**
*funcion para imprimir coordenadas en Grados
*@param  fcoord formato de las coordenadas
*@param x latitud
*@param y longitud 
**/ 
function printCG(fcoord,x,y){
	
	var str;
	
	switch(fcoord){
		case 0:
			str = sprintf(mainmap.geoUnits, Redondear(x,6)+"&deg;", Redondear(y,6)+"&deg;");
			break;
		case 1:
			coordx = GD2GM(x);
			coordy = GD2GM(y);
			str = sprintf(mainmap.geoUnits, coordx, coordy);  
			break;
		case 2:
			coordx = GD2GMS(x);
			coordy = GD2GMS(y);
			str = sprintf(mainmap.geoUnits, coordx, coordy);  
			break;
	}
	
	return str;
} 

/**
*funcion para imprimir coordenadas Planas
*@param x latitud
*@param y longitud 
**/ 
function printCP(x,y){
		
	str = sprintf(mainmap.geoUnits, Redondear(geoX,2), Redondear(geoY,2));
	
	return str;
}

/**
*funcion para imprimir coordenadas en Millas
*@param x latitud
*@param y longitud 
**/ 

function printCMI(x,y){
	
	//puntou = GD2UTM(geoX, geoY);
	
	//millX = geoX/1609.34;
	//millY = geoY/1609.34;
		
	str = sprintf(mainmap.geoUnits, Redondear(millX,2), Redondear(millY,2));
	
	return str;
}


/**
  *Funciones utiles
**/
/**
*Funcion para llevar coordenadas en grados decimales a grados minutos
**/
function GD2GM(value){
	
	grados = parseInt(value);
		
	minutos = (Mod(value) - Mod(grados)) * 60;
	minutos = Redondear(minutos,3);	
	if(minutos/10 < 1){
		minutos = '0'+minutos;
	}
		
	coord = grados + "&deg;" + minutos + "&quot;";
	
	return coord;	
}

/**
*Funcion para llevar coordenadas en grados decimales a grados minutos segundos
**/
function GD2GMS(value){
	
	grados = parseInt(value);
		
	minutos = parseInt((Mod(value) - Mod(grados)) * 60);
	if(minutos/10 < 1){
		minutos = '0'+minutos;
	}
		
	segundos = (((Mod(value) - Mod(grados)) * 60) - Mod(minutos)) * 60;
	segundos = Redondear(segundos);
	if(segundos/10 < 1){
		segundos = '0'+segundos;
	}
		
	coord = grados + "&deg;" + minutos + "&quot;" + segundos +"&#34;&#34;";
	
	return coord;
}

/**
* Funcion para el modulo
**/
function Mod(s){
  if(s < 0)
    return s*-1;
  else
    return s;
}

/**
 Funciones para el obtener acronimo dado nombre
 o nombre dado acronimo
**/

function BuscarAcro(strString){
	var acro;
	
	if(acronimo.reader.jsonData){	
		for(i = 0; i<acronimo.reader.jsonData.length; i++){
			if(acronimo.reader.jsonData[i].nombre == strString){
				acro = acronimo.reader.jsonData[i].acronimo;	
			}
		}
	}
	else acro = 'm';
	
	return acro;
}

function BuscarNom(strAcro){
	var nom;
	
	if(acronimo.reader.jsonData){	
		for(i = 0; i<acronimo.reader.jsonData.length; i++){
			if(acronimo.reader.jsonData[i].acronimo == strAcro){
				nom = acronimo.reader.jsonData[i].nombre;	
			}
		}
	}
	else nom = 'Metros';
	
	return nom;
}