// Tratamento do Nome

function preencherNome() {

let input = document.getElementById("inome"); //recebe a input toda

let erro = document.getElementById("ierroNome"); // sinaliza um erro na página
let nome = input.value; //recebe o valor digitado na input

// Valindado se há números
let nomeLimpo = limparLetrasComEspaco(nome); //remove tudo que não for letra

//se não houver ao menos uma letra: indica erro

if (!temLetras(nomeLimpo)) {
mostrarErro(input, erro, "Importante! use apenas letras");
input.value = "";
return;
}

esconderErro(input, erro);
input.value = nomeLimpo;
}

function validarNome() {
let input = document.getElementById("inome");
let erro = document.getElementById("ierroNome");
let nome = input.value.trim().toLowerCase(); // Remove espaços do início e fim

// Verifica se o nome tem pelo menos 3 caracteres

if (nome.length <= 4) {
mostrarErro(input, erro, "Digite pelo menos 4 caracteres.");
return;
}

// Validação de letras: remove tudo que não for letra

let nomeLimpo = limparLetrasComEspaco(nome); // Remove tudo que não for letra

//Enquanto houver dois espaços ele convertem em apenas 1

while (nomeLimpo.includes(" ")) {
nomeLimpo = nomeLimpo.replace(" ", " ");
}

// Verifica se o nome contém apenas letras e espaços

if (!temLetras(nome)) {
mostrarErro(input, erro, "Apenas caracteres não numéricos.");
input.value = "";
return;
}

// Verifica se o nome tem pelo menos 3 letras válidas

if (nomeLimpo.length < 4) {
mostrarErro(input, erro, "Mínimo de letras válidas: 3.");
return;
}

// Verifica se existe ao menos 1 espaço para ser válido

if (!nomeLimpo.includes(" ")) {
mostrarErro(input, erro, "Insira um nome Válido (nome + sobrenome)");
return;
 }

// Capitaliza o nome mantendo os espaços

let nomeFormatado = letrasCaixaAlta(nomeLimpo);

esconderErro(input, erro);
mostrarCorreto(input);
input.value = nomeFormatado;
}

// Validação da Data de Nascimento

function preencherDataNascimento() {
let input = document.getElementById("idataNascimento");
let erro = document.getElementById("ierroDataNascimento");
let dataNascimento = input.value;

// Limpa o valor, mantendo apenas números

let novaData = limparNumeros(dataNascimento);

// Verifica se há números (apenas números permitidos)

if (!temNumeros(novaData)) {
mostrarErro(input, erro, "Use apenas caracteres numéricos");
input.value = "";
return;
}

// Limita a 8 dígitos (formato de data ddmmyyyy)

novaData = novaData.slice(0, 8); // Permite apenas 8 dígitos

// Manter uma data válida

if (novaData.length >= 1 && novaData[0] > 3) {
// Remove o primeiro caractere (dígito inválido do dia)
novaData = novaData.slice(1);
mostrarErro(input, erro, "Primeiro dígito do dia deve ser 0, 1, 2 ou 3");
} else if (novaData.length >= 2 && novaData[0] == "0" && novaData[1] == "0") {
// Impede que o dia comece com 00
novaData = novaData.slice(1);
mostrarErro(input, erro, "O dia não pode começar com 00");
} else if (novaData.length >= 2 && novaData[0] == "3" && novaData[1] > 1) {
// Remove o segundo caractere do dia, se o primeiro for 3 e o segundo for
maior que 1
novaData = novaData[0] + novaData.slice(2);
mostrarErro(input, erro, "O dia vai no máximo até 31");
}

if (novaData.length >= 3 && novaData[2] > 1) {

// Remove o terceiro caractere (primeiro dígito do mês)
novaData = novaData.slice(0, 2) + novaData.slice(3);
mostrarErro(input, erro, "Primeiro dígito do mês deve ser 0 ou 1");
} else if (novaData.length >= 4 && novaData[2] == "0" && novaData[3] == "0") {
novaData = novaData.slice(0, 3); // remove apenas o segundo dígito do mês
mostrarErro(input, erro, "O mês não pode começar com 00");
} else if (novaData.length >= 4 && novaData[2] == "1" && novaData[3] > 2) {
// Remove o quarto caractere (segundo dígito do mês), se o mês for maior
que 12
novaData = novaData.slice(0, 3) + novaData.slice(4);
mostrarErro(input, erro, "O mês vai no máximo até 12");
}
 esconderErro(input, erro); // Caso esteja correto, remove o erro
input.value = formatarData(novaData); // Formata a data no formato dd/mm/yyyy
}

// Função que formata a data

function formatarData(data) {
let formatada = ""; // Inicializa a string formatada

// Adiciona a formatação para a data

for (let i = 0; i < data.length; i++) {
if (i == 2 || i == 4) formatada += "/"; // Coloca as barras nas posições
corretas
formatada += data[i];
}

return formatada; // Retorna a data formatada

}

