#include "MetaCoreRuntimeInput/MetaCoreRuntimeInput.h"

#include "MetaCorePlatform/MetaCoreInput.h"
#include <nlohmann/json.hpp>

#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <unordered_map>
#include <unordered_set>

namespace MetaCore {

class MetaCoreRuntimeInput::Impl {
public:
    MetaCoreInputMapDocument Map{};
    std::unordered_map<std::string, MetaCoreInputActionState> Actions{};
    std::unordered_map<std::string, float> Axes{};
    std::unordered_map<std::string, bool> Contexts{};
    std::vector<std::string> ContextStack{};
    std::unordered_map<std::string, std::string> Overrides{};
    std::unordered_map<std::uint64_t, ActionCallback> Subscribers{};
    std::vector<std::string> Warnings{};
    std::uint64_t NextSubscription = 1;

    void Emit(std::string id, MetaCoreInputActionPhase phase) const {
        MetaCoreInputActionEvent event{std::move(id), phase};
        for (const auto& [_, callback] : Subscribers) if (callback) callback(event);
    }
};

MetaCoreRuntimeInput::MetaCoreRuntimeInput() : Impl_(std::make_unique<Impl>()) {}
MetaCoreRuntimeInput::~MetaCoreRuntimeInput() = default;
void MetaCoreRuntimeInput::SetInputMap(MetaCoreInputMapDocument document) {
    Impl_->Map = std::move(document); Impl_->Actions.clear(); Impl_->Axes.clear(); Impl_->Contexts.clear();
    for (const auto& action : Impl_->Map.Actions) Impl_->Actions[action.Id] = {};
    for (const auto& axis : Impl_->Map.Axes) Impl_->Axes[axis.Id] = 0.0F;
    for (const auto& context : Impl_->Map.Contexts) Impl_->Contexts[context.Id] = context.EnabledByDefault;
}
const MetaCoreInputMapDocument& MetaCoreRuntimeInput::GetInputMap() const { return Impl_->Map; }

void MetaCoreRuntimeInput::Update(const MetaCoreInput& input, const MetaCoreInputConsumption& consumed) {
    if (!input.IsWindowFocused()) { CancelAll(); return; }
    std::unordered_map<std::string, bool> nextActions;
    std::unordered_map<std::string, float> nextAxes;
    std::unordered_set<std::string> consumedPaths;
    std::vector<const MetaCoreInputContextDefinition*> contexts;
    for (const auto& context : Impl_->Map.Contexts) if (Impl_->Contexts[context.Id]) contexts.push_back(&context);
    std::stable_sort(contexts.begin(), contexts.end(), [](auto* a, auto* b) { return a->Priority > b->Priority; });
    const auto bindingById = [&](std::string_view id) -> const MetaCoreInputBindingDefinition* {
        const auto it = std::find_if(Impl_->Map.Bindings.begin(), Impl_->Map.Bindings.end(), [&](const auto& value) { return value.BindingId == id; });
        return it == Impl_->Map.Bindings.end() ? nullptr : &*it;
    };
    for (const auto* context : contexts) {
        for (const auto& bindingId : context->BindingIds) {
            const auto* binding = bindingById(bindingId); if (!binding) continue;
            const auto overrideIt = Impl_->Overrides.find(binding->BindingId);
            const std::string& path = overrideIt == Impl_->Overrides.end() ? binding->ControlPath : overrideIt->second;
            if (consumedPaths.contains(path)) continue;
            if ((consumed.Keyboard && path.starts_with("<Keyboard>")) || (consumed.Mouse && path.starts_with("<Mouse>")) || (consumed.Gamepad && path.starts_with("<Gamepad>"))) continue;
            bool modifiersHeld = true;
            for (const auto& modifier : binding->Modifiers) modifiersHeld = modifiersHeld && std::abs(input.GetControlValue(modifier)) > 0.5F;
            const float value = modifiersHeld ? input.GetControlValue(path) * binding->Scale : 0.0F;
            if (binding->Target == MetaCoreInputBindingTarget::Action) nextActions[binding->TargetId] = nextActions[binding->TargetId] || std::abs(value) > 0.5F;
            else nextAxes[binding->TargetId] += value;
            if (context->ConsumeLowerPriority && std::abs(value) > 0.0001F) consumedPaths.insert(path);
        }
    }
    for (const auto& definition : Impl_->Map.Actions) {
        auto& state = Impl_->Actions[definition.Id]; const bool wasHeld = state.Held; const bool held = nextActions[definition.Id];
        state = {!wasHeld && held, held, wasHeld && !held};
        if (state.Pressed) Impl_->Emit(definition.Id, MetaCoreInputActionPhase::Started);
        if (held) Impl_->Emit(definition.Id, MetaCoreInputActionPhase::Performed);
        if (state.Released) Impl_->Emit(definition.Id, MetaCoreInputActionPhase::Canceled);
    }
    for (const auto& definition : Impl_->Map.Axes) {
        float value = std::clamp(nextAxes[definition.Id], -1.0F, 1.0F);
        if (std::abs(value) < definition.DeadZone) value = 0.0F;
        Impl_->Axes[definition.Id] = std::clamp(value * definition.Sensitivity, definition.Minimum, definition.Maximum);
    }
}

void MetaCoreRuntimeInput::CancelAll() {
    for (auto& [id, state] : Impl_->Actions) { if (state.Held) Impl_->Emit(id, MetaCoreInputActionPhase::Canceled); state = {false, false, state.Held}; }
    for (auto& [_, value] : Impl_->Axes) value = 0.0F;
}
MetaCoreInputActionState MetaCoreRuntimeInput::GetAction(std::string_view id) const { const auto it = Impl_->Actions.find(std::string(id)); return it == Impl_->Actions.end() ? MetaCoreInputActionState{} : it->second; }
float MetaCoreRuntimeInput::GetAxis(std::string_view id) const { const auto it = Impl_->Axes.find(std::string(id)); return it == Impl_->Axes.end() ? 0.0F : it->second; }
bool MetaCoreRuntimeInput::SetContextEnabled(std::string_view id, bool enabled) { auto it = Impl_->Contexts.find(std::string(id)); if (it == Impl_->Contexts.end()) return false; it->second = enabled; return true; }
bool MetaCoreRuntimeInput::PushContext(std::string_view id) { if (!SetContextEnabled(id, true)) return false; Impl_->ContextStack.emplace_back(id); return true; }
bool MetaCoreRuntimeInput::PopContext(std::string_view id) { auto it = std::find(Impl_->ContextStack.rbegin(), Impl_->ContextStack.rend(), id); if (it == Impl_->ContextStack.rend()) return false; Impl_->ContextStack.erase(std::next(it).base()); return SetContextEnabled(id, false); }
std::uint64_t MetaCoreRuntimeInput::Subscribe(ActionCallback callback) { const auto id = Impl_->NextSubscription++; Impl_->Subscribers.emplace(id, std::move(callback)); return id; }
void MetaCoreRuntimeInput::Unsubscribe(std::uint64_t id) { Impl_->Subscribers.erase(id); }
bool MetaCoreRuntimeInput::Rebind(std::string_view id, std::string path) { if (path.empty() || path.front() != '<') return false; const auto it = std::find_if(Impl_->Map.Bindings.begin(), Impl_->Map.Bindings.end(), [&](const auto& b){ return b.BindingId == id; }); if (it == Impl_->Map.Bindings.end()) return false; Impl_->Overrides[std::string(id)] = std::move(path); return true; }
bool MetaCoreRuntimeInput::ResetBinding(std::string_view id) { return Impl_->Overrides.erase(std::string(id)) > 0; }
void MetaCoreRuntimeInput::ResetAllBindings() { Impl_->Overrides.clear(); }
bool MetaCoreRuntimeInput::LoadOverrides(const std::filesystem::path& path) {
    Impl_->Warnings.clear(); std::ifstream input(path); if (!input) return true;
    try { nlohmann::json json; input >> json; for (auto it = json.begin(); it != json.end(); ++it) if (!Rebind(it.key(), it.value().get<std::string>())) Impl_->Warnings.push_back("忽略无效输入覆盖: " + it.key()); }
    catch (const std::exception& error) { Impl_->Warnings.push_back(std::string("输入覆盖损坏，已使用默认绑定: ") + error.what()); Impl_->Overrides.clear(); return false; }
    return true;
}
bool MetaCoreRuntimeInput::SaveOverrides(const std::filesystem::path& path) const {
    std::error_code error; std::filesystem::create_directories(path.parent_path(), error); const auto temporary = path.string() + ".tmp";
    nlohmann::json json = Impl_->Overrides; { std::ofstream output(temporary, std::ios::trunc); if (!output) return false; output << json.dump(2); if (!output.good()) return false; }
    std::filesystem::rename(temporary, path, error); if (!error) return true;
    std::filesystem::remove(path, error); error.clear(); std::filesystem::rename(temporary, path, error); return !error;
}
const std::vector<std::string>& MetaCoreRuntimeInput::GetWarnings() const { return Impl_->Warnings; }

std::filesystem::path MetaCoreGetInputOverridePath(std::string_view projectName) {
    std::string safe(projectName); for (char& value : safe) if (!std::isalnum(static_cast<unsigned char>(value)) && value != '-' && value != '_') value = '_';
#if defined(_WIN32)
    const char* root = std::getenv("LOCALAPPDATA");
    return std::filesystem::path(root ? root : ".") / "MetaCore" / safe / "InputBindings.json";
#else
    const char* xdg = std::getenv("XDG_DATA_HOME"); const char* home = std::getenv("HOME");
    const std::filesystem::path root = xdg ? xdg : (home ? std::filesystem::path(home) / ".local" / "share" : std::filesystem::path("."));
    return root / "MetaCore" / safe / "InputBindings.json";
#endif
}

} // namespace MetaCore