#pragma once
#include <cstdint>
#include <bitset>
#include <format>
#include <stdexcept>
#include <typeindex>
#include <unordered_map>
#include <new>

#ifndef MAX_ZECSY_ENTITIES
    #define MAX_ZECSY_ENTITIES 65536
#endif // !MAX_ZECSY_ENTITIES


namespace zecsy 
{
    using entity_id = uint64_t;

    class entity final
    {
    public:
        entity(class world* w, entity_id id);

        entity() = default;
        entity(const entity &) = default;
        entity(entity &&) = default;
        entity &operator=(const entity &) = default;
        entity &operator=(entity &&) = default;
        operator entity_id() const;

        bool is_alive() const;

        template<typename T>
        bool has() const;

        template<typename T>
        T& get();

        template<typename T>
        void set(const T& comp = T{});
    private:
        entity_id id = 0;
        class world* w = nullptr;
    };

    using zecsy_bits = std::bitset<MAX_ZECSY_ENTITIES + 1>;

    class component_storage
    {
    public:
        template<typename T>
        bool has(entity_id e) const;

        template<typename T>
        T& get(entity_id e);

        template<typename T>
        void set(entity_id e, const T& comp = T{});
    private:
        using comp_index = std::type_index;
        using comp_to_bitset = std::unordered_map<comp_index, zecsy_bits>;
        using entity_to_index = std::unordered_map<entity_id, size_t>;

        using comp_to_entity_dict = std::unordered_map<comp_index, 
              entity_to_index>;
        
        using comp_to_storage = std::unordered_map<comp_index, 
              std::vector<uint8_t>>;

        comp_to_bitset bitset_dict;
        comp_to_entity_dict entity_dict; 
        comp_to_storage storage_dict;
    };

    class world final
    {
    public:
        world() = default;
        world(const world &) = default;
        world(world &&) = default;
        world &operator=(const world &) = default;
        world &operator=(world &&) = default;
   
        entity make_entity();
        void destroy_entity(entity_id e);
        bool is_alive(entity_id e) const; 

        template<typename T>
        bool has(entity_id e) const;

        template<typename T>
        T& get(entity_id e);

        template<typename T>
        void set(entity_id e, const T& comp = T{});
    private:
        zecsy_bits entities_bitset;
        entity_id entity_counter = 0;
        component_storage storage;
    };

    inline entity::entity(class world* w, entity_id id): w(w), id(id)
    {

    }

    inline entity::operator entity_id() const 
    {
        return id;
    }

    inline bool entity::is_alive() const
    {
        return w && w->is_alive(id);
    }

    inline entity world::make_entity()
    {
        auto id = ++entity_counter;
        
        if(id > MAX_ZECSY_ENTITIES)
        {
            throw std::runtime_error(std::format("Entity id {} exceeds " 
                        "MAX_ZECSY_ENTITIES ({})", id, MAX_ZECSY_ENTITIES));
        }

        entities_bitset.set(id);
        return entity(this, id);
    }

    inline void world::destroy_entity(entity_id e)
    {
        entities_bitset.reset(e);
    }

    inline bool world::is_alive(entity_id e) const
    {
        return entities_bitset.test(e);
    }

    template<typename T>
    inline bool world::has(entity_id e) const
    {
        return storage.has<T>(e);
    }

    template<typename T>
    inline bool component_storage::has(entity_id e) const
    {
        if(bitset_dict.contains(typeid(T)))
        {
            return bitset_dict.at(typeid(T)).test(e);
        }
        return false;
    }

    template<typename T>
    inline T& component_storage::get(entity_id e)
    {
        if(!has<T>(e))
        {
            throw std::runtime_error(std::format("Entity #{} doesn't have {}",
                        e, typeid(T).name()));
        }

        auto index = entity_dict[typeid(T)].at(e);
        
        auto* ptr = reinterpret_cast<T*>(&storage_dict[typeid(T)][0]);
        ptr += index;

        return *ptr;
    }

    template<typename T>
    inline bool entity::has() const
    {
        return w->has<T>(id);    
    }

    template<typename T>
    inline T& world::get(entity_id e)
    {
        return storage.get<T>(e);
    }

    template<typename T>
    inline T& entity::get()
    {
        return w->get<T>(id);
    }

    template<typename T>
    inline void component_storage::set(entity_id e, const T& comp)
    {
        bitset_dict[typeid(T)].set(e);

        auto& storage = storage_dict[typeid(T)];

        size_t T_size = sizeof(T);
        size_t old_size = storage.size();

        storage.resize(old_size + T_size);
        void* ptr = &storage[0] + old_size;
        new(ptr) T(comp);

        entity_dict[typeid(T)][e] = old_size / T_size;
    }

    template<typename T>
    inline void world::set(entity_id e, const T& comp)
    {
        storage.set(e, comp);
    }

    template<typename T>
    inline void entity::set(const T& comp)
    {
        w->set(id, comp);
    }
};