#pragma once

#include <functional>
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <typeinfo>

namespace XCEngine {
namespace Editor {

class EventBus {
public:
    using EventHandler = std::function<void()>;

    template<typename T>
    uint64_t Subscribe(std::function<void(const T&)> handler) {
        static_assert(sizeof(T) > 0, "Event type must be defined");
        size_t typeId = typeid(T).hash_code();
        uint64_t handlerId = m_nextHandlerId++;
        
        auto it = m_handlers.find(typeId);
        if (it == m_handlers.end()) {
            m_handlers[typeId] = std::vector<HandlerEntry>();
        }
        
        HandlerEntry entry;
        entry.id = handlerId;
        entry.handler = [handler](const void* data) {
            handler(*static_cast<const T*>(data));
        };
        m_handlers[typeId].push_back(entry);
        
        return handlerId;
    }

    template<typename T>
    void Unsubscribe(uint64_t handlerId) {
        static_assert(sizeof(T) > 0, "Event type must be defined");
        size_t typeId = typeid(T).hash_code();
        
        auto it = m_handlers.find(typeId);
        if (it != m_handlers.end()) {
            auto& handlers = it->second;
            handlers.erase(
                std::remove_if(handlers.begin(), handlers.end(),
                    [handlerId](const HandlerEntry& entry) { return entry.id == handlerId; }),
                handlers.end()
            );
        }
    }

    template<typename T>
    void Publish(const T& event) {
        static_assert(sizeof(T) > 0, "Event type must be defined");
        size_t typeId = typeid(T).hash_code();
        
        auto it = m_handlers.find(typeId);
        if (it != m_handlers.end()) {
            for (const auto& entry : it->second) {
                entry.handler(&event);
            }
        }
    }

    void Clear() {
        m_handlers.clear();
    }

private:
    struct HandlerEntry {
        uint64_t id;
        std::function<void(const void*)> handler;
    };

    std::unordered_map<size_t, std::vector<HandlerEntry>> m_handlers;
    uint64_t m_nextHandlerId = 0;
};

}
}