client

type Client interface {
	Reader
	Writer
	Informers

	SetServer(server string)
	GetServer() string
	SetToken(token string)
	GetToken() string
}

type ClientOption interface {
	// ApplyToCreate applies this configuration to the given client options.
	ApplyToClient(*ClientOptions)
}

type ClientOptions struct {
	// EnableFor indicates the list of resources for the informer to ensure.
	EnableFor []object.Object

	// DisableFor indicates the list of resources for the informer to ignore.
	DisableFor []object.Object

	// CacheSyncPeriod is the time to wait before updating the cache
	CacheSyncPeriod time.Duration
}

type Config struct {
	// The server with port (e.g. `http://localhost:8080/`).
	// +required
	Server string

	// The Slurm JWT token for authentication.
	// +required
	AuthToken string

	// HTTPClient is the HTTP client to use for requests.
	HTTPClient *http.Client
}

type CreateOption interface {
	// ApplyToCreate applies this configuration to the given create options.
	ApplyToCreate(*CreateOptions)
}

type CreateOptions struct {
}

type DeleteOption interface {
	// ApplyToDelete applies this configuration to the given delete options.
	ApplyToDelete(*DeleteOptions)
}

type DeleteOptions struct {
}

type GetOption interface {
	// ApplyToGet applies this configuration to the given get options.
	ApplyToGet(*GetOptions)
}

type GetOptions struct {
	// SkipCache indicates not to use cache when fetching data.
	SkipCache bool

	// RefreshCache indicates to refresh the cache before reading from it.
	RefreshCache bool

	// WaitRefreshCache indicates to wait for the next cache refresh before reading from it.
	WaitRefreshCache bool
}

type Informer interface {
	// SetEventHandler sets an event handler to the informer. When cache changes,
	// event handlers will trigger.
	SetEventHandler(handler cache.ResourceEventHandler)

	// UnsetEventHandler unsets the event handler of the informer.
	UnsetEventHandler()

	// HasSynced return true if the informers underlying store has synced.
	HasSynced() (bool, error)

	// HasStarted return true if the informers underlying store has been started.
	HasStarted() bool

	// Run starts and runs the informer, returning after it stops.
	// The informer will be stopped when stopCh is closed.
	Run(stopCh <-chan struct{})
}

type InformerCache interface {
	Informer
	Reader
}

type Informers interface {
	// GetInformer fetches or constructs an informer for the given objectType that corresponds to the
	// non-list version of the resource.
	GetInformer(objectType object.ObjectType) InformerCache

	// Start runs all the informers known to this cache until the context is closed.
	// It blocks.
	Start(ctx context.Context)

	// Stop runs all the informers known to this cache until the context is closed.
	// It blocks.
	Stop()
}

type ListOption interface {
	// ApplyToList applies this configuration to the given list options.
	ApplyToList(*ListOptions)
}

type ListOptions struct {
	// SkipCache indicates not to use cache when fetching data.
	SkipCache bool

	// RefreshCache indicates to refresh the cache before reading from it.
	RefreshCache bool

	// WaitRefreshCache indicates to wait for the next cache refresh before reading from it.
	WaitRefreshCache bool
}

type ObjectKey = object.ObjectKey

type Reader interface {
	// Get retrieves an obj for the given object key from the Slurm Cluster.
	// obj must be a struct pointer so that obj can be updated with the response
	// returned by the Server.
	Get(ctx context.Context, key object.ObjectKey, obj object.Object, opts ...GetOption) error

	// List retrieves list of objects for a given namespace and list options. On a
	// successful call, Items field in the list will be populated with the
	// result returned from the server.
	List(ctx context.Context, list object.ObjectList, opts ...ListOption) error
}

type UpdateOption interface {
	// ApplyToUpdate applies this configuration to the given update options.
	ApplyToUpdate(*UpdateOptions)
}

type UpdateOptions struct {
}

type Writer interface {
	// Create saves the object obj in the Slurm cluster. obj must be a
	// struct pointer so that obj can be updated with the content returned by the Server.
	Create(ctx context.Context, obj object.Object, req any, opts ...CreateOption) error

	// Update updates the given obj in the Slurm cluster. obj must be a
	// struct pointer so that obj can be updated with the content returned by the Server.
	Update(ctx context.Context, obj object.Object, req any, opts ...UpdateOption) error

	// Delete deletes the given obj from Slurm cluster.
	Delete(ctx context.Context, obj object.Object, opts ...DeleteOption) error
}