script.js

const CONFIG = {
  tamanhoPalavra: 5,
  maxTentativas: 6,
  tentativasApi: 28,
  timeoutApi: 3500
};

const API_DICIONARIO = {
  aleatoria: "https://api.dicionario-aberto.net/random",
  verbete: (palavra) => `https://api.dicionario-aberto.net/word/${encodeURIComponent(palavra)}`
};

const PALAVRAS_SEGURAS = [
  "ABRIR", "ACHAR", "AGUAR", "AJUDA", "ANDAR", "APITO", "ARMAR", "ARROZ",
  "ASSAR", "BANCO", "BATER", "BEBER", "BICHO", "BOLSA", "BOTAO", "BRASA",
  "BROCA", "CABER", "CABO", "CAIXA", "CANOA", "CAPUZ", "CARRO", "CARTA",
  "CASCA", "CHAVE", "CHUVA", "CINTO", "CLARO", "COBRE", "COLAR", "CONTA",
  "CORDA", "CORTE", "COURO", "COZIR", "CREME", "CURVA", "DADOS", "DENTE",
  "DISCO", "DOBRA", "DUPLO", "FALAR", "FAROL", "FAZER", "FEIRA", "FERRO",
  "FIBRA", "FICAR", "FILME", "FOGAO", "FOLHA", "FORMA", "FORNO", "FORTE",
  "FRUTA", "GARFO", "GASTO", "GRADE", "GRAMA", "JOGAR", "LAPIS", "LAVAR",
  "LEITE", "LENCO", "LENTO", "LINHA", "LIVRO", "LIXAR", "LOUSA", "MACIO",
  "MALHA", "MANTA", "MARCA", "MASSA", "MEDIR", "METAL", "MOLDE", "MOTOR",
  "MOVEL", "MUDAR", "NAVIO", "NUVEM", "OLHAR", "PAPEL", "PARAR", "PEDRA",
  "PENTE", "PILHA", "PLACA", "PLANO", "PODER", "PORTA", "POSTE", "PRATO",
  "PREGO", "PROVA", "PULAR", "QUEDA", "RADIO", "REGUA", "ROCHA", "SABER",
  "SACAR", "SALTO", "SINAL", "SUBIR", "TAMPA", "TECER", "TELHA", "TESTE",
  "TOCAR", "TOMAR", "TRAJE", "TRAMA", "TRAVA", "TROCA", "USADO", "VELHO",
  "VENTO", "VERBO", "VERDE", "VESTE", "VIDRO", "VIRAR", "VISOR", "VIVER"
];

