/** Bloqueia a digitacao de caracteres */
function bloqueiaCaracteres(obj){
    var valor = obj.value;
    var len = valor.length;
    if (isNaN(valor) || valor.charAt(len-1) ==  ' ') {
        obj.value = valor.toString().substr(0, len-1);
    }
}
document.onkeypress = bloqueiaCaracteres;


/**
 * Valida dois campos NOME. As pesquisas que usam essa validação são:
 * Outorgante/Outorgado, Nascimento, Casamento, Óbito
 * @param idCampo1: id do primeiro campo. Esse campo é de preenchimento obrigatório
 * @param idCampo2: id do segundo campo. Esse campo não é de preenchimento obrigatório
 * @param nCampo1: nome do primeiro campo para ser usado na mensagem de erro
 * @param nCampo2: nome do segundo campo para ser usado na mensagem de erro
 */
function validaPesqComDoisCamposNomeMasApenasUmDeveSerPreenchido(idCampo1,idCampo2,nCampo1,nCampo2) {
    var campo1 = document.getElementById(idCampo1).value;
    var campo2 = document.getElementById(idCampo2).value;
    var ret = true;
    var msg1 = "";
    var msg2 = "";
    if (campo1.length > 0) {
        msg1 = validaNome(campo1);
        if (msg1 != "") {
            msg1 = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: "+nCampo1+"\n\n"+msg1;
            ret = false;
        }
    }
    if (campo2.length > 0) {
        msg2 = validaNome(campo2);
        if (msg2 != "") {
            if (!ret) {
                msg2 = "\n\nCampo: "+nCampo2+"\n\n"+msg2;
            } else {
                msg2 = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: "+nCampo2+"\n\n"+msg2;
            }
            ret = false;
        }
    }

    if (campo1.length <= 0 && campo2.length <= 0) {
        msg1 = "PESQUISA EM BRANCO\n\nCampo: "+nCampo1+"\n\nNão foi digitado nenhum valor para a pesquisa.";
        ret = false;
    }
    if (!ret) alert(msg1+msg2);
    return ret;
}

/**
 * Valida dois campos NOME. As pesquisas que usam essa validação são:
 * Outorgante/Outorgado, Nascimento, Casamento, Óbito
 * @param idCampo1: id do primeiro campo. Esse campo é de preenchimento obrigatório
 * @param idCampo2: id do segundo campo. Esse campo não é de preenchimento obrigatório
 * @param nCampo1: nome do primeiro campo para ser usado na mensagem de erro
 * @param nCampo2: nome do segundo campo para ser usado na mensagem de erro
 */
function validaPesqComDoisCamposNome(idCampo1,idCampo2,nCampo1,nCampo2) {
    var campo1 = document.getElementById(idCampo1).value;
    var campo2 = document.getElementById(idCampo2).value;
    var ret = true;
    var msg1 = "";
    var msg2 = "";
    if (campo1.length > 0) {
        msg1 = validaNome(campo1);
        if (msg1 != "") {
            msg1 = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: "+nCampo1+"\n\n"+msg1;
            ret = false;
        }
        if (campo2.length > 0) {
            msg2 = validaNome(campo2);
            if (msg2 != "") {
                if (!ret) {
                    msg2 = "\n\nCampo: "+nCampo2+"\n\n"+msg2;
                } else {
                    msg2 = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: "+nCampo2+"\n\n"+msg2;
                }
                ret = false;
            }
        }
    } else {
        msg1 = "PESQUISA EM BRANCO\n\nCampo: "+nCampo1+"\n\nNão foi digitado nenhum valor para a pesquisa.";
        ret = false;
    }
    if (!ret) alert(msg1+msg2);
    return ret;
}

/**
 * @param idBuscar: id do campo com o texto a ser pesquisado
 * @param tipo: o id do campo com o tipo de pesquisa: NOME, CPF
 */
