states

type BaseBone struct {
	Type    string   `json:"Type"`
	Name    string   `json:"Name"`
	Next    []string `json:"Next"`
	End     bool     `json:"End"`
	Comment string   `json:"Comment"`
}

type BaseState struct {
	Name            string `json:"Name,omitempty"`
	Type            string `json:"Type,omitempty"`
	Comment         string `json:"Comment,omitempty"`
	InputPath       string `json:"InputPath,omitempty"`
	OutputPath      string `json:"OutputPath,omitempty"`
	ResultPath      string `json:"ResultPath,omitempty"`
	Parameters      any    `json:"Parameters,omitempty"`
	MaxExecuteTimes int    `json:"MaxExecuteTimes,omitempty"`
	End             bool   `json:"End,omitempty"`
	Next            string `json:"Next,omitempty"`
	Retry           any    `json:"Retry,omitempty"`
	Catch           any    `json:"Catch,omitempty"`
}

type ChoiceBody struct {
	Choices []ChoiceBranch `mapstructure:"Choices"`
	Default string         `mapstructure:"Default" validate:"gte=0"`
}

type ChoiceBranch struct {
	Condition expression.BooleanExpression
	Next      string `mapstructure:"Next" validate:"required,gt=0"`
}

type ChoiceState struct {
	*BaseState
	*ChoiceBody
	// contains filtered or unexported fields
}

type FailBody struct {
	Abort bool   `mapstructure:"Abort"`
	Cause string `mapstructure:"Cause"`
	Error string `mapstructure:"Error"`
}

type FailData struct {
	Cause string `json:"cause"`
	Error string `json:"error"`
}

type FailState struct {
	*BaseState `json:",inline"`
	*FailBody  `json:",inline"`
}

type FieldError struct {
	// The error that occurred
	RawError error
	Line     int64
	Column   int64
	Offset   int64
	Paths    []string
}

type FiledPathError struct {
	// The error that occurred
	RawError error
	Paths    []string
}

type NextState struct {
	Name       string        // Next State Name
	Output     any           // State Output as the input of the next state
	Delay      time.Duration // Delay delay duration from current state to next state
	Retry      bool          // Whether to trigger retry
	RetryIndex int           // Which Indexed Retry strategy hit
}

type ParallelBody struct {
	Branches []map[string]interface{} `mapstructure:"Branches" validate:"required,gt=0"`
	// contains filtered or unexported fields
}

type ParallelState struct {
	*BaseState    `json:",inline"`
	*ParallelBody `json:",inline"`
	// contains filtered or unexported fields
}

type PassBody struct {
	Result map[string]any `mapstructure:"Result" validate:"required"`
}

type PassState struct {
	*BaseState `json:",inline"`
	*PassBody  `json:",inline"`
}

type QueryLanguageType string

type ResourceURI struct {
	Resource     string
	ResourceType string
	Function     string
}

type State interface {
	Validate() error
	GetName() string
	SetName(name string)
	GetType() string
	GetBone() StateBone
	IsEnd() bool
	GetNext() []string
	GetBaseState() *BaseState
	GetDefinition() (string, error)
}

type StateBone struct {
	BaseBone
	*StateMachineBone
	Branches []StateBone `json:"Branches"`
}

type StateFieldRequired struct {
	Comment    int
	Type       int
	InputPath  int
	OutputPath int
	Parameters int
	ResultPath int
	NextEnd    int
	Retry      int
	Catch      int
}

type StateMachine struct {
	*StateMachineHeader
	*StateMachineBody
}

type StateMachineBody struct {
	StartAt string         `mapstructure:"StartAt" validate:"required,gt=0"`
	States  map[string]any `mapstructure:"States" validate:"required,gt=0"`
	// contains filtered or unexported fields
}

type StateMachineBone struct {
	Version string               `json:"Version"`
	StartAt string               `json:"StartAt"`
	States  map[string]StateBone `json:"States"`
}