const DICIONARIO_BRASILEIRO = new Set([
  ...PALAVRAS_SEGURAS,
  "ABAFA", "ABAFO", "ABALO", "ABANA", "ABONO", "ACABA", "ACASO", "ACENO",
  "ACESA", "ACESO", "ACHOU", "ADEGA", "ADIAR", "ADUBO", "AEREO", "AFETO",
  "AGORA", "AGUDO", "AGUAS", "ALADO", "ALBUM", "ALUNO", "AMADO", "AMIGA",
  "AMIGO", "AMORA", "AMPLO", "ANEIS", "ANEXO", "ANIMO", "ANTES", "AONDE",
  "APAGA", "APAGO", "APOIO", "AREIA", "ARAME", "ARCAR", "ARDER", "ARDOR",
  "ARENA", "ASTRO", "ATIVO", "ATRAS", "BAIXA", "BAIXO", "BALAO", "BALDE",
  "BANHO", "BARCO", "BARRA", "BARRO", "BEIJO", "BOMBA", "BORDA", "BRAVO",
  "BREVE", "BRIGA", "BRISA", "BRUTO", "BUCHA", "BURRO", "CACAU", "CAFES",
  "CALDO", "CALMA", "CALOR", "CAMPO", "CANAL", "CANJA", "CANTO", "CAPAZ",
  "CARNE", "CASAL", "CEDER", "CEGAR", "CENAS", "CENSO", "CERCA", "CERTO",
  "CESTA", "CHAMA", "CHEFE", "CHEIO", "CIRCO", "CLIMA", "COBRA", "COISA",
  "CORPO", "CRIAR", "CRISE", "CRUZA", "CUBOS", "CUIDA", "CURTO", "DEDAL",
  "DESDE", "DEVER", "DOIDO", "ENVIO", "FATOR", "FASES", "FEITO", "FESTA",
  "FINAL", "FIRME", "FOLGA", "FRASE", "FREIO", "FROTA", "FUNDO", "FURAR",
  "GARRA", "GELAR", "GENIO", "GESSO", "GIRAR", "GLOBO", "GOLPE", "GRATO",
  "GRAVE", "GRITO", "GRUPO", "HASTE", "HORAS", "IDADE", "IDEIA", "IGUAL",
  "INDIO", "JOGAR", "JOVEM", "JUIZO", "LACRE", "LADOS", "LAGOA", "LARGO",
  "LAZER", "LEQUE", "LERDO", "LOCAL", "LONGE", "LUCRO", "LUGAR", "LUZES",
  "MACAS", "MAGRO", "MANGA", "MARCO", "MATAR", "MEDIA", "MELAO", "MENOR",
  "MEXER", "MILHO", "MINHA", "MORNO", "MORRO", "MUITO", "MUNDO", "MURAL",
  "NACAO", "NADAR", "NARIZ", "NEGAR", "NEGRO", "NENEM", "NINHO", "NIVEL",
  "NOBRE", "NOITE", "NORMA", "OBRAS", "OBTER", "ONDAS", "ONTEM", "ORDEM",
  "OSSOS", "OUTRO", "OUVIR", "PAGAR", "PALCO", "PARDO", "PARTO", "PASSA",
  "PASTA", "PATIO", "PEDAL", "PEITO", "PEIXE", "PERDA", "PERTO", "PESAR",
  "PESCA", "PINHO", "PISTA", "PLEBE", "PONTA", "PONTO", "POUCO", "PRAIA",
  "PRESO", "QUASE", "QUERO", "QUINA", "RADAR", "RAMAL", "RAZAO", "REGAR",
  "REGRA", "REINO", "RELVA", "RENDA", "RISCO", "RITMO", "RODAR", "RONCO",
  "ROUPA", "RUBRO", "RUGIR", "SABOR", "SAGAZ", "SEARA", "SELAR", "SENSO",
  "SERIO", "SERVE", "SOBRE", "SOBRA", "SOLAR", "SONHO", "SORTE", "SUAVE",
  "TABUA", "TALCO", "TARDE", "TEMPO", "TENIS", "TENSO", "TERMO", "TERRA",
  "TIGRE", "TINTA", "TONTO", "TORRE", "TORTA", "TRAGO", "TREVO", "TRONO",
  "TURMA", "UNIAO", "URUBU", "USINA", "VAGAO", "VALER", "VARAL", "VINHO",
  "VIGIA", "VOLTA", "VOTAR", "ZEBRA", "ZELAR", "ZUMBI"
]);

const TECLADO = [
  ["Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P"],
  ["A", "S", "D", "F", "G", "H", "J", "K", "L"],
  ["ENTER", "Z", "X", "C", "V", "B", "N", "M", "BACKSPACE"]
];

const PRIORIDADE_STATUS = {
  absent: 1,
  present: 2,
  correct: 3
};

const PADROES_BLOQUEIO_API = [
  /\bn\.\s*p\b/,
  /nome proprio/,
  /proper noun/,
  /topon/,
  /geogr/,
  /antrop/,
  /mitol/,
  /apelido/,
  /sobrenome/,
  /cidade/,
  /freguesia/,
  /concelho/,
  /provincia/,
  /povoacao/,
  /municipio/,
  /localidade/,
  /habitante/,
  /natural de/,
  /distrito/,
  /regiao/,
  /vila/,
  /povo/,
  /gentilico/
];

const PADROES_GRAMATICA_PERMITIDA = [
  /\bv\./,
  /\bm\./,
  /\bf\./,
  /\badj\./,
  /subst/
];

let estadoAtual = null;
const cacheValidacaoDicionario = new Map();

const app = document.getElementById("app");

const removerAcentos = (valor) =>
  String(valor || "").normalize("NFD").replace(/[\u0300-\u036f]/g, "");

const normalizarEntrada = (valor) =>
  removerAcentos(valor).toUpperCase().replace(/[^A-Z]/g, "");

