dukkha

type ArbitraryValues struct {
	rs.BaseField

	Data map[string]*rs.AnyObject `rs:"other"`
}

type ConfigResolvingContext interface {
	Context

	ShellManager
	ToolManager
	TaskManager
	RendererManager
}

type Context interface {
	TaskExecContext

	RunTask(ToolKey, TaskKey) error
}

type Env []*EnvEntry

type EnvEntry struct {
	rs.BaseField

	Name  string `yaml:"name"`
	Value string `yaml:"value"`
}

type EnvValues interface {
	GlobalValues

	SetMatrixFilter(mf map[string][]string)
	MatrixFilter() map[string][]string

	MatrixArch() string
	MatrixKernel() string
	MatrixLibc() string

	AddEnv(override bool, env ...*EnvEntry)
	AddListEnv(env ...string)
}

type ExecSpecGetFunc func(toExec []string, isFilePath bool) (env Env, cmd []string, err error)

type ExecValues interface {
	SetOutputPrefix(s string)
	OutputPrefix() string

	SetTaskColors(prefixColor, outputColor termenv.Color)
	PrefixColor() termenv.Color
	OutputColor() termenv.Color

	CurrentTool() ToolKey
	CurrentTask() TaskKey

	SetTask(k ToolKey, tK TaskKey)
}

type GlobalValues interface {
	SetCacheDir(dir string)
	OverrideDefaultGitBranch(branch string)

	WorkingDir() string
	CacheDir() string

	GitBranch() string
	GitWorkTreeClean() bool
	GitTag() string
	GitDefaultBranch() string
	GitCommit() string

	HostKernel() string
	HostKernelVersion() string
	HostArch() string
	HostOS() string
	HostOSVersion() string
}

type Renderer interface {
	rs.Field

	// Init the renderer and add itself to the context
	Init(ctx ConfigResolvingContext) error

	RenderYaml(rc RenderingContext, rawData interface{}) (result []byte, err error)
}

type RendererCreateFunc func() Renderer

type RendererManager interface {
	AllRenderers() map[string]Renderer
	AddRenderer(name string, renderer Renderer)
}

type RenderingContext interface {
	context.Context

	expand.Environ

	GlobalValues
	EnvValues

	// AddValues will merge provided values into existing values
	AddValues(values map[string]interface{}) error

	Env() map[string]string

	Values() map[string]interface{}

	rs.InterfaceTypeHandler
	rs.RenderingHandler
}

type ReplaceEntries map[string]*ReplaceEntry

type ReplaceEntry struct {
	Data []byte
	Err  error
}

type RunTaskOrRunCmd interface{}

type Shell interface {
	rs.Field

	GetExecSpec(toExec []string, isFilePath bool) (env Env, cmd []string, err error)
}

type ShellManager interface {
	AddShell(name string, impl Shell)
}

type ShellUser interface {
	GetShell(name string) (Shell, bool)
	AllShells() map[string]Shell
}

type Task interface {
	rs.Field

	// Kind of the tool managing this task (e.g. docker)
	ToolKind() ToolKind

	// Name of the tool managing this task (e.g. my-tool)
	ToolName() ToolName

	// Kind of the task (e.g. build)
	Kind() TaskKind

	// Name of the task (e.g. foo)
	Name() TaskName

	// Key of this task
	Key() TaskKey

	// GetMatrixSpecs for matrix execution
	//
	// The implementation MUST be safe to be used concurrently
	GetMatrixSpecs(rc RenderingContext) ([]matrix.Entry, error)

	// GetExecSpecs generate commands using current field values
	//
	// The implementation MUST be safe to be used concurrently
	GetExecSpecs(rc TaskExecContext, options TaskMatrixExecOptions) ([]TaskExecSpec, error)

	// GetHookExecSpecs generate hook run target
	//
	// The implementation MUST be safe to be used concurrently
	GetHookExecSpecs(ctx TaskExecContext, state TaskExecStage) ([]RunTaskOrRunCmd, error)

	// DoAfterFieldsResolved is a helper function to ensure no data race
	//
	// The implementation MUST be safe to be used concurrently
	DoAfterFieldsResolved(
		rc RenderingContext,
		depth int,
		do func() error,
		fieldNames ...string,
	) error

	ContinueOnError() bool
}

