/**
 * @fileoverview Validação da solução no jogo Ordenação.
 *
 * Fluxo de validação:
 *   1. Valores preservados — nenhum elemento foi perdido ou duplicado.
 *   2. Ordenação correta — lista em ordem crescente.
 *   3. Assinatura do algoritmo — obrigatória em fases "specific_algorithm".
 *      (delegado ao SortingValidationEngine quando integrado; stub até lá)
 *
 * Todas as mensagens de feedback vêm de configFase.validation.messages,
 * permitindo personalização por fase sem alterar este arquivo.
 */

"use strict";

import { SortingValidationEngine } from "./core/SortingValidationEngine.js";
import { bubbleProfile } from "./profiles/bubbleProfile.js";
import { selectionProfile } from "./profiles/selectionProfile.js";
import { insertionProfile } from "./profiles/insertionProfile.js";
import { shellProfile } from "./profiles/shellProfile.js";
import { countingProfile } from "./profiles/countingProfile.js";

const validationEngine = new SortingValidationEngine({
  bubble: bubbleProfile,
  selection: selectionProfile,
  shell: shellProfile,
  counting: countingProfile,
  insertion: insertionProfile,
});

/**
 * Verifica se todos os valores originais foram preservados (sem perdas nem duplicatas).
 * @param {number[]} listaInicial
 * @param {number[]} listaFinal
 * @returns {boolean}
 */
function verificarValoresPreservados(listaInicial, listaFinal) {
  if (listaInicial.length !== listaFinal.length) return false;
  const orig = [...listaInicial].sort((a, b) => a - b);
  const atual = [...listaFinal].sort((a, b) => a - b);
  return orig.every((v, i) => v === atual[i]);
}

/**
 * Verifica se a lista está em ordem crescente (não-decrescente).
 * @param {number[]} lista
 * @returns {boolean}
 */
function verificarOrdenacao(lista) {
  return lista.every((v, i) => i === 0 || lista[i - 1] <= v);
}

/**
 * Valida a solução do aluno para a fase atual.
 * @param {Array} historico - Histórico de execução do interpretador
 * @param {Object} configFase - Configuração da fase (inclui validation.messages)
 * @param {Object} gameConfig - Configuração geral do jogo
 * @param {Object} sceneRef - Referência à cena Phaser (contém lista atual)
 * @returns {{ sucesso: boolean, mensagem: string }}
 */
export const validationSolution = (historico, configFase, gameConfig, sceneRef) => {
  const lista = sceneRef.lista;
  const listaInicial = configFase.lista;
  const validation = configFase.validation ?? { mode: "result_only", messages: {} };
  const msgs = validation.messages ?? {};

  const fail = (message) => ({
    success: false,
    reason: message,
    // Compatibilidade retroativa com chamadas antigas
    sucesso: false,
    mensagem: message,
  });

  const ok = (message) => ({
    success: true,
    reason: message,
    // Compatibilidade retroativa com chamadas antigas
    sucesso: true,
    mensagem: message,
  });

  // 1) Valores preservados — detecta apagar ou duplicar elementos por engano
  if (!verificarValoresPreservados(listaInicial, lista)) {
    return fail(msgs.valoresAlterados);
  }

  // 2) Ordenação final
  if (!verificarOrdenacao(lista)) {
    return fail(msgs.listaDesordenada);
  }

  // 3) Assinatura do algoritmo (obrigatória em fases specific_algorithm)
  if (validation.mode === "specific_algorithm") {
    const resultado = validationEngine.validate({
      initialList: listaInicial,
      finalList: lista,
      trace: historico,
      expectedAlgorithm: validation.expectedAlgorithm,
      messages: msgs,
    });

    if (!resultado.success) {
      return fail(resultado.message);
    }
  }

  return ok(msgs.success ?? "Correto!");
};
