component.go

package strut

import (
	"errors"
	"fmt"
	"reflect"
	"sync"

	"github.com/disgoorg/disgo/discord"
	"github.com/disgoorg/disgo/handler"
	"github.com/disgoorg/snowflake/v2"
)

// Style is a button's appearance.
type Style = discord.ButtonStyle

const (
	Primary   = discord.ButtonStylePrimary
	Secondary = discord.ButtonStyleSecondary
	Success   = discord.ButtonStyleSuccess
	Danger    = discord.ButtonStyleDanger
	Link      = discord.ButtonStyleLink
)

// codecs caches one codec per state type, so a type used by several commands
// is only compiled once.
var codecs sync.Map // reflect.Type -> *stateCodec

func codecFor(t reflect.Type) (*stateCodec, error) {
	if c, ok := codecs.Load(t); ok {
		return c.(*stateCodec), nil
	}
	c, err := newStateCodec(t)
	if err != nil {
		return nil, err
	}
	actual, _ := codecs.LoadOrStore(t, c)
	return actual.(*stateCodec), nil
}

// Component is one built component. A build error travels with it and
// surfaces when the reply is sent, so a builder chain stays readable.
//
// Everything is placed with Row. Discord decides what may share one: up to
// five buttons, or a single select menu.
type Component struct {
	c   discord.InteractiveComponent
	err error
}

// Button carries state back to the handler registered with OnComponent.
func Button[S any](state S, label string, style Style) Component {
	id, err := encodeState(state)
	if err != nil {
		return Component{err: err}
	}
	return Component{c: discord.NewButton(style, label, id, "", 0)}
}

// LinkButton opens a URL. It carries no state, since Discord never sends an
// interaction for it.
func LinkButton(label, url string) Component {
	return Component{c: discord.NewLinkButton(label, url)}
}

// Select offers a fixed list of values, handed to the handler registered
// with OnSelect.
func Select[S, V any](state S, placeholder string, choices ...Choice[V]) Component {
	id, err := encodeState(state)
	if err != nil {
		return Component{err: err}
	}

	opts := make([]discord.StringSelectMenuOption, 0, len(choices))
	for _, ch := range choices {
		v, err := stateString(reflect.ValueOf(ch.Value))
		if err != nil {
			return Component{err: err}
		}
		opts = append(opts, discord.NewStringSelectMenuOption(ch.Name, v))
	}
	return Component{c: discord.NewStringSelectMenu(id, placeholder, opts...)}
}

// UserSelect picks users. The chosen ids reach the handler registered with
// OnEntitySelect.
func UserSelect[S any](state S, placeholder string) Component {
	return entitySelect(state, func(id string) discord.InteractiveComponent {
		return discord.NewUserSelectMenu(id, placeholder)
	})
}

// RoleSelect picks roles.
func RoleSelect[S any](state S, placeholder string) Component {
	return entitySelect(state, func(id string) discord.InteractiveComponent {
		return discord.NewRoleSelectMenu(id, placeholder)
	})
}

// ChannelSelect picks channels.
func ChannelSelect[S any](state S, placeholder string) Component {
	return entitySelect(state, func(id string) discord.InteractiveComponent {
		return discord.NewChannelSelectMenu(id, placeholder)
	})
}

// MentionableSelect picks users and roles together.
func MentionableSelect[S any](state S, placeholder string) Component {
	return entitySelect(state, func(id string) discord.InteractiveComponent {
		return discord.NewMentionableSelectMenu(id, placeholder)
	})
}

func entitySelect[S any](state S, build func(id string) discord.InteractiveComponent) Component {
	id, err := encodeState(state)
	if err != nil {
		return Component{err: err}
	}
	return Component{c: build(id)}
}

// WithDisabled greys the component out, which is how a menu is closed off
// once a choice has been made.
func (b Component) WithDisabled(disabled bool) Component {
	switch v := b.c.(type) {
	case discord.ButtonComponent:
		v.Disabled = disabled
		b.c = v
	case discord.StringSelectMenuComponent:
		v.Disabled = disabled
		b.c = v
	case discord.UserSelectMenuComponent:
		v.Disabled = disabled
		b.c = v
	case discord.RoleSelectMenuComponent:
		v.Disabled = disabled
		b.c = v
	case discord.ChannelSelectMenuComponent:
		v.Disabled = disabled
		b.c = v
	case discord.MentionableSelectMenuComponent:
		v.Disabled = disabled
		b.c = v
	}
	return b
}

