actions

func TestTypedAction(t *testing.T)

{
	action := NewTyped[renameInput, renameResult]("file.rename")
	router := New()
	err := HandleTyped(router, action, func(_ context.Context, input renameInput) (renameResult, error) {
		return renameResult{Path: input.Name}, nil
	})
	if err != nil {
		t.Fatalf("HandleTyped() error = %v", err)
	}

	got, err := DispatchTyped(context.Background(), router, action, renameInput{Name: "new.md"})
	if err != nil {
		t.Fatalf("DispatchTyped() error = %v", err)
	}
	if got.Path != "new.md" {
		t.Fatalf("DispatchTyped() = %#v", got)
	}
	if !router.Has(action.Name()) {
		t.Fatal("Has() did not report a typed action")
	}
}

func TestTypedActionRejectsRuntimeTypeMismatch(t *testing.T)

{
	action := NewTyped[renameInput, renameResult]("file.rename")
	router := New()
	if err := HandleTyped(router, action, func(_ context.Context, input renameInput) (renameResult, error) {
		return renameResult{Path: input.Name}, nil
	}); err != nil {
		t.Fatalf("HandleTyped() error = %v", err)
	}

	if _, err := router.Dispatch(context.Background(), action.Name(), "wrong"); err == nil {
		t.Fatal("Dispatch() accepted the wrong payload type")
	}
}

func parseAction(prototype Handler) actionMeta

{
	val := reflect.ValueOf(prototype)
	if val.Kind() != reflect.Ptr || val.Elem().Kind() != reflect.Struct {
		panic("actions: prototype must be a pointer to a struct")
	}

	typ := val.Elem().Type()
	var name, key string
	for i := 0; i < typ.NumField(); i++ {
		field := typ.Field(i)
		if action := field.Tag.Get("action"); action != "" {
			name = action
		}
		if keys := field.Tag.Get("keys"); keys != "" {
			key = keys
		}
	}
	if name == "" {
		panic("actions: struct must have an action tag")
	}

	return actionMeta{
		name: name,
		key:  key,
		new: func() Handler {
			newVal := reflect.New(typ).Elem()
			newVal.Set(val.Elem())
			return newVal.Addr().Interface().(Handler)
		},
	}
}

func HandlerName(prototype Handler) (string, error)

{
	value := reflect.ValueOf(prototype)
	if !value.IsValid() || value.Kind() != reflect.Ptr || value.IsNil() ||
		value.Elem().Kind() != reflect.Struct {
		return "", fmt.Errorf("actions: prototype must be a non-nil pointer to a struct")
	}
	typ := value.Elem().Type()
	for index := 0; index < typ.NumField(); index++ {
		if name := typ.Field(index).Tag.Get("action"); name != "" {
			return name, nil
		}
	}
	return "", fmt.Errorf("actions: struct must have an action tag")
}

func bindPayload(target any, payload any) error

{
	src := reflect.ValueOf(payload)
	if src.Kind() == reflect.Ptr {
		if src.IsNil() {
			return nil
		}
		src = src.Elem()
	}

	switch src.Kind() {
	case reflect.Map:
		for _, key := range src.MapKeys() {
			if err := setPayloadField(target, fmt.Sprint(key.Interface()), src.MapIndex(key)); err != nil {
				return err
			}
		}
	case reflect.Struct:
		srcType := src.Type()
		for i := 0; i < src.NumField(); i++ {
			field := srcType.Field(i)
			if !field.IsExported() {
				continue
			}
			name := field.Name
			if tag := field.Tag.Get("json"); tag != "" {
				name = strings.Split(tag, ",")[0]
			}
			if name == "-" || name == "" {
				continue
			}
			if err := setPayloadField(target, name, src.Field(i)); err != nil {
				return err
			}
		}
	default:
		return fmt.Errorf("actions: payload must be a map or struct")
	}
	return nil
}

func setPayloadField(target any, name string, value reflect.Value) error

