orbital

type Codec interface {
	EncodeTaskRequest(request TaskRequest) ([]byte, error)
	DecodeTaskRequest(bytes []byte) (TaskRequest, error)
	EncodeTaskResponse(response TaskResponse) ([]byte, error)
	DecodeTaskResponse(bytes []byte) (TaskResponse, error)
}

type Config struct {
	// JobsLimitNum is the maximum number of jobs to process at once.
	JobsLimitNum int
	// TaskLimitNum is the maximum number of tasks to process at once.
	TaskLimitNum int
	// ConfirmJobInterval is the interval between jobs scheduler attempts.
	ConfirmJobInterval time.Duration
	// JobConfig contains configuration for job processing.
	// ConfirmJobWorkerConfig holds the configuration for the job confirmation worker.
	ConfirmJobWorkerConfig WorkerConfig
	// CreateTasksWorkerConfig holds the configuration for the task creation worker.
	CreateTasksWorkerConfig WorkerConfig
	// ReconcilesWorkerConfig holds the configuration for the reconciliation worker.
	ReconcileWorkerConfig WorkerConfig
	// NotifyWorkerConfig holds the configuration for the notification worker.
	NotifyWorkerConfig WorkerConfig
	// ConfirmJobDelay is the delay before confirming a job.
	ConfirmJobDelay time.Duration
	// ConfirmJobTimeout is the timeout for jobs confirmation attempts.
	ConfirmJobTimeout time.Duration
	// CreateTasksInterval is the interval for task creation.
	CreateTasksInterval time.Duration
	// ProcessingJobDelay is the delay before processing jobs in reconcileTasks.
	ProcessingJobDelay time.Duration
}

type Entity struct {
	Name      query.EntityName
	ID        uuid.UUID
	CreatedAt int64
	UpdatedAt int64
	Values    map[string]any
}

type EntityTypes interface {
	Job | Task | JobCursor | JobEvent
}

type FindResult struct {
	Entity Entity
	Exists bool
}

type Handler func(ctx context.Context, request HandlerRequest) (HandlerResponse, error)

type HandlerRequest struct {
	TaskID       uuid.UUID
	Type         string
	Data         []byte
	WorkingState []byte
}

type HandlerResponse struct {
	WorkingState      []byte
	Result            Result
	ReconcileAfterSec int64
}

type Initiator interface {
	SendTaskRequest(ctx context.Context, request TaskRequest) error
	ReceiveTaskResponse(ctx context.Context) (TaskResponse, error)
}

type Job struct {
	ID           uuid.UUID
	Data         []byte
	Type         string
	Status       JobStatus
	ErrorMessage string
	UpdatedAt    int64
	CreatedAt    int64
}

type JobConfirmFunc func(ctx context.Context, job Job) (JobConfirmResult, error)

type JobConfirmResult struct {
	Confirmed bool
}

type JobCursor struct {
	ID        uuid.UUID
	Cursor    TaskResolverCursor
	UpdatedAt int64
	CreatedAt int64
}

type JobEvent struct {
	ID         uuid.UUID
	IsNotified bool
	UpdatedAt  int64
	CreatedAt  int64
}

type JobEventQuery struct {
	ID                 uuid.UUID // Filter job events by their ID.
	IsNotified         *bool     // Filter job events by whether they have been notified.
	RetrievalModeQueue bool      // If true, enables queue-like retrieval mode.
	Limit              int       // Maximum number of job events to return.
	OrderByUpdatedAt   bool      // If true, orders job events by updated_at in ascending order.
}

type JobStatus string

type ListJobsQuery struct {
	Status             JobStatus   // Filter jobs by their status.
	StatusIn           []JobStatus // Filter jobs by a list of statuses.
	UpdatedAt          int64       // Filter jobs updated at or after this timestamp.
	CreatedAt          int64       // Filter jobs created at or after this timestamp.
	Limit              int         // Maximum number of jobs to return.
	RetrievalModeQueue bool        // If true, enables queue-like retrieval mode.
	OrderByUpdatedAt   bool        // If true, orders jobs by updated_at in descending order.
}

type ListResult struct {
	Entities []Entity
	Cursor   query.Cursor
	Exists   bool
}

