/**
 * @fileoverview Configuração do jogo Ordenação.
 * @module games.ordenacao.config.config
 */

export const gameConfig = {
  gameId: "ordenacao",
  gameName: "Ordenação",
  type: "blocks",
  icon: "🔢",
  thumbnail: "/images/atividades/programacao/ordenacao-thumbnail.png",
  descricao: "Ordene os números em ordem crescente usando lógica e estruturas de repetição.",
  dificuldade: "Avançado",
  categoria: "Lógica",
  tempoEstimado: "20-40 min",
  conceitos: [
    "Listas",
    "Comparação de Valores",
    "Estruturas Condicionais",
    "Estruturas de Repetição",
    "Algoritmos de Ordenação",
  ],
  route: "/atividades/programacao/ordenacao",
  component: "OrdenacaoGame",
  objectives: [
    "Entender como comparar elementos em uma lista",
    "Usar estruturas condicionais para tomar decisões",
    "Implementar loops para repetir ações",
    "Aplicar o algoritmo Bubble Sort para ordenar números",
  ],
  metadata: {
    lastUpdated: "2026-05-12",
    version: "1.0.0",
  },
  fases: [
  {
    id: 1,
    nome: "Ordenar 2 Números",
    descricao: "Use uma estrutura condicional para comparar e trocar, se necessário, 2 números.",
    maxBlocks: 10,
    lista: [2, 1],
    validation: {
      mode: "result_only",
      messages: {
        success: "Ótimo! Os dois números estão na ordem certa.",
        listaDesordenada: "Os números ainda não estão em ordem crescente. Dica: compare o primeiro com o segundo e troque se o maior vier antes.",
        valoresAlterados: "Um dos valores foi perdido ou duplicado. Certifique-se de trocar os elementos sem apagar nenhum.",
      },
    },
    allowedBlocks: [
      "ord_lista_comparar",
      "ord_lista_trocar",
      "controls_if",
      "math_number",
    ],
    toolbox: null,
    starterBlock: null,
  },
  {
    id: 2,
    nome: "Ordenar 3 Números",
    descricao: "Use estruturas de repetição e condicionais para ordenar 3 números.",
    maxBlocks: 22,
    lista: [3, 1, 2],
    validation: {
      mode: "result_only",
      messages: {
        success: "Muito bem! Os três números estão em ordem crescente.",
        listaDesordenada: "A lista ainda não está ordenada. Verifique se você está comparando todos os pares necessários e repetindo as comparações o suficiente.",
        valoresAlterados: "Algum valor foi perdido ou duplicado. Troque apenas as posições dos elementos, sem sobrescrever nenhum deles.",
      },
    },
    allowedBlocks: [
      "ord_lista_comparar",
      "ord_lista_trocar",
      "controls_if",
      "ord_for_custom",
      "logic_compare",
      "math_number",
      "math_arithmetic",
      "variables",
    ],
    toolbox: null,
    starterBlock: null,
  },
  {
    id: 3,
    nome: "Bubble Sort",
    descricao: "Compare pares adjacentes e troque quando estiverem fora de ordem, repetindo as passadas até que nenhuma troca seja necessária.",
    maxBlocks: 46,
    lista: [34, 2, 8, 1, 0, 55, 3, 13, 21, 5],
    validation: {
      // A partir da fase 3, a assinatura do algoritmo é SEMPRE validada.
      // O aluno pode escrever sua solução com variações de estilo, mas
      // o padrão comportamental (comparações e trocas adjacentes, passadas
      // com limite decrescente) deve estar presente na trilha de execução.
      mode: "specific_algorithm",
      expectedAlgorithm: "bubble",
      allowEquivalentStrategies: false,
      messages: {
        success: "Excelente! Você implementou o Bubble Sort corretamente.",
        listaDesordenada: "A lista não ficou ordenada. O Bubble Sort precisa comparar todos os pares adjacentes em cada passada até que nenhuma troca seja necessária.",
        valoresAlterados: "Algum valor foi perdido ou duplicado. Verifique se você está trocando os elementos corretamente, sem sobrescrever nenhum deles.",
        algoritmoNaoDetectado: "Não consegui identificar um padrão de ordenação no seu código. O Bubble Sort compara posições vizinhas (j e j+1) e troca quando estão fora de ordem — em repetidas passadas.",
        algoritmoErrado: (detectado) => `A lista ficou ordenada, mas o padrão detectado foi "${detectado}", não Bubble Sort. Lembre-se: o Bubble Sort só troca elementos lado a lado (adjacentes), passada por passada.`,
      },
    },
    allowedBlocks: [
      "ord_lista_tamanho",
      "logic_compare",
      "ord_lista_comparar",
      "ord_lista_trocar",
      "controls_if",
      "controls_while",
      "ord_for_custom",
      "math_number",
      "math_arithmetic",
      "variables",
    ],
    toolbox: null,
    starterBlock: null,
  },
  {
    id: 3,
    nome: "Bubble Sort com Otimização",
    descricao: "Adicione ao Bubble Sort uma variável que encerra as passadas assim que nenhuma troca ocorrer.",
    maxBlocks: 56,
    lista: [34, 2, 8, 1, 0, 55, 3, 13, 21, 5],
    validation: {
      // Variação do Bubble Sort: aceita a versão com flag de parada antecipada.
      // A assinatura continua sendo bubble (comparações e trocas adjacentes),
      // mas a presença da otimização é incentivada, não obrigatória.
      mode: "specific_algorithm",
      expectedAlgorithm: "bubble",
      allowEquivalentStrategies: false,
      messages: {
        success: "Perfeito! Bubble Sort com otimização implementado corretamente. Se você usou uma variável para detectar quando nenhuma troca ocorre, ainda melhor!",
        listaDesordenada: "A lista não ficou ordenada. Verifique se as passadas cobrem todos os pares adjacentes e se o loop externo repete o suficiente.",
        valoresAlterados: "Algum valor foi perdido ou duplicado. A troca de dois elementos exige uma variável auxiliar ou desestruturação — verifique seu bloco de troca.",
        algoritmoNaoDetectado: "Não consegui identificar o padrão do Bubble Sort. Certifique-se de comparar e trocar pares adjacentes (posições j e j+1) em laços aninhados.",
        algoritmoErrado: (detectado) => `A lista ficou ordenada, mas o padrão detectado foi "${detectado}", não Bubble Sort. Nesta fase o Bubble Sort é obrigatório — compare apenas elementos lado a lado e use passadas repetidas.`,
      },
    },
    allowedBlocks: [
      "ord_lista_tamanho",
      "logic_compare",
      "ord_lista_comparar",
      "ord_lista_trocar",
      "logic_boolean",
      "logic_negate",
      "controls_if",
      "controls_while",
      "ord_for_custom",
      "controls_flow_statements",
      "math_number",
      "math_arithmetic",
      "variables",
    ],
    toolbox: null,
    starterBlock: null,
  },  
  {
    id: 5,
    nome: "Selection Sort",
    descricao: "Implemente o Selection Sort: para cada posição, encontre o menor elemento da parte não ordenada e coloque-o no lugar certo.",
    maxBlocks: 50,
    lista: [34, 2, 8, 1, 0, 55, 3, 13, 21, 5],
    validation: {
      mode: "specific_algorithm",
      expectedAlgorithm: "selection",
      allowEquivalentStrategies: false,
      messages: {
        success: "Ótimo! Você implementou o Selection Sort corretamente.",
        listaDesordenada: "A lista não ficou ordenada. No Selection Sort, para cada posição você deve varrer o restante da lista inteira para achar o menor elemento e colocá-lo no lugar certo.",
        valoresAlterados: "Algum valor foi perdido ou duplicado. Verifique se a troca entre a posição atual e o mínimo encontrado está correta.",
        algoritmoNaoDetectado: "Não consegui identificar um padrão de ordenação no seu código. O Selection Sort usa uma varredura interna para encontrar o mínimo a cada passada — sem esse passo, o algoritmo não está completo.",
        algoritmoErrado: (detectado) => `A lista ficou ordenada, mas o padrão detectado foi "${detectado}", não Selection Sort. Lembre-se: o Selection Sort encontra o menor elemento da parte não ordenada e o posiciona com uma única troca por passada.`,
      },
    },
    allowedBlocks: [
      "ord_lista_tamanho",
      "logic_compare",
      "ord_lista_comparar",
      "ord_lista_trocar",
      "controls_if",
      "ord_for_custom",
      "math_number",
      "math_arithmetic",
      "variables",
    ],
    toolbox: null,
    starterBlock: null,
  },
  {
    id: 6,
    nome: "Insertion Sort",
    descricao: "Implemente o Insertion Sort: pegue cada elemento e insira-o na posição correta dentro da parte já ordenada, deslocando os demais.",
    maxBlocks: 60,
    lista: [34, 2, 8, 1, 0, 55, 3, 13, 21, 5],
    validation: {
      mode: "specific_algorithm",
      expectedAlgorithm: "insertion",
      allowEquivalentStrategies: false,
      messages: {
        success: "Muito bem! Você implementou o Insertion Sort corretamente.",
        listaDesordenada: "A lista não ficou ordenada. No Insertion Sort, cada elemento deve ser inserido na posição correta dentro da parte já ordenada, deslocando os elementos maiores para a direita.",
        valoresAlterados: "Algum valor foi perdido ou duplicado. Cuidado ao deslocar elementos — você deve mover, não apagar.",
        algoritmoNaoDetectado: "Não consegui identificar um padrão de ordenação no seu código. O Insertion Sort percorre a lista para trás a partir do elemento atual, deslocando os maiores até encontrar o lugar certo para inserir.",
        algoritmoErrado: (detectado) => `A lista ficou ordenada, mas o padrão detectado foi "${detectado}", não Insertion Sort. Lembre-se: o Insertion Sort retrocede na parte ordenada deslocando elementos, ao invés de fazer varreduras completas ou trocas adjacentes repetidas.`,
      },
    },
    allowedBlocks: [
      "ord_lista_tamanho",
      "logic_compare",
      "logic_operation",
      "ord_lista_ler",
      "ord_lista_escrever",
      "controls_if",
      "controls_while",
      "ord_for_custom",
      "logic_boolean",
      "math_number",
      "math_arithmetic",
      "variables",
    ],
    toolbox: null,
    starterBlock: null,
  },
  {
    id: 7,
    nome: "Shell Sort",
    descricao: "Compare elementos separados por metade do tamanho da lista, reduza esse intervalo pela metade a cada rodada e finalize com uma passada completa adjacente.",
    maxBlocks: 76,
    lista: [34, 2, 8, 1, 0, 55, 3, 13, 21, 5],
    validation: {
      mode: "specific_algorithm",
      expectedAlgorithm: "shell",
      allowEquivalentStrategies: false,
      messages: {
        success: "Parabéns! Shell Sort implementado corretamente.",
        listaDesordenada: "A lista não ficou ordenada. Verifique se o intervalo é reduzido corretamente a cada rodada e se, quando intervalo = 1, o comportamento equivale ao Insertion Sort.",
        valoresAlterados: "Algum valor foi perdido ou duplicado. Verifique o deslocamento de elementos dentro do loop interno — nenhum valor deve ser apagado.",
        algoritmoNaoDetectado: "Não consegui identificar o padrão do Shell Sort. O algoritmo deve usar uma variável de intervalo que começa em tamanho / 2 e é dividida pela metade a cada rodada, realizando inserção com esse intervalo.",
        algoritmoErrado: (detectado) => `A lista ficou ordenada, mas o padrão detectado foi "${detectado}", não Shell Sort. O Shell Sort se distingue pelo uso de um intervalo maior que 1 nas passadas iniciais, reduzindo-o progressivamente.`,
      },
    },
    allowedBlocks: [
      "ord_lista_tamanho",
      "logic_compare",
      "logic_operation",
      "ord_lista_ler",
      "ord_lista_escrever",
      "controls_if",
      "controls_while",
      "ord_for_custom",
      "logic_boolean",
      "math_number",
      "math_arithmetic",
      "math_round",
      "variables",
    ],
    toolbox: null,
    starterBlock: null,
  },
  {
    id: 8,
    nome: "Counting Sort",
    descricao: "Conte quantas vezes cada valor aparece e reconstrua a lista a partir dessas contagens, sem comparar elementos entre si.",
    maxBlocks: 84,
    lista: [34, 2, 8, 1, 0, 55, 3, 13, 21, 5],
    validation: {
      mode: "specific_algorithm",
      expectedAlgorithm: "counting",
      allowEquivalentStrategies: false,
      messages: {
        success: "Excelente! Counting Sort implementado corretamente.",
        listaDesordenada: "A lista não ficou ordenada. Verifique se você está contando todos os valores, acumulando as contagens e reconstruindo a lista na ordem correta.",
        valoresAlterados: "Algum valor foi perdido ou duplicado. A lista de contagem deve registrar exatamente quantas vezes cada valor aparece — sem incrementar ou decrementar errado.",
        algoritmoNaoDetectado: "Não consegui identificar o padrão do Counting Sort. O algoritmo precisa de uma lista auxiliar de contagem e da reconstrução da lista de saída a partir dessas contagens — sem comparar elementos entre si.",
        algoritmoErrado: (detectado) => `A lista ficou ordenada, mas o padrão detectado foi "${detectado}", não Counting Sort. O Counting Sort não compara elementos: ele conta ocorrências e reconstrói a lista a partir dessas frequências.`,
      },
    },
    allowedBlocks: [
      "ord_lista_tamanho",
      "logic_compare",
      "ord_lista_ler",
      "ord_lista_escrever",
      "ord_lista_contagem_escrever",
      "ord_lista_contagem_ler",
      "controls_if",
      "controls_while",
      "ord_for_custom",
      "logic_boolean",
      "math_number",
      "math_arithmetic",
      "variables",
    ],
    toolbox: null,
    starterBlock: null,
  },
]
};
