Entity :: struct{
    version : u32;
    index: u32;
}

ENTITY_MAX :: 4294967295;

SparseSet:: struct($T: Type){

    reverse: [..]Entity;
    sparse: [..]u32; //todo change into a proper map
    dense: [..]T;
}

get_component :: (using self: *$SparseSet, et:Entity) -> *self.T{
    assert(has_component(self, et));

    return *dense[sparse[et.index]];
}

set_component :: (using self: *$SparseSet,val : $T ,et:Entity){
    dense[sparse[et.index]] = val;
}

has_component :: (using self: *$SparseSet, et:Entity) -> bool{

    return sparse.count > et.index && sparse[et.index] != ENTITY_MAX;
}

add_component :: (using self: *$SparseSet,comp: $T,et: Entity){
    assert(!has_component(self, et));

    array_add(*dense,comp);
    array_add(*reverse,et);


    while et.index >= sparse.count {
        array_add(*sparse,ENTITY_MAX);
    }

    print("added component at index % cmp %, dense is %", et.index, comp, dense.count);

    sparse[et.index] = cast(u32)dense.count-1;
}

Base_Registry:: struct($types: []Type){

    versions: [..]u32;

    //insert the sparse sets for each type at compile time
    #insert -> string {
        builder: String_Builder;

        for types {
            //print("set_%: SparseSet(%);\n", it, it);
            print_to_builder(*builder, "set_%: SparseSet(%);\n", it, it);
        }

        return builder_to_string(*builder);
    }

    find_pool :: ($t: Type,reg : *$Base_Registry) -> *SparseSet(t) {
         set := #insert -> string {
                    builder: String_Builder;

                    print( "reg.set_%;\n",t);
                    print_to_builder(*builder, "*reg.set_%;\n",t);

                    return builder_to_string(*builder);
        };
        return set;
    }

    get :: ($t: Type,reg : *$Base_Registry, et : Entity) -> t{

        return get_component(find_pool(t,reg),et);
    }

    set :: (cmp: $T,reg : *$Base_Registry, et : Entity) {
        set := find_pool(T,reg);

        if has_component(set,et) {
            set_component(set,cmp,et);
        }
        else {
            add_component(set,cmp,et);
        }
    }
}

tail :: (types: []Type) -> []Type{
        filter := types;
        filter.data += 1;
        filter.count -= 1;

        return filter;
}

View :: struct ($types: []Type){

    #assert(types.count > 0);
    #if(types.count == 1){
        mypool : *SparseSet(types[0]);
    }
    else{
        mypool : *SparseSet(types[0]);

        recursion : View(#run tail(types));
    }
}

init_view :: (v : *$V/View, reg : *$Base_Registry){

    v.mypool = reg.find_pool(V.types[0],reg);
    #if(v.types.count> 1){
        v.recursion = newv.recursion.new(reg);S
    }
}

has ::  (v : $V/View,eid: Entity) -> bool {
    hasSelf := has_component(v.mypool,entity);

    #if v.types.count <= 1{
        return hasSelf;
    }
    else {
        return hasSelf && has(v.recursion);
    }
}
each :: (v : $V/View, fn :  (eid: Entity)) {
    for v.mypool.reverse {
        #if v.types.count <= 1{
            fn(it);
        }
        else {
            if has(v.recursion, it_value) {
                 fn(it);
            }
        }
    }
}

for_expansion :: (v : $V/View, body: Code, flags: For_Flags) #expand {
        for eid : v.mypool.reverse {
            #if v.types.count > 1{
                if !has(v.recursion, it_value) continue;
            }

            `it := eid;
            `it_index := 0;

            #insert body;
        }
}


Registry :: struct {
    #as using base: Base_Registry(.[C1,C2,C3,C4] );

    new :: (reg : *Registry) -> Entity {
        array_add(*reg.versions, 1);

        return Entity.{version = 1, index = cast(u32)reg.versions.count-1};
    }

    get :: ($t: Type,reg : *Registry, et : Entity) -> t{
        return reg.base.get(t,*reg,et);
    }

    set :: (cmp: $T,reg : *Registry, et : Entity) -> T{
         return reg.base.set(cmp,*reg,et);
    }
}

C1 :: struct {
    var : float64;
}

C2 :: struct {
    stuff : float64;
    stuffother : s32;
}

C3 :: struct {
    vars : [3]float64;
}

C4 :: struct {
    var : bool;
}

main :: () {
    reg : Registry;
    et : Entity = Registry.new(*reg);

    test := C2.{stuff = 10, stuffother = 5};

    Registry.base.set(test,*reg,et);
    Registry.base.set(C1.{7.0},*reg,et);

    var := Registry.base.get(C2,*reg,et);

    assert(var.stuff == test.stuff && var.stuffother == test.stuffother);

    printe :: ( eid: Entity  ){
        print("\n entity % \n", eid);
    }

    testv : View(.[C1,C2]) ;
    init_view(*testv,*reg);

    for testv {
        print("\n entity % \n", it);
    }
}


#import "Basic";