execution

type History interface {
	StepHasSucceeded(ctx context.Context, workflowSlug, nodeID string, exceto uuid.UUID) (bool, error)
}

type Persister interface {
	IniciarTask(ctx context.Context, runID uuid.UUID, nodeID string, attempt int) error
	TerminarTask(ctx context.Context, runID uuid.UUID, nodeID string, attempt int,
		status run.Status, exit *int, failure string, log string) error

	// RecordStages records the phases of an SDK step while it runs. It is
	// what makes the screen advance before the step finishes.
	RecordStages(ctx context.Context, runID uuid.UUID, nodeID string, attempt int,
		sdkVersion string, stages json.RawMessage) error
}

type RecordedStage = Stage

type Reporter interface {
	Evento(execution.Event)
}

type Runner struct {
	Processo execution.Executor // serves `run:`; may be nil when there are only Go tasks
	Go       execution.Executor // serves `action:`; may be nil

	WorkDir string
	Env     map[string]string
	Report  Reporter

	// Timeout per node. Zero means no limit.
	Timeout time.Duration

	// MaxAttempts per node. Zero or 1 means a single attempt.
	MaxAttempts int
	BackoffBase time.Duration

	// Persist and RunID are used together: without both, per-step state is not
	// recorded and the DAG in the UI shows up with no execution state.
	Persist Persister
	RunID   uuid.UUID

	// Params are this run's values. They reach the step's command through a
	// template (see execution.Render) and the step's environment, so a
	// fetcher using the SDK sees them without being handed an argument.
	Params map[string]string

	// Trigger says why this Run exists: schedule, manual or backfill.
	Trigger string

	// LogicalDate is the slot this Run stands for. Nil on a manual trigger.
	LogicalDate *time.Time

	// Historico decides whether a step is running for the first time. Nil means
	// there is no way to know -- and then the step gets first=false, because
	// creating a table without being sure is worse than not creating it.
	History History

	// Vagas caps how many STEPS run at once -- in Kubernetes, how many pods
	// exist simultaneously. Nil means no limit.
	//
	// It has to be shared across every Runner in the process, which is why it
	// is injected rather than created here: the ceiling belongs to the CLUSTER,
	// not to one workflow. Without it, the dispatcher's concurrency limit
	// counted RUNS -- five runs with three parallel steps each gave fifteen
	// pods, not five.
	Slots chan struct{}

	// TentativaDoRun is this RUN's attempt, counted by the dispatcher. It goes
	// into the pod name so a retry does not find the previous attempt's pod.
	RunAttempt int

	// Pods runs steps as pods in Kubernetes. When present it serves every step
	// that declares `image:` -- and the same DAG runs as a pod in the cluster
	// and as a process on a laptop, with no change to the YAML.
	Pods execution.Executor
}

type Stage struct {
	Index    int            `json:"indice"`
	TaskName string         `json:"nome"`
	State    string         `json:"estado"`
	Ms       *int64         `json:"ms,omitempty"`
	At       string         `json:"em"`
	Numbers  map[string]any `json:"numeros,omitempty"`
}

type StepError struct {
	NodeID   string
	ExitCode int
	Message  string

	// Saida is the last few lines of stderr. Only the last ones, and not all of
	// them, because a chatty process would fill the database's error column --
	// and the cause is almost always at the end.
	Output []string
}