const escaparHtml = (valor) =>
  String(valor)
    .replace(/&/g, "&")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&#039;");

const numeroAleatorio = (maximo) => {
  if (window.crypto?.getRandomValues) {
    const valores = new Uint32Array(1);
    window.crypto.getRandomValues(valores);
    return valores[0] % maximo;
  }

  return Math.floor(Math.random() * maximo);
};

const escolherLocal = () => PALAVRAS_SEGURAS[numeroAleatorio(PALAVRAS_SEGURAS.length)];

const embaralhar = (lista) => {
  const copia = [...lista];

  for (let i = copia.length - 1; i > 0; i -= 1) {
    const j = numeroAleatorio(i + 1);
    [copia[i], copia[j]] = [copia[j], copia[i]];
  }

  return copia;
};

const fetchComTimeout = async (url, timeout = CONFIG.timeoutApi) => {
  const controller = new AbortController();
  const timer = window.setTimeout(() => controller.abort(), timeout);

  try {
    const resposta = await fetch(url, {
      cache: "no-store",
      signal: controller.signal
    });

    if (!resposta.ok) throw new Error("Resposta inválida da API.");
    return resposta;
  } finally {
    window.clearTimeout(timer);
  }
};

const buscarDetalhesDicionario = async (palavra) => {
  const resposta = await fetchComTimeout(API_DICIONARIO.verbete(palavra));
  const dados = await resposta.json();
  return Array.isArray(dados) ? dados : [];
};

const verbetePermitido = (palavra, registros) => {
  if (!/^[A-Z]{5}$/.test(palavra) || registros.length === 0) return false;

  const texto = removerAcentos(
    registros.map((registro) => `${registro.word || ""} ${registro.xml || ""}`).join(" ")
  ).toLowerCase();

  if (PADROES_BLOQUEIO_API.some((padrao) => padrao.test(texto))) return false;

  return PADROES_GRAMATICA_PERMITIDA.some((padrao) => padrao.test(texto));
};

const consultarDicionarioApi = async (palavra) => {
  const detalhes = await buscarDetalhesDicionario(palavra.toLowerCase());
  return verbetePermitido(palavra, detalhes);
};

const validarPalavraNoDicionario = async (palavra) => {
  if (!/^[A-Z]{5}$/.test(palavra)) {
    return { aceita: false, fonte: "formato" };
  }

  if (cacheValidacaoDicionario.has(palavra)) {
    return cacheValidacaoDicionario.get(palavra);
  }

  let validadaPelaApi = false;

  try {
    validadaPelaApi = await consultarDicionarioApi(palavra);
  } catch (_) {
    validadaPelaApi = false;
  }

  const resultado = validadaPelaApi
    ? { aceita: true, fonte: "api" }
    : {
        aceita: true,
        fonte: DICIONARIO_BRASILEIRO.has(palavra) ? "lista-pt-br" : "livre"
      };

  cacheValidacaoDicionario.set(palavra, resultado);
  return resultado;
};

const buscarPalavraAleatoriaDaApi = async () => {
  const requisicoes = Array.from({ length: CONFIG.tentativasApi }, async () => {
    const resposta = await fetchComTimeout(API_DICIONARIO.aleatoria);
    const dados = await resposta.json();
    const original = String(dados.word || "").trim();
    const normalizada = normalizarEntrada(original);

    return { original, normalizada };
  });

  const respostas = await Promise.allSettled(requisicoes);
  const candidatas = respostas
    .filter((resposta) => resposta.status === "fulfilled")
    .map((resposta) => resposta.value)
    .filter(({ normalizada }) => /^[A-Z]{5}$/.test(normalizada));

  const unicas = [...new Map(candidatas.map((item) => [item.normalizada, item])).values()];

  for (const candidata of unicas) {
    try {
      const detalhes = await buscarDetalhesDicionario(candidata.original);

      if (verbetePermitido(candidata.normalizada, detalhes)) {
        return {
          palavra: candidata.normalizada,
          origem: "API do dicionário",
          detalhe: "filtrada"
        };
      }
    } catch (_) {
      // Se o detalhamento falhar, seguimos procurando outra candidata.
    }
  }

  return null;
};

