# emit_spawn.ludic — spawn / despawn / self(), and seeding a component's fields
# from its declared defaults plus any per-spawn overrides.

fn emit_init_component(e: ptr, comp: ptr, rec: Node) -> void {
  let me = itoa(MAX_ENT)
  let c = find_comp(comp)
  if (c == null) { perr(`spawn: unknown property {comp}`) }
  let hp = nreg();  emit("  ");  emit(hp);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x i8], ptr @H_");  emit(comp);  emit(", i32 0, i32 ");  emit(e);  emit("\n")
  emit("  store i8 1, ptr ");  emit(hp);  emit("\n")
  let slot = nreg()
  emit("  ");  emit(slot);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x %Cmp_");  emit(comp);  emit("], ptr @S_");  emit(comp);  emit(", i32 0, i32 ");  emit(e);  emit("\n")
  # defaults
  var f = 0
  while f < len(c.kids) {
    let fd = c.kids[f]
    let addr = nreg()
    emit("  ");  emit(addr);  emit(" = getelementptr inbounds %Cmp_");  emit(comp);  emit(", ptr ");  emit(slot);  emit(", i32 0, i32 ");  emit(itoa(f));  emit("\n")
    let lt = llty(fd.ty)
    var v = "0"
    if (lt == "ptr") { v = "null" }
    if (fd.a != null) { let dv = emit_expr(fd.a);  v = dv.code }
    emit("  store ");  emit(lt);  emit(" ");  emit(v);  emit(", ptr ");  emit(addr);  emit("\n")
    f = f + 1
  }
  # per-spawn overrides
  if (rec != null) {
    var j = 0
    while j < len(rec.kids) {
      let fi = rec.kids[j]
      let fidx = field_index(c, fi.s)
      if fidx >= 0 {
        let addr = nreg()
        emit("  ");  emit(addr);  emit(" = getelementptr inbounds %Cmp_");  emit(comp);  emit(", ptr ");  emit(slot);  emit(", i32 0, i32 ");  emit(itoa(fidx));  emit("\n")
        let dv = emit_expr(fi.a)
        emit("  store ");  emit(llty(field_type(c, fi.s)));  emit(" ");  emit(dv.code);  emit(", ptr ");  emit(addr);  emit("\n")
      }
      j = j + 1
    }
  }
  # @OnAttach(Property) runs once the property is attached and seeded
  let ab = onattach_body(comp)
  if (ab != null) {
    let save = nloc
    let vslot = emit_alloca("ptr")
    emit("  store ptr ");  emit(slot);  emit(", ptr ");  emit(vslot);  emit("\n")
    loc_push(comp, vslot, comp)
    emit_block(ab)
    nloc = save
  }
  # EV1: a @Public attach hook fires prop_<P>_attach with the entity
  let aev = `prop_{comp}_attach`
  if (find_event(aev) != null) { emit("  call void @ev_");  emit(aev);  emit("(i32 ");  emit(e);  emit(")\n") }
}

# bind each of a model's properties to entity `e`'s component storage, so an
# @OnSpawn hook body can address them by name (like a query binding for one entity).
fn emit_bind_props(model: Node, e: ptr) -> void {
  let me = itoa(MAX_ENT)
  var c = 0
  while c < len(model.kids) {
    let pname = model.kids[c].s
    let slot = nreg()
    emit("  ");  emit(slot);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x %Cmp_");  emit(pname);  emit("], ptr @S_");  emit(pname);  emit(", i32 0, i32 ");  emit(e);  emit("\n")
    let vslot = emit_alloca("ptr")
    emit("  store ptr ");  emit(slot);  emit(", ptr ");  emit(vslot);  emit("\n")
    loc_push(pname, vslot, pname)
    c = c + 1
  }
}

