/**
@name ValidacaoNumero.js
@description Valida números e valores em moeda
@methods 
@created 02/12/2003
@author Jorge Bittencourt
*/


//*************************************************************************************************************
/**
@name Normalize
@description Retira os zeros da esquerda de uma string e a preenche com zeros à direita de forma
 que ela terá pelo menos três caracteres
@created 02/12/2003
@param valor: o valor a ser normalizado
@return a string normalizada
@author Jorge Bittencourt
*/
function Normalize(valor)
{
	var number;
	var vlNormalizado;

	// verifique se o valor é zero - eu testo se o valor é vazio porque se eu converter vazio para um número
	// o resultado é zero
	if (new Number(valor).valueOf() == 0 && valor != "")
	{
		return "000";
	}
	else
	{
		// tire os zeros da esquerda do número
		while(valor.substr(0,1) == "0")
			valor = valor.substr(1, valor.length - 1)

		// se o número só tiver 1 dígito, preencha-o com 2 zeros à esquerda
		if (valor.length == 1)
			vlNormalizado = "00" + valor;
		// se o número tiver 2 dígitos, preencha-o com 1 dígito à esquerda
		else if (valor.length == 2)
			vlNormalizado = "0" + valor;
		// se o número tiver mais do que 2 dígitos, ele já está normalizado
		else
			vlNormalizado = valor;

		return vlNormalizado;
	}

}

//*************************************************************************************************************
/**
@name pfnFormataMoeda
@description Formata um número como moeda à medida que ele é digitado
 Não impede o usuário de teclar dígitos, apenas não realiza a formatação caso a tecla digitada não seja um dígito
@created 02/12/2003
@param field: o campo onde o número está sendo digitado
@return Não retorna nada
@author Jorge Bittencourt
*/
function pfnFormataMoeda(field)
{
	// só prossiga se a tecla pressionada foi um dígito ou a tecla BACKSPACE e caso haja algum valor inserido no campo
	if (((event.keyCode >= 48 && event.keyCode <= 57) || (event.keyCode >= 96 && event.keyCode <= 105) || event.keyCode == 8 || event.keyCode == 46) && field.value.length != 0)
	{
		pfnFormateMoedaOnBlur(field);
	}
}


//*************************************************************************************************************
/**
@name pfnFormateMoedaOnBlur
@description Formata um campo como moeda (usado no evento onBlur)
@created 04/02/2004
@param field: o campo onde o número que deve ser formatado está
@return Não retorna nada
@author Jorge Bittencourt
*/
function pfnFormateMoedaOnBlur(field)
{
	field.value = pfnFormateValorMoeda(field.value);
}


