workflow

type AddNodeExternalEventParams struct {
	WorkflowInstanceID int64  `json:"workflow_instance_id" validate:"gt=0"`
	TaskType           string `json:"task_type" validate:"required"`
	// TaskInstanceID     int64              `json:"task_instance_id" validate:"required"`
	NodeEvent *NodeExternalEvent `json:"node_event" validate:"required"`
}

type AsynchronousWaitCheckFunc func(ctx context.Context, nodeContext *JSONContext) error

type BaseTaskWorker struct {
	EmptyTaskWorker
}

type CreateWorkflowReq struct {
	WorkflowType string         // 工作流类型
	BusinessID   string         // 业务ID
	Context      map[string]any // 上下文,可以为空
	IsRun        bool           // 是否立即执行,如果为true，则立即执行
	TaskId       int64          // 任务id
}

type EmptyTaskWorker struct {
}

type EndNodeWorker struct {
	BaseTaskWorker
}

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

type NodeContextKey = string

type NodeDefinitionConfig struct {
	ID            string   `json:"id"`               // 节点ID, 唯一标识, 用于标识节点
	Name          string   `json:"name"`             // 节点名称
	NextNodes     []string `json:"next_nodes"`       // 后置节点ID列表
	FailMaxCount  *int64   `json:"fail_max_count"`   // 失败次数达到 fail_max_count次后，<0的忽略
	MaxWaitTimeTs *int64   `json:"max_wait_time_ts"` // 最大等待时间，单位秒，<=0 忽略
}

type NodeExternalEvent struct {
	// 事件时间,单位秒,会用来做版本控制，最新的版本会覆盖旧的版本
	EventTs      int64  `json:"event_ts"`
	EventContent string `json:"event_content"`
}

type NormalTaskWorker struct {
	BaseTaskWorker
	// contains filtered or unexported fields
}

type Pager struct {
	IsNoLimit *bool `json:"is_no_limit"`
	Page      int64 `json:"page"`
	Size      int64 `json:"size"`
}

type QueryWorkflowInstanceParams struct {
	WorkflowInstanceID *int64   `json:"workflow_instance_id"`
	WorkflowTypeIn     []string `json:"workflow_type_in"`
	BusinessID         *string  `json:"business_id"`
	StatusIn           []string `json:"status_in"`
	IDGreaterThan      *int64   `json:"id_greater_than"`
	TaskID             *int64   `json:"task_id"`
	OrderbyIDAsc       *bool    `json:"orderby_id_asc"`
	Page               *Pager   `json:"page"`
}

type QueryWorkflowTaskInstanceParams struct {
	WorkflowTaskInstanceID *int64   `json:"workflow_task_instance_id"`
	WorkflowInstanceID     *int64   `json:"workflow_instance_id"`
	TaskType               *string  `json:"task_type"`
	StatusIn               []string `json:"status_in"`
	IDGreaterThan          *int64   `json:"id_greater_than"`
	OrderbyIDAsc           *bool    `json:"orderby_id_asc"`
	Page                   *Pager   `json:"page"`
}

type RegisterWorkflowTaskParams struct {
	WorkflowType string
	TaskKey      string
	TaskWorker   WorkflowTaskNodeWorker
	IsPublic     bool // 是否公开，如果为true，则可以被其他工作流使用
}

type RestartWorkflowNodeParams struct {
	WorkflowInstanceID      int64  `json:"workflow_instance_id" validate:"gt=0"`
	TaskType                string `json:"task_type" validate:"required"`
	IsForcedRestartWorkflow bool   `json:"is_forced_restart_workflow"` // 是否强制重启工作流,如果是true即使工作流实例已经结束,也会重启工作流

}

type RestartWorkflowParams struct {
	WorkflowInstanceID int64 `json:"workflow_instance_id" validate:"gt=0"`
	// Context            map[string]any // 上下文,如果有值，则覆盖掉原来的上下文
	IsRun bool // 是否立即执行,如果为true，则立即执行
}

type RootNodeWorker struct {
	BaseTaskWorker
}

