// --------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------
// Funciones busqueda en arrays
// --------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------


// --------------------------------------------------------------------------------------
// Busqueda exacta en un array dado 
//
// Parametros:
// aTabla - array en el que se busca
// sCampo - nombre/propiedad del campo por el que se busca
// valor - valor del campo que se busca
//
// Devuelve un array de resultados
// --------------------------------------------------------------------------------------
_global.arrayBusca = function(aTabla,sCampo,valor) {
	var arrayTemp = new Array();
	var total = aTabla.length;
	for (var i=0;i<total;i++) {
		if (aTabla[i][sCampo] == valor) {
			arrayTemp.push(aTabla[i]);
		}
	}
	return arrayTemp;
}



// --------------------------------------------------------------------------------------
// Busqueda valor alfanumerico similar en un array dado 
//
// Parametros:
// aTabla - array en el que se busca
// sCampo - nombre/propiedad del campo por el que se busca
// valor - valor del campo que se busca
//
// Devuelve un array de resultados
// --------------------------------------------------------------------------------------
_global.arrayBuscaSimilar = function(aTabla,sCampo,valor) {
	valor = valor.toLowerCase();
	var valorSinAcentos = quitaAcentos(valor);
	var valorConAcentos = poneAcentos(valor);
	
	var aPosibilidadesPalabras = obtieneArrayAcentos(valor);
	//trace(aPosibilidadesPalabras.length);
	
	var arrayTemp = new Array();
	var total = aTabla.length;
	
	for (var i=0;i<total;i++) {
		var valorEnTabla = aTabla[i][sCampo].toLowerCase();
		
		// Si encuentra la cadena directamente o sin acentos
		if (valorEnTabla.indexOf(valor) != -1 || valorEnTabla.indexOf(valorSinAcentos) != -1) {
			arrayTemp.push(aTabla[i]);
		} else {
			// Si no, busca en el array de posibilidades de acentos
			for (var j=0;j<aPosibilidadesPalabras.length;j++) {
				if ( valorEnTabla.indexOf(aPosibilidadesPalabras[j]) != -1 ) {
					arrayTemp.push(aTabla[i]);
					break;
				}
			}
		}
	}
	return arrayTemp;
}

// --------------------------------------------------------------------------------------
// Funcion para obtener un array de palabras con o sin acentos de una cadena
//
// Parametros:
// cadena - cadena a insertar posibles acentos para generar el array de posibilidades 
//
// Devuelve array con todas las posibilidades
// --------------------------------------------------------------------------------------
_global.obtieneArrayAcentos = function(cadena) {
	// Crea un array de posibilidades (con acentos en cada vocal y sin acentos)
	aPosibilidades = new Array();
	
	var aPalabras = cadena.split(' ');
	
	for (var i=0;i<aPalabras.length;i++) {
		var palabra = aPalabras[i];
		
		// Quita acentos
		quitaAcentos(palabra);
		
		// Añade palabra sin acentos para comparacion
		aPosibilidades.push(palabra);
		
		// Recorre caracteres en busca de vocales para almacenar las posibles palabras
		for (var j=0;j<palabra.length;j++) {
			var letra = palabra.charAt(j);
			if (letra == 'a') { var palabraTemp = palabra.substr(0,j) + 'á' + palabra.substr(j+1,palabra.length-1); }
			if (letra == 'e') { var palabraTemp = palabra.substr(0,j) + 'é' + palabra.substr(j+1,palabra.length-1); }
			if (letra == 'i') { var palabraTemp = palabra.substr(0,j) + 'í' + palabra.substr(j+1,palabra.length-1); }
			if (letra == 'o') { var palabraTemp = palabra.substr(0,j) + 'ó' + palabra.substr(j+1,palabra.length-1); }
			if (letra == 'u') { var palabraTemp = palabra.substr(0,j) + 'ú' + palabra.substr(j+1,palabra.length-1); }
			if (palabraTemp != undefined) {
				if (palabraTemp != palabraTempAnterior) {
					//trace("palabra temp: " + palabraTemp);
					var palabraTempAnterior = palabraTemp;
					aPosibilidades.push(palabraTemp);
				}
				
			}
		}

	}

	return aPosibilidades;
}



// --------------------------------------------------------------------------------------
// Busqueda caracteres iniciales de una cadena en un array dado 
//
// Parametros:
// aTabla - array en el que se busca
// sCampo - nombre/propiedad del campo por el que se busca
// valor - valor del campo que se busca
//
// Devuelve un array de resultados
// --------------------------------------------------------------------------------------
function arrayBuscaInicio(aTabla,sCampo,valor) {
	var arrayTemp = new Array();
	var total = aTabla.length;
	var longitud = valor.length;
	for (var i=0;i<total;i++) {
		var valorLetraEnTabla = aTabla[i][sCampo].substr(0,longitud).toLowerCase();
		//trace(valorLetraEnTabla);
		if (valorLetraEnTabla.substr(0,longitud).indexOf(valor.toLowerCase()) != -1) {
			arrayTemp.push(aTabla[i]);
		}
	}
	return arrayTemp;
}

// --------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------
// Fin Funciones busqueda
// --------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------






// --------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------
// Funciones generales
// --------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------


// --------------------------------------------------------------------------------------
// Ordena un array dado
//
// Parametros:
// aTabla - array en el que se busca
// sCampo - nombre/propiedad del campo por el que se busca
// bDesc - si es true lo ordena de mayor a menor
// --------------------------------------------------------------------------------------
_global.arrayOrdena = function(aTabla, sCampo, bDesc) {
	if (bDesc) { var d = Array.DESCENDING }
	aTabla.sortOn(sCampo, d);
}

// --------------------------------------------------------------------------------------
// Duplica un array
//
// Parametros:
// aOrigen - array que se duplica
// --------------------------------------------------------------------------------------
_global.arrayDuplica = function(aOrigen) {
	return aOrigen.slice();
}

// --------------------------------------------------------------------------------------
// Elimina uno o varios elementos de un array a partir de una posicion
//
// Parametros:
// aOrigen - array del que se elimina el valor/posicion
// posicion - posicion que se elimina
// num_elementos - numero de elementos que se eliminan a partir de esa posicion
// --------------------------------------------------------------------------------------
_global.arrayElimina = function(aOrigen, posicion, num_elementos) {
	aOrigen.splice(posicion, num_elementos);
}

// --------------------------------------------------------------------------------------
// Crea un array de valores aleatorios desde un array origen
//
// Parametros:
// aOrigen - array origen del que se obtienen los aleatorios
// --------------------------------------------------------------------------------------
_global.arrayCreaAleatorios = function(aOrigen) {
	var aAleatorios = new Array();
	while (aOrigen.length > 0) {
		aAleatorios.push(arrayValorAleatorio(aOrigen));
	}
	return aAleatorios;
}

// --------------------------------------------------------------------------------------
// Coge un valor aleatorio de un array dado, lo elimina de este, y devuelve el valor ...
//
// Parametros:
// aOrigen - array del que se extrae el valor aleatorio
// --------------------------------------------------------------------------------------
_global.arrayValorAleatorio = function(aOrigen) {
	// Escoge una posicion aleatoria en el array
	var num_pos_valor = random(aOrigen.length);

	// Guarda el valor correspondiente a la posicion
	var valor = aOrigen[num_pos_valor];

	// Lo elimina del array
	arrayElimina(aOrigen, num_pos_valor, 1);

	// Devuelve el valor
	return valor;
}


// --------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------
// Fin Funciones generales
// --------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------