adopt

type Adoptable[T any] interface {
	Annotator[T]
	Labeler[T]
}

type AdoptionHandler[K Object, A Adoptable[A]] struct {
	// OperationsContext allows the adoption handler to control the sync loop
	// it's called from to deal with transient errors.
	queue.OperationsContext

	// ControllerFieldManager is the value to use when adopting the object
	// for visibility by the controller
	// If adoption is the only thing the controller needs to do with this object,
	// then it's fine to set this value to the fieldmanager used for "owned"
	// types. But a new value should be used if the controller needs to modify
	// the adopted objects in other ways, so that server-side-apply doesn't
	// revert the changes performed elsewhere in the controller.
	ControllerFieldManager string

	// AdopteeCtx tells the handler how to fetch the adoptee from context
	AdopteeCtx typedctx.MustValueContext[types.NamespacedName]

	// OwnerCtx tells the handler how to fetch the owner from context
	OwnerCtx typedctx.MustValueContext[types.NamespacedName]

	// AdoptedCtx will store the object after it has been adopted
	AdoptedCtx typedctx.SettableContext[K]

	// ObjectAdoptedFunc is called when an adoption was performed
	ObjectAdoptedFunc func(ctx context.Context, obj K)

	// ObjectMissingFunc is called when the object cannot be found
	ObjectMissingFunc func(ctx context.Context, err error)

	// GetFromCache is where we expect to find the object if it is being watched
	// This will usually be a wrapper around an informer cache `Get`.
	GetFromCache func(ctx context.Context) (K, error)

	// Indexer is the index we expect to find adopted objects
	// The absence of the object from this indexer triggers adoption.
	Indexer *typed.Indexer[K]

	// IndexName is the name of the index to look for owned objects
	IndexName string

	// Labels to add if the object is not found in the index
	// Note that this must include a label that matches the index, otherwise
	// the controller will never stop attempting to add labels.
	Labels map[string]string

	// NewPatch returns an empty object satisfying Adoptable
	// This is typically an apply configuration, like `applycorev1.Secret(name, namespace)`
	NewPatch func(types.NamespacedName) A

	// OwnerAnnotationPrefix is a common prefix for all owner annotations
	OwnerAnnotationPrefix string

	// OwnerAnnotationKeyFunc generates an ownership annotation key for a given owner
	OwnerAnnotationKeyFunc func(owner types.NamespacedName) string

	// OwnerFieldManagerFunc generates a field manager name for a given owner
	OwnerFieldManagerFunc func(owner types.NamespacedName) string

	// ApplyFunc applies adoption-related changes to the object to the cluster
	ApplyFunc ApplyFunc[K, A]

	// ExistsFunc checks if the object to be adopted exists in the cluster
	ExistsFunc ExistsFunc

	// Next is the next handler in the chain (use NoopHandler if not chaining)
	Next handler.ContextHandler
}

type Annotator[T any] interface {
	WithAnnotations(entries map[string]string) T
}

type ApplyFunc[K Object, A Adoptable[A]] func(ctx context.Context, object A, opts metav1.ApplyOptions) (result K, err error)

type ExistsFunc func(ctx context.Context, nn types.NamespacedName) error

type IndexKeyFunc func(ctx context.Context) (indexName string, indexValue string)

type Labeler[T any] interface {
	WithLabels(entries map[string]string) T
}

type Object interface {
	comparable
	runtime.Object
	metav1.Object
}