const escolherPalavra = async () => {
  const candidatas = embaralhar(PALAVRAS_SEGURAS).slice(0, 12);
  let fallbackLocal = null;

  for (const palavra of candidatas) {
    const validacao = await validarPalavraNoDicionario(palavra);

    if (validacao.fonte === "api") {
      return {
        palavra,
        origem: "API do dicionario",
        detalhe: "validada"
      };
    }

    if (!fallbackLocal && validacao.aceita) {
      fallbackLocal = palavra;
    }
  }

  return {
    palavra: fallbackLocal || escolherLocal(),
    origem: "pt-BR",
    detalhe: "fallback local"
  };
};

const inicializarJogo = ({ palavra, origem, detalhe }) => ({
  palavra,
  origem,
  detalhe,
  tentativas: [],
  tentativaAtual: Array(CONFIG.tamanhoPalavra).fill(""),
  cursor: 0,
  mensagem: "",
  tipoMensagem: "",
  validando: false,
  maxTentativas: CONFIG.maxTentativas
});

const verificarTentativa = (palavra, tentativa) => {
  const resultado = Array(CONFIG.tamanhoPalavra).fill(null);
  const letrasRestantes = palavra.split("");

  tentativa.split("").forEach((letra, indice) => {
    if (palavra[indice] === letra) {
      resultado[indice] = { letra, status: "correct" };
      letrasRestantes[indice] = null;
    }
  });

  tentativa.split("").forEach((letra, indice) => {
    if (resultado[indice]) return;

    const indicePresente = letrasRestantes.indexOf(letra);

    if (indicePresente !== -1) {
      resultado[indice] = { letra, status: "present" };
      letrasRestantes[indicePresente] = null;
      return;
    }

    resultado[indice] = { letra, status: "absent" };
  });

  return resultado;
};

const jogoVencido = (estado) =>
  estado.tentativas.some((tentativa) => tentativa.every((celula) => celula.status === "correct"));

const jogoPerdido = (estado) =>
  estado.tentativas.length >= estado.maxTentativas && !jogoVencido(estado);

const jogoFinalizado = (estado) => jogoVencido(estado) || jogoPerdido(estado);

const letrasCorretas = (tentativas) => {
  const letras = Array(CONFIG.tamanhoPalavra).fill("");

  tentativas.forEach((tentativa) => {
    tentativa.forEach((celula, indice) => {
      if (celula.status === "correct") letras[indice] = celula.letra;
    });
  });

  return letras;
};

const proximaLinhaComAcertos = (tentativas) => letrasCorretas(tentativas);

const primeiroCampoEditavel = (letras) => {
  const vazio = letras.findIndex((letra) => letra === "");
  return vazio === -1 ? 0 : vazio;
};

const classes = (...valores) => valores.filter(Boolean).join(" ");

const calcularPanico = (estado) => {
  if (!estado || jogoVencido(estado)) return 0;
  return Math.min(1, estado.tentativas.length / estado.maxTentativas);
};

const aplicarPanico = (estado) => {
  const nivel = calcularPanico(estado);

  document.body.style.setProperty("--darkness", (nivel * 0.8).toFixed(2));
  document.body.style.setProperty("--panic-opacity", (nivel * 0.68).toFixed(2));
  document.body.style.setProperty("--panic-y", `${Math.round((1 - nivel) * 18)}px`);
  document.body.style.setProperty("--panic-scale", (0.82 + nivel * 0.18).toFixed(2));
  document.body.dataset.panic = nivel > 0 ? "true" : "false";
};

const statusDoTeclado = (tentativas) => {
  const status = {};

  tentativas.flat().forEach((celula) => {
    const atual = status[celula.letra];

    if (!atual || PRIORIDADE_STATUS[celula.status] > PRIORIDADE_STATUS[atual]) {
      status[celula.letra] = celula.status;
    }
  });

  return status;
};