type RunFunc func(ctx context.Context, nodeContext *JSONContext) error

type TaskInstanceEntity struct {
	ID                 int64 //ID 可能为0,因为还没有创建
	WorkflowInstanceID int64
	TaskType           string
	TaskName           string
	Status             string
	NodeContext        *JSONContext
	CreatedAt          int64
	UpdatedAt          int64
	PreNodesKeys       []string
	NextNodesKeys      []string
}

type UpdateWorkflowInstanceField struct {
	Status          *string      `json:"status"`
	WorkflowContext *JSONContext `json:"workflow_context"`
}

type UpdateWorkflowInstanceParams struct {
	Where    *UpdateWorkflowInstanceWhere `json:"where" validate:"required"`
	Fields   *UpdateWorkflowInstanceField `json:"field" validate:"required"`
	LimitMax int                          `json:"limit_max" validate:"required"`
}

type UpdateWorkflowInstanceWhere struct {
	IDIn     []int64  `json:"id_in"`
	StatusIn []string `json:"status_in"`
}

type UpdateWorkflowTaskInstanceField struct {
	Status      *string      `json:"status"`
	NodeContext *JSONContext `json:"node_context"`
	FailCount   *int64       `json:"fail_count"`
}

type UpdateWorkflowTaskInstanceParams struct {
	Where    *UpdateWorkflowTaskInstanceWhere `json:"where" validate:"required"`
	Fields   *UpdateWorkflowTaskInstanceField `json:"field" validate:"required"`
	LimitMax int                              `json:"limit_max" validate:"required"`
}

type UpdateWorkflowTaskInstanceWhere struct {
	IDIn []int64 `json:"id_in"`
}

type WorkflowConfig struct {
	ID    string                  `json:"id"`    // 工作流类型ID, 唯一标识, 用于标识工作流类型
	Name  string                  `json:"name"`  // 工作流类型名称
	Nodes []*NodeDefinitionConfig `json:"nodes"` // 构建工作流任务
}

type WorkflowDefinition struct {
	ID         string
	Name       string
	NodesCount int64
	RootNode   *WorkflowTaskNodeDefinition
	Nodes      []*WorkflowTaskNodeDefinition // 节点列表,冗余字段,方便构建节点详情
}

type WorkflowInstance struct {
	ID              int64
	WorkflowType    string
	BusinessID      string
	Status          string
	WorkflowContext *JSONContext
	TaskId          int64
	CreatedAt       int64
	UpdatedAt       int64
	Definitions     *WorkflowDefinition
}

type WorkflowInstanceDetailEntity struct {
	ID              int64
	WorkflowType    string
	BusinessID      string
	Status          WorkflowInstanceStatus
	WorkflowContext *JSONContext
	CreatedAt       int64
	UpdatedAt       int64
	TaskInstances   []*TaskInstanceEntity
}

type WorkflowInstancePo struct {
	ID              int64                  `gorm:"column:id;primaryKey;autoIncrement" json:"id"	`
	WorkflowType    string                 `gorm:"column:workflow_type" json:"workflow_type"`
	BusinessID      string                 `gorm:"column:business_id" json:"business_id"`
	Status          WorkflowInstanceStatus `gorm:"column:status" json:"status"`
	WorkflowContext []byte                 `gorm:"column:workflow_context" json:"workflow_context"` // 工作流上下文
	TaskId          int64                  `gorm:"column:task_id" json:"task_id"`
	CreatedAt       int64                  `gorm:"column:created_at" json:"created_at"`
	UpdatedAt       int64                  `gorm:"column:updated_at" json:"updated_at"`
}

type WorkflowInstanceStatus = string

type WorkflowLock interface {
	// NonBlockingSynchronized
	//  @Description:  1.非阻塞同步块,如果没有拿到锁，立刻返回错误
	//                 2.可以重入锁
	//  @param ctx 原来的ctx
	//  @param key 分布式锁的的key
	//  @param maxLockTimeDuration 锁最大的时间
	//  @param f 具体执行函数的闭包
	//  @return error
	NonBlockingSynchronized(ctx context.Context, key string, maxLockTimeDuration time.Duration, f func(context.Context) error) error
}