function validaPesqCartaoAssin(idBuscar, tipo) {
    var valor = document.getElementById(idBuscar).value;
    var tipoPesq = document.getElementById(tipo).value;
    var ret = true;
    var msg = "";
    if (tipoPesq == "CPF") {
        msg += validaCpf(valor);
        if (msg != "") {
            msg = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: Buscar\n\n"+msg;
            ret = false;
        }
    }
    if (tipoPesq == "NOME") {
        msg += validaNome(valor);
        if (msg != "") {
            msg = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: Buscar\n\n"+msg;
            ret = false;
        }
    }
    if (!ret) alert(msg);
    return ret;
}

/**
 * @param idPrimeiroCampo: o id do primeiro dos oito campos
 */
function validaPesqCodAlfanum(idPrimeiroCampo) {
    var codAlfaNum = "";
    var ret = true;
    msg = "";
    var idParcial = idPrimeiroCampo.substr(0, (idPrimeiroCampo.length-1));
    for (var i = 1; i < 9; i++) {
        codAlfaNum += document.getElementById(idParcial+i).value;
    }
    msg = validaCodHexa(codAlfaNum,32);
    if (msg != "") {
        msg = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: Código Alfanumérico\n\n"+msg;
        ret = false;
    }
    if (!ret) alert(msg);
    return ret;
}

/**
 * @param idEscrevente: id do campo com o nome do Escrevente ou Notário
 */
function validaPesqSinalPub(idEscrevente) {
    var escrevente = document.getElementById(idEscrevente).value;
    var msg = "";
    var ret = true;
    msg = validaNome(escrevente);
    if (msg != "") {
        msg = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: Nome do Escrevente ou Notário\n\n"+msg;
        ret = false;
    }
    if (!ret) alert(msg);
    return ret;
}

/**
 * @param idData: id do campo com a data
 * @param idCarimbo: id do campo com o código do carimbo
 */
function validaPesquisaCarimbo(idData, idCarimbo) {
    var ret = true;
    var msgData = "";
    var msgEscrev = "";
    var data = document.getElementById(idData).value;
    var carimbo = document.getElementById(idCarimbo).value;
    msgData = validaData_ddmmaaaa(data);
    if (msgData != "") {
        msgData = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: Data Reconhecimento\n\n"+msgData;
        ret = false;
    }
    msgEscrev = verificaCodCarimbo(carimbo,7);
    if (msgEscrev != "") {
        if (msgData != "") {
            msgEscrev = "\n\nCampo: Código Criptografado\n\n"+msgEscrev;
        } else {
            msgEscrev = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\nCampo: Código Criptografado\n\n"+msgEscrev;
        }
        ret = false;
    }
    if (!ret) alert(msgData+msgEscrev);
    return ret;
}

/**
 * @param cod: código a ser validado
 * @param min: qtde mínima de caracteres no código
 */
function verificaCodCarimbo(cod,min) {
    var sinais = "!@#$%&*()_-+=[]{}/\\|;:<>\'\"§£¢¬. ";
    var msg = "";
  
    for (var i = 0; i < cod.length; i++) {
        for (var y = 0; y < sinais.length; y++) {
            if (cod.charAt(i) == sinais.charAt(y)) {
                msg = "- Use somente letras e números.\n";
            }
        }
    }
    if (cod.length < min) {
        msg += "- Digite pelo menos "+min+" caracteres.";
    }
    return msg;
}
/*
 * @param idLivro: id do campo com o valor do Livro
 * @param idFolha: id do campo com o valor da Folha
 */
function validaPesqLivroFolha(idLivro, idFolha) {
    var msg = "O TEXTO DIGITADO NÃO PODE SER PESQUISADO\n\n";
    var ret = true;
    var livro = document.getElementById(idLivro).value;
    var folha = document.getElementById(idFolha).value;
    
    if (livro.length == 0) {
        msg += "Campo: Livro\n\n- Preencha o campo Livro\n\n"
        ret = false;
    }
    if (folha.length == 0) {
        msg += "Campo: Folha\n\n- Preencha o campo Folha\n"
        ret = false;
    }
    if (ret) {
        ret = validaLetraNumero(livro);
        if (!ret) {
            msg += "Campo: Livro\n\n- Use somente letras e números\n";
        }
        if (ret) {
            ret = validaLetraNumero(folha);
            if (ret) {
                if (isNaN(folha)) {
                    msg += "Campo: Folha\n\n- Use somente números\n";
                    ret = false;
                }
            } else {
                msg += "Campo: Folha\n\n- Use somente números\n";
                ret = false;
            }
        }
    }
    if (!ret) alert(msg);
    return ret;
}

