/**
 * @fileoverview Utility module for validators.js
 * 
 * @module games.turtle.validation.validators
 */

import { BaseGameValidator } from "../../../../shared/BaseGameValidator";

/**
 * Validador específico do Turtle Game
 *
 * Diferente de outros jogos, o Turtle valida principalmente através de
 * comparação visual de desenhos, não apenas por sequência de ações.
 */
class TurtleValidator extends BaseGameValidator {
  /**
   * Valida a solução do aluno baseado no desenho produzido
   *
   * @param {Array} history - Histórico de ações (para debug/estatísticas)
   * @param {Object} config - Configuração da fase atual
   * @param {Object} gameConfig - Configuração global do jogo
   * @param {Object} sceneRef - Referência à cena Phaser (para acessar métodos de comparação)
   * @returns {Object} { success: boolean, reason?: string }
   */
  validatePhase(history, config, gameConfig, sceneRef) {
    // 1. Fail-Safe: Verificar se a configuração foi passada
    if (!config || Object.keys(config).length === 0) {
      return this.failure(
        gameConfig?.mensagens?.erroGeral ||
          "Erro técnico: Fase não configurada.",
      );
    }

    // 2. Fase 10 (Desafio Livre) - Sempre sucesso
    // Também aceita fases com requiredDrawingMatch = false
    if (config.id === 10 || config.requiredDrawingMatch === false) {
      return this.success();
    }

    // 3. Verificar se há referência à cena (necessária para comparação visual)
    if (!sceneRef) {
      return this.failure(
        gameConfig?.mensagens?.erroGeral || "Erro técnico na validação.",
      );
    }

    // 4. Fases 1-9: Validar desenho produzido
    return this._validateDrawing(sceneRef, config, gameConfig);
  }

  /**
   * Valida se o desenho do jogador corresponde à solução esperada
   * Método privado chamado apenas por validatePhase() para fases 1-9
   *
   * @param {Object} scene - Referência à cena Phaser
   * @param {Object} config - Configuração da fase
   * @param {Object} gameConfig - Configuração global
   * @returns {Object} { success: boolean, reason?: string }
   * @private
   */
  _validateDrawing(scene, config, gameConfig) {
    try {
      // 1. Verificar se o jogador desenhou algo
      const hasPlayerDrawing = this._hasPlayerDrawing(scene);

      if (!hasPlayerDrawing) {
        return this.failure(
          config?.mensagens?.semDesenho ||
            gameConfig?.mensagens?.semDesenho ||
            "Você não desenhou nada! Certifique-se de usar os comandos move() com a caneta abaixada.",
        );
      }

      // 2. Comparar desenhos usando método da scene (compareDrawings)
      // O método scene.compareDrawings() acessa validationGraphics e playerGraphics
      // que já foram preparados no onBeforeRun() através de generateValidationDrawing()
      const drawingsMatch = scene.compareDrawings();

      if (!drawingsMatch) {
        return this.failure(
          config?.mensagens?.desenhoNaoConfere ||
            gameConfig?.mensagens?.desenhoNaoConfere ||
            "O desenho não está correto. Verifique a forma, posição e cores.",
        );
      }

      // 3. Sucesso - desenho corresponde à solução!
      return this.success();
    } catch (error) {
      return this.failure(
        gameConfig?.mensagens?.erroGeral ||
          "Erro inesperado durante a validação.",
      );
    }
  }

  /**
   * Verifica se o jogador produziu algum desenho
   * Checa se o commandBuffer do playerGraphics possui comandos de desenho
   *
   * @param {Object} scene - Referência à cena Phaser
   * @returns {boolean} true se há desenho, false caso contrário
   * @private
   */
  _hasPlayerDrawing(scene) {
    return (
      scene.playerGraphics &&
      scene.playerGraphics.commandBuffer &&
      scene.playerGraphics.commandBuffer.length > 0
    );
  }

  // --- Métodos Herdados da Base ---
  // success() - retorna { success: true }
  // failure(reason) - retorna { success: false, reason }
}

// Singleton para reutilização
const validatorInstance = new TurtleValidator();

/**
 * Função exportada para validação de soluções do Turtle Game
 *
 * @param {Array} history - Histórico de ações
 * @param {Object} config - Configuração da fase
 * @param {Object} gameConfig - Configuração global
 * @param {Object} sceneRef - Referência à cena (necessário para comparação visual)
 * @returns {Object} { success: boolean, reason?: string }
 */
export const validateSolution = (history, config, gameConfig, sceneRef) => {
  return validatorInstance.validatePhase(history, config, gameConfig, sceneRef);
};
