/**
 * @fileoverview Utility module for config.js
 * 
 * @module games.mole-mash.config.config
 */

"use strict";

export const gameConfig = {
  gameId: "molemash",
  gameName: "Toupeira",
  type: "blocks",
  icon: "🐹",
  thumbnail: "/images/atividades/programacao/molemash-thumbnail.png",
  descricao:
    "Programe o comportamento de uma toupeira em uma matriz 3x3 usando lógica, variáveis e aleatoriedade.",
  dificuldade: "Intermediário",
  categoria: "Lógica",
  tempoEstimado: "40-60 min",
  conceitos: [
    "Matrizes",
    "Loops Aninhados",
    "Aleatoriedade",
    "Estado e Variáveis",
  ],
  route: "/atividades/programacao/molemash",
  component: "MoleMashGame",
  objectives: [
    "Dominar o sistema de coordenadas 3x3",
    "Utilizar loops para varredura de área",
    "Implementar lógica de memória para evitar repetições",
    "Criar um ciclo de jogo (game loop) infinito",
  ],
  metadata: { lastUpdated: "2026-01-02", version: "1.0.0" },

  mensagens: {
    semMovimento:
      "O código rodou, mas nenhum comando de movimento foi executado. Verifique suas conexões.",
    foraTabuleiro:
      "A toupeira tentou saltar para fora do tabuleiro! Use coordenadas entre 1 e 3.",
    faltamSaltos:
      "A meta era de {requiredHits} saltos, mas a execução parou em {actualHits}. Verifique seu laço de repetição.",
    erroEstrutura:
      "Hmm, parece que falta algo importante no seu código. Revise a estrutura dos blocos e verifique se está usando os comandos necessários para completar o desafio.",
    caminhoErrado:
      "A toupeira não seguiu o caminho exato planejado. Verifique a ordem dos seus blocos de movimento.",
  },

  fases: [
    {
      id: 1,
      showMatrix: true,
      ignoreSequenceOrder: true,
      nome: "Movimento Sequencial",
      descricao:
        "A toupeira deve aparecer na primeira linha, passando pelas colunas 1, 2 e 3.",
      allowedBlocks: ["mover_toupeira", "math_number"],
      timeout: 10,
      /**
       * Verifica se há chamadas moverToupeira com linha 1 e coluna numérica
       */
      validationRegex: /moverToupeira\s*\(\s*1\s*,\s*(\d+)\s*\)\s*;/g,
      expectedSequence: [
        { l: 1, c: 1 },
        { l: 1, c: 2 },
        { l: 1, c: 3 },
      ],
    },
    {
      id: 2,
      showMatrix: true,
      ignoreSequenceOrder: true,
      nome: "Os Quatro Cantos",
      descricao:
        "Faça a toupeira saltar pelos cantos do tabuleiro: (1,1), (1,3), (3,3) e (3,1).",
      allowedBlocks: ["mover_toupeira", "math_number"],
      timeout: 10,
      /**
       * Verifica se há chamadas moverToupeira com ambos os parâmetros numéricos
       */
      validationRegex: /moverToupeira\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)\s*;/g,
      expectedSequence: [
        { l: 1, c: 1 },
        { l: 1, c: 3 },
        { l: 3, c: 3 },
        { l: 3, c: 1 },
      ],
    },
    {
      id: 3,
      showMatrix: true,
      nome: "O Pêndulo Vertical",
      descricao:
        "Use um loop para fazer a toupeira alternar entre o centro (2,2) e o topo (1,2) 5 vezes.",
      allowedBlocks: ["mover_toupeira", "math_number", "controls_repeat_ext"],
      timeout: 15,
      requiredHits: 10, // 5 vezes o par de movimentos
      /**
       * Garante que existe um loop (for/while) com duas chamadas moverToupeira dentro
       */
      validationRegex: /(for|while)[\s\S]*moverToupeira[\s\S]*moverToupeira/,
      mensagens: {
        saltoInsuficiente:
          "Para esta análise, precisamos de exatamente 10 saltos registrados.",
        saltoErrado:
          "No salto {numero}, a toupeira deveria ter ido para o {local}. Verifique sua lógica de repetição.",
      },
    },
    {
      id: 4,
      showMatrix: true,
      nome: "Varredura Completa",
      descricao:
        "Use loops aninhados para percorrer todas as 9 casas do tabuleiro (Linhas 1 a 3 e Colunas 1 a 3).",
      allowedBlocks: [
        "mover_toupeira",
        "math_number",
        "math_arithmetic",
        "controls_repeat_ext",
        "variables_get",
        "variables_set",
      ],
      timeout: 20,
      /**
       * Verifica se há loops aninhados (um loop dentro de outro)
       */
      validationRegex: /(for|while).*\{.*(for|while).*\}/s,
      mensagens: {
        buracosFaltando:
          "A toupeira visitou {visitados} buracos, mas para mapear o jardim completo, ela precisa passar por todos os 9!",
      },
    },
    {
      id: 5,
      nome: "A Toupeira Inquieta",
      descricao:
        "A toupeira está agitada! Faça ela saltar 10 vezes para uma coluna aleatória (1-3), mas sempre permanecendo na Linha 2.",
      allowedBlocks: [
        "mover_toupeira",
        "math_number",
        "math_random_int",
        "controls_repeat_ext",
      ],
      timeout: 15,
      /**
       * Garante loop com moverToupeira(2, mathRandomInt(1,3)) - linha fixa, coluna aleatória
       */
      validationRegex:
        /(for|while)[\s\S]*moverToupeira\s*\(\s*2\s*,\s*\(?mathRandomInt\s*\(\s*1\s*,\s*3\s*\)\)?\s*\)/,
      requiredHits: 10,
      mensagens: {
        linhaErrada:
          "Atenção: nesta fase a toupeira deve se mover apenas horizontalmente na Linha 2.",
        semMovimento:
          "A toupeira ficou parada! Certifique-se de usar o bloco de número aleatório para as colunas.",
      },
    },
    {
      id: 6,
      nome: "Coordenadas na Memória",
      descricao:
        "A toupeira quer organização! Sorteie a linha (1-3) e a coluna (1-3), guarde cada valor em uma variável e só então use essas variáveis para mover a toupeira 20 vezes.",
      allowedBlocks: [
        "mover_toupeira",
        "math_number",
        "math_random_int",
        "controls_repeat_ext",
        "variables_get",
        "variables_set",
      ],
      timeout: 20,
      /**
       * O Regex agora é "intolerante":
       * 1. Busca (\w+) = mathRandomInt(1, 3) -> Grupo 1
       * 2. Busca (\w+) = mathRandomInt(1, 3) -> Grupo 2
       * 3. Busca moverToupeira(\1, \2)
       */
      validationRegex:
        /(for|while)[\s\S]*(\w+)\s*=\s*\(?mathRandomInt\s*\(\s*1\s*,\s*3\s*\)\)?[\s\S]*(\w+)\s*=\s*\(?mathRandomInt\s*\(\s*1\s*,\s*3\s*\)\)?[\s\S]*moverToupeira\s*\(\s*\2\s*,\s*\3\s*\)/,
      requiredHits: 20,
    },
    {
      id: 7,
      nome: "O Centro Proibido",
      descricao:
        'A toupeira jurou nunca mais pisar na Linha 2! Repita 20 vezes: sorteie um "número de sorte" entre 1 e 10 e guarde-o numa variável. Se o número for 5 ou menos, ela vai para a Linha 1. Senão (Else), ela vai para a Linha 3. A coluna é sempre aleatória.',
      allowedBlocks: [
        "mover_toupeira",
        "math_number",
        "math_random_int",
        "controls_repeat_ext",
        "variables_get",
        "variables_set",
        "controls_if",
        "controls_ifelse",
        "logic_compare",
      ],
      timeout: 25,
      /**
       * O Regex garante:
       * 1. Sorteio (1-10) guardado em variável (\w+)
       * 2. O IF usa essa mesma variável (\1)
       * 3. O ELSE está presente
       * 4. moverToupeira é chamado
       */
      validationRegex:
        /(\w+)\s*=\s*\(?mathRandomInt\s*\(\s*1\s*,\s*10\s*\)\)?[\s\S]*if\s*\(\s*\1\s*(<=|<)\s*(5|6)[\s\S]*else\s*\{[\s\S]*moverToupeira/,
      requiredHits: 20,
    },
    {
      id: 8,
      nome: "Memória de Curto Prazo",
      descricao:
        'A toupeira só consegue lembrar em qual LINHA ela estava. A coluna não importa agora! Sorteie uma nova linha: se for igual à "ultima_linha", a toupeira deve ir para a Linha 2 por segurança. Se for diferente, use a linha sorteada. A coluna deve ser sempre sorteada e não precisa de memória. Precisa executar 10 vezes.',
      allowedBlocks: [
        "mover_toupeira",
        "math_number",
        "math_random_int",
        "controls_repeat_ext",
        "variables_get",
        "variables_set",
        "controls_ifelse",
        "logic_compare",
      ],
      requiredHits: 10,
      timeout: 40,
      /**
       * O Regex foca na variável da linha:
       * 1. Sorteio da linha (\w+)
       * 2. Comparação dessa variável com a de memória (\w+)
       * 3. Atualização da memória no final do loop
       */
      validationRegex:
        /(\w+)\s*=\s*\(?mathRandomInt[\s\S]*if\s*\(\s*\1\s*==\s*(\w+)\s*\)[\s\S]*moverToupeira[\s\S]*\2\s*=\s*\1/,
      mensagens: {
        repeticaoLinha:
          "A IA detectou uma repetição de linha! Se a toupeira não estiver na linha de segurança (2), ela deve obrigatoriamente mudar de linha.",
      },
    },
    {
      id: 9,
      nome: "O Algoritmo Perfeito",
      descricao:
        'Mova a toupeira 30 vezes para posições aleatórias entre 1 e 3 sem repetir o buraco anterior: use o bloco "Enquanto" para sortear de novo se a posição for igual à "ultima_linha" e "ultima_coluna", e salve a nova posição na memória no final.',
      allowedBlocks: [
        "mover_toupeira",
        "math_number",
        "math_random_int",
        "controls_repeat_ext",
        "controls_whileUntil",
        "variables_get",
        "variables_set",
        "logic_compare",
        "logic_operation",
      ],
      timeout: 40,
      /**
       * Verifica mathRandomInt(1,3), depois um while com comparação (==|!=) e operador lógico (&&||)
       */
      validationRegex:
        /mathRandomInt\s*\(\s*1\s*,\s*3\s*\)[\s\S]*while\s*\([\s\S]*(==|!=)[\s\S]*(&&|\|\|)/,
    },
    {
      id: 10,
      nome: "O Desafio da IA Final",
      descricao:
        "Crie a sequência final da toupeira: use um loop para repetir 30 vezes sem repetir o buraco anterior, garantindo que se ela sair da Linha 2 o próximo salto seja para a Linha 1 ou 3, e use o bloco Aguardar entre os saltos.",
      allowedBlocks: [
        "mover_toupeira",
        "math_number",
        "math_random_int",
        "variables_get",
        "variables_set",
        "controls_repeat_ext",
        "logic_compare",
        "logic_operation",
        "controls_ifelse",
        "aguardar",
      ],
      requiredHits: 30,
      timeout: 60,
      /**
       * 1. (for|while) -> Procura o início do loop.
       * 2. (?=.*if\s*\([\s\S]*==\s*2\)) -> (Lookahead) Garante que existe o IF da linha 2.
       * 3. (?=.*moverToupeira) -> (Lookahead) Garante que existe o movimento.
       * 4. (?=.*aguardar) -> (Lookahead) Garante que existe a pausa.
       * 5. (?=.*ult_l\s*=\s*) -> (Lookahead) Garante que a memória é atualizada.
       */
      validationRegex:
        /for[\s\S]*mathRandomInt\s*\(\s*1\s*,\s*3\s*\)[\s\S]*if\s*\(\s*ult_l\s*==\s*2\s*\)[\s\S]*moverToupeira[\s\S]*ult_l\s*=\s*l[\s\S]*aguardar/,
      mensagens: {
        mesmoLugar:
          "Falha de imprevisibilidade: a toupeira não pode saltar no mesmo buraco duas vezes seguidas.",
        linhaCentral:
          "Falha de fuga: ao sair da linha central (2), a IA deve mover a toupeira para as extremidades (1 ou 3).",
      },
    },
  ],
};
