const (

	// Including adds in the mutation cache is not safe: We could add a slice, store it,
	// and then the slice gets deleted without the informer hearing anything about that.
	// Then the obsolete slice remains in the mutation cache.
	//
	// To mitigate this, we use a TTL and check a pool again once added slices expire.
	DefaultMutationCacheTTL = time.Minute

	// DefaultSyncDelay defines how long to wait between receiving the most recent
	// informer event and syncing again. This is long enough that the informer cache
	// should be up-to-date (matters mostly for deletes because an out-dated cache
	// causes redundant delete API calls) and not too long that a human mistake
	// doesn't get fixed while that human is waiting for it.
	DefaultSyncDelay = 30 * time.Second
)

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

type DriverResources struct {
	// Each driver may manage different resource pools.
	Pools map[string]Pool
}

type DroppedFieldsError struct {
	PoolName                  string
	SliceIndex                int
	DesiredSlice, ActualSlice *resourceapi.ResourceSlice
}

type Options struct {
	// DriverName is the required name of the DRA driver.
	DriverName string

	// KubeClient is used to read Node objects (if necessary) and to access
	// ResourceSlices. It must be specified.
	KubeClient kubernetes.Interface

	// If the owner is a v1.Node, then the NodeName field in the
	// ResourceSlice objects is set and used to identify objects
	// managed by the controller. The UID is not needed in that
	// case, the controller will determine it automatically.
	//
	// The owner must be cluster-scoped. This is not always possible,
	// therefore it is optional. A driver without a owner must take
	// care that remaining slices get deleted manually as part of
	// a driver uninstall because garbage collection won't work.
	Owner *Owner

	// This is the initial desired set of slices. Nil means "no resources".
	Resources *DriverResources

	// Queue can be used to override the default work queue implementation.
	Queue workqueue.TypedRateLimitingInterface[string]

	// MutationCacheTTL can be used to change the default TTL of one minute.
	// See source code for details.
	MutationCacheTTL *time.Duration

	// SyncDelay defines how long to wait between receiving the most recent
	// informer event and syncing again. The default is 30 seconds.
	//
	// This is long enough that the informer cache should be up-to-date
	// (matter mostly for deletes because an out-dated cache causes
	// redundant delete API calls) and not too long that a human mistake
	// doesn't get fixed while that human is waiting for it.
	SyncDelay *time.Duration

	// ErrorHandler will get called whenever the controller encounters
	// a problem while trying to publish ResourceSlices. The controller
	// will retry once the handler returns. What the handler does with
	// that information is up to the handler. It could log the error,
	// replace the slices if they cannot be published (see below),
	// or force the program running the controller to fail by exiting.
	//
	// If some fields were dropped because the cluster does not support
	// the feature they depend on, then the error is or wraps an
	// [DroppedFieldsError] instance. Use [errors.As] to convert to that
	// type:
	//    var droppedFields *resourceslice.DroppedFieldsError
	//    if errors.As(err, &droppedFields) { ... do something with droppedFields ... }
	//
	// The default is [utilruntime.HandleErrorWithContext] which just logs
	// the problem.
	ErrorHandler func(ctx context.Context, err error, msg string)
}

type Owner struct {
	APIVersion string
	Kind       string
	Name       string
	UID        types.UID
}

type Pool struct {
	// NodeSelector may be different for each pool. Must not get set together
	// with Resources.NodeName. If nil and Resources.NodeName is not set,
	// then devices are available on all nodes.
	NodeSelector *v1.NodeSelector

	// Generation can be left at zero. It gets bumped up automatically
	// by the controller.
	Generation int64

	// Slices is a list of all ResourceSlices that the driver
	// wants to publish for this pool. The driver must ensure
	// that each resulting slice is valid. See the API
	// definition for details, in particular the limit on
	// the number of devices.
	//
	// If slices are not valid, then the controller will
	// log errors produced by the apiserver.
	//
	// Drivers should publish at least one slice for each
	// pool that they normally manage, even if that slice
	// is empty. "Empty pool" is different from "no pool"
	// because it shows that the driver is up-and-running
	// and simply doesn't have any devices.
	Slices []Slice
}

type Slice struct {
	// Devices lists all devices which are part of the slice.
	Devices                []resourceapi.Device
	SharedCounters         []resourceapi.CounterSet
	PerDeviceNodeSelection *bool
}

type Stats struct {
	// NumCreates counts the number of ResourceSlices that got created.
	NumCreates int64
	// NumUpdates counts the number of ResourceSlices that got update.
	NumUpdates int64
	// NumDeletes counts the number of ResourceSlices that got deleted.
	NumDeletes int64
}