type WorkflowRepo interface {
	CreateWorkflowInstance(ctx context.Context, workflowInstance *WorkflowInstancePo) (*WorkflowInstancePo, error)
	CreateWorkflowTaskInstance(ctx context.Context, workflowTaskInstance *WorkflowTaskInstancePo) (*WorkflowTaskInstancePo, error)
	QueryWorkflowInstance(ctx context.Context, param *QueryWorkflowInstanceParams) ([]*WorkflowInstancePo, error)
	CountWorkflowInstance(ctx context.Context, param *QueryWorkflowInstanceParams) (int64, error)
	QueryWorkflowTaskInstance(ctx context.Context, param *QueryWorkflowTaskInstanceParams) ([]*WorkflowTaskInstancePo, error)
	UpdateWorkflowInstance(ctx context.Context, param *UpdateWorkflowInstanceParams) error
	UpdateWorkflowTaskInstance(ctx context.Context, param *UpdateWorkflowTaskInstanceParams) error
	Transaction(ctx context.Context, fn func(ctx context.Context) error) error
}

type WorkflowService interface {
	/**
	 * @description: 创建工作流
	 * @param ctx context.Context
	 * @param req *CreateWorkflowReq
	 * @return *WorkflowInstance, error
	 */
	CreateWorkflow(ctx context.Context, req *CreateWorkflowReq) (*WorkflowInstance, error)
	/**
	 * @description: 查询工作流实例数量
	 * @param ctx context.Context
	 * @param params *QueryWorkflowInstanceParams
	 * @return int64, error
	 */
	CountWorkflowInstance(ctx context.Context, params *QueryWorkflowInstanceParams) (int64, error)
	/**
	 * @description: 查询工作流实例详情
	 * @param ctx context.Context
	 * @param params *QueryWorkflowInstanceParams
	 * @return []*WorkflowInstanceDetailEntity, error
	 */
	QueryWorkflowInstanceDetail(ctx context.Context, params *QueryWorkflowInstanceParams) ([]*WorkflowInstanceDetailEntity, error)
	/**
	 * @description: 查询工作流实例Po
	 * @param ctx context.Context
	 * @param params *QueryWorkflowInstanceParams
	 * @return []*WorkflowInstancePo, error
	 */
	QueryWorkflowInstancePo(ctx context.Context, params *QueryWorkflowInstanceParams) ([]*WorkflowInstancePo, error)
	/**
	 * @description: 运行工作流
	 *				 workflowID 为工作流实例ID,一个工作流实例只会被一个goroutine运行
	 *				 如果有其他goroutine正在运行该工作流实例，则返回错误
	 * @param ctx context.Context
	 * @param workflowID int64
	 * @return error
	 */
	RunWorkflow(ctx context.Context, workflowID int64) error
	/**
	 * @description: 取消工作流，手动取消工作流，目前没有使用，将来使用扩展
	 *				 workflowInstanceID 为工作流实例ID,一个工作流实例只会被一个goroutine运行
	 *				 如果有其他goroutine正在运行该工作流实例，则返回错误
	 * @param ctx context.Context
	 * @param workflowInstanceID int64
	 * @return error
	 */
	CancelWorkflowInstance(ctx context.Context, workflowInstanceID int64) error

	/**
	 * @description: 添加节点外部事件, 给外部输入使用，会写入节点上下文
	 * 				  一个工作流实例只会被一个goroutine运行,如果有其他goroutine正在运行该工作流实例，则返回错误
	 *                会将事件addParams.NodeEvent写入额外节点上下文的 NodeContextKeyNodeEvent(node_event)
	 * @param ctx context.Context
	 * @param addParams *AddNodeExternalEventParams
	 *				  addParams.WorkflowInstanceID 为工作流实例ID
	 *				  addParams.TaskType 为任务类型
	 *				  addParams.NodeEvent 为节点事件
	 *				  addParams.NodeEvent.EventTs 为事件时间, 会用来做版本控制，最新的版本会覆盖旧的版本
	 *				  addParams.NodeEvent.EventContent 为事件内容
	 * @return error
	 */
	AddNodeExternalEvent(ctx context.Context, addParams *AddNodeExternalEventParams) error

	/**
	 * @description: 重新开始工作流任务
	 *                如果isAsynchronous为true,一次性只能有一个进程操作工作流,可能会出现当前工作流正在被其他进程操作的情况
	 *                所以失败的情况可能会出现的比较频繁
	 * @param ctx context.Context
	 * @param restartParams *RestartWorkflowTaskParams
	 *				  restartWorkflowNodeParams.WorkflowInstanceID 为工作流实例ID
	 *				  restartWorkflowNodeParams.TaskType 为任务类型
	 *				  restartWorkflowNodeParams.IsAsynchronous 为是否异步重启,如果为true，则不等待任务执行完成,直接返回
	 * @return error
	 */
	RestartWorkflowNode(ctx context.Context, restartWorkflowNodeParams *RestartWorkflowNodeParams) error

	/**
	 * @description: 重启工作流实例, 只有失败和取消状态可以重启，正常完成的不能重启
	 * @param ctx context.Context
	 * @param restartWorkflowParams *RestartWorkflowParams 重启工作流参数
	 *				  restartWorkflowParams.WorkflowInstanceID 为工作流实例ID
	 *				  restartWorkflowParams.Context 为上下文,如果有值，则覆盖掉原来的上下文
	 *				  restartWorkflowParams.IsRun 为是否立即执行,如果为true，则立即执行
	 * @return error 重启工作流实例
	 */
	RestartWorkflowInstance(ctx context.Context, restartWorkflowParams *RestartWorkflowParams) error
}

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