// WithEmoji puts an emoji on a button.
func (b Component) WithEmoji(emoji discord.ComponentEmoji) Component {
	if v, ok := b.c.(discord.ButtonComponent); ok {
		v.Emoji = &emoji
		b.c = v
	}
	return b
}

// WithRange lets a select menu take between min and max values. Without it a
// menu takes exactly one.
func (b Component) WithRange(min, max int) Component {
	if min < 0 || max < min {
		b.err = errors.Join(b.err, fmt.Errorf("strut: select range %d to %d is impossible", min, max))
		return b
	}

	switch v := b.c.(type) {
	case discord.StringSelectMenuComponent:
		v.MinValues, v.MaxValues = &min, max
		b.c = v
	case discord.UserSelectMenuComponent:
		v.MinValues, v.MaxValues = &min, max
		b.c = v
	case discord.RoleSelectMenuComponent:
		v.MinValues, v.MaxValues = &min, max
		b.c = v
	case discord.ChannelSelectMenuComponent:
		v.MinValues, v.MaxValues = &min, max
		b.c = v
	case discord.MentionableSelectMenuComponent:
		v.MinValues, v.MaxValues = &min, max
		b.c = v
	default:
		b.err = errors.Join(b.err, errors.New("strut: WithRange applies to select menus only"))
	}
	return b
}

// Row adds one action row. Discord allows up to five buttons in a row, or a
// single select menu on its own.
func (r Reply) Row(components ...Component) Reply {
	if len(components) == 0 {
		return r
	}
	if len(components) > maxRowComponents {
		r.err = errors.Join(r.err, errTooManyInRow(len(components)))
		return r
	}

	out := make([]discord.InteractiveComponent, 0, len(components))
	for _, c := range components {
		if c.err != nil {
			r.err = errors.Join(r.err, c.err)
			continue
		}
		out = append(out, c.c)
	}
	if r.err != nil {
		return r
	}

	r.Components = append(r.Components, discord.NewActionRow(out...))
	return r
}

// maxRowComponents is Discord's per-row limit.
const maxRowComponents = 5

func errTooManyInRow(n int) error {
	return fmt.Errorf("strut: %d components in one row, max %d", n, maxRowComponents)
}

func encodeState[S any](state S) (string, error) {
	c, err := codecFor(reflect.TypeFor[S]())
	if err != nil {
		return "", err
	}
	return c.encode(reflect.ValueOf(state))
}

// OnComponent registers a handler for components carrying S. The route comes
// from S's type name, so it survives a restart.
func (f *Framework[D]) OnComponent[S any](h func(*Event[D], S) error) *Framework[D] {
	c, err := codecFor(reflect.TypeFor[S]())
	if err != nil {
		f.errs = append(f.errs, err)
		return f
	}
	if err := f.claim(c.route, c.typ.Name()); err != nil {
		f.errs = append(f.errs, err)
		return f
	}

	f.register(c.route, func(ev *Event[D], state reflect.Value) *Error[D] {
		ev.meta = Meta{Name: c.route}

		if !f.live.begin() {
			return &Error[D]{Kind: ErrShuttingDown, Event: ev}
		}
		defer f.live.done()

		return f.wrap(ev, f.chain(func(e *Event[D]) error {
			return h(e, state.Interface().(S))
		})(ev))
	})

	f.mux.Component(c.route, func(e *handler.ComponentEvent) error {
		state, err := c.decode(e.Vars)
		if err != nil {
			return err
		}
		return f.runComponent(e, c.route, func(ev *Event[D]) error {
			return h(ev, state.Interface().(S))
		})
	})
	return f
}