type TaskCreateFunc func(toolName string) Task

type TaskExecContext interface {
	context.Context

	RenderingContext
	ShellUser
	ToolUser
	TaskUser

	DeriveNew() Context

	Cancel()

	TranslateANSIStream() bool
	RetainANSIStyle() bool
	ColorOutput() bool
	FailFast() bool
	ClaimWorkers(n int) int

	ExecValues
}

type TaskExecOptions interface {
	NextMatrixExecOptions(useShell bool, shellName string, toolCmd []string) TaskMatrixExecOptions
}

type TaskExecSpec struct {
	// Delay execution
	Delay time.Duration

	// StdoutAsReplace to replace same string in following TaskExecSpecs
	// use output to stdout of this exec
	StdoutAsReplace string

	// ShowStdout when StdoutAsReplace is set
	ShowStdout bool

	FixStdoutValueForReplace func(data []byte) []byte

	// StderrAsReplace to replace same string in following TaskExecSpecs
	// use output to stderr of this exec
	StderrAsReplace string

	// ShowStderr when StderrAsReplace is set
	ShowStderr bool

	FixStderrValueForReplace func(data []byte) []byte

	Chdir string

	// EnvSuggest to provide environment variables when not set by user
	EnvSuggest Env
	// EnvOverride to override existing environment variables
	EnvOverride Env

	Command []string

	AlterExecFunc func(
		replace ReplaceEntries,
		stdin io.Reader, stdout, stderr io.Writer,
	) (RunTaskOrRunCmd, error)

	Stdin io.Reader

	IgnoreError bool

	// UseShell if true, write command to local script cache
	// and execute with the target shell (as referenced by ShellName)
	UseShell bool

	// ShellName to reference a shell to execute command
	// when `UseShell` is true
	//
	// the availability of the shells denpends on `shells` in dukkha config
	// a special shell name is `embedded`, which will use the built-in shell
	// for command evaluation
	ShellName string
}

type TaskExecStage uint8

type TaskKey struct {
	Kind TaskKind
	Name TaskName
}

type TaskKind string

type TaskManager interface {
	AddToolSpecificTasks(kind ToolKind, name ToolName, tasks []Task)
}

type TaskMatrixExecOptions interface {
	ID() int
	Total() int

	UseShell() bool
	ShellName() string
	ToolCmd() []string

	Seq() int

	IsLast() bool
}

type TaskName string

type TaskReference struct {
	ToolKind ToolKind
	ToolName ToolName
	TaskKind TaskKind
	TaskName TaskName

	MatrixFilter map[string][]string
}

type TaskUser interface {
	GetToolSpecificTasks(k ToolKey) ([]Task, bool)
	AllToolSpecificTasks() map[ToolKey][]Task
}

type Tool interface {
	rs.Field

	// Kind of the tool, e.g. golang, docker
	Kind() ToolKind

	Name() ToolName

	Key() ToolKey

	GetCmd() []string

	GetEnv() Env

	UseShell() bool

	ShellName() string

	GetTask(TaskKey) (Task, bool)

	Init(kind ToolKind, cachdDir string) error

	ResolveTasks(tasks []Task) error

	Run(taskCtx TaskExecContext) error

	DoAfterFieldsResolved(
		mCtx TaskExecContext,
		depth int,
		do func() error,
		fieldNames ...string,
	) error
}

type ToolCreateFunc func() Tool

type ToolKey struct {
	Kind ToolKind
	Name ToolName
}

type ToolKind string

type ToolManager interface {
	AddTool(k ToolKey, t Tool)
}

type ToolName string

type ToolUser interface {
	AllTools() map[ToolKey]Tool
	GetTool(k ToolKey) (Tool, bool)
}