fn emit_spawn(st: Node) -> ptr {
  let e = emit_bind("call i32 @L_alloc()")
  let ak = find_arch_id(st.s)
  if ak > 0 {
    let me = itoa(MAX_ENT)
    let kp = nreg();  emit("  ");  emit(kp);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x i32], ptr @L_kind, i32 0, i32 ");  emit(e);  emit("\n")
    emit("  store i32 ");  emit(itoa(ak));  emit(", ptr ");  emit(kp);  emit("\n")
    let arch = find_arch(st.s)
    var c = 0
    while c < len(arch.kids) {
      let cn = arch.kids[c].s
      var rec = null
      var i = 0
      while i < len(st.kids) { if (st.kids[i].s == cn) { rec = st.kids[i].a };  i = i + 1 }
      emit_init_component(e, cn, rec)
      c = c + 1
    }
    let ob = onspawn_body(st.s)                 # @OnSpawn(Model) hook runs after init
    if (ob != null) {
      let save = nloc
      emit_bind_props(arch, e)
      emit_block(ob)
      nloc = save
    }
    # EV1: a @Public spawn hook also fires the public event model_<M>_spawn, so
    # mods (native or foreign, over the ABI) see the entity born.
    let sev = `model_{st.s}_spawn`
    if (find_event(sev) != null) { emit("  call void @ev_");  emit(sev);  emit("(i32 ");  emit(e);  emit(")\n") }
  } else {
    var i = 0
    while i < len(st.kids) { emit_init_component(e, st.kids[i].s, st.kids[i].a);  i = i + 1 }
  }
  return e                                        # the new entity id (for ludic_spawn_<M>)
}

fn emit_despawn(st: Node) -> void {
  let v = emit_expr(st.a)
  # @OnDespawn: dispatch on the entity's kind and run the matching model's hook
  if len(g_ondespawn) > 0 {
    let me = itoa(MAX_ENT)
    let kp = nreg();  emit("  ");  emit(kp);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x i32], ptr @L_kind, i32 0, i32 ");  emit(v.code);  emit("\n")
    let kind = emit_bind(`load i32, ptr {kp}`)
    var i = 0
    while i < len(g_ondespawn) {
      let mname = g_ondespawn[i].s
      let c = emit_bind(`icmp eq i32 {kind}, {itoa(find_arch_id(mname))}`)
      let yes = lbl("dh");  let no = lbl("dhn")
      emit("  br i1 ");  emit(c);  emit(", label %");  emit(yes);  emit(", label %");  emit(no);  emit("\n")
      emit(yes);  emit(":\n  call void @on_despawn_");  emit(mname);  emit("(i32 ");  emit(v.code);  emit(", i32 0)\n")   # reason = EndReason.Despawned
      let dev = `model_{mname}_despawn`                                                  # EV1: @Public despawn event
      if (find_event(dev) != null) { emit("  call void @ev_");  emit(dev);  emit("(i32 ");  emit(v.code);  emit(", i32 0)\n") }
      emit("  br label %");  emit(no);  emit("\n");  emit(no);  emit(":\n")
      i = i + 1
    }
  }
  if len(g_events) > 0 { emit("  call void @ludic_sweep_entity(i32 ");  emit(v.code);  emit(")\n") }   # EV5: drop entity-scoped listeners
  emit("  call void @L_free_entity(i32 ");  emit(v.code);  emit(")\n")
}

# attach P on e [{ overrides }] — add a property to a live entity. Structural
# (not a toggle): seeds the property's fields and fires @OnAttach, but only on a
# real transition — if the entity already has the property it is a no-op, so the
# hook fires once per genuine attach (flecs/Bevy "real add" semantics).
fn emit_attach(st: Node) -> void {
  let ev = emit_expr(st.a)
  let me = itoa(MAX_ENT)
  let hp = nreg();  emit("  ");  emit(hp);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x i8], ptr @H_");  emit(st.s);  emit(", i32 0, i32 ");  emit(ev.code);  emit("\n")
  let cur = emit_bind(`load i8, ptr {hp}`)
  let isnew = emit_bind(`icmp eq i8 {cur}, 0`)
  let doit = lbl("attach");  let done = lbl("attdone")
  emit("  br i1 ");  emit(isnew);  emit(", label %");  emit(doit);  emit(", label %");  emit(done);  emit("\n")
  emit(doit);  emit(":\n");  g_term = false
  emit_init_component(ev.code, st.s, st.b)     # sets has=1, seeds defaults+overrides, fires @OnAttach
  if not g_term { emit("  br label %");  emit(done);  emit("\n") }
  emit(done);  emit(":\n");  g_term = false
}

