patch_settings.h

#pragma once

#include <string>
#include <vector>
#include <memory>
#include <functional>
#include <Windows.h>
#include "imgui.h"
#include <toml++/toml.hpp>

// UI type for settings
enum class SettingUIType {
    InputBox, // Text input box for exact values
    Slider,   // Slider for dragging values
    Drag      // DragFloat widget (compact inline control)
};

// Callback type for notifying parent patch of setting changes
using SettingChangedCallback = std::function<void()>;

// Base class for all patch settings
class PatchSetting {
  public:
    virtual ~PatchSetting() = default;

    virtual void RenderUI() = 0;
    virtual std::string GetName() const = 0;
    virtual void ResetToDefault() = 0;

    // TOML serialization
    virtual void SaveToToml(toml::table& settingsTable) const = 0;
    virtual bool LoadFromToml(const toml::table& settingsTable) = 0;

    // Set callback for when setting value changes in UI
    void SetChangedCallback(SettingChangedCallback callback) { onChangedCallback = callback; }

  protected:
    SettingChangedCallback onChangedCallback;

    // Call this when value changes in UI
    void NotifyChanged() {
        if (onChangedCallback) { onChangedCallback(); }
    }

    // Helper to write to protected memory
    void WriteToMemory(void* address, const void* data, size_t size) {
        if (!address) return;

        DWORD oldProtect;
        if (VirtualProtect(address, size, PAGE_EXECUTE_READWRITE, &oldProtect)) {
            memcpy(address, data, size);
            VirtualProtect(address, size, oldProtect, &oldProtect);
        }
    }
};

// Float setting with configurable UI type and optional presets
class FloatSetting : public PatchSetting {
  private:
    float* valuePtr;
    std::string name;
    float defaultValue;
    float minValue;
    float maxValue;
    std::string description;
    std::vector<std::pair<std::string, float>> presets;
    SettingUIType uiType;
    void* boundAddress = nullptr;

  public:
    FloatSetting(float* ptr, const std::string& name, float defaultVal, float minVal, float maxVal, const std::string& desc = "", const std::vector<std::pair<std::string, float>>& presets = {},
        SettingUIType uiType = SettingUIType::InputBox)
        : valuePtr(ptr), name(name), defaultValue(defaultVal), minValue(minVal), maxValue(maxVal), description(desc), presets(presets), uiType(uiType) {
        *valuePtr = defaultValue;
    }

    void BindToAddress(void* address) { boundAddress = address; }

    void RenderUI() override {
#ifdef IMGUI_VERSION
        if (!description.empty()) { ImGui::Text("%s", description.c_str()); }

        bool changed = false;

        // Render presets if available
        if (!presets.empty()) {
            ImGui::Text("Presets:");
            float rowHeight = ImGui::GetFrameHeightWithSpacing() + ImGui::GetStyle().ScrollbarSize;
            ImGui::BeginChild(("##presets_" + name).c_str(), ImVec2(0, rowHeight), ImGuiChildFlags_None, ImGuiWindowFlags_HorizontalScrollbar);
            for (const auto& [label, value] : presets) {
                if (ImGui::Button(label.c_str())) {
                    *valuePtr = value;
                    changed = true;
                }
                ImGui::SameLine();
            }
            ImGui::EndChild();
            ImGui::Separator();
            ImGui::Spacing();
        }

        // Render input widget based on UI type
        // Use ##name as widget ID so the technical name doesn't appear as a label (the user-friendly description is already shown above)
        std::string widgetId = "##" + name;
        ImGui::Text("Custom Value:");
        ImGui::SetNextItemWidth(-FLT_MIN);
        switch (uiType) {
        case SettingUIType::Slider:
            if (ImGui::SliderFloat(widgetId.c_str(), valuePtr, minValue, maxValue, "%.5f")) { changed = true; }
            break;

        case SettingUIType::Drag:
            if (ImGui::DragFloat(widgetId.c_str(), valuePtr, (maxValue - minValue) / 100.0f, minValue, maxValue, "%.5f")) { changed = true; }
            break;

        case SettingUIType::InputBox:
        default:
            if (ImGui::InputFloat(widgetId.c_str(), valuePtr, 0.0f, 0.0f, "%.5f")) {
                // Clamp to bounds
                if (*valuePtr < minValue) *valuePtr = minValue;
                if (*valuePtr > maxValue) *valuePtr = maxValue;
                changed = true;
            }
            ImGui::TextDisabled("Range: %g - %g", minValue, maxValue);
            break;
        }

        if (changed) {
            // Auto-reapply to memory if bound
            if (boundAddress) { WriteToMemory(boundAddress, valuePtr, sizeof(float)); }
            // Notify parent patch of change for debounced reinstall
            NotifyChanged();
        }
#endif
    }

