relay

func (*Transport) Register(prototype core.Handler)
{
	val := reflect.ValueOf(prototype)
	if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Struct {
		panic("Transport.Register: prototype must be a pointer to a struct")
	}

	elemType := val.Elem().Type()

	var topic string
	for i := 0; i < elemType.NumField(); i++ {
		field := elemType.Field(i)
		if field.Type == reflect.TypeOf(core.Pattern{}) {
			topic = field.Tag.Get("relay")
			break
		}
	}

	if topic == "" {
		panic(fmt.Sprintf("Transport.Register: struct %s missing Pattern with relay tag", elemType.Name()))
	}

	t.mu.Lock()
	t.handlers[topic] = prototype
	t.mu.Unlock()

	relaymanager.Register[map[string]any](t.relay, topic, t.dispatch(topic, prototype))

	t.Logger.Info("Registered relay handler", "topic", topic)
}

func (*Transport) dispatch(topic string, prototype core.Handler) func(ctx context.Context, payload map[string]any) error
{
	return func(ctx context.Context, payload map[string]any) error {
		val := reflect.ValueOf(prototype)
		elemType := val.Elem().Type()
		newVal := reflect.New(elemType).Elem()
		newVal.Set(val.Elem())

		instance := newVal.Addr().Interface()
		t.container.Inject(instance)

		if err := t.applyPayload(instance, payload); err != nil {
			return fmt.Errorf("payload binding failed: %w", err)
		}

		handler := instance.(core.Handler)
		_, err := handler.Handle(ctx)

		busInstance := t.Bus
		if busInstance != nil {
			bus.EmitAsync(ctx, busInstance, instance)
		}

		return err
	}
}

func (*Transport) setFieldByNameOrTag(dst reflect.Value, dstType reflect.Type, name string, val reflect.Value)
{
	for i := 0; i < dst.NumField(); i++ {
		fieldMeta := dstType.Field(i)
		field := dst.Field(i)

		if !field.CanSet() {
			continue
		}

		tag := fieldMeta.Tag.Get("relay")
		if strings.EqualFold(fieldMeta.Name, name) || (tag != "" && tag == name) {
			if field.Type() == val.Type() {
				field.Set(val)
			} else if val.Kind() == reflect.Interface && reflect.TypeOf(val.Interface()) == field.Type() {
				field.Set(reflect.ValueOf(val.Interface()))
			}
			break
		}
	}
}