#include "core/rendering/palette_manager.hpp"

#include <algorithm>
#include <cctype>
#include <string>

#include "core/rendering/surface.hpp"
#include "core/resources/resource_cache.hpp"
#include "game/options.hpp"
#include "utils/utils.hpp"

PaletteManager::PaletteManager(
    std::vector<std::string> raw_paths,
    const std::string& initial_name,
    std::shared_ptr<Surface> game_surface,
    std::shared_ptr<Surface> border_surface,
    OnChangeCallback on_change)
    : palettes_(std::move(raw_paths)),
      game_surface_(std::move(game_surface)),
      border_surface_(std::move(border_surface)),
      on_change_(std::move(on_change)) {
    current_ = findIndex(initial_name);

    // Leer y aplicar paleta inicial directamente desde el archivo
    // (Resource::Cache aún no está disponible en este punto del ciclo de vida)
    const auto initial_palette = readPalFile(palettes_.at(current_));
    game_surface_->setPalette(initial_palette);
    border_surface_->setPalette(initial_palette);

    // Procesar la lista: conservar solo los nombres de archivo (sin ruta)
    processPathList();
}

void PaletteManager::next() {
    if (++current_ == palettes_.size()) {
        current_ = 0;
    }
    apply();
}

void PaletteManager::previous() {
    current_ = (current_ > 0) ? current_ - 1 : palettes_.size() - 1;
    apply();
}

auto PaletteManager::setByName(const std::string& name) -> bool {
    const std::string upper_name = toUpper(name + ".pal");
    for (size_t i = 0; i < palettes_.size(); ++i) {
        if (toUpper(palettes_[i]) == upper_name) {
            current_ = i;
            apply();
            return true;
        }
    }
    return false;
}

auto PaletteManager::getNames() const -> std::vector<std::string> {
    std::vector<std::string> names;
    names.reserve(palettes_.size());
    for (const auto& p : palettes_) {
        std::string name = p;
        const size_t pos = name.find(".pal");
        if (pos != std::string::npos) { name.erase(pos, 4); }
        std::ranges::transform(name, name.begin(), ::toupper);
        names.push_back(std::move(name));
    }
    return names;
}

auto PaletteManager::getCurrentName() const -> std::string {
    std::string name = palettes_.at(current_);
    const size_t pos = name.find(".pal");
    if (pos != std::string::npos) { name.erase(pos, 4); }
    std::ranges::transform(name, name.begin(), ::toupper);
    return name;
}

void PaletteManager::apply() {
    game_surface_->loadPalette(Resource::Cache::get()->getPalette(palettes_.at(current_)));
    border_surface_->loadPalette(Resource::Cache::get()->getPalette(palettes_.at(current_)));

    Options::video.palette = getCurrentName();

    if (on_change_) {
        on_change_();
    }
}

auto PaletteManager::findIndex(const std::string& name) const -> size_t {
    const std::string upper_name = toUpper(name + ".pal");
    for (size_t i = 0; i < palettes_.size(); ++i) {
        if (toUpper(getFileName(palettes_[i])) == upper_name) {
            return i;
        }
    }
    return 0;
}

void PaletteManager::processPathList() {
    for (auto& palette : palettes_) {
        palette = getFileName(palette);
    }
}