decoda/app/src/config/gameRegistry.js

/**
 * @fileoverview Registro centralizado de todos os jogos da plataforma.
 * 
 * Carrega configurações de todos os 5 jogos educacionais (Autômato, Criptografia, Toupeira,
 * Semáforo, Tartaruga) e fornece utilities para buscá-los, filtrá-los e gerenciá-los.
 * Este é o ponto único de verdade para descoberta e acesso a jogos.
 *
 * @module config/gameRegistry
 * @requires ../atividades/programacao/_/config/config.js
 */ 

import { gameConfig as ASPIRADOR_GAME_CONFIG } from "../atividades/programacao/aspirador/config/config.js";
import { gameConfig as AUTOMATO_GAME_CONFIG } from "../atividades/programacao/automato/config/config.js";
import { gameConfig as CRIPTO_GAME_CONFIG } from "../atividades/programacao/cripto/config/config.js";
import { gameConfig as EXEMPLO_GAME_CONFIG } from "../atividades/programacao/exemplo/config/config.js";
import { gameConfig as MOLE_MASH_GAME_CONFIG } from "../atividades/programacao/mole-mash/config/config.js";
import { gameConfig as ORDERNACAO_GAME_CONFIG } from "../atividades/programacao/ordenacao/config/config.js";
import { gameConfig as PADROES_GAME_CONFIG } from "../atividades/programacao/padroes/config/config.js";
import { gameConfig as PUZZLE_GAME_CONFIG } from "../atividades/programacao/puzzle/config/config.js";
import { gameConfig as SEMAFORO_GAME_CONFIG } from "../atividades/programacao/semaforo/config/config.js";
import { gameConfig as TURTLE_GAME_CONFIG } from "../atividades/programacao/turtle/config/config.js";

import { gameCategory as GAME_CATEGORIES } from "./categories.js";

/**
 * Registro centralizado de todos os 5 jogos da plataforma.
 * Chave é o ID do jogo (usado em URLs e rotas).
 *
 * @type {Object<string, GameConfig>}
 * @constant GAMES_REGISTRY
 * 
 * @property {GameConfig} aspirador - Jogo Aspirador (movimentação em grid)
 * @property {GameConfig} automato - Jogo Autômato (movimentação em grid)
 * @property {GameConfig} cripto - Jogo Criptografia (cifras)
 * @property {GameConfig} molemash - Jogo Toupeira (reatividade)
 * @property {GameConfig} ordenacao - Jogo Ordenação (algoritmos de ordenação)
 * @property {GameConfig} puzzle - Jogo Quebra Cabeças (propriedades com combos)
 * @property {GameConfig} semaforo - Jogo Semáforo (lógica condicional)
 * @property {GameConfig} turtle - Jogo Tartaruga (desenho em canvas)
 */
export const GAMES_REGISTRY = {
  aspirador: ASPIRADOR_GAME_CONFIG,
  automato: AUTOMATO_GAME_CONFIG,
  cripto: CRIPTO_GAME_CONFIG,
  exemplo: EXEMPLO_GAME_CONFIG,
  molemash: MOLE_MASH_GAME_CONFIG,
  ordenacao: ORDERNACAO_GAME_CONFIG,
  padroes: PADROES_GAME_CONFIG,
  puzzle: PUZZLE_GAME_CONFIG,
  semaforo: SEMAFORO_GAME_CONFIG,
  turtle: TURTLE_GAME_CONFIG,
};

/**
 * Utilitários para buscar, filtrar e gerenciar jogos do registry.
 * Fornece interface única para acesso aos jogos com múltiplas estratégias de busca.
 *
 * @namespace gameRegistryUtils
 * @type {Object}
 */
export const gameRegistryUtils = {
  getActiveGames() {
    return Object.values(GAMES_REGISTRY);
  },

  getFeaturedGames() {
    return Object.values(GAMES_REGISTRY);
  },

  getGamesByCategory(categoria) {
    return Object.values(GAMES_REGISTRY).filter(
      (game) => game.categoria === categoria,
    );
  },

  getGamesByDifficulty(dificuldade) {
    return Object.values(GAMES_REGISTRY).filter(
      (game) => game.dificuldade === dificuldade,
    );
  },

  getGameById(id) {
    return GAMES_REGISTRY[id];
  },

  searchGames(query) {
    const searchTerm = query.toLowerCase();
    return Object.values(GAMES_REGISTRY).filter(
      (game) =>
        game.gameName.toLowerCase().includes(searchTerm) ||
        game.descricao.toLowerCase().includes(searchTerm) ||
        game.conceitos.some((concept) =>
          concept.toLowerCase().includes(searchTerm),
        ),
    );
  },

  getCategoriesWithCounts() {
    const categories = {};
    Object.values(GAMES_REGISTRY).forEach((game) => {
      if (!categories[game.categoria]) {
        categories[game.categoria] = {
          ...GAME_CATEGORIES[game.categoria],
          games: [],
        };
      }
      categories[game.categoria].games.push(game);
    });
    return categories;
  },

  registerGame(gameConfig) {
    if (!gameConfig.id && !gameConfig.gameId) {
      throw new Error("Game must have an ID or gameId");
    }
    const id = gameConfig.gameId || gameConfig.id;
    GAMES_REGISTRY[id] = gameConfig;
  },

  unregisterGame(gameId) {
    delete GAMES_REGISTRY[gameId];
  },

  updateGame(gameId, updates) {
    if (GAMES_REGISTRY[gameId]) {
      GAMES_REGISTRY[gameId] = { ...GAMES_REGISTRY[gameId], ...updates };
    }
  },
};

export const getGameConfig = (gameId) => {
  const config = GAMES_REGISTRY[gameId];
  if (!config) {
    throw new Error(`Jogo '${gameId}' não encontrado no registry`);
  }
  return config;
};


/**
 * Retorna a lista de todas as configurações de jogos registradas.
 * @returns {Array<GameConfig>} Array com todas as configurações de jogos
 */
export const getAllGames = () => {
  return Object.values(GAMES_REGISTRY);
};


/**
 * Registra um novo jogo no registry global.
 * Se `gameConfig.gameId` ou `gameConfig.id` não existir, lança erro.
 * @param {GameConfig} gameConfig - Configuração do jogo a ser registrada
 * @returns {GameConfig} A configuração registrada
 * @throws {Error} Se `gameId` não for provido
 */
export const registerGame = (gameConfig) => {
  if (!gameConfig.gameId) {
    throw new Error("gameId é obrigatório para registrar um jogo");
  }

  const id = gameConfig.gameId || gameConfig.id;
  GAMES_REGISTRY[id] = gameConfig;
  return gameConfig;
};

export const GAME_REGISTRY = GAMES_REGISTRY;

export default GAMES_REGISTRY;