type ListTasksQuery struct {
	JobID              uuid.UUID    // Filter tasks by the associated job ID.
	Status             TaskStatus   // Filter tasks by their status.
	StatusIn           []TaskStatus // Filter tasks by a list of statuses.
	CreatedAt          int64        // Filter tasks created at or after this timestamp.
	UpdatedAt          int64        // Filter tasks updated at or after this timestamp.
	Limit              int          // Maximum number of tasks to return.
	IsReconcileReady   bool         // If true, filters tasks that are ready to be reconciled.
	RetrievalModeQueue bool         // If true, enables queue-like retrieval mode.
	OrderByUpdatedAt   bool         // If true, orders jobs by updated_at in ascending order.
}

type Manager struct {
	Config *Config

	JobTerminationEventFunc TerminationEventFunc
	// contains filtered or unexported fields
}

type ManagerOptsFunc func(mgr *Manager)

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

type Option func(*config) error

type Repository struct {
	Store Store
}

type Responder interface {
	ReceiveTaskRequest(ctx context.Context) (TaskRequest, error)
	SendTaskResponse(ctx context.Context, response TaskResponse) error
}

type Result string

type Store interface {
	Create(ctx context.Context, r ...Entity) ([]Entity, error)
	Update(ctx context.Context, r ...Entity) ([]Entity, error)
	Find(ctx context.Context, q query.Query) (FindResult, error)
	List(ctx context.Context, q query.Query) (ListResult, error)
	Transaction(ctx context.Context, txFunc TransactionFunc) error
}

type Task struct {
	ID                uuid.UUID
	JobID             uuid.UUID
	Type              string
	Data              []byte
	WorkingState      []byte
	LastSentAt        int64
	SentCount         int64
	ReconcileAfterSec int64
	ETag              string
	Status            TaskStatus
	Target            string
	UpdatedAt         int64
	CreatedAt         int64
}

type TaskInfo struct {
	// Data contains the byte data that needs to be sent.
	Data []byte
	// Type specifies the type of the data.
	Type string
	// Targets lists the target identifiers associated with job.
	Target string
}

type TaskRequest struct {
	TaskID       uuid.UUID `json:"taskId"`       // TaskID is used to identify the task.
	Type         string    `json:"type"`         // Type is the type of the task.
	Data         []byte    `json:"data"`         // Data is the static context for the task.
	WorkingState []byte    `json:"workingState"` // WorkingState is the current state of the task that the operator works upon.
	ETag         string    `json:"eTag"`         // ETag is used to identify the version of the TaskRequest.
}

type TaskResolverCursor string

type TaskResolverFunc func(ctx context.Context, job Job, cursor TaskResolverCursor) (TaskResolverResult, error)

type TaskResolverResult struct {
	// TaskInfos contains the data to be sent for each target.
	TaskInfos []TaskInfo
	// Cursor provides information for pagination or continuation.
	Cursor TaskResolverCursor
	// Done indicates whether the resolution process is complete.
	Done bool
}

type TaskResponse struct {
	TaskID            uuid.UUID `json:"taskId"`                 // TaskID is used to identify the task.
	Type              string    `json:"type"`                   // Type is the type of the task.
	WorkingState      []byte    `json:"workingState"`           // WorkingState is the state of the task that the operator updates.
	ETag              string    `json:"eTag"`                   // ETag is used to correlate the TaskResponse with the TaskRequest.
	Status            string    `json:"status"`                 // Status is the status of the task.
	ErrorMessage      string    `json:"errorMessage,omitempty"` // ErrorMessage contains the error message if the task fails.
	ReconcileAfterSec int64     `json:"reconcileAfterSec"`      // ReconcileAfterSec is the time in seconds after which the next TaskRequest should be queued again.
}

type TaskStatus string

type TerminationEventFunc func(ctx context.Context, job Job) error

type TransactionFunc func(context.Context, Repository) error

type WorkerConfig struct {
	// NoOfWorkers specifies the number of concurrent workers.
	NoOfWorkers int
	// ExecInterval is the interval between executions.
	ExecInterval time.Duration
	// Timeout is the maximum duration allowed for a single execution.
	Timeout time.Duration
}