/*
 * Função que move o cursor para o próximo campo.
 * qChrPorCampo: quantidade de carateres que o presente campo deverá ter para
 * que o cursor vá para o próximo campo.
 * idProxCampo: id do próximo campo.
 * obj: o objeto campo atual.
 */
function cursorProximoCampo(qChrPorCampo, idProxCampo, obj) {
    if (obj.value.length == qChrPorCampo) {
        document.getElementById(idProxCampo).focus();
    }
}

/**
 * Função que verifica se há algum caracter não hexadecimal em um valor passado.
 * Para tanto, é usada uma expressão regular que verifica a presença de qualquer
 * caracter que seja diferente dos números de 0 a 9, ou que seja diferente das letras
 * de 'a' a 'f' e seus equivalentes maiúsculos. <vlr> é o valor de uma entrada de
 * texto como, por exemplo, <input type="text"... />
 * @param vlr: o hexa
 * @param qtdeCaract: a quantidade de caracteres que se espera que o código (vlr) tenha
 */
function validaCodHexa(vlr, qtdeCaract) {
    var msg = "";
    var regExpIsHexa = /[^0-9a-fA-F]/;
    var hasNotHexa = regExpIsHexa.test(vlr);
    if (vlr.length < qtdeCaract) {
        msg += "- Todos os campos devem ser preenchidos com quatro caracteres cada.";
    } else {
        if (hasNotHexa) {
            msg += "- Use somente caracteres de: '0' a '9', de 'a' a 'f', e de 'A' a 'F'.\n";
        }
    }
    return msg;
}

/**
 * Função para a validação de um <nome> digitado em uma entrada de texto como
 * <input type="text"... />. O parâmetro <txt> é o valor digitado e deve ser passado
 * quando da chamada à função. A função retorna um valor boolean, ou seja, é interessante
 * que a chamada da função no código (x)html seja feita usando-se return. Detsa forma
 * o formulário, caso se trate de um, somente será submetido se a validação retornar
 * true. Ex.: onsubmit="return validaNome(document.getElementById('myInputText').value);"
 * @param txt: o texto a ser validado
 */
