#include "ents/entity.h"
#include "world/entity_view.h"
#include "flecs/flecs.h"
#include "librg.h"
#include "world/world.h"

#include "ecs/components.h"
#include "ecs/systems.h"
#include "zpl.h"

// NOTE(zaklaus): bring in entity spawnlist
#include "entity_spawnlist.c"

void entity_spawndef_cleanup() {
    zpl_array_free(entity_spawnlist); entity_spawnlist = NULL;
}
void entity_spawndef_register(spawndef def) {
    if (!entity_spawnlist) {
        zpl_array_init(entity_spawnlist, zpl_heap());
    }

    zpl_array_append(entity_spawnlist, def);
}

uint64_t entity_spawn(uint16_t class_id) {
    ecs_entity_t e = ecs_new(world_ecs(), 0);
    
    ecs_set(world_ecs(), e, Classify, { .id = class_id });
    entity_wake(e);
    
    if (class_id != EKIND_SERVER) {
        ecs_set(world_ecs(), e, Velocity, {0});
        Position *pos = ecs_get_mut(world_ecs(), e, Position);
#if 1
        pos->x=(float)(rand() % world_dim());
        pos->y=(float)(rand() % world_dim());
        entity_set_position(e, pos->x, pos->y);
#else
        pos->x=350.0f;
        pos->y=88.0f;
#endif
        
        librg_entity_track(world_tracker(), e);
        librg_entity_chunk_set(world_tracker(), e, librg_chunk_from_realpos(world_tracker(), pos->x, pos->y, 0));
        librg_entity_owner_set(world_tracker(), e, (int64_t)e);
    }
    
    return (uint64_t)e;
}

uint64_t entity_spawn_id(uint16_t id){
    for (zpl_isize i = 0; i < zpl_array_count(entity_spawnlist); ++i){
        if (entity_spawnlist[i].id == id){
            ZPL_ASSERT(entity_spawnlist[i].proc);
            return entity_spawnlist[i].proc();
        }
    }
    return 0;
}

void entity_batch_despawn(uint64_t *ids, size_t num_ids) {
    for (size_t i = 0; i < num_ids; i++ ) {
        librg_entity_untrack(world_tracker(), ids[i]);
        ecs_delete(world_ecs(), ids[i]);
    }
}

void entity_despawn(uint64_t ent_id) {
    librg_entity_untrack(world_tracker(), ent_id);
    ecs_delete(world_ecs(), ent_id);
}

void entity_set_position(uint64_t ent_id, float x, float y) {
    Position *p = ecs_get_mut(world_ecs(), ent_id, Position);
    p->x = x;
    p->y = y;
    librg_entity_chunk_set(world_tracker(), ent_id, librg_chunk_from_realpos(world_tracker(), x, y, 0));
    entity_wake(ent_id);
}

void entity_wake(uint64_t ent_id) {
    StreamInfo *si = ecs_get_mut(world_ecs(), ent_id, StreamInfo);
    si->tick_delay = 0.0f;
    si->last_update = 0.0f;
}

static ecs_query_t *ecs_streaminfo = NULL;

void entity_update_action_timers() {
    static double last_update_time = 0.0f;
    if (!ecs_streaminfo) {
        ecs_streaminfo = ecs_query_new(world_ecs(), "components.StreamInfo");
        last_update_time = get_cached_time();
    }
    
    ecs_iter_t it = ecs_query_iter(world_ecs(), ecs_streaminfo);
    
    while (ecs_query_next(&it)) {
        StreamInfo *si = ecs_field(&it, StreamInfo, 1);
        
        for (int32_t i = 0; i < it.count; i++) {
            if (si[i].last_update < get_cached_time()) {
                si[i].last_update = get_cached_time() + si[i].tick_delay;
                si[i].tick_delay += (get_cached_time() - last_update_time) * 0.5f;
            }
        }
    }
    
    last_update_time = get_cached_time();
}

bool entity_can_stream(uint64_t ent_id) {
    StreamInfo *si = ecs_get_mut(world_ecs(), ent_id, StreamInfo);
    return (si->last_update < get_cached_time());
}
