dcmd

type AdvUserArg struct {
	EnableUserID         bool // Whether to check for user IDS
	EnableUsernameSearch bool // Whether to search for usernames
	RequireMembership    bool // Whether this requires a membership of the server, if set then Member will always be populated
}

type AdvUserMatch struct {
	// Member may not be present if "RequireMembership" is false
	Member *dstate.MemberState

	// User is always present
	User *discordgo.User
}

type ArgDef struct {
	Name    string
	Type    ArgType
	Help    string
	Default interface{}

	// Choices and AutocompleteFunc are mutually exclusive and only apply to interaction commands
	Choices          []*discordgo.ApplicationCommandOptionChoice
	AutocompleteFunc func(data *Data, arg *ParsedArg) (choices []*discordgo.ApplicationCommandOptionChoice, err error)
}

type ArgType interface {
	// CheckCompatibility reports the degree to which the input matches the type.
	CheckCompatibility(def *ArgDef, part string) CompatibilityResult

	// Attempt to parse it, returning any error if one occured.
	ParseFromMessage(def *ArgDef, part string, data *Data) (val interface{}, err error)
	ParseFromInteraction(def *ArgDef, data *Data, options *SlashCommandsParseOptions) (val interface{}, err error)

	// Name as shown in help
	HelpName() string

	SlashCommandOptions(def *ArgDef) []*discordgo.ApplicationCommandOption
}

type Category struct {
	Name        string
	Description string
	HelpEmoji   string
	EmbedColor  int
}

type ChannelArg struct {
	AllowThreads bool
}

type ChannelNotFound struct {
	ID int64
}

type Cmd interface {
	// Run the command with the provided data,
	// response is either string, error, embed or custom that implements CmdResponse
	// if response is nil, and an error is returned that is not PublicError,
	// the string "An error occured. Contact bot owner" becomes the response
	Run(data *Data) (interface{}, error)
}

type CmdDescArgDefs interface {
	Cmd

	CmdWithDescriptions
	CmdWithArgDefs
}

type CmdWithArgDefs interface {

	/*
		Returns the argument definitions

		if 'combos' is non nil, then that takes priority over 'required'
		Combos wllows the command to take different combinations and orders of arguments

		Example: a `clean` command that deletes x amount of messages and can optionally filter by user
		could look like this
		“`
		argDefs = []*ArgDef{
		    {Name: "limit", Type: Int, Default: 10},
		    {Name: "user", Type: User, RequireMention: true},
		}
		requiredArgs = 0
		“`
		Here the clean command can take any number of arguments, if no arguments are passed, limit will be 10, and user will be nil.
		if only a limit is provided, then user will be nil and
		Here we have the 2 arguments, and atm we can only invoke this as `clean x` or `clean x @user`
		using combos we can also allow any order here, this is possible because the user arg cannot be a number.
		so if we use the combos:
		“`
		combos = [][]int{
			[]int{0},   // Allow only a limit to be passed
			[]int{0,1}, // Allow both a limit and user to be passed, in that order
			[]int{1},   // Allow only a user to be passed, then limit will have its default value of 10
			[]int{1,0}, // Allow both a user and limit to be passed, in that order
			[]int{},    // Allow no arguments to be passe, limit will then have its default of 10, and user will be nil
		}
		“`
		As you can see, the integers are indexes in the argument definitions returned. The above combos will allow any combination or arguments, even none.

		Argument combos generally work as expected in non-ambiguous cases, but it cannot for example detect the difference between two text arguments.
	*/
	ArgDefs(data *Data) (args []*ArgDef, required int, combos [][]int)
}

type CmdWithCanUse interface {
	CanUse(data *Data) (bool, error)
}

type CmdWithCategory interface {
	Category() *Category
}

type CmdWithCustomParser interface {

	// Parse the arguments and return the command data
	// sripped is the rest of the message with the command name removed
	Parse(stripped string, data *Data) (*Data, error)
}

type CmdWithDescriptions interface {
	Descriptions(data *Data) (short, long string)
}

type CmdWithSwitches interface {
	Switches() []*ArgDef
}

type CompatibilityResult int

type Container struct {
	// Default mention handler, used when the bot is mentioned without any command specified
	DefaultMention RunFunc

	// Default not found handler, called when no command is found from input
	NotFound RunFunc

	// Default DM not found handler, same as NotFound but for Direct Messages, if none specified
	// will use notfound if set.
	DMNotFound RunFunc

	// Set to ignore bots
	IgnoreBots bool
	// Dumps the stack in a response message when a panic happens in a command
	SendStackOnPanic bool
	// Set to send error messages that a command returned as a response message
	SendError bool
	// Set to also run this muxer in dm's
	RunInDM bool

	// The muxer names
	Names []string
	// The muxer description
	Description string
	// The muxer long description
	LongDescription string

	// Commands this muxer will check
	Commands []*RegisteredCommand

	HelpTitleEmoji string
	HelpColor      int
	HelpOwnEmbed   bool
	Category       string

	Parent *Container
	// contains filtered or unexported fields
}