function validaNome(txt) {
    //O valor digitado no campo de entrada de texto
    var texto = txt.replace("  "," ");
    //Tamanho (length) do valor digitado
    var tam = texto.length;
    //A mensagem de erro
    var msg = "";
    //Um contador
    var contador = 0;
    //Outro contador
    var j = 0;
    //O texto sem espaços
    var txtSemEspaco = texto.replace(" ","");
    //Valor boolean que informa a existência ou não de três caracteres iguais seguidos
    var contTresLetrasIguaisSeguidas = false;
    //Valor boolean que informa a existência de ao menos um dos caracteres da
    //string <sinais> no valor digitado
    var haCaracEstranho = false;
    //Caracteres que não podem estar presentes no valor digitado
    var sinais = "!@#$%&*()_-+=[]{}/\\|;:<>\"§£¢¬";
    //Verifica se existe espaço duplo
    var myRegExp1 = /  {1}/;
    //Verifica se existem números
    var myRegExp3 = /\d/;
    //Caso haja espaço duplo: true; false, caso contrário
    var haEspacoDuplo = myRegExp1.test(texto);
    //Caso haja ao menos um número: true; false, caso contrário
    var haNumeros = myRegExp3.test(texto);
    var haDuasPalavras = false;
  
    var contLetra = 0;
    var espacoEncontrado = false;
    for (var u = 0; u < tam; u++) {
        if (texto.charAt(u) == ' ') {
            espacoEncontrado = true;
        } else {
            if (espacoEncontrado)
                contLetra += 1;
        }
    }
    if (espacoEncontrado && contLetra > 1) {
        haDuasPalavras = true;
    }

    if (!haDuasPalavras) {
        msg += "- O texto deve ter pelo menos duas palavras.\nA segunda palavra deve ter no mínimo duas letras.\n"
    }
    /*verifica se há algum caracter estranho */
    for (var v = 0; v < txtSemEspaco.length; v++) {
        for (var m = 0; m < sinais.length; m++) {
            if (txtSemEspaco.charAt(v) == sinais.charAt(m)) {
                haCaracEstranho = true;
            }
        }
    }
    if (haCaracEstranho) {
        msg += "- Use somente letras para fazer sua pesquisa.\n"
    }

    /*Verifica se a primeira palavra tem um mínimo de três letras */
    while (texto.charAt(j) != ' ' && j < tam) {
        contador += 1;
        j += 1;
    }
    if (contador < 3) {
        msg += "- A primeira palavra deve ter pelo menos três letras.\n"
    }

    /*Verifica se há três ou mais letras iguais seguidas */
    var partes = texto.split(" ");
    for (var g = 0; g < partes.length; g++) {
        if (partes[g].length > 2) {
            for (var i = 2; i < txtSemEspaco.length; i++) {
                if (txtSemEspaco.charAt(i) == txtSemEspaco.charAt(i-1) && txtSemEspaco.charAt(i-1) == txtSemEspaco.charAt(i-2)) {
                    contTresLetrasIguaisSeguidas = true;
                }
            }
        }
    }
    if (contTresLetrasIguaisSeguidas) {
        msg += "- Não há nomes com três ou mais letras iguais uma seguida da outra.\n"
    }

    /*Verifica se há espaço no início do texto */
    if (texto.charAt(0) ==  ' ') {
        msg += "- O texto não pode ser iniciado com espaço.\n"
    }

    /*Verifica se há espaços duplos */
    if (haEspacoDuplo) {
        msg += "- Coloque apenas um espaço entre as palavras.\n";
    }

    /*Verifica se há a presença de números */
    if (haNumeros) {
        msg += "- Não use números nesta pesquisa.\n";
    }
    return msg;
}

/**
 * Função para a validação de um <cpf> digitado em uma entrada de texto como
 * <input type="text"... />. O parâmetro <cpf> é o cpf digitado e deve ser passado
 * quando da chamada à função. Este valor deverá ser, até a presente versão desta versão,
 * composto somente de números, ou seja, sem a separação com pontos (.) e traço (-).
 * A função retorna um valor boolean, ou seja, é interessante que a chamada da função
 * no código (x)html seja feita usando-se return. Detsa forma o formulário, caso se
 * trate de um, somente será submetido se a validação retornar true.
 * Ex.: onsubmit="return validaNome(document.getElementById('myInputText').value);"
 * @param cpf: o CPF
 */
function validaCpf(cpf){
    var msg = "";
    //Retorno boolean
    var ret = true;
    //Contador
    var i;
    //O CPF
    var s = cpf;
    //A primeira parte do CPF (primeiros 9 números)
    var c = s.substr(0,9);
    //A segunda parte do CPF (dois dígitos verificadores)
    var dv = s.substr(9,2);
    //Qualquer dos dígitos verificadores
    var d1 = 0;
    for (i = 0; i < 9; i++) d1 += c.charAt(i)*(10-i);
    if (d1 == 0) ret = false;
    d1 = 11 - (d1 % 11);
    if (d1 > 9) d1 = 0;
    if (dv.charAt(0) != d1) ret = false;
    d1 *= 2;
    for (i = 0; i < 9; i++) d1 += c.charAt(i)*(11-i);
    d1 = 11 - (d1 % 11);
    if (d1 > 9) d1 = 0;
    if (dv.charAt(1) != d1) ret = false;
    if(!ret) msg = "- CPF inválido: lembre-se de usar apenas números.";
    return msg;
}

