// ---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O
//
// OBJETO: PorcentajesSuelos
//
// DESCRIPCION: objeto coleccion con elementos relacionando padron-suelo-porcentaje.
//				Se utiliza para calcular el indice de productividad final.
//				(ver aimsMiio.js, funcion calculoIndProdTodosArr).
//
//				Se utiliza para generar el reporte html de porcentajes de suelos por padron.
//				(ver aimsMio.js, funcion finCreateConeatPageImp()).
//
//				Tambien se almacena el indice de productividad de cada suelo.
//				El calculo ya esta implementado pero incluir esta info aqui podria ayudar
//				para depurar el codigo 'legacy' rehaciendo el calculo y cotejar las diferencias.
//
// PROPIEDADES:
//		tot_elem    (number) - mantiene la cantidad existente de elementos padron-suelo-porcentaje.
//
// METODOS:
//		Padrones - retornar un array con los padrones que tengan suelos y porcentajes.
//		SuelosPorcentajesDePadron - retornar los porcentanjes de suelos de un padron.
//		IndProdDeSuelo - obtener el indice de productividad de un suelo, dado un identificador de suelo.
//		CalcularIPF   - calcular indice de productividad para un padron.
//		CalcularIVR   - calcular el indice de valor real.
//		Cant		  - total de elementos.
//		NuevoElem	  - agregar un nuevo elemento padron-suelo-area.
//		VaciarObjeto  - reinicializar el objeto a un estado 'vacio' (sin datos).
//
// FECHA: 25/10/2001
//
// ---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O---O


// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
// METODO: Padrones
//
// DESCRIPCION: obtener los padrones que tienen suelos.
//
// PARAMETROS:
//		nada.
//
// RETORNO: arrPad - array con los padrones que tienen suelos (y porcentajes).
//
// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
PorcentajesSuelos.prototype.Padrones = function()
{
	var arrRetPad = new Array();
	var arrTemp   = new Array();
	var x = 0;
	var strPadAnterior = "";

	// Copiar los elementos del array atributo arrPadron a arrTemp
	// (se hace esto porque sino el sort() afectaria al array original.
	for (var i = 0; i < this.arrPadron.length; i++) {
		arrTemp[i] = this.arrPadron[i];
	}

	arrTemp.sort();

	// Construir un array de padrones pero con elementos unicos.
	for (var i = 0; i < arrTemp.length; i++) {
		if (arrTemp[i] != strPadAnterior) {
			arrRetPad[x] = arrTemp[i];
			strPadAnterior = arrTemp[i];
			x++;
		}
	}
	return arrRetPad;
}

// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
// METODO: SuelosPorcentajesDePadron
//
// DESCRIPCION: obtener los suelos y porcentajes de un padron dado.
//				Nota: se hace el ajuste de porcentaje en el caso de que la sumatoria de los
//					  mismos no de 100% exacto.
//					  Criterio de ajuste: al porcentaje mayor se le suma o resta el valor pico necesario
//										  para que la suma total resulte 100.00%.
//
// PARAMETROS:
//		strPadron (string) - numero de padron.
//
// RETORNO: arrSuePorc - arrays paralelos con el siguiente formato:
//						 arrSuePorc[0] - array de suelos para strPadron.
//						 arrSuePorc[1] - array de porcentajes para strPadron.
// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
PorcentajesSuelos.prototype.SuelosPorcentajesDePadron = function(strPadron)
{
	var arrSuePorc = new Array();   // Retorno: array de arrays paralelos (ver comentario RETORNO).

	var arrSue = new Array();
	var arrPorc = new Array();
	var nTotArea = 0.0;

	// Calcular el area total del padron strPadron.
	for (var i = 0; i < this.Cant(); i++) {
		if (this.arrPadron[i] == strPadron) {
			nTotArea += this.arrArea[i];
		}
	}

	// Calcular los porcentajes de cada suelo para el padron strPadron.
	var nTotPorcCalc = 0.0;    // Porcentaje total calculado (se usa para verificar los casos 100.01
							   // o 99.99 luego del redondeo a 2 decimales de cada porcentaje).
	var nElem = 0;
	for (var i = 0; i < this.Cant(); i++) {
		if (this.arrPadron[i] == strPadron) {
			nPorc = this.arrArea[i] * 100 / nTotArea;
			arrSue[nElem]  = this.arrSC[i];
			arrPorc[nElem] = FormatNumCon2Dec(nPorc);

			nTotPorcCalc += arrPorc[nElem];   // Ir sumando los porc. parciales obtenidos.
			nElem++;
		}
	}

	// Ajustar los porcentajes con el criterio explicado en cabezal de comentarios del metodo.
	var nDifAjuste = 100 - nTotPorcCalc
	if (nDifAjuste != 0) {
		// La sumatoria no dio 100 % exacto.

		// Buscar el suelo con el mayor porcentaje.
		var nMayorPorc = 0.0;
		var nPosMayor;
		for (var i = 0; i < arrPorc.length; i++) {
			if (arrPorc[i] >= nMayorPorc) {
				nMayorPorc = arrPorc[i];
				nPosMayor = i;
			}
		}

		// El suelo de mayor porcentaje esta en arrPorc[nPosMayor].
		// Ajustarlo en base a nDifAjuste.

		arrPorc[nPosMayor] += FormatNumCon2Dec(nDifAjuste);

		// Ajustar la cifra a 2 decimales. (Testeado: parece redundante pero no lo es).
		arrPorc[nPosMayor] = FormatNumCon2Dec(arrPorc[nPosMayor]);
	}

	// Retornar el array arrSuePorc de arrays paralelos de suelos y porcentajes.
	arrSuePorc[0] = arrSue;
	arrSuePorc[1] = arrPorc;

	return arrSuePorc;
}


// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
// METODO: NuevoElem
//
// DESCRIPCION: agregar un nuevo elemento con la relacion padron-suelo-area.
//
// PARAMETROS:
//		strPadron (string) - numero de padron
//		strSC     (string) - identificador de suelo (segun campo SC de tabla SDE.INDPROD).
//		nArea     (numero) - area expresada en hectareas con decimales.
//		nIndProd  (numero) - indice de productividad para el suelo.
//
// RETORNO: nada.
// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
PorcentajesSuelos.prototype.NuevoElem = function(strPadron, strSC, nArea, nIndProd)
{
	var i;

	// Buscar la pareja padron-suelo...
	// ... si existe, acumular el area a la ya existente para esa pareja.
	for (i = 0; i < this.Cant(); i++) {
		if ((this.arrPadron[i] == strPadron) && (this.arrSC[i] == strSC)) {
			// Encontro la pareja padron-suelo... acumular el area.
			this.arrArea[i] += 1 * nArea;
			return;
		}
	}

	// No encontro la dupla padron-suelo... dar de alta la correspondencia padron-suelo-area-ind. prod.
	this.arrPadron[i]  = strPadron;
	this.arrSC[i]      = strSC;
	this.arrArea[i]    = 1 * nArea;
	this.arrIndProd[i] = 1 * nIndProd;

	this.tot_elem++;   // Seria lo mismo que: this.tot_elem = i + 1
}

// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
// METODO: IndProdDeSuelo
//
// DESCRIPCION: retornar indice de productividad para el suelo strSC.
//
// PARAMETROS:
//		strSC (string) - identificador de grupo de suelo Coneat.
//
// RETORNO: nIndProd - indice de productividad para el padron strPadron.
//
// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
PorcentajesSuelos.prototype.IndProdDeSuelo = function(strSC)
{
	var i;

	// Buscar indice de productividad para el suelo strSC.
	for (i = 0; i < this.Cant(); i++) {
		if (this.arrSC[i] == strSC) {
			return this.arrIndProd[i];
		}
	}

	// No existe el suelo (!).
	// NUNCA deberia entrar aca.
	return 0;
}


// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
// METODO: CalcularIPF
//
// DESCRIPCION: calcular el indice de productividad final para padron strPadron con factor extrinseco nFext.
//
// PARAMETROS:
//		strPadron (string) - numero de padron.
//		nFext     (number) - factor extrinseco.
//
// RETORNO: nIndProd - indice de productividad final para el padron strPadron.
//
// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
PorcentajesSuelos.prototype.CalcularIPF = function(strPadron, nFext)
{
	var arrSuePorc = new Array();
	var arrSue     = new Array();
	var arrPorc    = new Array();
	var nIPF_retorno = 0;

	arrSuePorc = this.SuelosPorcentajesDePadron(strPadron);
	arrSue     = arrSuePorc[0];
	arrPorc    = arrSuePorc[1];

	// Calcular indice promedio.
	var nIndProm = 0;

	for (var i = 0; i < arrPorc.length; i++) {
		nIndProm += (arrPorc[i] * this.IndProdDeSuelo(arrSue[i]) / 100);
	}

	// Redondear a entero (los .5 los redondea hacia arriba).
	nIndProm = Math.round(nIndProm);

	// Calcular indice de productivdad final.
	nIPF_retorno = Math.round(nIndProm * (nFext / 100 + 1));

	if (nIPF_retorno == 0)
		return  1;  // PARCHE 22/3/2004: si dan cero, en forma arbitraria se fija en 1.
	else
		return nIPF_retorno;

}


// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
// METODO: CalcularIVR
//
// DESCRIPCION: calcular el indice de valor real IVR.
//
// FORMULA: nIVR = nIPF * (1 + ((nAfec_ruta + nAfec_cp) / 100))
//
// PARAMETROS:
//		nIPF       (number) - indice de productividad final.
//							  Nota: debe ser el IPF calculado por PorcentajesSuelos.CalcularIPF.
//		nAfec_ruta (number) - afectacion de ruta.
//		nAfec_cp   (number) - afectacion de centro poblado.
//
// RETORNO: nIVR - indice de valor real.
//
// FECHA: 12/4/2002
// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
PorcentajesSuelos.prototype.CalcularIVR = function(nIPF, nAfec_ruta, nAfec_cp)
{
	var nIVR = nIPF * (1 + ((nAfec_ruta + nAfec_cp) / 100));

	// Redondear a entero (los .5 los redondea hacia arriba).
	nIVR = Math.round(nIVR);

	return  nIVR;
}


// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
// METODO: Cant
//
// DESCRIPCION: retornar la cantidad de correspondencias suelo-color.
//
// PARAMETROS: ninguno.
//
// RETORNO: (integer) - cantidad de elemetntos.
// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
PorcentajesSuelos.prototype.Cant = function()
{
	return this.tot_elem;
}


// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
// METODO: VaciarObjeto
//
// DESCRIPCION: reinicializar el objeto PorcentajesSuelos a un estado 'vacio'.
//				Deja el objeto al mismo estado que si se hubiera hecho un new del objeto.
//
// PARAMETROS: ninguno.
//
// RETORNO: nada.
// ---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M---M
PorcentajesSuelos.prototype.VaciarObjeto = function()
{
	// Eliminar los objetos arrays...
	delete this.arrPadron;
	delete this.arrSC;
	delete this.arrArea;
	delete this.arrIndProd;
	// ... crear de nuevo los arrays.
	this.arrPadron  = new Array();
	this.arrSC      = new Array();
	this.arrArea    = new Array();
	this.arrIndProd = new Array();

	this.tot_elem = 0;
}


// -----------------------------------------------------------------------------------------------------
// CONSTRUCTOR: PorcentajesSuelos
//
// PARAMETROS: ninguno.
//
// USO: var objPorcentajes = new PorcentajesSuelos();
//
// -----------------------------------------------------------------------------------------------------
function PorcentajesSuelos()
{
	// Arrays paralelos que mantienen la correspondencia padron-suelo-area.
	// Estos arrays NO estan ordenados.
	this.arrPadron  = new Array();  // Array de identificadores de padrones.
	this.arrSC      = new Array();  // Array de identificadores de suelos.
	this.arrArea    = new Array();  // Array de areas.
	this.arrIndProd = new Array();  // Array de indice de produc. para cada suelo.

	// PROPIEDADES.
	this.tot_elem = 0;				// Contador de cantidad de elementos. Iniciar en cero.
}