remote

type DefaultRemoteDiff[apiObject comparable] struct {
	// contains filtered or unexported fields
}

type DefaultRemoteExternalReconciler[k8sObject object.RemoteObject, apiObject comparable, apiClient any] struct {
	// contains filtered or unexported fields
}

type DefaultRemoteRead[T any] struct {
	// contains filtered or unexported fields
}

type DefaultRemoteReconciler[k8sObject object.RemoteObject, apiObject comparable, apiClient any] struct {
	controller.Reconciler
}

type DefaultRemoteReconcilerAction[k8sObject object.RemoteObject, apiObject comparable, apiClient any] struct {
	controller.ReconcilerAction
}

type RemoteDiff[apiObject comparable] interface {
	// NeedCreate is true when need to create K8s object
	NeedCreate() bool

	// NeedUpdate is true when need to update K8s object
	NeedUpdate() bool

	// GetObjectsToCreate is the list of object to create on K8s
	GetObjectToCreate() apiObject

	// SetObjectsToCreate permit to set the list of object to create on K8s
	SetObjectToCreate(object apiObject)

	// GetObjectsToUpdate is the list of object to update on K8s
	GetObjectToUpdate() apiObject

	// SetObjectsToUpdate permit to set the list of object to update on K8s
	SetObjectToUpdate(object apiObject)

	// AddDiff permit to add diff
	// It add return line at the end
	AddDiff(diff string)

	// Diff permit to print human diff
	Diff() string

	// IsDiff permit to know is there are current diff to print
	IsDiff() bool
}

type RemoteExternalReconciler[k8sObject object.RemoteObject, apiObject comparable, apiClient any] interface {
	Build(k8sO k8sObject) (object apiObject, err error)
	Get(k8sO k8sObject) (object apiObject, err error)
	Create(apiO apiObject, k8sO k8sObject) (err error)
	Update(apiO apiObject, k8sO k8sObject) (err error)
	Delete(k8sO k8sObject) (err error)
	Diff(currentOject apiObject, expectedObject apiObject, originalObject apiObject, k8sO k8sObject, ignoresDiff ...patch.CalculateOption) (patchResult *patch.PatchResult, err error)
	Client() apiClient
}

type RemoteRead[apiObject comparable] interface {
	// GetCurrentObject permit to get the current object
	GetCurrentObject() apiObject

	// SetCurrentObject permit to set the current object
	SetCurrentObject(object apiObject)

	// GetExpectedObject permit to get the  expected object
	GetExpectedObject() apiObject

	// SetExpectedObject permit to set the expected object
	SetExpectedObject(object apiObject)
}

type RemoteReconciler[k8sObject object.RemoteObject, apiObject comparable, apiClient any] interface {
	controller.Reconciler

	// Reconcile permit to reconcile the step (one K8s resource)
	Reconcile(ctx context.Context, req reconcile.Request, o k8sObject, data map[string]interface{}, reconciler RemoteReconcilerAction[k8sObject, apiObject, apiClient]) (res reconcile.Result, err error)
}

type RemoteReconcilerAction[k8sObject object.RemoteObject, apiObject comparable, apiClient any] interface {
	controller.ReconcilerAction

	// GetRemoteHandler permit to get the handler to manage the remote resources
	GetRemoteHandler(ctx context.Context, req reconcile.Request, o k8sObject, logger *logrus.Entry) (handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], res reconcile.Result, err error)

	// Confirgure permit to init external provider driver (API client REST)
	// It can also permit to init condition on status
	Configure(ctx context.Context, o k8sObject, data map[string]any, handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], logger *logrus.Entry) (res reconcile.Result, err error)

	// Read permit to read the actual resource state from provider and set it on data map
	Read(ctx context.Context, o k8sObject, data map[string]any, handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], logger *logrus.Entry) (read RemoteRead[apiObject], res reconcile.Result, err error)

	// Create permit to create resource on provider
	// It only call if diff.NeeCreated is true
	Create(ctx context.Context, o k8sObject, data map[string]any, handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], object apiObject, logger *logrus.Entry) (res reconcile.Result, err error)

	// Update permit to update resource on provider
	// It only call if diff.NeedUpdated is true
	Update(ctx context.Context, o k8sObject, data map[string]any, handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], object apiObject, logger *logrus.Entry) (res reconcile.Result, err error)

	// Delete permit to delete resource on provider
	// It only call if you have specified finalizer name when you create reconciler and if resource as marked to be deleted
	Delete(ctx context.Context, o k8sObject, data map[string]any, handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], logger *logrus.Entry) (err error)

	// OnError is call when error is throwing
	// It the right way to set status condition when error
	OnError(ctx context.Context, o k8sObject, data map[string]any, handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], currentErr error, logger *logrus.Entry) (res reconcile.Result, err error)

	// OnSuccess is call at the end if no error
	// It's the right way to set status condition when everithink is good
	OnSuccess(ctx context.Context, o k8sObject, data map[string]any, handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], diff RemoteDiff[apiObject], logger *logrus.Entry) (res reconcile.Result, err error)

	// Diff permit to compare the actual state and the expected state
	Diff(ctx context.Context, o k8sObject, read RemoteRead[apiObject], data map[string]any, handler RemoteExternalReconciler[k8sObject, apiObject, apiClient], logger *logrus.Entry, ignoreDiff ...patch.CalculateOption) (diff RemoteDiff[apiObject], res reconcile.Result, err error)

	GetIgnoresDiff() []patch.CalculateOption
}