# detach P on e — remove a property from a live entity. Fires @OnDetach with the
# property bound by name (its data still lives in @S_ storage, so the teardown
# body reads the outgoing value), then clears the has-flag so queries skip it.
# Only fires on a real transition; detaching an absent property is a no-op.
fn emit_detach(st: Node) -> void {
  let ev = emit_expr(st.a)
  let me = itoa(MAX_ENT)
  let hp = nreg();  emit("  ");  emit(hp);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x i8], ptr @H_");  emit(st.s);  emit(", i32 0, i32 ");  emit(ev.code);  emit("\n")
  let cur = emit_bind(`load i8, ptr {hp}`)
  let here = emit_bind(`icmp ne i8 {cur}, 0`)
  let doit = lbl("detach");  let done = lbl("detdone")
  emit("  br i1 ");  emit(here);  emit(", label %");  emit(doit);  emit(", label %");  emit(done);  emit("\n")
  emit(doit);  emit(":\n");  g_term = false
  emit("  store i8 0, ptr ");  emit(hp);  emit("\n")           # clear has-flag (data persists in @S_)
  let hb = ondetach_body(st.s)                                 # @OnDetach reads the outgoing value
  if (hb != null) {
    let save = nloc
    let slot = nreg();  emit("  ");  emit(slot);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x %Cmp_");  emit(st.s);  emit("], ptr @S_");  emit(st.s);  emit(", i32 0, i32 ");  emit(ev.code);  emit("\n")
    let vslot = emit_alloca("ptr")
    emit("  store ptr ");  emit(slot);  emit(", ptr ");  emit(vslot);  emit("\n")
    loc_push(st.s, vslot, st.s)
    emit_block(hb)
    nloc = save
  }
  let dev = `prop_{st.s}_detach`                               # EV1: @Public detach event
  if (find_event(dev) != null) { emit("  call void @ev_");  emit(dev);  emit("(i32 ");  emit(ev.code);  emit(")\n") }
  if not g_term { emit("  br label %");  emit(done);  emit("\n") }
  emit(done);  emit(":\n");  g_term = false
}

# enable/disable. `<P> on <e>` toggles a property's has-flag on an entity (its
# data persists, so re-enabling restores it, and queries already skip a cleared
# flag). A bare `<Model>` / `<Handler>` flips a global enabled flag.
fn emit_toggle(st: Node) -> void {
  var val = "0";  if st.ival == 1 { val = "1" }
  if (st.ty != null) and (st.ty == "layer") {    # enable/disable layer L
    emit("  store i32 ");  emit(val);  emit(", ptr @LE_");  emit(st.s);  emit("\n")
    var lev = `layer_{st.s}_hide`;  if st.ival == 1 { lev = `layer_{st.s}_show` }   # public layer -> event
    if (find_event(lev) != null) { emit("  call void @ev_");  emit(lev);  emit("()\n") }
    return
  }
  if (st.a != null) {
    let ev = emit_expr(st.a)
    let me = itoa(MAX_ENT)
    let hp = nreg();  emit("  ");  emit(hp);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x i8], ptr @H_");  emit(st.s);  emit(", i32 0, i32 ");  emit(ev.code);  emit("\n")
    emit("  store i8 ");  emit(val);  emit(", ptr ");  emit(hp);  emit("\n")
    var hb: Node = null
    if st.ival == 1 { hb = onenable_body(st.s) } else { hb = ondisable_body(st.s) }
    if (hb != null) {
      let save = nloc
      let slot = nreg();  emit("  ");  emit(slot);  emit(" = getelementptr inbounds [");  emit(me);  emit(" x %Cmp_");  emit(st.s);  emit("], ptr @S_");  emit(st.s);  emit(", i32 0, i32 ");  emit(ev.code);  emit("\n")
      let vslot = emit_alloca("ptr")
      emit("  store ptr ");  emit(slot);  emit(", ptr ");  emit(vslot);  emit("\n")
      loc_push(st.s, vslot, st.s)
      emit_block(hb)
      nloc = save
    }
    # EV1: a @Public enable/disable hook fires prop_<P>_enable / prop_<P>_disable
    var tev = `prop_{st.s}_disable`;  if st.ival == 1 { tev = `prop_{st.s}_enable` }
    if (find_event(tev) != null) { emit("  call void @ev_");  emit(tev);  emit("(i32 ");  emit(ev.code);  emit(")\n") }
  } else {
    var g = "@HE_";  if is_model(st.s) { g = "@ME_" }     # model vs handler
    emit("  store i32 ");  emit(val);  emit(", ptr ");  emit(g);  emit(st.s);  emit("\n")
  }
}