#define NOMINMAX
#include <EntropyCore.h>

#include <chrono>
#include <optional>
#include <thread>
#include <vector>

using namespace EntropyEngine::Core;
using namespace EntropyEngine::Core::Logging;
using namespace std::chrono_literals;

// A simple EntropyObject-derived type
class GameObject : public EntropyObject
{
    ENTROPY_CLASS_BODY(GameObject)
    std::string _name;

public:
    explicit GameObject(std::string name) : _name(std::move(name)) {}
    std::string toString() const override {
        if (hasHandle()) {
            return std::format("GameObject('{}')#({:p}, idx={}, gen={})", _name, handleOwner(), handleIndex(),
                               handleGeneration());
        } else {
            return std::format("GameObject('{}')@{:p}", _name, static_cast<const void*>(this));
        }
    }
    const std::string& name() const {
        return _name;
    }
};

// Tag type for typed handle
struct GameObjectTag
{
};

// A tiny owner/registry that stamps handle identity onto objects
class GameObjectPool
{
public:
    using Handle = TypeSystem::TypedHandle<GameObjectTag, GameObjectPool>;

private:
    struct Slot
    {
        RefObject<GameObject> obj;  // owning reference
        uint32_t generation = 1;    // start at 1 so {0,0} remains invalid
        bool occupied = false;
    };

    std::vector<Slot> _slots;

public:
    explicit GameObjectPool(size_t capacity = 16) : _slots(capacity) {}

    // Insert returns a typed handle; stamps identity on the object
    Handle insert(RefObject<GameObject> obj) {
        // Find a free slot
        uint32_t index = 0;
        for (; index < _slots.size(); ++index) {
            if (!_slots[index].occupied) break;
        }
        if (index == _slots.size()) {
            _slots.emplace_back();
        }
        Slot& s = _slots[index];
        s.obj = std::move(obj);
        s.occupied = true;
        // Stamp identity (owner, index, generation)
        if (s.obj) {
            HandleAccess::set(*s.obj.get(), this, index, s.generation);
        }
        return Handle(this, index, s.generation);
    }

    // Validate typed handle
    bool validate(const Handle& h) const noexcept {
        if (h.getOwner() != this) return false;
        uint32_t idx = h.getIndex();
        if (idx >= _slots.size()) return false;
        const Slot& s = _slots[idx];
        return s.occupied && s.generation == h.getGeneration();
    }

    // Resolve typed handle to a retained reference (copy of RefObject)
    RefObject<GameObject> resolve(const Handle& h) const noexcept {
        if (!validate(h)) return {};
        return _slots[h.getIndex()].obj;  // copy retains
    }

    // Erase object by handle (clears identity, bumps generation)
    void erase(const Handle& h) noexcept {
        if (!validate(h)) return;
        Slot& s = _slots[h.getIndex()];
        if (s.obj) {
            HandleAccess::clear(*s.obj.get());
        }
        s.obj = {};
        s.occupied = false;
        // Bump generation so stale handles become invalid
        s.generation++;
        if (s.generation == 0) s.generation = 1;  // avoid 0
    }

    // Convenience: make a handle from a live object that is currently stamped
    std::optional<Handle> toHandle(const RefObject<GameObject>& obj) const noexcept {
        if (!obj || !obj->hasHandle()) return std::nullopt;
        if (obj->handleOwner() != this) return std::nullopt;
        return Handle(const_cast<GameObjectPool*>(this), obj->handleIndex(), obj->handleGeneration());
    }
};

int main() {
    // The global logger is auto-configured with a console sink.
    Logger::global().setMinLevel(Logging::LogLevel::Trace);

    GameObjectPool pool(4);

    // Create a couple of objects
    auto player = makeRef<GameObject>("Player");
    auto enemy = makeRef<GameObject>("Enemy");

    // Insert into the pool; this stamps handle identity on the objects
    auto hPlayer = pool.insert(player);
    auto hEnemy = pool.insert(enemy);

    ENTROPY_LOG_INFO_CAT("HandleExample", std::format("Player debug: {}", player->debugString()));
    ENTROPY_LOG_INFO_CAT("HandleExample", std::format("Enemy  debug: {}", enemy->debugString()));

    // Resolve handles back to objects
    auto playerRef = pool.resolve(hPlayer);
    auto enemyRef = pool.resolve(hEnemy);

    ENTROPY_LOG_INFO_CAT("HandleExample", std::format("Resolved Player valid: {}", static_cast<bool>(playerRef)));
    ENTROPY_LOG_INFO_CAT("HandleExample", std::format("Resolved Enemy  valid: {}", static_cast<bool>(enemyRef)));

    // Demonstrate object -> handle via stamped identity
    if (auto objHandle = pool.toHandle(player)) {
        ENTROPY_LOG_INFO_CAT("HandleExample", std::format("Object->Handle roundtrip: index={} gen={}",
                                                          objHandle->getIndex(), objHandle->getGeneration()));
    }

    // Erase the enemy; its handle should become invalid after generation bump
    pool.erase(hEnemy);
    auto enemyAfterErase = pool.resolve(hEnemy);
    ENTROPY_LOG_INFO_CAT("HandleExample",
                         std::format("After erase, old enemy handle valid: {}", static_cast<bool>(enemyAfterErase)));

    // Re-insert a new object; likely reuses the same slot but with new generation
    auto newEnemy = makeRef<GameObject>("Enemy#2");
    auto hEnemy2 = pool.insert(newEnemy);

    ENTROPY_LOG_INFO_CAT("HandleExample", std::format("New enemy debug: {}", newEnemy->debugString()));
    ENTROPY_LOG_INFO_CAT(
        "HandleExample",
        std::format("Old enemy handle index/gen = {}/{}; New handle index/gen = {}/{}", hEnemy.getIndex(),
                    hEnemy.getGeneration(), hEnemy2.getIndex(), hEnemy2.getGeneration()));

    // Small pause to make logs readable if needed
    std::this_thread::sleep_for(10ms);

    return 0;
}