type GenericJob interface {
  // Object returns the job instance.
  Object() client.Object
  // IsSuspended returns whether the job is suspend or not.
  IsSuspended() bool
  // Suspend will suspend the job.
  Suspend() error
  // UnSuspend will unsuspend the job.
  UnSuspend() error
  // InjectNodeAffinity will inject the node affinity extracting from workload to job.
  InjectNodeSelectors(nodeSelectors []map[string]string) error
  // RestoreNodeAffinity will restore the original node affinity of job.
  RestoreNodeSelectors(nodeSelectors []map[string]string) error
  // Finished means whether the job is completed/failed or not,
  Finished()  finished bool
  // PodSets returns the podSets corresponding to the job.
  PodSets() []kueue.PodSet
  // EquivalentToWorkload validates whether the workload is semantically equal to the job.
  EquivalentToWorkload(wl kueue.Workload) bool
  // PriorityClass returns the job's priority class name.
  PriorityClass() string
  // QueueName returns the queue name the job enqueued.
  QueueName() string
  // IgnoreFromQueueing returns whether the job should be ignored in queuing, e.g. lacking the queueName.
  IgnoreFromQueueing() bool
  // PodsReady instructs whether job derived pods are all ready now.
  PodsReady() bool

type BatchJob struct {
  batchv1.Job
}

var _ GenericJob = &BatchJob{}

type reconcileOptions struct {
  client                     client.Client
  scheme                     *runtime.Scheme
  record                     record.EventRecorder
  manageJobsWithoutQueueName bool
  waitForPodsReady           bool
}

func GenericReconcile(ctx context.Context, req ctrl.Request, reconcileOptions) (ctrl.Result, error) {
    // generic logics here
}

// Take batchv1.Job for example, all we want to do is just calling the GenericReconcile()
func (r *JobReconciler) Reconcile(ctx context.Context, req ctrl.Request, job GenericInterface) (ctrl.Result, error) {
  var batchJob BatchJob
  return GenericReconcile(ctx, req, &batchJob, reconcileOptions)
}

GenericReconcile:
    // Ignore unmanaged jobs, like lacking queueName.
    if job.Ignored():
        return

    // Ensure there's only one corresponding workload and
    // return the matched workload, it could be nil.
    workload = EnsureOneWorkload()

    // Handing job is finished.
    if job.Finished():
        // Processing marking workload finished if not.
        SetWorkloadCondition()
        return

    // Handing workload is nil.
    if workload == nil:
        // If workload is nil, the job should be unsuspend.
        if !job.IsSuspend():
            // When stopping the job, we'll call Suspend(), RestoreNodeAffinity() etc.,
            // and update the job with client.
            StopJob()

        // When creating workload, we'll call PodSets(), QueueName(), PodsCount() etc.
        // to fill up the workload.
        workload = CreateWorkload()
        // creating the constructed workload with client
        // ...

    // Handing job is suspend.
    if job.IsSuspend():
        // If job is suspend but workload is admitted,
        // we should start the job.
        if workload.Spec.Admission != nil:
            // When starting the job, we'll call Unsuspend(), InjectNodeAffinity() etc..
            StartJob()
            return

        // If job is suspend but we changed its queueName,
        // we should update the workload's queueName.
        // ...

    // Handing job is unsuspend.

    // If job is unsuspend but workload is unadmitted,
    // we should suspend the job.
    if workload.Spec.Admission == nil:
        StopJob()
        return

    // Processing other logics like all-or-nothing scheduling
    // ...