import "libs:ash"

import "ash"

// Define components
Position :: struct { x, y: f32 }
Velocity :: struct { x, y: f32 }

main :: proc() {
    // Create world
    world: ash.World
    ash.world_init(&world)
    defer ash.world_destroy(&world)

    // Spawn entities with components
    ash.world_spawn(&world, Position{0, 0}, Velocity{1, 0})
    ash.world_spawn(&world, Position{10, 5}, Velocity{0, 1})
    ash.world_spawn(&world, Position{-5, 3}) // No velocity

    // Query and iterate
    filter := ash.filter_contains(&world, {Position, Velocity})
    query := ash.world_query(&world, filter)

    it := ash.query_iter(query)
    for entry in ash.query_next(&it) {
        pos := ash.entry_get(entry, Position)
        vel := ash.entry_get(entry, Velocity)
        pos.x += vel.x
        pos.y += vel.y
    }
}

entity := ash.world_spawn(&world)
ash.world_despawn(&world, entity)

// Entity ID is recycled but generation changes
new_entity := ash.world_spawn(&world)
assert(entity != new_entity) // Different generation

Position :: struct { x, y: f32 }
Health   :: struct { current, max: i32 }
Tag      :: struct {}                     // Zero-size tags supported

// Manual registration (optional)
pos_id := ash.world_register(&world, Position)
vel_id := ash.world_register(&world, Velocity)

// Or just use them - auto-registered on first use
entity := ash.world_spawn(&world, Position{0, 0}, Health{100, 100}, Tag{})

// Cache IDs before the loop
pos_id := ash.world_register(&world, Position)
vel_id := ash.world_register(&world, Velocity)

// Or query IDs
pos_id := ash.world_get_component_id(&world, Position)
vel_id := ash.world_get_component_id(&world, Velocity)

it := ash.query_iter_archs(query)
for arch in ash.query_next_arch(&it) {
    positions  := ash.archetype_slice(arch, Position, pos_id)
    velocities := ash.archetype_slice(arch, Velocity, vel_id)
    // ...
}

entry := ash.world_entry(&world, entity)

// Check if entity has component
if ash.entry_has(entry, Position) {
    pos := ash.entry_get(entry, Position)
    pos.x += 10
}

// Add component
ash.entry_set(&entry, Velocity{1, 0})

// Remove component
ash.entry_remove(&entry, Velocity)

// Entities with Position AND Velocity
filter := ash.filter_contains(&world, {Position, Velocity})

// Entities with Position but NOT Poison
filter := ash.filter_create(&world, requires = {Position}, excludes = {Poison})

// Entities with Position and at least one of Sprite, Text, or Shape
filter := ash.filter_create(&world, requires = {Position}, anyof = {Sprite, Text, Shape})

// Exact match - only entities with exactly these components
filter := ash.filter_create(&world, requires = {Position, Velocity}, exact = true)

// OR filters
filter := ash.filter_or(&world, {
    {requires = {A, B}},
    {requires = {C, D}},
})

query := ash.world_query(&world, filter)

it := ash.query_iter(query)
for entry in ash.query_next(&it) {
    pos := ash.entry_get(entry, Position)
    vel := ash.entry_get(entry, Velocity)
    pos.x += vel.x
    pos.y += vel.y
}

pos_id := ash.world_get_component_id(&world, Position)
vel_id := ash.world_get_component_id(&world, Velocity)

it := ash.query_iter_archs(query)
for arch in ash.query_next_arch(&it) {
    positions := ash.archetype_slice(arch, Position, pos_id)
    velocities := ash.archetype_slice(arch, Velocity, vel_id)

    for i in 0..<len(positions) {
        positions[i].x += velocities[i].x
        positions[i].y += velocities[i].y
    }
}

it := ash.query_iter(query)
for entry in ash.query_next(&it) {
    health := ash.entry_get(entry, Health)
    if health.current <= 0 {
        ash.entry_queue_despawn(&entry)
    }
}

ash.world_flush(&world) // Execute queued commands

// Called when any entity is spawned
ash.world_on_spawn(&world, proc(w: ^ash.World, e: ash.Entity, user_data: rawptr) {
    fmt.println("Spawned:", e)
}, nil)

// Called when Position component is added
ash.world_on_add(&world, Position, proc(w: ^ash.World, e: ash.Entity, user_data: rawptr) {
    fmt.println("Position added to:", e)
}, nil)

// Called before entity is despawned (components still accessible)
ash.world_on_despawn(&world, proc(w: ^ash.World, e: ash.Entity, user_data: rawptr) {
    fmt.println("Despawning:", e)
}, nil)

// Called before component is removed
ash.world_on_remove(&world, Position, proc(w: ^ash.World, e: ash.Entity, user_data: rawptr) {
    entry := ash.world_entry(w, e)
    pos := ash.entry_get(entry, Position)
    fmt.println("Removing position:", pos)
}, nil)

handle := ash.world_on_spawn(&world, my_callback, nil)
ash.world_unobserve(&world, handle)

Time :: struct {
    delta: f32,
    elapsed: f32,
}

time := Time{delta = 0.016, elapsed = 0}
ash.world_set_resource(&world, &time)

// Access anywhere
t := ash.world_get_resource(&world, Time)
t.elapsed += t.delta

// Check and remove
if ash.world_has_resource(&world, Time) {
    ash.world_remove_resource(&world, Time)
}