workflow

type AtmosExecParams struct {
	// Ctx is the context for cancellation.
	Ctx context.Context
	// AtmosConfig is the atmos configuration.
	AtmosConfig *schema.AtmosConfiguration
	// Args are command arguments (e.g., ["terraform", "plan", "vpc"]).
	Args []string
	// Dir is the working directory for the command.
	Dir string
	// Env are environment variables for the command.
	Env []string
	// DryRun if true, don't actually execute the command.
	DryRun bool
}

type AtmosExecutor func(params *AtmosExecParams) error

type AuthProvider interface {
	// NeedsAuth returns true if authentication is needed for the given steps.
	NeedsAuth(steps []schema.WorkflowStep, commandLineIdentity string) bool

	// Authenticate performs authentication for the given identity.
	// Returns an error if authentication fails.
	Authenticate(ctx context.Context, identity string) error

	// GetCachedCredentials returns cached credentials for the identity.
	// Returns an error if no valid cached credentials are available.
	GetCachedCredentials(ctx context.Context, identity string) (any, error)

	// PrepareEnvironment prepares environment variables for the authenticated identity.
	// Returns the modified environment slice.
	PrepareEnvironment(ctx context.Context, identity string, baseEnv []string) ([]string, error)
}

type CommandRunner interface {
	// RunShell executes a shell command with the given parameters.
	// Parameters:
	//   - command: The shell command to execute
	//   - name: A name for the command (for logging/identification)
	//   - dir: Working directory for the command
	//   - env: Environment variables for the command
	//   - dryRun: If true, don't actually execute the command
	// Returns an error if the command fails.
	RunShell(command, name, dir string, env []string, dryRun bool) error

	// RunAtmos executes an atmos command with the given parameters.
	// Returns an error if the command fails.
	RunAtmos(params *AtmosExecParams) error
}

type ContainerRunner struct {
	// Stack scopes the instance label namespace so background steps in different
	// stacks resolve to distinct instances.
	Stack string
	// DryRun skips the actual runtime calls (start/wait/stop become no-ops).
	DryRun bool
}

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

type ContainerStepParams struct {
	Workflow     string
	WorkflowPath string
	BasePath     string
	WorkflowDef  *schema.WorkflowDefinition
	Step         *schema.WorkflowStep
	HostWorkDir  string
	Command      string
	StepEnv      []string
	RuntimeEnv   []string
	DryRun       bool
}

type ControlChild struct {
	Step   schema.WorkflowStep
	Matrix map[string]string
}

type ControlChildExecutor func(ctx context.Context, child *ControlChild, output ControlChildOutput) (*ControlChildResult, error)

type ControlChildOutput struct {
	Mode   string
	Prefix string
}

type ControlChildResult struct {
	Stdout   string
	Stderr   string
	Canceled bool
}

type ControlCommandExecutor struct {
	WorkflowDefinition  *schema.WorkflowDefinition
	BasePath            string
	BaseEnv             []string
	CommandLineStack    string
	CommandLineIdentity string
	PrepareEnv          ControlEnvironmentFunc
	RunCommand          ControlCommandRunner
	// contains filtered or unexported fields
}

type ControlCommandRequest struct {
	Context context.Context
	Program string
	Args    []string
	Dir     string
	Env     []string
	Streams process.Streams
	Stdout  *bytes.Buffer
	Stderr  *bytes.Buffer
}

type ControlCommandRunner func(request *ControlCommandRequest) error

type ControlEnvironmentFunc func(baseEnv []string, identity string, stepName string, workflowEnv map[string]string, stepEnv map[string]string) ([]string, error)

type ControlExecutionOptions struct {
	TemplateData ControlTemplateDataFunc
	StoreResult  ControlStoreResultFunc
}

type ControlResult struct {
	Name      string
	Stdout    string
	Stderr    string
	Status    string
	Err       error
	Canceled  bool
	Completed int64
}

type ControlStoreResultFunc func(result *scheduler.Result)

type ControlTemplateDataFunc func(stepName string, matrix map[string]string) map[string]any

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

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

type DependencyProvider interface {
	// LoadToolVersionsDependencies loads tools from .tool-versions file.
	// Returns an empty map if the file doesn't exist.
	LoadToolVersionsDependencies() (map[string]string, error)

	// ResolveWorkflowDependencies extracts tool dependencies from a workflow definition.
	ResolveWorkflowDependencies(workflowDef *schema.WorkflowDefinition) (map[string]string, error)

	// MergeDependencies merges two dependency maps, with overlay taking precedence.
	MergeDependencies(base, overlay map[string]string) (map[string]string, error)

	// EnsureTools ensures all required tools are installed.
	EnsureTools(dependencies map[string]string) error

	// UpdatePathForTools updates PATH to include tool binaries.
	UpdatePathForTools(dependencies map[string]string) error
}

type ExecuteOptions struct {
	// DryRun if true, commands are not actually executed.
	DryRun bool

	// CommandLineStack overrides the stack for all steps.
	CommandLineStack string

	// FromStep skips steps until this step name is reached.
	FromStep string

	// CommandLineIdentity sets the identity for steps without explicit identity.
	CommandLineIdentity string
}

type ExecutionResult struct {
	// WorkflowName is the name of the workflow.
	WorkflowName string

	// Steps contains results for each step.
	Steps []StepResult

	// Success indicates whether all steps succeeded.
	Success bool

	// Error is the first error encountered, if any.
	Error error

	// ResumeCommand is the command to resume from the failed step.
	ResumeCommand string
}

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

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

type ShellExecutor func(command, name, dir string, env []string, dryRun bool) error

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

type StepResult struct {
	// StepName is the name of the step.
	StepName string

	// Command is the command that was executed.
	Command string

	// Success indicates whether the step succeeded.
	Success bool

	// Error is the error if the step failed.
	Error error

	// Skipped indicates if the step was skipped (e.g., due to --from-step).
	Skipped bool
}

type UIProvider interface {
	// PrintMessage prints a message to the user.
	PrintMessage(format string, args ...any)

	// PrintError prints an error message to the user.
	PrintError(err error, title, explanation string)
}

type WorkflowLoader interface {
	// LoadWorkflow loads a workflow definition from the given path.
	// Parameters:
	//   - atmosConfig: The atmos configuration
	//   - workflowPath: Path to the workflow file
	//   - workflowName: Name of the workflow to load
	// Returns the workflow definition and any error.
	LoadWorkflow(atmosConfig *schema.AtmosConfiguration, workflowPath, workflowName string) (*schema.WorkflowDefinition, error)

	// ListWorkflows returns all available workflows.
	ListWorkflows(atmosConfig *schema.AtmosConfiguration) ([]schema.DescribeWorkflowsItem, error)
}

type WorkflowParams struct {
	// Ctx is the context for cancellation.
	Ctx context.Context
	// AtmosConfig is the atmos configuration.
	AtmosConfig *schema.AtmosConfiguration
	// Workflow is the name of the workflow.
	Workflow string
	// WorkflowPath is the path to the workflow file.
	WorkflowPath string
	// WorkflowDefinition is the parsed workflow definition.
	WorkflowDefinition *schema.WorkflowDefinition
	// Opts are the execution options.
	Opts ExecuteOptions
}