//*************************************************************************************************************
/**
@name pfnFormateValorMoeda
@description Formata um número como moeda
@created 04/02/2004
@param valor: o valor a ser formatado
@return O valor formatado
@author Jorge Bittencourt
*/
function pfnFormateValorMoeda(valor_)
{
	// a próxima conversão é para compatibilidade com páginas em vbscript, para ter certeza que valor será
	// uma string UTF-8
	var valor;
	valor = new String(valor_);


	// o valor digitado sem formatação
	var valorSemFormatacao; 
	// o valor final a ser mostrado ao usuário
	var valorFinal;
	// o número de conjuntos de três números antes da parte decimal do número
	var casas;
	// determine o número de dígitos que sobram por não completar grupos de 3 dígitos 
	var casasIncompletas;
	// determina se o valor digitado é um número negativo
	var numeroNegativo = false;
	
	//tire qualquer espaço do começo e fim de valor
	valor = valor.replace(/(\s)*$|^(\s)*/g, "");
	
	//Se for um número só após a virgula.
	//if (valor.indexOf(',') == valor.length-2 && valor.length != 0)
	//	valor = valor + '0';
	
	// tire os pontos e troque as vírgulas pelos pontos para transformar o número brasileiro em um número americano
	valorSemFormatacao = pfnToNumeroAmericano(valor);
	
	// verifique se o número é válido
	if (isNaN(valorSemFormatacao))
		return valor;
	
	// verifique se o número é negativo
	if (valorSemFormatacao.substr(0, 1) == "-")
		numeroNegativo = true;

	// agora retire todos os pontos e traço (do número negativo) para formatá-lo
	valorSemFormatacao = valorSemFormatacao.replace(/[.-]/g, "");
		
	// o primeiro dígito que o usuário digita é especial - coloque os zeros à esquerda e saia
	if (valor.length == 1)
	{
		valor = "0,0" + valor;
		return valor;
	}
	
	// coloque ou tire os zeros necessários da esquerda
	valorSemFormatacao = Normalize(valorSemFormatacao);
	
	// aqui há outro caso especial: se o resultado dessa função é uma string vazia, então só
	// havia zeros na string digitada, então retorne um 0 formatado e saia
	if (valorSemFormatacao.length == 0)
	{
		valor = ""
		return valor;
	}
	
	// determine quantos conjuntos de três dígitos há no número
	// não leve em conta os dois últimos números dos centavos
	casas = Math.floor((valorSemFormatacao.length - 2)/3);
	casasIncompletas = (valorSemFormatacao.length - 2) % 3;

	// comece colocando os dígitos à esqeuerda do valor original que não completam um grupo de três dígitos
	valorFinal = valorSemFormatacao.substr(0, casasIncompletas);

	for (i = 0; i < casas; i++)
	{	
		// pegue grupos de 3 dígitos seguidos do valor original e adicione-os ao valor final acrescentando os pontos
		if (i != 0 || ( i == 0 && casasIncompletas > 0))
			valorFinal = valorFinal + ".";
		valorFinal = valorFinal + valorSemFormatacao.substr(casasIncompletas + i * 3, 3);
	}

	// termine colocando os dígitos equivalentes aos centavos
	valorFinal = valorFinal + "," + valorSemFormatacao.substr(valorSemFormatacao.length - 2, 2);
	
	// se o número for negativo, recoloque o sinal
	if (numeroNegativo)
		valorFinal = "-" + valorFinal;
		
	return valorFinal;
}

//*************************************************************************************************************
/**
@name pfnIsNumeric
@description Determina se a última tecla digitada no teclado é um dígito
@created 24/11/2003
@return true, se a tecla for um dígito, false, caso contrário
@author Jorge Bittencourt
*/
function pfnIsNumeric()
{
    if (event.keyCode < 48 || event.keyCode > 57)
    {
        event.returnValue = false;
        return false;
    }
    else
    {
        event.returnValue = true;
        return true;
    }
}

//*************************************************************************************************************
/**
@name pfnValideFormateMoeda
@description Valida e formata um número. A validação verifica se o número contém apenas caracters numéricos 
 (dígitos, e opcionalmente pontos e uma vírgula), se ele é maior ou igual a zero e se ele é menor do que o 
 tamanho máximo permitido
@created 10/03/2004
@param valor: o número (ou string equivalente ao número) a ser validado
@param mensagemErro: a mensagem a ser exibida se a validação falhar
@return O número formatado, caso a validação tenha sucesso, ou o número passado como parâmetro, caso contrário
@author Jorge Bittencourt
*/
function pfnValideFormateMoeda(valor, mensagemErro)
{
	if (pfnValideValorMaximo(valor, mensagemErro) && pfnValideNumeroNaoNegativo(valor, mensagemErro, true))
		return pfnFormateValorMoeda(valor);
	else
		return valor;
}


//*************************************************************************************************************
/**
@name pfnValideFormateMoedaOnBlur
@description Valida e formata um número quando um campo perde o foco. A validação verifica se um número contém
 apenas caracters numéricos (dígitos, e opcionalmente pontos e uma vírgula), se ele é maior ou igual a zero e
 se ele é menor do que o tamanho máximo permitido
@created 10/03/2004
@param input: o campo onde o valor foi digitado
@param mensagemErro: a mensagem a ser exibida se a validação falhar
@return Não retorna nada
@author Jorge Bittencourt
*/
function pfnValideFormateMoedaOnBlur(input, mensagemErro)
{
	if (pfnValideValorMaximo(input.value, mensagemErro) && pfnValideNumeroNaoNegativo(input.value, mensagemErro, true))
		pfnFormateMoedaOnBlur(input);
	else
	{
		input.select();
		input.focus();
	}
}