    void SaveToToml(toml::table& settingsTable) const override { settingsTable.insert(name, static_cast<double>(*valuePtr)); }

    bool LoadFromToml(const toml::table& settingsTable) override {
        auto val = settingsTable[name].value<double>();
        if (val.has_value()) {
            float newValue = static_cast<float>(val.value());
            if (newValue < minValue) newValue = minValue;
            if (newValue > maxValue) newValue = maxValue;
            *valuePtr = newValue;
            if (boundAddress) { WriteToMemory(boundAddress, valuePtr, sizeof(float)); }
            return true;
        }
        return false;
    }

    std::string GetName() const override { return name; }
    void ResetToDefault() override { *valuePtr = defaultValue; }
};

// Int setting with slider and optional presets
class IntSetting : public PatchSetting {
  private:
    int* valuePtr;
    std::string name;
    int defaultValue;
    int minValue;
    int maxValue;
    std::string description;
    std::vector<std::pair<std::string, int>> presets;
    SettingUIType uiType;
    void* boundAddress = nullptr;

  public:
    IntSetting(
        int* ptr, const std::string& name, int defaultVal, int minVal, int maxVal, const std::string& desc = "", const std::vector<std::pair<std::string, int>>& presets = {}, SettingUIType uiType = SettingUIType::Slider)
        : valuePtr(ptr), name(name), defaultValue(defaultVal), minValue(minVal), maxValue(maxVal), description(desc), presets(presets), uiType(uiType) {
        *valuePtr = defaultValue;
    }

    void BindToAddress(void* address) { boundAddress = address; }

    void RenderUI() override {
#ifdef IMGUI_VERSION
        if (!description.empty()) { ImGui::Text("%s", description.c_str()); }

        bool changed = false;

        // Render presets if available
        if (!presets.empty()) {
            ImGui::Text("Presets:");
            float rowHeight = ImGui::GetFrameHeightWithSpacing() + ImGui::GetStyle().ScrollbarSize;
            ImGui::BeginChild(("##presets_" + name).c_str(), ImVec2(0, rowHeight), ImGuiChildFlags_None, ImGuiWindowFlags_HorizontalScrollbar);
            for (const auto& [label, value] : presets) {
                if (ImGui::Button(label.c_str())) {
                    *valuePtr = value;
                    changed = true;
                }
                ImGui::SameLine();
            }
            ImGui::EndChild();
            ImGui::Separator();
        }

        // Render input based on UI type
        std::string widgetId = "##" + name;
        ImGui::Text("Custom Value:");
        ImGui::SetNextItemWidth(-FLT_MIN);
        switch (uiType) {
        case SettingUIType::Slider:
            if (ImGui::SliderInt(widgetId.c_str(), valuePtr, minValue, maxValue)) { changed = true; }
            break;

        case SettingUIType::Drag:
            if (ImGui::DragInt(widgetId.c_str(), valuePtr, (maxValue - minValue) / 100.0f, minValue, maxValue)) { changed = true; }
            break;

        case SettingUIType::InputBox:
        default:
            if (ImGui::InputInt(widgetId.c_str(), valuePtr)) {
                // Clamp to bounds
                if (*valuePtr < minValue) *valuePtr = minValue;
                if (*valuePtr > maxValue) *valuePtr = maxValue;
                changed = true;
            }
            ImGui::TextDisabled("Range: %d - %d", minValue, maxValue);
            break;
        }

        if (changed) {
            // Auto-reapply to memory if bound
            if (boundAddress) { WriteToMemory(boundAddress, valuePtr, sizeof(int)); }
            // Notify parent patch of change for debounced reinstall
            NotifyChanged();
        }
#endif
    }

    void SaveToToml(toml::table& settingsTable) const override { settingsTable.insert(name, static_cast<int64_t>(*valuePtr)); }

    bool LoadFromToml(const toml::table& settingsTable) override {
        auto val = settingsTable[name].value<int64_t>();
        if (val.has_value()) {
            int newValue = static_cast<int>(val.value());
            if (newValue < minValue) newValue = minValue;
            if (newValue > maxValue) newValue = maxValue;
            *valuePtr = newValue;
            if (boundAddress) { WriteToMemory(boundAddress, valuePtr, sizeof(int)); }
            return true;
        }
        return false;
    }

