layout.go

package strut

import (
	"errors"

	"github.com/disgoorg/disgo/discord"
)

// Discord's newer layout components. They need the IsComponentsV2 message
// flag, which strut sets whenever a reply uses one.

// Text starts a reply built from layout components.
func Text(content string) Reply { return Reply{}.Text(content) }

// Text adds a block of markdown as its own component.
func (r Reply) Text(content string) Reply {
	r.v2 = true
	r.Components = append(r.Components, discord.NewTextDisplay(content))
	return r
}

// Textf adds formatted markdown.
func (r Reply) Textf(format string, a ...any) Reply {
	r.v2 = true
	r.Components = append(r.Components, discord.NewTextDisplayf(format, a...))
	return r
}

// Separator adds a divider.
func (r Reply) Separator() Reply {
	r.v2 = true
	r.Components = append(r.Components, discord.NewSeparator(discord.SeparatorSpacingSizeSmall))
	return r
}

// Section pairs text with one accessory, such as a button or a thumbnail.
type Section struct {
	text      []string
	accessory discord.SectionAccessoryComponent
	err       error
}

// NewSection starts a section holding the given markdown blocks.
func NewSection(text ...string) Section { return Section{text: text} }

// WithButton puts a button beside the text.
func (s Section) WithButton(b Component) Section {
	if b.err != nil {
		s.err = errors.Join(s.err, b.err)
		return s
	}
	if btn, ok := b.c.(discord.ButtonComponent); ok {
		s.accessory = btn
	}
	return s
}

// WithThumbnail puts an image beside the text.
func (s Section) WithThumbnail(url string) Section {
	s.accessory = discord.NewThumbnail(url)
	return s
}

// Section adds a section to the reply.
func (r Reply) Section(s Section) Reply {
	if s.err != nil {
		r.err = errors.Join(r.err, s.err)
		return r
	}

	subs := make([]discord.SectionSubComponent, 0, len(s.text))
	for _, t := range s.text {
		subs = append(subs, discord.NewTextDisplay(t))
	}

	section := discord.NewSection(subs...)
	if s.accessory != nil {
		section = section.WithAccessory(s.accessory)
	}

	r.v2 = true
	r.Components = append(r.Components, section)
	return r
}

// Container groups components behind an accent colour.
type Container struct {
	components []discord.ContainerSubComponent
	color      int
	err        error
}

// NewContainer starts a container.
func NewContainer() Container { return Container{} }

// WithColor sets the accent colour.
func (c Container) WithColor(color int) Container { c.color = color; return c }

// Text adds markdown inside the container.
func (c Container) Text(content string) Container {
	c.components = append(c.components, discord.NewTextDisplay(content))
	return c
}

// Row adds a row of components inside the container.
func (c Container) Row(components ...Component) Container {
	if len(components) == 0 {
		return c
	}
	if len(components) > maxRowComponents {
		c.err = errors.Join(c.err, errTooManyInRow(len(components)))
		return c
	}

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

// Separator adds a divider inside the container.
func (c Container) Separator() Container {
	c.components = append(c.components, discord.NewSeparator(discord.SeparatorSpacingSizeSmall))
	return c
}

// Container adds a container to the reply.
func (r Reply) Container(c Container) Reply {
	if c.err != nil {
		r.err = errors.Join(r.err, c.err)
		return r
	}

	container := discord.NewContainer(c.components...)
	if c.color != 0 {
		container = container.WithAccentColor(c.color)
	}

	r.v2 = true
	r.Components = append(r.Components, container)
	return r
}