/**
 * @fileoverview Hook para gerenciar o estado e handlers dos modais do jogo.
 *
 * Encapsula: abertura/fechamento dos modais de fases, sucesso e falha;
 * contagem de blocos restantes; callback de mudança de workspace.
 *
 * @module hooks.useGameModals
 */

import { useState, useCallback, useEffect } from "react";
import { GAME_STATES } from "../contexts/GameStateContext";

/**
 * Hook que gerencia estado e handlers dos modais do jogo.
 *
 * @param {Object}   options
 * @param {string}   options.executionState      - Estado atual de execução (GAME_STATES)
 * @param {number}   options.currentPhase        - Número da fase atual
 * @param {Object}   options.phaseConfig         - Configuração da fase atual
 * @param {Object}   options.gameConfig          - Configuração completa do jogo
 * @param {Function} options.setCurrentPhase     - Setter da fase atual
 * @param {Function} options.restart             - Reinicia estado de execução
 * @param {Function} options.setOnWorkspaceChange - Registra callback de workspace
 * @param {boolean}  options.usaModalFalha       - Se deve abrir modal ao falhar
 *
 * @returns {{
 *   modalFasesAberto: boolean,
 *   setModalFasesAberto: Function,
 *   modalSucessoAberto: boolean,
 *   modalFalhaAberto: boolean,
 *   blocksRemainingCount: number|null,
 *   handleProximaFase: Function,
 *   handleFecharModalSucesso: Function,
 *   handleFecharModalFalha: Function,
 *   handleTentarNovamente: Function,
 * }}
 */
export function useGameModals({
  executionState,
  currentPhase,
  phaseConfig,
  gameConfig,
  setCurrentPhase,
  restart,
  setOnWorkspaceChange,
  usaModalFalha,
}) {
  const [modalFasesAberto, setModalFasesAberto] = useState(false);
  const [modalSucessoAberto, setModalSucessoAberto] = useState(false);
  const [modalFalhaAberto, setModalFalhaAberto] = useState(false);
  const [blocksRemainingCount, setBlocksRemainingCount] = useState(null);

  // Atualiza contagem de blocos restantes ao mudar a workspace.
  const handleWorkspaceChange = useCallback(
    (blockCount) => {
      if (phaseConfig.maxBlocks === Infinity) {
        setBlocksRemainingCount(null);
        return;
      }
      const blocosUsados = typeof blockCount === "number" ? blockCount : 0;
      const blocosRestantes = phaseConfig.maxBlocks - blocosUsados;
      setBlocksRemainingCount(blocosRestantes);
    },
    [phaseConfig.maxBlocks],
  );

  // Registra e limpa o callback de mudança de workspace.
  useEffect(() => {
    if (setOnWorkspaceChange) {
      setOnWorkspaceChange(handleWorkspaceChange);
    }
    return () => {
      if (setOnWorkspaceChange) {
        setOnWorkspaceChange(null);
      }
    };
  }, [setOnWorkspaceChange, handleWorkspaceChange]);

  // Abre modal de sucesso ou falha conforme o estado de execução.
  useEffect(() => {
    if (executionState === GAME_STATES.SUCESSO) {
      setModalSucessoAberto(true);
    }
    if (executionState === GAME_STATES.FALHA && usaModalFalha) {
      setModalFalhaAberto(true);
    }
  }, [executionState, usaModalFalha]);

  const handleProximaFase = useCallback(() => {
    const proximaFase = currentPhase + 1;
    if (proximaFase <= gameConfig.fases.length) {
      setCurrentPhase(proximaFase);
    }
    setModalSucessoAberto(false);
    restart();
  }, [currentPhase, gameConfig.fases.length, setCurrentPhase, restart]);

  const handleFecharModalSucesso = useCallback(() => {
    setModalSucessoAberto(false);
  }, []);

  const handleFecharModalFalha = useCallback(() => {
    setModalFalhaAberto(false);
  }, []);

  const handleTentarNovamente = useCallback(() => {
    setModalFalhaAberto(false);
    restart();
  }, [restart]);

  return {
    modalFasesAberto,
    setModalFasesAberto,
    modalSucessoAberto,
    modalFalhaAberto,
    blocksRemainingCount,
    handleProximaFase,
    handleFecharModalSucesso,
    handleFecharModalFalha,
    handleTentarNovamente,
  };
}