type Data struct {
	Cmd      *RegisteredCommand
	Args     []*ParsedArg
	Switches map[string]*ParsedArg

	// These fields are always available
	ChannelID int64
	Author    *discordgo.User

	// Only set if this command was not ran through slash commands
	TraditionalTriggerData *TraditionalTriggerData

	// Only set if this command was ran through discord slash commands
	SlashCommandTriggerData *SlashCommandTriggerData

	// Only provided if the command was ran in a DM Context
	GuildData *GuildContextData

	// The session that triggered the command
	Session *discordgo.Session

	Source      TriggerSource
	TriggerType TriggerType

	// The chain of containers we went through, first element is always root
	ContainerChain []*Container

	// The system that triggered this command
	System *System
	// contains filtered or unexported fields
}

type ErrArgExpectedType struct {
	Name     string
	Expected string
	Got      string
}

type ErrResolvedNotFound struct {
	Key  string
	ID   int64
	Type string
}

type FloatArg struct {
	Min, Max float64
}

type GuildContextData struct {
	CS *dstate.ChannelState
	GS *dstate.GuildSet
	MS *dstate.MemberState
}

type HelpFormatter interface {
	// Called when there is help generated for 2 or more commands
	ShortCmdHelp(cmd *RegisteredCommand, container *Container, data *Data) string

	// Called when help is only generated for 1 command
	// You are supposed to dump all command detilas such as arguments
	// the long description if it has one, switches and whatever else you have in mind.
	FullCmdHelp(cmd *RegisteredCommand, container *Container, data *Data) *discordgo.MessageEmbed
}

type ImproperMention struct {
	Part string
}

type IntArg struct {
	Min, Max int64

	// if we wanna support large numbers like snowflakes we have to use strings with interactions
	InteractionString bool
}

type InvalidFloat struct {
	Part string
}

type InvalidInt struct {
	Part string
}

type MiddleWareFunc func(next RunFunc) RunFunc

type NoMention struct {
	Part string
}

type OutOfRangeError struct {
	Min, Max interface{}
	Got      interface{}
	Float    bool
	ArgName  string
}

type ParsedArg struct {
	Def   *ArgDef
	Value interface{}
	Raw   *RawArg
}

type PrefixProvider interface {
	Prefix(data *Data) string
}

type RawArg struct {
	Str       string
	Container rune
}

type RegisteredCommand struct {
	Command Cmd
	Trigger *Trigger
	// contains filtered or unexported fields
}

type Response interface {
	// Channel, session, command etc can all be found in this context
	Send(data *Data) ([]*discordgo.Message, error)
}

type ResponseSender interface {
	SendResponse(cmdData *Data, resp interface{}, err error) error
}

type RunFunc func(data *Data) (interface{}, error)

type SimpleCmd struct {
	ShortDesc, LongDesc string

	CmdArgDefs      []*ArgDef
	RequiredArgDefs int
	ArgDefCombos    [][]int

	CmdSwitches []*ArgDef

	RunFunc func(data *Data) (interface{}, error)
}

type SimplePrefixProvider struct {
	// contains filtered or unexported fields
}

type SlashCommandTriggerData struct {
	Interaction *discordgo.Interaction
	// The options slice for the command options themselves
	// This is a helper so you don't have to dig it out yourself in the case of nested subcommands
	Options []*discordgo.ApplicationCommandInteractionDataOption
}

type SlashCommandsParseOptions struct {
	Options     map[string]*discordgo.ApplicationCommandInteractionDataOption
	Interaction *discordgo.Interaction
}

type SortedCommandEntry struct {
	Cmd       *RegisteredCommand
	Container *Container
}

type SortedCommandSet struct {
	Commands []*SortedCommandEntry

	// Set if this is a set of commands grouped by categories
	Category *Category

	// Set if this is a container helpContainer
	Container *Container
}

type StdHelpCommand struct {
	SendFullInDM      bool
	SendTargettedInDM bool

	Formatter HelpFormatter
}

type StdHelpFormatter struct{}

type StdResponseSender struct {
	LogErrors bool
}

type StringArg struct{}

type System struct {
	Root           *Container
	Prefix         PrefixProvider
	ResponseSender ResponseSender
	State          dstate.StateTracker
}

type TemporaryResponse struct {
	Response       interface{}
	Duration       time.Duration
	EscapeEveryone bool
}

type TraditionalTriggerData struct {
	Message               *discordgo.Message
	MessageStrippedPrefix string
	PrefixUsed            string
}

type Trigger struct {
	Names       []string
	Middlewares []MiddleWareFunc

	HideFromHelp bool

	EnableInDM            bool
	EnableInGuildChannels bool
	EnableInThreads       bool
}

type TriggerSource int

type TriggerType int

type UserArg struct{}

type UserError interface {
	IsUserError() bool
}

type UserIDArg struct{}

type UserNotFound struct {
	Part string
}