//Maisculo = obrigatorio, Minusculo = opcional
mMskAlpha = "L";           // A-Z,a-z 
mMskAlphaOpt = "l";
mMskAlphaNum = "A";        // A-Z,a-z,0-9 
mMskAlphaNumOpt  = "a";
mMskAscii = "C";           // qquer caracter
mMskAsciiOpt = "c";
mMskNumeric = "0";         // 0-9 
mMskNumericOpt = "9";
mMskNumSymOpt = "#";       // + ou - 

/** 
 * Retorna o caracter na posição "pos" da máscara se for um literal.
 */
function CM_getIfMaskLiteral(formato, pos) {
    charDig = formato.charAt(pos);
    if (charDig != mMskAlpha && charDig != mMskAlphaOpt &&
            charDig != mMskAlphaNum && charDig != mMskAlphaNumOpt &&
            charDig != mMskAscii && charDig != mMskAsciiOpt &&
            charDig != mMskNumeric && charDig != mMskNumericOpt &&
            charDig != mMskNumSymOpt) {
        return charDig;
    }
    return "";
}

/** 
 * Retorna TRUE se o caracter "charDig" digitado na posição "pos" for válido.
 */
function CM_isCaracterValido(formato, charDig, pos) {
        textovalido = false;
        //Verifica se o tamanho do texto é válido
        if (String(formato).length <= pos) {
            return "O tamanho do texto digitado é maior do que o tamanho " +
                "permitido. Tamanho permitido: \"" + 
                String(formato).length + "\".";
        }
        //Verifica se a máscara é válida
        
        mask = formato.charAt(pos);
        if(mask == mMskAsciiOpt || (mask == mMskAscii && charDig != " ")){
        	textovalido = true;
        } else if ((charDig >= "A" && charDig <= "Z") || (charDig >= "a" && charDig <= "z")) {
            textovalido = (mask == mMskAlpha || mask == mMskAlphaOpt || 
                mask == mMskAlphaNum || mask == mMskAlphaNumOpt);
        } else if (charDig >= "0" && charDig <= "9") {
            textovalido = (mask == mMskAlphaNum || mask == mMskAlphaNumOpt ||
                mask == mMskNumeric || mask == mMskNumericOpt);
        } else if (charDig == "+") {
            textovalido = (mask == mMskNumSymOpt);
        } else if (charDig == "-") {
            textovalido = (mask == mMskNumSymOpt || charDig == mask);
        } else if (charDig == " ") {
            textovalido = (mask == mMskAlphaOpt || mask == mMskAlphaNumOpt ||
                mask == mMskNumericOpt || mask == mMskNumSymOpt);
        } else {
            textovalido = (mask == charDig);
        }
        //Retorna o resultado da verificação
        if (!textovalido) {
            return "O caracter \"" + charDig + "\" não é permitido " +
                "na posição \"" + (pos+1) + "\"";
        } else {
            return "";
        }
}

/** 
 * Retorna o conteúdo do campo sem a máscara.
 */
function CM_getConteudoSemMascara(formato, textodigitado){
	var nTextoSize = String(textodigitado).length;
	var conteudo = "";
	for(var i = 0; i < nTextoSize; i++){
		if(CM_getIfMaskLiteral(formato, i) == ""){
			conteudo = conteudo + textodigitado.charAt(i);
		}
	}
	return conteudo;
}

/** 
 * Aplica a máscara num conteúdo limpo, ou seja, que está sem máscara.
 */
function CM_aplicaMascaraAoConteudo(formato, conteudo){
	var nFormatoSize = String(formato).length;
	var nConteudoSize = String(conteudo).length;
	var nConteudo = 0;
	var valorFinal = "";
	var charLiteral;
	for(var i = 0; i < nFormatoSize && nConteudo < nConteudoSize; i++){
		charLiteral = CM_getIfMaskLiteral(formato, i);
		if(charLiteral == ""){
			valorFinal = valorFinal + conteudo.charAt(nConteudo++);
		}else{
			valorFinal = valorFinal + charLiteral;
		}
	}
	return valorFinal;
}

/** 
 * Aplica o comportamento da propriedade maskAlign.
 */
