// Tests for interface smart-cast cgen bugs in field access and variable
// declaration paths.
//
// 1. Interface→interface smart-cast: `parent.id` where parent is smart-cast
//    from one interface to another. Cgen used to emit
//    `(I_X_as_I_Y(parent)->id)` (`->` on a struct value) instead of
//    `(I_X_as_I_Y(parent).id)`.
//
// 2. Variable declared from a smart-cast selector should take the smart-cast
//    type, not the original interface. `mut dd := w.face` inside
//    `if mut w.face is Concrete` was being typed as the original interface,
//    so embedded-field access (e.g. `dd.context.x`) crashed in cgen.
//
// 3. Auto-deref of a `mut` method receiver passed as `voidptr` to a generic
//    method was emitting `*f` instead of `f` because the voidptr parameter
//    type carried the `.generic` flag during cgen, defeating the
//    `voidptr_type !in [...]` early-return.
import eventbus

// ── (1) interface→interface smart-cast field access ────────────────────────

interface Foo {
	id string
}

interface Bar {
	id string
}

struct ImplFB {
	id string
}

fn check_iface_to_iface(parent Foo) string {
	if parent is Bar {
		return parent.id
	}
	return ''
}

fn test_interface_to_interface_smartcast_field_access() {
	i := &ImplFB{
		id: 'iface_to_iface'
	}
	assert check_iface_to_iface(i) == 'iface_to_iface'
}

// ── (2) selector smart-cast var declaration ────────────────────────────────

struct Inner {
	value string
}

struct ConcreteWithEmbed {
	Inner
	tag string
}

interface IFace {}

struct WrapIF {
mut:
	face IFace
}

fn check_selector_smartcast_var(mut w WrapIF) string {
	if mut w.face is ConcreteWithEmbed {
		// `dd` should be ConcreteWithEmbed, not IFace, so accessing the
		// embedded `Inner.value` field works.
		dd := w.face
		return '${dd.tag}:${dd.value}'
	}
	return ''
}

fn test_selector_smartcast_var_declaration() {
	mut c := ConcreteWithEmbed{
		Inner: Inner{
			value: 'inner_v'
		}
		tag:   'tag_v'
	}
	mut w := WrapIF{
		face: &c
	}
	assert check_selector_smartcast_var(mut w) == 'tag_v:inner_v'
}

// ── (3) auto-deref of mut receiver passed as voidptr to a generic method ───

struct Counter {
mut:
	got_self int
	hits     int
}

fn counter_handler(receiver voidptr, args voidptr, sender voidptr) {
	mut c := unsafe { &Counter(receiver) }
	c.hits++
}

fn (mut c Counter) wire(mut bus eventbus.EventBus[string]) {
	// Bare `c` here. The receiver is a `voidptr` parameter on a generic
	// method, and the bug emitted `*c` (struct value) for the C call.
	bus.subscriber.subscribe_method('hit', counter_handler, c)
	c.got_self = unsafe { int(i64(voidptr(c)) & 0xffffffff) }
}

fn test_voidptr_mut_receiver_in_generic_method() {
	mut c := &Counter{}
	mut bus := eventbus.new[string]()
	c.wire(mut bus)
	bus.publish('hit', unsafe { nil }, unsafe { nil })
	bus.publish('hit', unsafe { nil }, unsafe { nil })
	assert c.hits == 2
}