struct Entity {
	id u16
}

struct Position {
	x f64
	y f64
	z f64
}

struct Velocity {
	x f64
	y f64
	z f64
}

interface ComponentStore[T] {
	len() int
mut:
	add(Entity, T)
}

struct Store[T] {
mut:
	items []T
}

fn (mut s Store[T]) add(_ Entity, value T) {
	s.items << value
}

fn (s &Store[T]) len() int {
	return s.items.len
}

@[heap]
struct Registry {
mut:
	data map[string]ComponentStore
}

fn new_registry() &Registry {
	return &Registry{
		data: map[string]ComponentStore{}
	}
}

fn (mut r Registry) create_store[T]() {
	if T.name in r.data {
		return
	}
	r.data[T.name] = Store[T]{}
}

fn (mut r Registry) add_component[T](entity Entity, component T) {
	r.create_store[T]()
	r.data[T.name].add(entity, component)
}

fn (mut r Registry) count[T]() int {
	return r.data[T.name].len()
}

fn test_generic_interface_map_values_can_store_multiple_concrete_instantiations() {
	mut registry := new_registry()
	entity := Entity{
		id: 1
	}
	registry.add_component(entity, Position{
		x: 10
		y: 2
		z: 0
	})
	registry.add_component(entity, Position{
		x: 11
		y: 3
		z: 1
	})
	registry.add_component(entity, Velocity{
		x: 1
		y: 2
		z: 3
	})
	assert registry.count[Position]() == 2
	assert registry.count[Velocity]() == 1
}