// OnSelect registers a handler for a select menu carrying S. The chosen
// values are decoded into V.
func (f *Framework[D]) OnSelect[S, V any](h func(*Event[D], S, []V) error) *Framework[D] {
	c, err := codecFor(reflect.TypeFor[S]())
	if err != nil {
		f.errs = append(f.errs, err)
		return f
	}
	if err := f.claim(c.route, c.typ.Name()); err != nil {
		f.errs = append(f.errs, err)
		return f
	}

	valueOf, err := stateSetter(fieldSpec{Type: reflect.TypeFor[V]()})
	if err != nil {
		f.errs = append(f.errs, fmt.Errorf("strut: select values: %w", err))
		return f
	}

	f.mux.SelectMenuComponent(c.route, func(data discord.SelectMenuInteractionData, e *handler.ComponentEvent) error {
		state, err := c.decode(e.Vars)
		if err != nil {
			return err
		}

		sm, ok := data.(discord.StringSelectMenuInteractionData)
		if !ok {
			return fmt.Errorf("strut: %s is not a string select menu", c.route)
		}

		values := make([]V, 0, len(sm.Values))
		for _, raw := range sm.Values {
			v := reflect.New(reflect.TypeFor[V]())
			if err := valueOf(v.Elem(), raw); err != nil {
				return err
			}
			values = append(values, v.Elem().Interface().(V))
		}

		return f.runComponent(e, c.route, func(ev *Event[D]) error {
			return h(ev, state.Interface().(S), values)
		})
	})
	return f
}

// OnEntitySelect registers a handler for a user, role, channel or mentionable
// select carrying S. Those menus always return ids.
func (f *Framework[D]) OnEntitySelect[S any](h func(*Event[D], S, []snowflake.ID) error) *Framework[D] {
	c, err := codecFor(reflect.TypeFor[S]())
	if err != nil {
		f.errs = append(f.errs, err)
		return f
	}
	if err := f.claim(c.route, c.typ.Name()); err != nil {
		f.errs = append(f.errs, err)
		return f
	}

	f.register(c.route, func(ev *Event[D], state reflect.Value) *Error[D] {
		return &Error[D]{Kind: ErrCommandFailed, Event: ev,
			Err: errors.New("strut: an entity select is driven by its chosen ids")}
	})

	f.mux.SelectMenuComponent(c.route, func(data discord.SelectMenuInteractionData, e *handler.ComponentEvent) error {
		state, err := c.decode(e.Vars)
		if err != nil {
			return err
		}

		var ids []snowflake.ID
		switch d := data.(type) {
		case discord.UserSelectMenuInteractionData:
			ids = d.Values
		case discord.RoleSelectMenuInteractionData:
			ids = d.Values
		case discord.ChannelSelectMenuInteractionData:
			ids = d.Values
		case discord.MentionableSelectMenuInteractionData:
			ids = d.Values
		default:
			return fmt.Errorf("strut: %s is not an entity select menu", c.route)
		}

		return f.runComponent(e, c.route, func(ev *Event[D]) error {
			return h(ev, state.Interface().(S), ids)
		})
	})
	return f
}

// runComponent builds an Event for a component interaction and reports any
// failure through the framework's error handler.
func (f *Framework[D]) runComponent(ce *handler.ComponentEvent, route string, run func(*Event[D]) error) error {
	ctx, cancel := tokenContext(ce.Ctx, ce.CreatedAt())
	defer cancel()

	e := &Event[D]{
		data:   f.opts.Data,
		ctx:    ctx,
		client: ce.Client(),
		log:    f.log,
		kind:   Slash,
		meta:   Meta{Name: route},
		fw:     f,
		src:    interactionSource[*handler.ComponentEvent]{ce},
		res:    componentResponder{ce},
		opener: componentResponder{ce},
	}

	if err := f.chain(run)(e); err != nil {
		var already *Error[D]
		if !errors.As(err, &already) {
			already = &Error[D]{Kind: ErrCommandFailed, Event: e, Err: err}
		}
		f.report(nil, already)
	}
	return nil
}

// register records a component handler so the test harness can drive it.
func (f *Framework[D]) register(route string, h func(*Event[D], reflect.Value) *Error[D]) {
	if f.components == nil {
		f.components = map[string]func(*Event[D], reflect.Value) *Error[D]{}
	}
	f.components[route] = h
}

// wrap turns a handler error into the framework's error type.
func (f *Framework[D]) wrap(e *Event[D], err error) *Error[D] {
	if err == nil {
		return nil
	}
	var already *Error[D]
	if errors.As(err, &already) {
		return already
	}
	return &Error[D]{Kind: ErrCommandFailed, Event: e, Err: err}
}