/**
 * @fileoverview Helpers para criação e manipulação de toolbox Blockly
 * @module blockly.toolbox
 */

import { obterCorCategoria } from "@/blockly/blocklyColors";

/**
 * Cria a estrutura base de uma toolbox vazia.
 * @returns {Object} Estrutura categoryToolbox
 * 
 * @example
 * const toolbox = criarToolboxBase();
 */
export const criarToolboxBase = () => ({
  kind: "categoryToolbox",
  contents: [],
});

/**
 * Cria uma categoria para a toolbox.
 * Se a cor não for fornecida, usa a cor padrão baseada no nome.
 * 
 * @param {string} nome - Nome da categoria
 * @param {number|string} [cor] - Cor HSV ou hex (opcional)
 * @param {string} [cssContainer] - Nome do container CSS (opcional)
 * @returns {Object} Categoria do Blockly
 * 
 * @example
 * // Usa cor padrão (210)
 * const logica = criarCategoria("Lógica", null, "cat_logica");
 * 
 * // Usa cor customizada
 * const custom = criarCategoria("Custom", 180, "cat_custom");
 */
export const criarCategoria = (nome, cor = null, cssContainer = null) => ({
  kind: "category",
  name: nome,
  colour: cor ?? obterCorCategoria(nome),
  contents: [],
  ...(cssContainer && { cssConfig: { container: cssContainer } }),
});

/**
 * Remove categorias vazias da toolbox.
 * 
 * @param {Object} toolbox - Objeto toolbox
 * @returns {Object} Toolbox filtrada
 * 
 * @example
 * const toolbox = criarToolboxBase();
 * // ... adicionar categorias
 * return filtrarCategoriasVazias(toolbox);
 */
export const filtrarCategoriasVazias = (toolbox) => {
  toolbox.contents = toolbox.contents.filter(
    (cat) => cat.contents && cat.contents.length > 0
  );
  return toolbox;
};

/**
 * Adiciona um bloco a uma categoria específica.
 * 
 * @param {Object} toolbox - Objeto toolbox
 * @param {number} categoryIndex - Índice da categoria
 * @param {Object} blockDef - Definição do bloco
 * @returns {void}
 * 
 * @example
 * adicionarBlocoCategoria(toolbox, 0, { kind: "block", type: "robo_if" });
 */
export const adicionarBlocoCategoria = (toolbox, categoryIndex, blockDef) => {
  if (
    categoryIndex !== undefined &&
    toolbox.contents[categoryIndex] &&
    blockDef
  ) {
    if (!toolbox.contents[categoryIndex].contents) {
      toolbox.contents[categoryIndex].contents = [];
    }
    toolbox.contents[categoryIndex].contents.push(blockDef);
  }
};

/**
 * Cria a definição de um bloco para toolbox.
 * 
 * @param {string} tipo - Tipo do bloco
 * @param {Object} [inputs] - Inputs shadow opcionais
 * @returns {Object} Definição do bloco
 * 
 * @example
 * const bloco = criarDefinicaoBloco("math_number");
 * const blocoComInputs = criarDefinicaoBloco("math_random_int", {
 *   FROM: { shadow: { type: "math_number", fields: { NUM: 1 } } }
 * });
 */
export const criarDefinicaoBloco = (tipo, inputs = null) => ({
  kind: "block",
  type: tipo,
  ...(inputs && { inputs }),
});

/**
 * Valida se um bloco existe nas definições.
 * 
 * @param {string} blockId - ID do bloco
 * @param {Object} blockDefinitions - Objeto com definições
 * @returns {Object|null} Definição do bloco ou null
 * 
 * @example
 * const blockDef = validarBloco("robo_if", blockDefinitions);
 * if (blockDef) {
 *   // usar blockDef
 * }
 */
export const validarBloco = (blockId, blockDefinitions) => {
  const blockDef = blockDefinitions[blockId];
  if (!blockDef) {
    console.warn(`[Blockly] Bloco "${blockId}" não encontrado`);
    return null;
  }
  return blockDef;
};

/**
 * Gera toolbox completa a partir de estrutura declarativa.
 * Elimina necessidade de categoryMap e lógica manual de distribuição.
 * 
 * @param {Array} estrutura - Array de {nome, cor?, cssContainer?, blocos[]}
 * @param {Array} allowedBlocks - Blocos permitidos nesta fase
 * @returns {Object} Toolbox do Blockly
 * 
 * @example
 * const toolbox = gerarToolboxDeEstrutura([
 *   { nome: "Lógica", cssContainer: "cat_logica", blocos: ["robo_if", "robo_if_else"] },
 *   { nome: "Movimento", cor: 210, blocos: ["robo_mover"] }
 * ], ["robo_if", "robo_mover"]);
 */
export const gerarToolboxDeEstrutura = (estrutura, allowedBlocks) => {
  const toolbox = criarToolboxBase();
  
  estrutura.forEach(categoria => {
    const cat = criarCategoria(categoria.nome, categoria.cor, categoria.cssContainer);
    
    // Adiciona apenas blocos permitidos desta categoria
    categoria.blocos
      .filter(blockId => allowedBlocks.includes(blockId))
      .forEach(blockId => {
        cat.contents.push(criarDefinicaoBloco(blockId));
      });
    
    // Só adiciona categoria se tiver blocos
    if (cat.contents.length > 0) {
      toolbox.contents.push(cat);
    }
  });
  
  return toolbox;
};