type StateMachineGroupState struct {
	GroupID    int            //自身的所处的group
	GroupIndex int            // 自身所在的GroupIndex
	Depth      int            //节点所在的 深度
	Name       string         // StateName
	State      State          //State
	SubGroup   *SubGroupState //子group列表
}

type StateMachineHeader struct {
	Version       string `json:"Version" mapstructure:"Version" ` // 语法版本， 默认1.0
	Type          string `json:"Type" mapstructure:"Type"`
	Comment       string `json:"Comment" mapstructure:"Comment"`
	QueryLanguage string `json:"QueryLanguage" mapstructure:"QueryLanguage"`
	// 任务执行超时时间， 过期自动设置任务状态为失败状态
	TimeoutSeconds int `json:"TimeoutSeconds" mapstructure:"TimeoutSeconds" validate:"gte=0"`
	// 任务执行超时终止时间，找过指定时间后，如果任务状态为非Success，任务自动终止并且设置为 Abort状态
	AbortTimeoutSeconds int `json:"AbortTimeoutSeconds" mapstructure:"AbortTimeoutSeconds" validate:"gte=0"`
	// Execution 的信息路径
	ExecutionInfoPath string `json:"ExecutionInfoPath" mapstructure:"ExecutionInfoPath"`
	// 默认input参数
	DefaultInput map[string]interface{} `json:"DefaultInput" mapstructure:"DefaultInput"`
	// contains filtered or unexported fields
}

type StateMachineTimeout struct {
	Timeout      time.Duration
	TaskTimeout  time.Duration
	AbortTimeout time.Duration
}

type StateType string

type SubGroupState struct {
	MasterGroupID int
	MasterName    string
	SubGroupID    int    `json:"group_id"`
	SubStartAt    string `json:"start_at"`
}

type SucceedState struct {
	*BaseState `json:",inline"`
}

type SuspendState struct {
	*BaseState
}

type TaskBody struct {
	// Block : if block execution for task, default false
	// if true, the task will block the workflow execution until the manual call to resume the task
	// if false, the task will be executed automatically
	Block            bool   `mapstructure:"Block"`
	Resource         string `mapstructure:"Resource" validate:"required,gt=0"`
	TimeoutSeconds   uint   `mapstructure:"TimeoutSeconds" validate:"gte=0"`
	HeartbeatSeconds uint   `mapstructure:"HeartbeatSeconds" validate:"gte=0"`
	// Retry for decode
	Retry []TaskRetryNode `mapstructure:"Retry"`
	// Catch for decode
	Catch []TaskCatchNode `mapstructure:"Catch"`
}

type TaskCatchNode struct {
	ErrorEquals []string `mapstructure:"ErrorEquals"`
	Next        string   `mapstructure:"Next"`
	ResultPath  string   `mapstructure:"ResultPath"`
}

type TaskRetryNode struct {
	ErrorEquals     []string `mapstructure:"ErrorEquals"`
	IntervalSeconds uint     `mapstructure:"IntervalSeconds"`
	MaxAttempts     uint     `mapstructure:"MaxAttempts"`
	BackoffRate     float64  `mapstructure:"BackoffRate"`
}

type TaskSendData struct {
	Success bool     // is task submit success
	Retry   []int    // current retry times, index is retry times for each Retry branch
	Errors  []string // send error list
	Output  any      // task state execute output
}

type TaskState struct {
	*BaseState `json:",inline"`
	*TaskBody  `json:",inline"`
}

type TaskTimeout struct {
	TaskTimeout      time.Time
	HeartBeatTimeout time.Time
}

type WaitBody struct {
	Seconds       uint   `mapstructure:"Seconds" validate:"gte=0"`
	Timestamp     string `mapstructure:"Timestamp" validate:"gte=0"`
	SecondsPath   string `mapstructure:"SecondsPath" validate:"gte=0"`
	TimestampPath string `mapstructure:"TimestampPath" validate:"gte=0"`
}

type WaitState struct {
	*BaseState `json:",inline"`
	*WaitBody  `json:",inline"`
}