//*************************************************************************************************************
/**
@name pfnValideNumeric
@description Valida se um campo contém somente caracteres numéricos, exibe a mensagem de erro (se esta for não-vazia)
 e focaliza o campo
@created 28/04/2004
@param campo: o campo que contém o texto a ser validado
@param mensagem: a mensagem de erro a ser exibida - se for vazia, nada é exibido
@return true, se o campo só tiver caracteres numéricos, false, caso contrário
@author Jorge Bittencourt
*/
function pfnValideNumeric(campo, mensagem)
{
    // assuma que a validação terá sucesso
    var resultado = true;

    // verifique se o campo é non-null
    if (campo != null)
    {
        // recupere o texto digitado
        var texto = campo.value;
        // verifique se algo foi digitado
        if (pfnTrim(texto).length > 0)
        {
            // se há caracteres não-numéricos, há um erro
            if (texto.search(/\D/g, "") != -1)
            {
                // verifique se uma mensagem deve ser exibida
                if (mensagem != "")
                    alert(mensagem);
                // selecione o campo
                campo.select();
                campo.focus();
                resultado = false;
            }
        }
    }
    // retorne o resultado
    return resultado;
}


//*************************************************************************************************************
/**
@name pfnToNumeroAmericano
@description Transforma um número brasileiro em um número americano sem separadores de casas decimais,
 para que possa ser tratado no javascript. Tira todos os pontos (os separadores de casas decimais no Brasil, 
 e troca as vírgulas por pontos (os separadores de decimais).
@created 04/02/2004
@param numeroBr: o número no formato brasileiro
@return o número no formato americano
@author Jorge Bittencourt
*/
function pfnToNumeroAmericano(numeroBr)
{
	return numeroBr.replace(/\./g, "").replace(/\,/g, ".");
}


//*************************************************************************************************************
/**
@name ValideNumeroMaximo
@description Verifica se um número é maior que o máximo especificado. Se for, opcionalmente exibe mensagem de erro.
@created 28/07/2004
@param input: o input onde o número está sendo digitado
@param valorMaximo: o número máximo
@param msgErroValorMaximo: a mensagem de erro a ser exibida se o valor máximo for excedido. Se for uma string 
 vazia e houver um errro, não exiba nada
@param msgErroValorInvalido: a mensagem de erro a ser exibida se o valor for inválido. Se for uma string 
 vazia e houver um errro, não exiba nada
@return true, se o valor do input for válido e menor ou igual ao valor máximo e false, caso contrário. 
 Se algum dos parâmetros  for inválido, o retorno será undefined, para facilitar o debugging.
@author Jorge Bittencourt
*/
function ValideNumeroMaximo(input, valorMaximo, msgErroValorMaximo, msgErroValorInvalido)
{	
  if (input != null)
  {
    var valor = input.value;
    if (pfnTrim(valor) != "")
    {
    	// primeiro verifique se o input é válido e se há dígitos no campo
    	if (!isNaN(valor) && !isNaN(valorMaximo))
    	{
    		var numero = pfnToNumeroAmericano(pfnTrim(valor));
    		// verifique se o número é válido
    		var numObject = new Number(numero);
    		if (!isNaN(numObject))
    		{
    			// se o número for maior que o permitido e houver uma mensagem de erro, exiba a mensagem
    			if (numObject > valorMaximo && msgErroValorMaximo != "")
    			{
    				alert(msgErroValorMaximo);
    				input.select();
    				input.focus();
    			}
    			// retorne o resultado
    			return numObject > valorMaximo;
    		}
    	}
    	else if (msgErroValorInvalido != "")
    	{
    		alert(msgErroValorInvalido);
    		input.select();
    		input.focus();
    		return false;
    	}
    }
  }
}

