prefixargs.go

package strut

// Prefix commands receive a line of text rather than a structured payload, so
// every option needs a parser of its own, and arguments are positional.

import (
	"fmt"
	"reflect"
	"strconv"
	"strings"
	"time"

	"github.com/disgoorg/snowflake/v2"
)

// textSetter fills one field from the command line.
type textSetter struct {
	index    []int
	name     string
	flag     bool
	rest     bool
	lazy     bool
	opt      bool
	variadic bool
	elem     reflect.Type // element type, for a variadic setter
	fn       func(dst reflect.Value, tok string) error
}

// decodeText fills a command from text arguments, positionally in declaration
// order.
func (dec *decoder) decodeText(proto reflect.Value, lex *Lexer) (reflect.Value, error) {
	out := reflect.New(dec.typ)
	out.Elem().Set(proto)

	// Flags are named, so they are pulled out wherever they appear before
	// positional parsing consumes the rest.
	tokens, flags := splitFlags(lex, dec.text)

	pos := 0
	for i, s := range dec.text {
		dst := out.Elem().FieldByIndex(s.index)

		if s.flag {
			if flags[s.name] {
				if err := s.fn(dst, "true"); err != nil {
					return reflect.Value{}, err
				}
			}
			continue
		}

		// A variadic soaks up every remaining argument, parsing each one.
		if s.variadic {
			left := tokens[pos:]
			pos = len(tokens)

			out := reflect.MakeSlice(reflect.SliceOf(s.elem), len(left), len(left))
			for i, tok := range left {
				if err := s.fn(out.Index(i), tok); err != nil {
					return reflect.Value{}, err
				}
			}
			dst.Set(out)
			continue
		}

		if s.rest {
			left := strings.Join(tokens[pos:], " ")
			pos = len(tokens)
			if left == "" {
				if s.opt {
					continue
				}
				return reflect.Value{}, &ArgumentError{Field: s.name}
			}
			if err := s.fn(dst, left); err != nil {
				return reflect.Value{}, err
			}
			continue
		}

		if pos >= len(tokens) {
			if s.opt {
				continue
			}
			return reflect.Value{}, &ArgumentError{Field: s.name}
		}
		// A lazy optional yields its token unless there are enough left for
		// everything after it.
		if s.opt && s.lazy && len(tokens)-pos <= remainingRequired(dec.text[i+1:]) {
			continue
		}
		if err := s.fn(dst, tokens[pos]); err != nil {
			return reflect.Value{}, err
		}
		pos++
	}
	return out, nil
}

func remainingRequired(rest []textSetter) int {
	n := 0
	for _, s := range rest {
		if !s.opt && !s.flag {
			n++
		}
	}
	return n
}

// splitFlags consumes every token, separating --name flags from positionals.
func splitFlags(lex *Lexer, setters []textSetter) ([]string, map[string]bool) {
	known := map[string]bool{}
	for _, s := range setters {
		if s.flag {
			known[s.name] = true
		}
	}

	var tokens []string
	flags := map[string]bool{}
	for {
		tok, ok := lex.Next()
		if !ok {
			return tokens, flags
		}
		if name, found := strings.CutPrefix(tok, "--"); found && known[name] {
			flags[name] = true
			continue
		}
		tokens = append(tokens, tok)
	}
}

// newTextSetters compiles text parsers, rejecting types a prefix command
// cannot receive.
func newTextSetters(spec *structSpec) ([]textSetter, error) {
	out := make([]textSetter, 0, len(spec.Fields))

	for _, f := range spec.Fields {
		fn, err := textSetterFor(f)
		if err != nil {
			return nil, err
		}
		out = append(out, textSetter{
			index:    f.Index,
			name:     f.Tag.Name,
			flag:     f.Tag.Flag,
			rest:     f.Tag.Rest,
			lazy:     f.Tag.Lazy,
			opt:      f.Optional,
			variadic: f.Variadic,
			elem:     f.Type,
			fn:       fn,
		})
	}
	return out, nil
}

func textSetterFor(f fieldSpec) (func(reflect.Value, string) error, error) {
	check, err := fieldValidator(f)
	if err != nil {
		return nil, err
	}

	name, target, optional := f.Tag.Name, f.Type, f.Optional
	wrap := func(v reflect.Value, dst reflect.Value, raw string) error {
		if err := store(dst, v, target, optional, check); err != nil {
			return &ArgumentError{Field: name, Input: raw, Err: err}
		}
		return nil
	}

	// A custom type parses itself, which is how entity-like options reach
	// prefix commands.
	if reflect.PointerTo(f.Type).Implements(textArgumentType) {
		return func(dst reflect.Value, tok string) error {
			v := reflect.New(target)
			if err := v.Interface().(TextArgument).FromText(NewLexer(tok)); err != nil {
				return &ArgumentError{Field: name, Input: tok, Err: err}
			}
			return wrap(v.Elem(), dst, tok)
		}, nil
	}

	switch f.Type {
	case snowflakeType:
		return parseWith(wrap, name, parseSnowflake), nil
	case durationType:
		return parseWith(wrap, name, time.ParseDuration), nil
	}

	switch f.Kind {
	case kindString:
		return func(dst reflect.Value, tok string) error {
			return wrap(reflect.ValueOf(tok), dst, tok)
		}, nil
	case kindInt:
		return parseWith(wrap, name, func(s string) (int64, error) {
			return strconv.ParseInt(s, 10, 64)
		}), nil
	case kindFloat:
		return parseWith(wrap, name, func(s string) (float64, error) {
			return strconv.ParseFloat(s, 64)
		}), nil
	case kindBool:
		return parseWith(wrap, name, strconv.ParseBool), nil
	}

	return nil, fmt.Errorf(
		"option %q: %s cannot be parsed from text; implement TextArgument or drop Prefix from Kinds",
		f.Tag.Name, f.Kind)
}

func parseWith[T any](
	wrap func(reflect.Value, reflect.Value, string) error,
	name string,
	parse func(string) (T, error),
) func(reflect.Value, string) error {
	return func(dst reflect.Value, tok string) error {
		v, err := parse(tok)
		if err != nil {
			return &ArgumentError{Field: name, Input: tok, Err: err}
		}
		return wrap(reflect.ValueOf(v), dst, tok)
	}
}

// parseSnowflake accepts a raw ID or any of Discord's mention forms.
func parseSnowflake(s string) (snowflake.ID, error) {
	trimmed := strings.Trim(s, "<>@!#&")
	return snowflake.Parse(trimmed)
}