type WorkflowTaskInstancePo struct {
	ID                 int64                  `gorm:"column:id;primaryKey;autoIncrement"`
	WorkflowInstanceID int64                  `gorm:"column:workflow_instance_id"`
	TaskType           string                 `gorm:"column:task_type"`
	Status             WorkflowTaskNodeStatus `gorm:"column:status"`
	FailCount          int64                  `gorm:"column:fail_count"`
	NodeContext        []byte                 `gorm:"column:node_context"` // 节点上下文, input,output结合在一起
	CreatedAt          int64                  `gorm:"column:created_at"`
	UpdatedAt          int64                  `gorm:"column:updated_at"`
}

type WorkflowTaskNode struct {
	ID                 int64
	WorkflowInstanceID int64
	TaskType           string
	Status             string
	NodeContext        *JSONContext
	CreatedAt          int64
	UpdatedAt          int64
	FailCount          int64
}

type WorkflowTaskNodeDefinition struct {
	TaskType      string
	TaskName      string
	FailMaxCount  int64 // 失败次数达到 fail_max_count次后，<0的忽略
	MaxWaitTimeTs int64 // 最大等待时间，单位秒，<=0 忽略
	PreNodes      []*WorkflowTaskNodeDefinition
	NextNodes     []*WorkflowTaskNodeDefinition
	TaskWorker    WorkflowTaskNodeWorker // 工作流任务节点工作器,需要外部实现
}

type WorkflowTaskNodeStatus = string

type WorkflowTaskNodeWorker interface {
	/**
	 * @description:  任务执行
	 * @return error nil表示执行成功了，不需要处理
	 * @param ctx context.Context 上下文
	 * @param nodeContext *JSONContext 节点上下文, run函数自己维护，run中更改了nodeContext,那么就会同步更改到数据库里面
	 */
	Run(ctx context.Context, nodeContext *JSONContext) error
	/**
	 * @description:  异步等待检查
	 * @return error nil表示检查成功了，不需要处理
	 * @param ctx context.Context 上下文
	 * @param nodeContext *JSONContext 节点上下文, run函数自己维护，run中更改了nodeContext,那么就会同步更改到数据库里面
	 */
	AsynchronousWaitCheck(ctx context.Context, nodeContext *JSONContext) error
}