function CM_ajustaConteudoPeloMaskAlign(ctrl){
	var maskAlign = ctrl.getAttribute("maskAlign");
	var textodigitado = ctrl.value;
	if(String(maskAlign).toLowerCase() == "right" && textodigitado != ""){
		var formato = ctrl.getAttribute("formato");
		var nFormatoSize = String(formato).length;
		var nTextoSize = String(textodigitado).length;
		var espacos = "";
		for (var i = nTextoSize; i < nFormatoSize; i++){
			espacos = espacos + " ";
		}
		textodigitado = espacos + CM_getConteudoSemMascara(formato, textodigitado);
		textodigitado = CM_aplicaMascaraAoConteudo(formato, textodigitado);
		if(ctrl.value != textodigitado){
			ctrl.value = textodigitado;
		}
	}
}

/** 
 * Retorna TRUE se o formato do "textodigitado" for igual ao formato
 * da máscara. Esta função não valida a máscara inteira, somente a parte que o 
 * usuário digitou. Se a máscara exige a digitação de caracteres ainda não digitados
 * esta função não acusa o erro. Para verificar toda a máscara deve-se usar a 
 * função CM_isFormatoInteiroValido(formato, textodigitado, maskAlign)
 */
function CM_isFormatoValido(formato, textodigitado) {
    var msgformato = "";
    var nPosTexto = 0;
    while (nPosTexto < String(textodigitado).length && msgformato == "") {
        msgformato = CM_isCaracterValido(formato, textodigitado.charAt(nPosTexto), nPosTexto);
        nPosTexto++;
    }
    return msgformato;  
}

/** 
 * Esta função deve ser chamada somente pelo onBlur.
 * Ela faz a mesma validação CM_isFormatoValido faz e adicionalmente também
 * nos caracteres ainda não digitados.
 */
function CM_isFormatoInteiroValido(formato, textodigitado, maskAlign) {
	var msgformato = "";
	var nPosTexto = 0;
	var nFormatoSize = String(formato).length;
	var nTextoSize = String(textodigitado).length;
	var i;
	//com o loop abaixo verificando a mascara inteira deve usar este if:
	//if(nFormatoSize > nTextoSize){
	//com o loop abaixo veriricando só a mascara digitada deve usar este if:
	if( (nFormatoSize > nTextoSize) && (maskAlign != null && String(maskAlign).toLowerCase() == "right" && nTextoSize > 0)){
		var espacos = "";
		for (var i = nTextoSize; i < nFormatoSize; i++){
			espacos = espacos + " ";
		}
		if(maskAlign == null || String(maskAlign).toLowerCase() != "right"){
			textodigitado = textodigitado + espacos;
		}else{
			textodigitado = espacos + CM_getConteudoSemMascara(formato, textodigitado);
			textodigitado = CM_aplicaMascaraAoConteudo(formato, textodigitado);
		}
	}
	//loop para verificar a mascara inteira
	//while (nPosTexto < nFormatoSize && msgformato == "") {
	//loop para verificar a mascara até onde foi digitado (se a condição deste loop for alterada rever if acima)
    while (nPosTexto < String(textodigitado).length && msgformato == "") {
		msgformato = CM_isCaracterValido(formato, textodigitado.charAt(nPosTexto), nPosTexto);
		nPosTexto++;
	}
	return msgformato;  
}

/**
 * Verifica se valor digitado no campo "ctrl" é válido.
 */
function CM_verificaValor(ctrl) {
    //verifica se o texto é válido
    var msgformato = CM_isFormatoInteiroValido(ctrl.getAttribute("formato"), ctrl.value, ctrl.getAttribute("maskAlign"));
    var valordigitado = ctrl.value;
    //se não for válido, limpa o campo e mostra uma mensagem
    if (msgformato != "") {
        //alert (msgformato + msgKey("label.js.valorDigitado","") + valordigitado + "\".");
        //ctrl.focus();
        if(ctrl.className.indexOf('erro')==-1){
        	ctrl.className=ctrl.className+' erro';
        }
        return false;
    }
    if(ctrl.className.indexOf('erro')!=-1){
      	ctrl.className=ctrl.className.substring(0,ctrl.className.indexOf('erro'));
    }
    return true;
}
    
/** 
 * Tratamento de digitação no componente.
 */