const renderizarGrade = (estado) => {
  const finalizado = jogoFinalizado(estado);
  const acertos = letrasCorretas(estado.tentativas);

  return `
    <div class="board" role="grid" aria-label="Tentativas">
      ${Array.from({ length: estado.maxTentativas }).map((_, linha) => `
        <div class="row" role="row">
          ${Array.from({ length: CONFIG.tamanhoPalavra }).map((_, coluna) => {
            if (linha < estado.tentativas.length) {
              const celula = estado.tentativas[linha][coluna];

              return `
                <div class="${classes("cell", celula.status, "filled")}" role="gridcell">
                  ${escaparHtml(celula.letra)}
                </div>
              `;
            }

            if (linha === estado.tentativas.length && !finalizado) {
              const letra = estado.tentativaAtual[coluna];
              const dicaTravada = acertos[coluna] && acertos[coluna] === letra;

              return `
                <button
                  class="${classes("cell", "editable", letra && "filled", dicaTravada && "locked-hint", estado.cursor === coluna && "selected")}"
                  type="button"
                  data-cell="${coluna}"
                  role="gridcell"
                  aria-label="Letra ${coluna + 1}"
                >${escaparHtml(letra)}</button>
              `;
            }

            return `<div class="cell" role="gridcell"></div>`;
          }).join("")}
        </div>
      `).join("")}
    </div>
  `;
};

const renderizarTeclado = (estado) => {
  const status = statusDoTeclado(estado.tentativas);
  const finalizado = jogoFinalizado(estado);
  const bloqueado = finalizado || estado.validando;

  return `
    <div class="keyboard" aria-label="Teclado virtual">
      ${TECLADO.map((linha) => `
        <div class="key-row">
          ${linha.map((tecla) => {
            const teclaEspecial = tecla === "ENTER" || tecla === "BACKSPACE";
            const texto = tecla === "BACKSPACE" ? "⌫" : tecla;
            const rotulo = tecla === "BACKSPACE" ? "Apagar" : tecla === "ENTER" ? "Enviar" : tecla;
            const statusTecla = status[tecla] || "";

            return `
              <button
                class="${classes("key", teclaEspecial && "wide", statusTecla)}"
                type="button"
                data-key="${tecla}"
                title="${rotulo}"
                ${bloqueado ? "disabled" : ""}
              >${texto}</button>
            `;
          }).join("")}
        </div>
      `).join("")}
    </div>
  `;
};

const mensagemFinal = (estado) => {
  if (jogoVencido(estado)) {
    return {
      texto: "Você venceu!",
      tipo: "win"
    };
  }

  if (jogoPerdido(estado)) {
    return {
      texto: `Você perdeu. A palavra era ${estado.palavra}.`,
      tipo: "loss"
    };
  }

  return {
    texto: estado.validando ? "Consultando API do dicionario..." : estado.mensagem || "&nbsp;",
    tipo: estado.tipoMensagem
  };
};

const renderizar = () => {
  aplicarPanico(estadoAtual);

  const mensagem = mensagemFinal(estadoAtual);

  app.innerHTML = `
    <img class="panic-art" src="panic.png" alt="" aria-hidden="true">
    ${jogoVencido(estadoAtual) ? `
      <img class="victory-art victory-characters" src="victory-characters.png" alt="" aria-hidden="true">
      <img class="victory-art victory-trophy" src="victory-trophy.png" alt="" aria-hidden="true">
    ` : ""}

    <div class="source-bar">
      <span><strong>${estadoAtual.tentativas.length}</strong>/${estadoAtual.maxTentativas}</span>
    </div>

    ${renderizarGrade(estadoAtual)}

    <p class="${classes("message", mensagem.tipo)}">${mensagem.texto}</p>

    ${renderizarTeclado(estadoAtual)}

    <p class="credits">Made by Leonardo Silva, Renato Vasconcelos and Victor Gabriel</p>

    ${jogoFinalizado(estadoAtual) ? `
      <div class="actions">
        <button class="restart" type="button" data-action="reiniciar">Reiniciar</button>
      </div>
    ` : ""}
  `;
};

const atualizarEstado = (parcial) => {
  estadoAtual = { ...estadoAtual, ...parcial };
  renderizar();
};

const inserirLetra = (letra) => {
  if (!estadoAtual || jogoFinalizado(estadoAtual)) return;

  const normalizada = normalizarEntrada(letra);
  if (normalizada.length !== 1) return;

  const letras = [...estadoAtual.tentativaAtual];
  letras[estadoAtual.cursor] = normalizada;

  atualizarEstado({
    tentativaAtual: letras,
    cursor: Math.min(CONFIG.tamanhoPalavra - 1, estadoAtual.cursor + 1),
    mensagem: "",
    tipoMensagem: ""
  });
};