{
	dst := reflect.ValueOf(target).Elem()
	dstType := dst.Type()

	nilValue := !value.IsValid() || value.Kind() == reflect.Interface && value.IsNil()
	if !nilValue && value.Kind() == reflect.Interface {
		value = value.Elem()
	}

	for i := 0; i < dst.NumField(); i++ {
		fieldMeta := dstType.Field(i)
		field := dst.Field(i)
		if _, injected := fieldMeta.Tag.Lookup("inject"); injected {
			continue
		}
		if !field.CanSet() {
			continue
		}
		if !fieldNameMatches(fieldMeta, name) {
			continue
		}
		if nilValue {
			switch field.Kind() {
			case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map,
				reflect.Ptr, reflect.Slice:
				field.SetZero()
				return nil
			default:
				return fmt.Errorf("actions: cannot bind nil to %s", fieldMeta.Name)
			}
		}
		if value.IsValid() && value.Type().AssignableTo(field.Type()) {
			field.Set(value)
			return nil
		}
		if value.IsValid() && value.Type().ConvertibleTo(field.Type()) {
			field.Set(value.Convert(field.Type()))
			return nil
		}
		if value.IsValid() && value.Kind() == reflect.String {
			return reflectutil.Bind(field, value.String())
		}
		return fmt.Errorf("actions: cannot bind %s", fieldMeta.Name)
	}
	return fmt.Errorf("actions: unknown payload field %q", name)
}

func TestRouter_Dispatch(t *testing.T)

{
	doc := &document{}
	r := New()
	r.Provide("document", doc)
	r.Register(&saveAction{})

	result, err := r.Dispatch(context.Background(), "file.save", map[string]any{
		"name":  "notes.md",
		"count": 2,
	})
	if err != nil {
		t.Fatalf("Dispatch() error = %v", err)
	}
	if result != 2 {
		t.Fatalf("result = %v, want 2", result)
	}
	if doc.saved != "notes.md" {
		t.Fatalf("saved = %q, want notes.md", doc.saved)
	}
}

func TestRouter_DispatchKey(t *testing.T)

{
	doc := &document{}
	r := New()
	r.Provide("document", doc)
	r.Register(&saveAction{})

	_, err := r.DispatchKey(context.Background(), "ctrl+s", struct {
		Name  string `json:"name"`
		Count int    `json:"count"`
	}{Name: "book.md", Count: 1})
	if err != nil {
		t.Fatalf("DispatchKey() error = %v", err)
	}
	if doc.saved != "book.md" {
		t.Fatalf("saved = %q, want book.md", doc.saved)
	}
}

func TestRouter_ActionsAndKeyBindings(t *testing.T)

{
	r := New()
	r.Register(&saveAction{})

	actions := r.Actions()
	if len(actions) != 1 || actions[0] != "file.save" {
		t.Fatalf("Actions() = %v", actions)
	}

	bindings := r.KeyBindings()
	if bindings["ctrl+s"] != "file.save" {
		t.Fatalf("KeyBindings() = %v", bindings)
	}
}

func TestRouter_DuplicateKeyBindingPanics(t *testing.T)

{
	r := New()
	r.Register(&saveAction{})

	defer func() {
		if recover() == nil {
			t.Fatal("Register() did not panic")
		}
	}()

	r.Register(&duplicateKeyAction{})
}

func TestRouter_Events(t *testing.T)

{
	bus := events.New()
	defer bus.Close()

	var seen *saveAction
	events.Subscribe(bus, func(ctx context.Context, e *saveAction) error {
		seen = e
		return nil
	})

	r := New(WithEvents(bus))
	r.Provide("document", &document{})
	r.Register(&saveAction{})

	_, err := r.Dispatch(context.Background(), "file.save", map[string]any{"name": "event.md"})
	if err != nil {
		t.Fatalf("Dispatch() error = %v", err)
	}
	if seen == nil || seen.Name != "event.md" {
		t.Fatalf("seen = %#v", seen)
	}
}

func TestRouter_AsyncEventsPropagateClosedBus(t *testing.T)

{
	bus := events.New()
	if err := bus.Shutdown(context.Background()); err != nil {
		t.Fatalf("Shutdown: %v", err)
	}

	r := New(WithAsyncEvents(bus))
	r.Provide("document", &document{})
	r.Register(&saveAction{})

	_, err := r.Dispatch(context.Background(), "file.save", map[string]any{"name": "event.md"})
	if !errors.Is(err, events.ErrBusClosed) {
		t.Fatalf("Dispatch() error = %v, want ErrBusClosed", err)
	}
}