    std::string GetName() const override { return name; }
    void ResetToDefault() override { *valuePtr = defaultValue; }
};

// Bool setting with checkbox
class BoolSetting : public PatchSetting {
  private:
    bool* valuePtr;
    std::string name;
    bool defaultValue;
    std::string description;
    void* boundAddress = nullptr;

  public:
    BoolSetting(bool* ptr, const std::string& name, bool defaultVal, const std::string& desc = "") : valuePtr(ptr), name(name), defaultValue(defaultVal), description(desc) { *valuePtr = defaultValue; }

    void BindToAddress(void* address) { boundAddress = address; }

    void RenderUI() override {
#ifdef IMGUI_VERSION
        bool changed = false;

        if (ImGui::Checkbox(name.c_str(), valuePtr)) { changed = true; }

        if (!description.empty()) {
            ImGui::SameLine();
            ImGui::TextDisabled("(?)");
            if (ImGui::IsItemHovered()) { ImGui::SetTooltip("%s", description.c_str()); }
        }

        if (changed) {
            // Auto-reapply to memory if bound
            if (boundAddress) { WriteToMemory(boundAddress, valuePtr, sizeof(bool)); }
            // Notify parent patch of change for debounced reinstall
            NotifyChanged();
        }
#endif
    }

    void SaveToToml(toml::table& settingsTable) const override { settingsTable.insert(name, *valuePtr); }

    bool LoadFromToml(const toml::table& settingsTable) override {
        auto val = settingsTable[name].value<bool>();
        if (val.has_value()) {
            *valuePtr = val.value();
            if (boundAddress) { WriteToMemory(boundAddress, valuePtr, sizeof(bool)); }
            return true;
        }
        return false;
    }

    std::string GetName() const override { return name; }
    void ResetToDefault() override { *valuePtr = defaultValue; }
};

// Enum/Choice setting with dropdown
class EnumSetting : public PatchSetting {
  private:
    int* valuePtr;
    std::string name;
    int defaultValue;
    std::string description;
    std::vector<std::string> choices;
    void* boundAddress = nullptr;

  public:
    EnumSetting(int* ptr, const std::string& name, int defaultVal, const std::string& desc, const std::vector<std::string>& choices)
        : valuePtr(ptr), name(name), defaultValue(defaultVal), description(desc), choices(choices) {
        *valuePtr = defaultValue;
    }

    void BindToAddress(void* address) { boundAddress = address; }

    void RenderUI() override {
#ifdef IMGUI_VERSION
        if (!description.empty()) { ImGui::Text("%s", description.c_str()); }

        bool changed = false;

        // Create combo box
        const char* currentChoice = (*valuePtr >= 0 && *valuePtr < static_cast<int>(choices.size())) ? choices[*valuePtr].c_str() : "Invalid";

        std::string widgetId = "##" + name;
        ImGui::SetNextItemWidth(-FLT_MIN);
        if (ImGui::BeginCombo(widgetId.c_str(), currentChoice)) {
            for (size_t i = 0; i < choices.size(); i++) {
                bool isSelected = (*valuePtr == static_cast<int>(i));
                if (ImGui::Selectable(choices[i].c_str(), isSelected)) {
                    *valuePtr = static_cast<int>(i);
                    changed = true;
                }
                if (isSelected) { ImGui::SetItemDefaultFocus(); }
            }
            ImGui::EndCombo();
        }

        if (changed) {
            // Auto-reapply to memory if bound
            if (boundAddress) { WriteToMemory(boundAddress, valuePtr, sizeof(int)); }
            // Notify parent patch of change for debounced reinstall
            NotifyChanged();
        }
#endif
    }

    void SaveToToml(toml::table& settingsTable) const override { settingsTable.insert(name, static_cast<int64_t>(*valuePtr)); }

    bool LoadFromToml(const toml::table& settingsTable) override {
        auto val = settingsTable[name].value<int64_t>();
        if (val.has_value()) {
            int newValue = static_cast<int>(val.value());
            if (newValue >= 0 && newValue < static_cast<int>(choices.size())) {
                *valuePtr = newValue;
                if (boundAddress) { WriteToMemory(boundAddress, valuePtr, sizeof(int)); }
                return true;
            }
        }
        return false;
    }

    std::string GetName() const override { return name; }
    void ResetToDefault() override { *valuePtr = defaultValue; }
};