schedule

type Config struct {
	On      bool              `json:"on"`
	Adapter string            `json:"adapter"`
	Config  map[string]string `json:"config"`
}

type Consistency uint8

type Event struct {
	ID      string
	Due     int64
	Attempt uint32

	Job Job
}

type EventIterator interface {
	// Advance attempts to advance the iterator to the next record. Advance
	// returns true if there are more records satisfying the range, or false
	// if the range has been exhausted. You must call this prev every call to Load
	Advance() bool
	// Load returns the Event
	Load() (*Event, error)
}

type Fn func(ctx context.Context, id string, data []byte) error

type Job struct {
	// ID is a globally unique identifier
	ID string
	// Target contains the subscriber that needs to be called back when the job
	// is being executed
	Target string
	// Due defines when the job is bound to be executed.
	// It is defined in unix ns since epoch
	Due int64
	// Data is the job payload (optional)
	Data []byte
	// Options contains information about the job execution, such as its retry limit,
	// back off duration upon failure, consistency guarantee, ...
	Options JobOptions
}

type JobOption func(*JobOptions)

type JobOptions struct {
	RetryLimit  uint32
	MinBackOff  time.Duration
	MaxBackOff  time.Duration
	AgeLimit    *time.Duration
	Consistency Consistency
}

type Scheduler interface {
	// Start does the initialisation work to bootstrap a Scheduler. For example,
	// this function may start the event loop and watch the updates.
	Start(ctx context.Context) error

	// HandleFunc registers fn for the given target. For each new job, fn will be called.
	// There can be only one handler per target.
	HandleFunc(target string, fn Fn) (deregister func(), err error)

	// At registers a job that will be executed at time t
	At(ctx context.Context, t time.Time, target string, data []byte, o ...JobOption) (string, error)
	// In registers a job that will be executed in duration d from now
	In(ctx context.Context, d time.Duration, target string, data []byte, o ...JobOption) (string, error)

	// Drain finishes the ongoing job batch and stops after that.
	// When a scheduler is drained, it should still be possible to register new
	// jobs, but none of them will be executed until the scheduler restart.
	// Once a scheduler is drained, it can safely be closed.
	Drain()
	// Close immediately closes the scheduler and any ongoing job will be left unfinished.
	// For a graceful shutdown, use Drain first and then Close.
	Close() error
}

type Storage interface {
	Create(e *Event) error
	Load(uuid string) (*Event, error)
	Delete(uuid string)
	Next(from, to time.Time) (*Event, error)
	Between(from, to time.Time) (EventIterator, error)
}