//*************************************************************************************************************
/**
@name pfnValideNumeroNaoNegativo
@description Verifica se um número é não-negativo. Exibe a mensagem de erro caso valor contenha qualquer 
 caractere não-numérico ou se for um número negativo. Não exibe uma mensagem de erro se o parâmetro permiteVazio 
 for verdadeiro e o número for equivalente a uma string vazia
@created 08/03/2004
@param valor: o número (ou string correspondente ao número) a ser validado
@param mensagemErro: a mensagem a ser exibida caso a verificação falhe. Só exibe a mensagem se mensagemErro não 
 for uma string vazia
@param permiteVazio: se for verdadeiro e o número for equivalente a uma string vazia, não exibe a mensagem de erro.
@return true, se a validação tiver sucesso, ou seja, valor for um número válido e não-negativo; false, caso contrário.
@author Jorge Bittencourt
*/
function pfnValideNumeroNaoNegativo(valor, mensagemErro, permiteVazio)
{
	// converta o valor para uma string
	var str = new String(valor);
	if (str == "")
	{
		if (!permiteVazio)
		{	
			if (mensagemErro != "")
				alert(mensagemErro);
			return false;
		}
		else
			return true;
	}
	else
	{
		var numero = new Number(pfnToNumeroAmericano(str)).valueOf();
		if (isNaN(numero) || numero < 0)
		{
			if (mensagemErro != "")
				alert(mensagemErro);
			return false;
		}
	}
	// nesse ponto a validação teve sucesso
	return true;
}
			
	
/*************************************************************************************************************
/**
@name pfnValideNumeroNaoNegativoOnBlur
@description Verifica se um input contém um número não-negativo. Exibe a mensagem de erro caso a string do
 input tenha qualquer caractere não-numérico ou se for um número negativo. Não exibe uma mensagem de erro
 se o parâmetro permiteVazio for verdadeiro e o input estiver vazio
@created 08/03/2004
@param input: O input html que contém a string a ser validada
@param mensagemErro: a mensagem a ser exibida caso a verificação falhe. Só exibe a mensagem se mensagemErro não
 for uma string vazia
@param permiteVazio: se for verdadeiro e o input estiver vazio, não exibe a mensagem de erro
@return Não retorna nada
@author Jorge Bittencourt
*/
function pfnValideNumeroNaoNegativoOnBlur(input, mensagemErro, permiteVazio)
{
	if (!pfnValideNumeroNaoNegativo(input.value, mensagemErro, permiteVazio))
	{
		input.focus();
	}
}


//*************************************************************************************************************
/**
@name pfnValideValorMaximo
@description Verifica se um número é válido, ou seja, só contém caracteres numéricos (e uma vírgula e pontos, 
 opcionais) e não é maior que o valor máximo permitido no site da cobrança
@created 10/03/2004
@param valor: o número a ser validado
@param mensagemErro: a mensagem a ser exibida caso a verificação falhe. A mensagem só é exibida se for diferente
 de uma string vazia
@return true, se a validação tiver sucesso; false, caso contrário
@author Jorge Bittencourt
*/
function pfnValideValorMaximo(valor, mensagemErro)
{
	// converta o número para o formato americano
	var numero = new Number(pfnToNumeroAmericano(valor)).valueOf();
	
	// verifique se o número é válido ou maior do que o máximo permitido
	if (isNaN(numero) || numero > 99999999.99)
	{
		if (mensagemErro != "")
			alert(mensagemErro);
		return false;
	}
	return true;
}


//*************************************************************************************************************
/**
@name pfnValideValorMaximoOnBlur
@description Verifica se um número é válido, ou seja, só contém caracteres numéricos (e úma vírgula e pontos, 
 opcionais) e não é maior que o valor máximo permitido no site da cobrança
@created 10/03/2004
@param input: o campo onde o número foi digitado
@param mensagemErro: a mensagem a ser exibida caso a verificação falhe. A mensagem só é exibida se for diferente
 de uma string vazia
@return true, se a validação tiver sucesso; false, caso contrário
@author Jorge Bittencourt
*/
function pfnValideValorMaximoOnBlur(input, mensagemErro)
{
	if (!pfnValideValorMaximo(input.value, mensagemErro))
		input.focus();
}