cmds

type BareCommand interface {
	Command
	Run(ctx context.Context, parsedValues *values.Values) error
}

type Command interface {
	Description() *CommandDescription
	ToYAML(w io.Writer) error
}

type CommandDescription struct {
	Name  string `yaml:"name"`
	Short string `yaml:"short"`
	Long  string `yaml:"long,omitempty"`
	// TODO(manuel, 2023-12-21) Does this need to be a list of pointers? Could it just be a list of struct?
	Layout         []*layout.Section      `yaml:"layout,omitempty"`
	Schema         *schema.Schema         `yaml:"schema,omitempty"`
	AdditionalData map[string]interface{} `yaml:"additionalData,omitempty"`
	Type           string                 `yaml:"type,omitempty"`
	Tags           []string               `yaml:"tags,omitempty"`
	Metadata       map[string]interface{} `yaml:"metadata,omitempty"`

	Parents []string `yaml:",omitempty"`
	// Source indicates where the command was loaded from, to make debugging easier.
	Source string `yaml:",omitempty"`
}

type CommandDescriptionOption func(*CommandDescription)

type CommandJsonSchema struct {
	Type        string                         `json:"type"`
	Description string                         `json:"description,omitempty"`
	Properties  map[string]*JsonSchemaProperty `json:"properties"`
	Required    []string                       `json:"required,omitempty"`
}

type CommandWithMetadata interface {
	Command
	Metadata(ctx context.Context, parsedValues *values.Values) (map[string]interface{}, error)
}

type ExitWithoutGlazeError struct{}

type GlazeCommand interface {
	Command
	// RunIntoGlazeProcessor is called to actually execute the command.
	//
	// NOTE(manuel, 2023-02-27) We can probably simplify this to only take resolved values
	//
	// The ps and GlazeProcessor calls could be replaced by a GlazeCommand specific section,
	// which would allow the GlazeCommand to parse into a specific struct. The GlazeProcessor
	// is just something created by the passed in GlazeSection anyway.
	//
	// When we are just left with building a convenience wrapper for Glaze based commands,
	// instead of forcing it into the upstream interface.
	//
	// https://github.com/go-go-golems/glazed/issues/217
	// https://github.com/go-go-golems/glazed/issues/216
	// See https://github.com/go-go-golems/glazed/issues/173
	RunIntoGlazeProcessor(ctx context.Context, parsedValues *values.Values, gp middlewares.Processor) error
}

type JsonSchemaProperty struct {
	Type                 string                         `json:"type"`
	Description          string                         `json:"description,omitempty"`
	Enum                 []string                       `json:"enum,omitempty"`
	Default              interface{}                    `json:"default,omitempty"`
	Items                *JsonSchemaProperty            `json:"items,omitempty"`
	Required             bool                           `json:"-"`
	Properties           map[string]*JsonSchemaProperty `json:"properties,omitempty"`
	AdditionalProperties *JsonSchemaProperty            `json:"additionalProperties,omitempty"`
}

type TemplateCommand struct {
	*CommandDescription
	Template string
}

type TemplateCommandDescription struct {
	Name      string               `yaml:"name"`
	Short     string               `yaml:"short"`
	Long      string               `yaml:"long,omitempty"`
	Layout    []*layout.Section    `yaml:"layout,omitempty"`
	Flags     []*fields.Definition `yaml:"flags,omitempty"`
	Arguments []*fields.Definition `yaml:"arguments,omitempty"`
	Schema    schema.Schema        `yaml:"schema,omitempty"`
	Template  string               `yaml:"template"`
}

type TemplateCommandLoader struct{}

type WriterCommand interface {
	Command
	RunIntoWriter(ctx context.Context, parsedValues *values.Values, w io.Writer) error
}