function validarDataNascimento() {
let input = document.getElementById("idataNascimento");
let erro = document.getElementById("ierroDataNascimento");
let dataNascimento = input.value.trim();

// Limpa o valor, mantendo apenas números

let novaData = limparNumeros(dataNascimento);

// Verifica se há números (apenas números permitidos)

if (!temNumeros(novaData)) {
mostrarErro(input, erro, "Use apenas caracteres numéricos");
return;
}

//Remove as barras para tratar

while (novaData.includes("/")) {
novaData = novaData.substring("/", "");
}

if (novaData.length != 8) {
mostrarErro(input, erro, "Tamanho inválido");
return;
}

// Limita a 8 dígitos (formato de data ddmmyyyy)

novaData = novaData.slice(0, 8); // Permite apenas 8 dígitos

// Validando a data
let anoBase = new Date().getFullYear(); // Pega o ano atual (ex: 2025)

if (novaData.length == 8) {
let dia = parseInt(novaData.slice(0, 2));
let mes = parseInt(novaData.slice(2, 4));
let ano = parseInt(novaData.slice(4, 8));

// Valida se o ano não é no futuro

if (ano > anoBase) {
novaData = novaData.slice(0, 4); // remove os dígitos do ano
mostrarErro(input, erro, "Ano de nascimento não pode ser maior que o
ano atual!");
 return;
}

// Valida se a pessoa teria mais de 120 anos

if (anoBase - ano > 120) {
novaData = novaData.slice(0, 4); // remove os dígitos do ano
mostrarErro(input, erro, "Ano muito antigo para ser válido");
return;
}

// Validando a data completa

let dataCompleta = new Date(ano, mes - 1, dia);
if (
dataCompleta.getFullYear() !== ano ||
dataCompleta.getMonth() !== mes - 1 ||
dataCompleta.getDate() !== dia
) {
novaData = novaData.slice(0, 4); // remove parte do ano para forçar
correção
mostrarErro(input, erro, "Data inválida");
return;
}
}

esconderErro(input, erro); // Caso esteja correto, remove o erro

mostrarCorreto(input);
input.value = formatarData(novaData); // Formata a data no formato dd/mm/yyyy
}

// Função que analisa o CPF

function preencherCpf() {
let input = document.getElementById("icpf"); //recebe o elemento pelo id
let erro = document.getElementById("ierroCpf"); //recebe o ponto do erro
let cpf = input.value; //pega o valor digitado pelo usuario

//envia para função que limpa oq não for número com o parâmetro(cpf)
//ou seja, oq o usuario estiver digitando no momento
let cpfLimpo = limparNumeros(cpf); //remove tudo que não for número

// Validação se não há números

//espera um retorno direto da função que verifica se há ao menos 1 número
//se não houver, indica o erro enviando para a função de erro
if (!temNumeros(cpf)) {
mostrarErro(input, erro, "Apenas Caracteres Numéricos");
input.value = "";
return;
}

// Limita a 11 dígitos
cpfLimpo = cpfLimpo.slice(0, 11); //proibe o usuario de digitar mais digitos q
o necessario

esconderErro(input, erro); //caso esteja errado, apaga a mensagem de erro

input.value = formatarCpf(cpfLimpo); //devolve pra input o cpf formatado
}

// Função que formata o CPF

function formatarCpf(cpf) {
 let formatado = ""; //incia vazio esperando a informação do usuário

//loop fazendo a formatação

for (let i = 0; i < cpf.length; i++) {
if (i == 3 || i == 6) formatado += ".";
if (i == 9) formatado += "-";
formatado += cpf[i];
}

return formatado;
}

// Validação do CPF, ao sair do Input

function validarCpf() {
let input = document.getElementById("icpf"); //recebe o elemento pelo id
let cpf = input.value.trim(); //pega o valor digitado pelo usuario
let erro = document.getElementById("ierroCpf"); //recebe o ponto do erro

let cpfLimpo = limparNumeros(cpf); //remove tudo que não for número

if (!temNumeros(cpf)) {
mostrarErro(input, erro, "Apenas Caracteres Numéricos");
input.value = "";
}

if (cpfLimpo.length < 11) {

mostrarErro(input, erro, "Precisa de 11 dígitos no mínimo");
return;
}

// Limita a 11 dígitos
cpfLimpo = cpfLimpo.slice(0, 11); //proibe o usuario de digitar mais digitos q
o necessario
esconderErro(input, erro); //caso esteja errado, apaga a mensagem de erro

let resultado = formatarCpf(cpfLimpo);

mostrarCorreto(input);
input.value = resultado; //devolve pra input o cpf formatado
return true;
}

// =============================================================================

// Validação conforme o preenchimento da Placa do Carro

function preencherPlacaCarro() {
let input = document.getElementById("iplacaCarro");
let erro = document.getElementById("ierroPlacaCarro");
let placa = input.value.toUpperCase();

let letras = limparLetras(placa).toUpperCase().slice(0, 3);

let numeros = limparNumeros(placa).slice(0, 4);

// Verifica se o usuário digitou menos de 3 letras no começo

if (placa.length <= 3 && letras.length < placa.length) {
mostrarErro(input, erro, "As 3 primeiras posições devem ser letras.");

// Limpa apenas os caracteres inválidos, mantendo os válidos

input.value = letras;
 return;
}

// Se digitou mais de 3 letras e ainda não começou a digitar números

if (placa.length > 3 && numeros.length == 0) {
mostrarErro(input, erro, "Apenas números após as 3 letras.");
input.value = "";
return;
}

let resultado = letras + numeros;

// Atualiza o input, limitando a 7 caracteres no total

input.value = resultado.slice(0, 7);

// Se estiver completo, marca como válido

if (resultado.length == 7) {
esconderErro(input, erro);
mostrarCorreto(input);
} else {
esconderErro(input, erro); // ainda digitando
}

input.value = formatarPlacaCarro(resultado);
}