/**
 * @fileoverview Utility module for config.js
 * 
 * @module games.cripto.config.config
 */

export const gameConfig = {
  gameId: "cripto",
  gameName: "Cripto",
  type: "blocks",
  icon: "🔐",
  thumbnail: "/images/atividades/programacao/cripto-thumbnail.png",
  descricao:
    "Aprenda fundamentos de criptografia e segurança cibernética programando blocos para proteger dados e comunicações.",
  dificuldade: "Avançado",
  categoria: "Lógica",
  tempoEstimado: "45-60 min",
  conceitos: [
    "Criptografia",
    "Repetição",
    "Variaveis",
    "Funções",
    "Condicionais",
  ],
  route: "/atividades/programacao/cripto",
  component: "CriptoGame",
  objectives: [
    "Entender os conceitos básicos de criptografia",
    "Implementar algoritmos de criptografia simples",
    "Aplicar lógica de programação para resolver desafios de segurança",
  ],
  metadata: {
    lastUpdated: "2026-02-12",
    version: "1.0.0",
  },

  fases: [
    {
      id: 1,
      nome: "De Letra para Número",
      descricao:
        'Converta cada letra do alfabeto em sua posição numérica (A=0, B=1, C=2...). Primeiro, defina a ENTRADA como o alfabeto completo "ABCDEFGHIJKLMNOPQRSTUVWXYZ". Depois, use um loop "enquanto" para percorrer cada posição e adicionar o número correspondente à SAÍDA. Dica: o CONTADOR já representa a posição da letra!',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "obter_saida",
        "text_length",
        "controls_whileUntil",
        "logic_compare",
        "math_number",
        "math_arithmetic",
        "text",
      ],
      /**
       * Garante que há um loop com incremento do contador para evitar loop infinito
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*\+/,
      expectedInput: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
      expectedOutput: "012345678910111213141516171819202122232425",
    },
    {
      id: 2,
      nome: "De Número para Letra",
      descricao:
        'Reverta o processo! A ENTRADA contém dígitos "0123456789" (cada dígito é a posição de uma letra). Crie a variável "letra" para guardar cada caractere. Use o bloco "no texto obter letra #" para pegar cada dígito, depois busque no ALFABETO a letra correspondente. Por exemplo: dígito "0" → letra "A", dígito "1" → letra "B".',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "text_length",
        "text_charAt",
        "controls_whileUntil",
        "logic_compare",
        "math_number",
        "math_arithmetic",
        "text",
        "alfabeto",
        "definir_letra",
        "obter_letra",
      ],
      /**
       * Garante que há um loop com incremento do contador
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*\+/,
      expectedInput: "0123456789",
      expectedOutput: "ABCDEFGHIJ",
      alfabeto: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
    },
    {
      id: 3,
      nome: "Cifra de César (+3)",
      descricao:
        'Implemente a Cifra de César com deslocamento fixo de +3. Para a ENTRADA "TECNOLOGIA", cada letra deve avançar 3 posições (exemplo: A→D, B→E, C→F). Crie variáveis: "letra" (use "no texto obter letra #"), "posicao" (use "no texto encontrar primeira ocorrência de" para achar a letra no ALFABETO), "nova_posicao" (calcule: (posicao + 3) RESTO DA DIVISÃO POR 26 - use o bloco "resto da divisão de... por..."), e "nova_letra" (pegue do ALFABETO na nova_posicao).',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "text_length",
        "text_charAt",
        "text_indexOf",
        "controls_whileUntil",
        "logic_compare",
        "math_number",
        "math_arithmetic",
        "math_modulo",
        "text",
        "alfabeto",
        "definir_letra",
        "obter_letra",
        "definir_posicao",
        "obter_posicao",
        "definir_nova_posicao",
        "obter_nova_posicao",
        "definir_nova_letra",
        "obter_nova_letra",
      ],
      /**
       * Garante loop com incremento de contador
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*\+/,
      expectedInput: "TECNOLOGIA",
      expectedOutput: "WHFQRORJLD",
      alfabeto: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
      chave: 3,
    },
    {
      id: 4,
      nome: "Cifra de César (-3)",
      descricao:
        'Descriptografe uma mensagem cifrada com deslocamento -3. Para a ENTRADA "GHFRGD", volte 3 posições: G→D, H→E, etc. Crie as mesmas variáveis da fase anterior: "letra", "posicao", "nova_posicao" e "nova_letra". Importante: calcule nova_posicao como (posicao - 3 + 26) RESTO DA DIVISÃO POR 26 (use o bloco "resto da divisão de... por..."). O +26 evita números negativos!',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "text_length",
        "text_charAt",
        "text_indexOf",
        "controls_whileUntil",
        "logic_compare",
        "math_number",
        "math_arithmetic",
        "math_modulo",
        "text",
        "alfabeto",
        "definir_letra",
        "obter_letra",
        "definir_posicao",
        "obter_posicao",
        "definir_nova_posicao",
        "obter_nova_posicao",
        "definir_nova_letra",
        "obter_nova_letra",
      ],
      /**
       * Garante loop com incremento de contador
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*\+/,
      expectedInput: "GHFRGD",
      expectedOutput: "DECODA",
      alfabeto: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
      chave: -3,
    },
    {
      id: 5,
      nome: "Criptografia com Chave Variável",
      descricao:
        'Use uma chave customizada para criptografar! Para a ENTRADA "NUCLEO" com chave 5, desloque cada letra 5 posições. Crie a variável "chave" com valor 5. Depois use as mesmas variáveis das fases anteriores: "letra", "posicao", "nova_posicao" (use o bloco "resto da divisão" para calcular (posicao + chave) % 26) e "nova_letra". Na fórmula, use a variável "chave" em vez do número fixo 3.',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "text_length",
        "text_charAt",
        "text_indexOf",
        "controls_whileUntil",
        "logic_compare",
        "math_number",
        "math_arithmetic",
        "math_modulo",
        "text",
        "alfabeto",
        "definir_letra",
        "obter_letra",
        "definir_posicao",
        "obter_posicao",
        "definir_nova_posicao",
        "obter_nova_posicao",
        "definir_nova_letra",
        "obter_nova_letra",
        "definir_chave",
        "obter_chave",
      ],
      /**
       * Garante loop com incremento de contador
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*\+/,
      expectedInput: "NUCLEO",
      expectedOutput: "SZHQJT",
      alfabeto: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
      chave: 5,
    },
    {
      id: 6,
      nome: "Descriptografia com Chave Variável",
      descricao:
        'Desfaça a criptografia anterior! Para a ENTRADA "SZHQJT" com chave 5, volte 5 posições. Use as mesmas variáveis da Fase 5, mas agora calcule nova_posicao como: (posicao - chave + 26) RESTO DA DIVISÃO POR 26 (use o bloco "resto da divisão de... por..."). Lembre-se: sempre some 26 antes do módulo quando subtrair!',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "text_length",
        "text_charAt",
        "text_indexOf",
        "controls_whileUntil",
        "logic_compare",
        "math_number",
        "math_arithmetic",
        "math_modulo",
        "text",
        "alfabeto",
        "definir_letra",
        "obter_letra",
        "definir_posicao",
        "obter_posicao",
        "definir_nova_posicao",
        "obter_nova_posicao",
        "definir_nova_letra",
        "obter_nova_letra",
        "definir_chave",
        "obter_chave",
      ],
      /**
       * Garante loop com incremento de contador
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*\+/,
      expectedInput: "SZHQJT",
      expectedOutput: "NUCLEO",
      alfabeto: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
      chave: 5,
    },
    {
      id: 7,
      nome: "Código Leetspeak",
      descricao:
        'Use condicionais para substituir letras específicas por números! Para a ENTRADA "SOBERANIA", substitua A→4, E→3, S→5 e I→1, mantendo as outras iguais. Crie a variável "letra" para pegar cada caractere (use "no texto obter letra #"). Depois use blocos SE-SENÃO: se letra = "A" então concatene "4", senão se letra = "E" então concatene "3", senão se letra = "S" então concatene "5", senão se letra = "I" então concatene "1", senão concatene a própria letra.',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "text_length",
        "text_charAt",
        "controls_whileUntil",
        "controls_if",
        "logic_compare",
        "math_number",
        "text",
        "definir_letra",
        "definir_nova_letra",
        "obter_nova_letra",
        "obter_letra",
      ],
      /**
       * Garante loop com incremento de contador
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*\+/,
      expectedInput: "SOBERANIA",
      expectedOutput: "5OB3R4N14",
    },
    {
      id: 8,
      nome: "Mensagem Invertida",
      descricao:
        'Inverta a ordem das letras! Para a ENTRADA "DECODA", o resultado deve ser "ADOCED". Duas abordagens: (1) Inicie CONTADOR com (comprimento - 1) e decremente até 0, OU (2) Crie variável "letra", pegue cada caractere e use o bloco "criar texto com" para juntar: primeira entrada = letra, segunda entrada = SAÍDA atual. Isso coloca cada letra ANTES das anteriores.',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "obter_saida",
        "text_length",
        "text_charAt",
        "text_join",
        "controls_whileUntil",
        "logic_compare",
        "math_number",
        "math_arithmetic",
        "text",
        "definir_letra",
        "obter_letra",
      ],
      /**
       * Garante loop com incremento de contador (ou decremento para inversão)
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*(\+|-)/,
      expectedInput: "DECODA",
      expectedOutput: "ADOCED",
    },
    {
      id: 9,
      nome: "Alfabeto Secreto",
      descricao:
        'Use um alfabeto embaralhado para cifrar! Para a ENTRADA "FENALUTA", use os blocos ALFABETO (normal) e ALFABETO_SECRETO (embaralhado). Crie variáveis: "letra" (pegue com "no texto obter letra #"), "posicao" (use "no texto encontrar" para buscar a letra no ALFABETO normal), e "letra_secreta" (pegue com "no texto obter letra #" na mesma posição do ALFABETO_SECRETO). Exemplo: R está na posição 17 do normal → posição 17 do secreto é A.',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "text_length",
        "text_charAt",
        "text_indexOf",
        "controls_whileUntil",
        "logic_compare",
        "math_number",
        "text",
        "alfabeto",
        "alfabeto_secreto",
        "definir_letra",
        "obter_letra",
        "definir_posicao",
        "obter_posicao",
        "definir_letra_secreta",
        "obter_letra_secreta",
      ],
      /**
       * Garante loop com incremento de contador
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*\+/,
      expectedInput: "FENALUTA",
      expectedOutput: "YTFQSXZQ",
      alfabeto: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
      alfabetoSecreto: "QWERTYUIOPASDFGHJKLZXCVBNM",
    },
    {
      id: 10,
      nome: "Somador de Integridade (Hash)",
      descricao:
        'Para garantir que uma mensagem não foi alterada, usamos um "Hash" — uma assinatura numérica única. Para cada letra da ENTRADA "CRIPTOGRAFIA", descubra sua posição no ALFABETO e atualize a variável "SOMA" usando a fórmula: (SOMA * 31 + posicao). Para manter o número dentro de um limite, use o RESTO DA DIVISÃO por 1000000007. Dentro do loop, chame "definir SAÍDA como SOMA" para ver o hash atualizando letra a letra.',
      timeout: 30,
      allowedBlocks: [
        "obter_contador",
        "definir_contador",
        "definir_entrada",
        "obter_entrada",
        "definir_saida",
        "concatenar_saida",
        "text_length",
        "text_charAt",
        "text_indexOf",
        "controls_whileUntil",
        "logic_compare",
        "math_number",
        "math_arithmetic",
        "math_modulo",
        "text",
        "alfabeto",
        "definir_letra",
        "obter_letra",
        "definir_posicao",
        "obter_posicao",
        "definir_soma",
        "obter_soma",
      ],
      /**
       * Garante loop com incremento de contador
       */
      validationRegex: /(while|for)[\s\S]*definirContador[\s\S]*\+/,
      expectedInput: "CRIPTOGRAFIA",
      expectedOutput: "911701368",
      alfabeto: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
    },
  ],
  mensagens: {
    entradaIncorreta:
      "Entrada incorreta. Você deve definir a ENTRADA como o alfabeto completo.",
    saidaIncorreta:
      "Saída incorreta. Cada letra deve ser convertida para sua posição numérica (A=0, B=1, C=2...). O CONTADOR já representa essa posição!",
    erroGeral: "Algo deu errado durante a execução. Verifique seu código.",
    erroEstrutura:
      'Loop Infinito Detectado!\n\nSeu código não incrementa o CONTADOR dentro do loop WHILE. Isso causará um loop infinito!\n\n💡 Solução:\nAdicione um bloco "definir CONTADOR como (obter CONTADOR + 1)" dentro do loop para que o contador avance a cada iteração.',
    sucessoGenerico: "Parabéns! Você completou o desafio!",
    timeoutExcedido:
      "O tempo de execução foi excedido. Verifique se não há loops infinitos ou se o contador está sendo incrementado corretamente.",
  },
};
