#pragma once

#include <istream>  // Para istream
#include <string>   // Para string
#include <utility>  // Para pair
#include <vector>   // Para vector

#include "game/entities/enemy.hpp"  // Para Enemy::Data
#include "game/entities/item.hpp"   // Para Item::Data
#include "game/gameplay/room.hpp"   // Para Room::Data

/**
 * @brief Cargador de archivos de habitaciones
 *
 * Responsabilidades:
 * - Cargar archivos de room (.room)
 * - Cargar archivos de tilemap (.tmx)
 * - Parsear datos de room, enemy e item
 * - Validar y convertir valores de configuración
 *
 * Esta clase contiene solo métodos estáticos y no debe instanciarse.
 */
class RoomLoader {
    public:
        // Constructor eliminado para prevenir instanciación
        RoomLoader() = delete;
        ~RoomLoader() = delete;
        RoomLoader(const RoomLoader&) = delete;
        auto operator=(const RoomLoader&) -> RoomLoader& = delete;
        RoomLoader(RoomLoader&&) = delete;
        auto operator=(RoomLoader&&) -> RoomLoader& = delete;

        /**
         * @brief Carga un archivo de room (.room)
         * @param file_path Ruta al archivo de room
         * @param verbose Si true, muestra información de debug
         * @return Room::Data con todos los datos de la habitación
         *
         * Parsea un archivo .room que contiene:
         * - Variables de configuración (name, colors, borders, etc.)
         * - Bloques [enemy]...[/enemy] con datos de enemigos
         * - Bloques [item]...[/item] con datos de items
         */
        static auto loadRoomFile(const std::string& file_path, bool verbose = false) -> Room::Data;

        /**
         * @brief Carga un archivo de tilemap (.tmx)
         * @param file_path Ruta al archivo de tilemap
         * @param verbose Si true, muestra información de debug
         * @return Vector de índices de tiles
         *
         * Parsea un archivo .tmx en formato CSV generado por Tiled
         */
        static auto loadRoomTileFile(const std::string& file_path, bool verbose = false) -> std::vector<int>;

    private:
        /**
         * @brief Asigna valores a una estructura Room::Data
         * @param room Estructura a modificar
         * @param key Nombre de la variable
         * @param value Valor a asignar
         * @return true si la variable fue reconocida y asignada, false si no
         */
        static auto setRoom(Room::Data& room, const std::string& key, const std::string& value) -> bool;

        /**
         * @brief Asigna valores a una estructura Enemy::Data
         * @param enemy Estructura a modificar
         * @param key Nombre de la variable
         * @param value Valor a asignar
         * @return true si la variable fue reconocida y asignada, false si no
         */
        static auto setEnemy(Enemy::Data& enemy, const std::string& key, const std::string& value) -> bool;

        /**
         * @brief Asigna valores a una estructura Item::Data
         * @param item Estructura a modificar
         * @param key Nombre de la variable
         * @param value Valor a asignar
         * @return true si la variable fue reconocida y asignada, false si no
         */
        static auto setItem(Item::Data& item, const std::string& key, const std::string& value) -> bool;

        /**
         * @brief Parsea una línea en formato "key=value"
         * @param line Línea a parsear
         * @return Par {key, value}. Si no hay '=', devuelve {"", ""}
         */
        static auto parseKeyValue(const std::string& line) -> std::pair<std::string, std::string>;

        /**
         * @brief Registra un parámetro desconocido en la consola
         * @param file_name Nombre del archivo siendo parseado
         * @param key Nombre del parámetro desconocido
         * @param verbose Si true, muestra el mensaje
         */
        static void logUnknownParameter(const std::string& file_name, const std::string& key, bool verbose);

        /**
         * @brief Carga un bloque [enemy]...[/enemy] desde un stream
         * @param file Stream del archivo
         * @param file_name Nombre del archivo (para debug)
         * @param verbose Si true, muestra información de debug
         * @return Enemy::Data con los datos del enemigo
         */
        static auto loadEnemyFromFile(std::istream& file, const std::string& file_name, bool verbose) -> Enemy::Data;

        /**
         * @brief Carga un bloque [item]...[/item] desde un stream
         * @param file Stream del archivo
         * @param file_name Nombre del archivo (para debug)
         * @param verbose Si true, muestra información de debug
         * @return Item::Data con los datos del item
         */
        static auto loadItemFromFile(std::istream& file, const std::string& file_name, bool verbose) -> Item::Data;
};