const apagarLetra = () => {
  if (!estadoAtual || jogoFinalizado(estadoAtual)) return;

  const letras = [...estadoAtual.tentativaAtual];
  let cursor = estadoAtual.cursor;

  if (letras[cursor]) {
    letras[cursor] = "";
  } else if (cursor > 0) {
    cursor -= 1;
    letras[cursor] = "";
  }

  atualizarEstado({
    tentativaAtual: letras,
    cursor,
    mensagem: "",
    tipoMensagem: ""
  });
};

const moverCursor = (direcao) => {
  if (!estadoAtual || jogoFinalizado(estadoAtual)) return;

  atualizarEstado({
    cursor: Math.max(0, Math.min(CONFIG.tamanhoPalavra - 1, estadoAtual.cursor + direcao)),
    mensagem: "",
    tipoMensagem: ""
  });
};

const enviarTentativa = async () => {
  if (!estadoAtual || jogoFinalizado(estadoAtual)) return;
  if (estadoAtual.validando) return;

  if (estadoAtual.tentativaAtual.some((letra) => !letra)) {
    atualizarEstado({
      mensagem: "Complete a palavra antes de enviar.",
      tipoMensagem: "error"
    });
    return;
  }

  const tentativa = estadoAtual.tentativaAtual.join("");
  atualizarEstado({
    validando: true,
    mensagem: "",
    tipoMensagem: ""
  });

  const validacao = await validarPalavraNoDicionario(tentativa);

  if (!validacao.aceita) {
    atualizarEstado({
      validando: false,
      mensagem: "Use uma palavra com 5 letras.",
      tipoMensagem: "error"
    });
    return;
  }

  const tentativaVerificada = verificarTentativa(estadoAtual.palavra, tentativa);
  const tentativas = [...estadoAtual.tentativas, tentativaVerificada];
  const proximaLinha = proximaLinhaComAcertos(tentativas);

  atualizarEstado({
    validando: false,
    tentativas,
    tentativaAtual: proximaLinha,
    cursor: primeiroCampoEditavel(proximaLinha),
    mensagem: "",
    tipoMensagem: ""
  });
};

const executarTecla = async (tecla) => {
  if (tecla === "ENTER") {
    await enviarTentativa();
    return;
  }

  if (tecla === "BACKSPACE") {
    apagarLetra();
    return;
  }

  inserirLetra(tecla);
};

app.addEventListener("click", async (event) => {
  const celula = event.target.closest("[data-cell]");
  const tecla = event.target.closest("[data-key]");
  const acao = event.target.closest("[data-action]");

  if (celula) {
    atualizarEstado({
      cursor: Number(celula.dataset.cell),
      mensagem: "",
      tipoMensagem: ""
    });
    return;
  }

  if (tecla) {
    await executarTecla(tecla.dataset.key);
    return;
  }

  if (acao?.dataset.action === "reiniciar") {
    iniciarNovoJogo();
  }
});

document.addEventListener("keydown", async (event) => {
  if (!estadoAtual) return;

  const alvo = event.target instanceof Element ? event.target : null;
  if (alvo?.closest("[data-key], [data-action]")) return;

  if (event.key === "Enter") {
    event.preventDefault();
    await enviarTentativa();
    return;
  }

  if (event.key === "Backspace") {
    event.preventDefault();
    apagarLetra();
    return;
  }

  if (event.key === "ArrowLeft") {
    event.preventDefault();
    moverCursor(-1);
    return;
  }

  if (event.key === "ArrowRight") {
    event.preventDefault();
    moverCursor(1);
    return;
  }

  const letra = normalizarEntrada(event.key);

  if (letra.length === 1) {
    event.preventDefault();
    inserirLetra(letra);
  }
});

const renderizarCarregamento = () => {
  aplicarPanico(null);
  app.innerHTML = `<div class="loading">Buscando palavra...</div>`;
};

async function iniciarNovoJogo() {
  renderizarCarregamento();
  const escolha = await escolherPalavra();
  estadoAtual = inicializarJogo(escolha);
  renderizar();
}

iniciarNovoJogo();