func TestRouter_RejectsUnknownPayloadField(t *testing.T)

{
	r := New()
	r.Provide("document", &document{})
	r.Register(&saveAction{})

	if _, err := r.Dispatch(context.Background(), "file.save", map[string]any{"typo": "notes.md"}); err == nil {
		t.Fatal("Dispatch() accepted an unknown payload field")
	}
	if _, err := r.Dispatch(context.Background(), "file.save", map[string]any{"typo": nil}); err == nil {
		t.Fatal("Dispatch() accepted an unknown nil payload field")
	}
}

func TestRouter_PayloadCannotOverwriteInjectedDependency(t *testing.T)

{
	trusted := &document{}
	attacker := &document{}
	r := New()
	r.Provide("document", trusted)
	r.Register(&saveAction{})

	if _, err := r.Dispatch(context.Background(), "file.save", map[string]any{
		"document": attacker,
		"name":     "trusted.md",
	}); err == nil {
		t.Fatal("Dispatch() accepted an injected field in the payload")
	}
	if attacker.saved != "" {
		t.Fatalf("payload replaced injected dependency: %#v", attacker)
	}
}

func TestRouter_PayloadRequiresExplicitFieldTag(t *testing.T)

{
	r := New()
	r.Provide("document", &document{})
	r.Register(&saveAction{})

	if _, err := r.Dispatch(context.Background(), "file.save", map[string]any{
		"isAdmin": true,
	}); err == nil {
		t.Fatal("Dispatch() accepted an untagged exported field")
	}
}

func TestRouter_RegisterDefinition(t *testing.T)

{
	r := New()
	doc := &document{}
	r.Provide("document", doc)
	err := r.RegisterDefinition(Definition{
		Name: "static.save",
		Key:  "ctrl+shift+s",
		New: func() Handler {
			return &saveAction{}
		},
	})
	if err != nil {
		t.Fatalf("RegisterDefinition() error = %v", err)
	}

	result, err := r.Dispatch(context.Background(), "static.save", map[string]any{"name": "static.md"})
	if err != nil {
		t.Fatalf("Dispatch() error = %v", err)
	}
	if result != 0 || doc.saved != "static.md" {
		t.Fatalf("Dispatch() = %v, saved = %q", result, doc.saved)
	}
}

func TestRouter_RegisterDefinitionsIsTransactional(t *testing.T)

{
	router := New()
	err := router.RegisterDefinitions(
		Definition{Name: "one", Key: "ctrl+x", New: func() Handler { return &saveAction{} }},
		Definition{Name: "two", Key: "ctrl+x", New: func() Handler { return &duplicateKeyAction{} }},
	)
	if err == nil {
		t.Fatal("RegisterDefinitions() accepted a duplicate key")
	}
	if len(router.Actions()) != 0 {
		t.Fatalf("RegisterDefinitions() left actions after failure: %v", router.Actions())
	}
}

func HandleTyped[P, R any](r *Router, action Typed[P, R], handler func(context.Context, P) (R, error)) error

{
	if handler == nil {
		return fmt.Errorf("actions: typed handler cannot be nil")
	}

	r.mu.Lock()
	defer r.mu.Unlock()
	if _, exists := r.handlers[action.name]; exists {
		return fmt.Errorf("actions: handler %q already registered", action.name)
	}
	if _, exists := r.typed[action.name]; exists {
		return fmt.Errorf("actions: handler %q already registered", action.name)
	}
	r.typed[action.name] = func(ctx context.Context, payload any) (any, error) {
		typed, ok := payload.(P)
		if !ok {
			return nil, fmt.Errorf("actions: payload for %q has type %T", action.name, payload)
		}
		return handler(ctx, typed)
	}
	return nil
}

func DispatchTyped[P, R any](ctx context.Context, r *Router, action Typed[P, R], payload P) (R, error)

{
	var zero R

	r.mu.RLock()
	handler := r.typed[action.name]
	r.mu.RUnlock()
	if handler == nil {
		return zero, fmt.Errorf("actions: no handler for %q", action.name)
	}
	result, err := handler(ctx, payload)
	if err != nil {
		return zero, err
	}
	typed, ok := result.(R)
	if !ok {
		return zero, fmt.Errorf("actions: result for %q has type %T", action.name, result)
	}
	return typed, nil
}