/**
 * Função que atribui uma máscara aum campo que recebe uma data. A máscara é aplciada
 * à medida em que o valor é digitado. O formato da máscara é dd/mm/aaaa. O parâmetro
 * <obj> é o objeto que está recebendo o valor. Para acionar a máscara para que
 * atue sobre um elemento de entrada de texto, tal como um <input type="text"... />
 * basta adicionar o atributo <onkeyup>, desta forma: onkeyup="mascaraData(this);".
 * this é a referência ao próprio objeto que recebe o valor (um input, por exemplo).
 * É recomendável também usar o atributo <maxlength>, com o valor igual a 10 para
 * garantir que não mais de 10 caracteres serão digitados. Ex.: 02/12/2001
 * @param obj: o obejto (elemento) que possui o valor de data
 */
function mascaraData(obj){
    var data = obj.value;
    var retorno;
    if (data.length == 2){
        data = data + '/';
        obj.value = data;
        retorno = true;
    }
    if (data.length == 5){
        data = data + '/';
        obj.value = data;
        retorno = true;
    }
    return retorno;
}

/**
 * Função que valida uma data no formato dd/mm/aaa. <dt> é o valor digitado na entrada
 * de texto (normalmente um <input type="text"... />). <dt> deve ter o formato dd/mm/aaaa.
 * Para garantir esse formato, é aconselhável usar uma máscara como a oferecida pela
 * função <mascaraData> presente neste repositório.
 * A presente função realiza as seguintes verificações:
 * - Anos maiores do que o corrente;
 * - Anos menores do que 1500;
 * - Dias máximos nos meses prevendo, inclusive, anos bissextos.
 * O retorno é um valor boolean que quando false indica algum erro na data.
 * @param dt: a data no formato dd/mm/aaaa
 */
function validaData_ddmmaaaa(dt) {
    var data = dt;
    var dia = data.substr(0,2);
    var mes = data.substr(3,2);
    var ano = data.substr(6,4);
    var msg = "";
    var dataAtual = new Date();
    var anoAtual = dataAtual.getYear();
    //Verifica o dia/mês/ano
    if (isNaN(dia) || dia > 31 || dia < 1){
        msg += "- Formato de data não válido: Problema com o DIA.\n";
    }
    if (isNaN(mes) || mes > 12 || mes < 1) {
        msg += "- Formato de data não válido: Problema com o Mês.\n";
    }
    var validaAno = true;
  
    if(navigator.appName == 'Microsoft Internet Explorer') {
        if (isNaN(ano) || ano > anoAtual || ano < 1500) {
            validaAno = false;
        }
    } else {
        if (isNaN(ano) || (ano-1900) > anoAtual || ano < 1500) {
            validaAno = false;
        }
    }
    if (!validaAno) {
        msg += "- Formato de data não válido: Problema com o Ano.\n";
        msg += "Se você digitou um ano igual ou menor do que o atual,\n";
        msg += "e mesmo assim recebeu esta mensagem de erro, talvez\n";
        msg += "seja necessário ajustar o ano do seu computador.\n";
    }

    //Verifica  dias com no máximo 30 dias
    if (mes == 4 || mes == 6 || mes == 9 || mes == 11){
        if (dia > 30) {
            msg += "- Formato de data não válido: Este mês não possui mais de 30 dias.\n";
        }
    }
    if (mes == 2){
        bissexto = ano % 4;
        if (bissexto == 0){
            if (dia > 29){
                msg += "- Fevereiro em anos bissextos possui no máximo 29 dias.\n";
            }
        }else{
            if (dia > 28){
                msg += "- Fevereiro, em anos não bissextos, possui no máximo 28 dias.\n";
            }
        }
    }
    return msg;
}

/**
 * Verifica se o texto (txt) é composto somente de letras e números
 * @param txt: o texto a ser validado
 */
function validaLetraNumero(txt) {
    var texto = txt;
    var ret = true;
    var sinais = "!@#$%&*()_-+=[]{}/\\|;:<>\'\"§£¢¬. ";
  
    for (var i = 0; i < texto.length; i++) {
        for (var y = 0; y < sinais.length; y++) {
            if (texto.charAt(i) == sinais.charAt(y)) {
                ret = false;
            }
        }
    }
    return ret;
}