function CM_KPS(ctrl, event) {
    //Verifica as teclas de controle
    if (C_getDeveInibirTeclasControle(ctrl, event)) {
        C_CancelaEvento(event);
        return;
    }
    //Nas situações abaixo não deve fazer validação não faz nada
    if (C_NaoPodeProcessarOnKeyPress(ctrl, event)) {
        return;
    }
    //pega a tecla que foi digitada
    tecla = C_TeclaDigitada(event);
    //pega os dados do texto que está sendo digitado
    pos = C_getPosTextoDigitado(ctrl);
    charDigitado = String.fromCharCode(tecla);
    textoDigitado = C_getTextoDigitado(ctrl, charDigitado);
    formato = ctrl.getAttribute("formato");
    //So permite a digitacao caso esteja no fim do campo
    if (pos < String(formato).length && pos == (String(textoDigitado).length-1)) {
        //Verifica se o formato é válido
        var msgformato = CM_isFormatoValido(formato, textoDigitado);
        if (msgformato != "") {
            //Verifica se deve completar a máscara
            var charMask = CM_getIfMaskLiteral(formato, pos);
            if (charMask != "" && C_getSelLength(ctrl) == 0) {
                textoDigitado = ctrl.value + charMask + charDigitado;
                if (CM_isFormatoValido(formato, textoDigitado) == "") {
                    if (F_isIExplorer()) {
                        range = ctrl.createTextRange();
                        range.move('character', pos);            
                        range.text = charMask;
                    } else {
                        ctrl.value = ctrl.value + charMask;
                        if (ctrl.onchange != null) {
                            ctrl.onchange(ctrl);
                        }
                    }
                } else {
                  C_CancelaEvento(event);
                  return;
                }
            } else {
                C_CancelaEvento(event);
                return;
            }
        }
    } else {
        //Se não tiver uma faixa de seleção ou a posição do cursor esteja
        //antes do final da mascara, sobrescreve os caracteres
        if (C_getSelLength(ctrl) > 1 || pos > String(formato).length-1) {
            C_CancelaEvento(event);
            return;
        } else {
            textoDigitado = ctrl.value.substr(0, pos) + charDigitado + 
                ctrl.value.substr(pos+1);
            if (CM_isFormatoValido(formato, textoDigitado) == "") {
                if (F_isIExplorer()) {
                    range = ctrl.createTextRange();
                    range.move('character', pos);            
                    range.moveEnd('character', 1);
                    range.select();
                } else {
                    ctrl.selectionEnd = pos+1;
                }
            } else {
                C_CancelaEvento(event);
                return;
            }
        }
    }
}

/** 
 * Trata a saída do campo para não permitir que o campo fique com valores inválidos 
 */
function CM_BLR(ctrl) {
	//Verifica se o formato do campo é válido
	CM_ajustaConteudoPeloMaskAlign(ctrl);
	CM_verificaValor(ctrl);
}

/**
 * Trata a digitação no campo.
 */
function CM_KDN(ctrl, event) {
    if (C_getDeveInibirTeclasControle(ctrl, event)) {
        C_CancelaEvento(event);
        return;
    }
}

/**
 * Passa o foco para o próximo campo.
 */
function CM_KUP(ctrl, event) {
    focoProxCampo = ctrl.getAttribute("focoProxCampo");
    //Pula para o próximo controle
    if (focoProxCampo != null) {
        formato = ctrl.getAttribute("formato");
        pos = C_getPosTextoDigitado(ctrl);
        if (formato.length == ctrl.value.length &&
           pos == ctrl.value.length) {
            ctrlFoco = FF_GetProxCtrl(ctrl);
            if (ctrlFoco != null) {
                ctrlFoco.focus();
            }
        }
    }
}

function CM_MOV(ctrl, e){
	if(ctrl.className.indexOf('erro')!= -1){
		C_mostraHint(e, msgKey('label.js.valorInvalido',ctrl.value));
	}
}

function CM_MMOV(ctrl, event){
	if(ctrl.className.indexOf('erro')!= -1){
		C_moveHint(event);
	}
}

function CM_MOUT(ctrl, event){
	if(ctrl.className.indexOf('erro')!= -1){
		C_escondeHint();
	}
}