package ecs

import "core:container/queue"
import "core:testing"

@(test) create_world_test :: proc(t: ^testing.T) {
    A :: struct { v: [3]u32 }
    B :: struct { v: [3]u32 }
    C :: struct { v: [3]u32 }
    
    w, ok := create_world(
        name = "World",
        max_entities = 16,
        components_to_register = { A, B, C, }
    )
    assert(ok)
    defer destroy_world(w)
}

@(test) check_entity_id_queue_test :: proc(t: ^testing.T) {
    A :: struct { v: [3]u32 }
    B :: struct { v: [3]u32 }
    C :: struct { v: [3]u32 }
    
    MAX_ENTITIES :: 16
    w, ok := create_world(
        name = "World",
        max_entities = MAX_ENTITIES,
        components_to_register = { A, B, C, }
    )
    assert(ok)
    defer destroy_world(w)

    assert(queue.len(w.entity_id_queue) == MAX_ENTITIES)
}

@(test) create_entities_test :: proc(t: ^testing.T) {
    A :: struct { v: [3]u32 }
    B :: struct { v: [3]u32 }
    C :: struct { v: [3]u32 }
    
    w, ok := create_world(
        name = "World",
        max_entities = 1,
        components_to_register = { A, B, C, }
    )
    assert(ok)
    defer destroy_world(w)
    
    // This entity should be OK.
    e1, created_1 := create_entity(w)
    assert(created_1)
    assert(e1 != Invalid_Entity)

    // This entity should NOT be OK (because 'max_entities' is 1).
    e2, created_2 := create_entity(w)
    assert(!created_2)
    assert(e2 == Invalid_Entity)
}

@(test) add_component_test :: proc(t: ^testing.T) {
    A :: struct { v: [3]u32 }
    B :: struct { v: [3]u32 }
    C :: struct { v: [3]u32 }
    
    w, ok := create_world(
        name = "World",
        max_entities = 1,
        components_to_register = { A, B, C, }
    )
    assert(ok)
    defer destroy_world(w)
    
    e, created := create_entity(w)
    assert(created)
    assert(e != Invalid_Entity)

    added_component, component_added := add_component(e, w, A { v = { 1, 2, 3 } })
    assert(component_added)
    assert(added_component != nil)
    assert(added_component.v == { 1, 2, 3})
}