package system

import (
	"context"
	"fmt"

	zitadelv1alpha1 "gitea.corredorconect.com/software-engineering/zitadel-k8s-operator/api/v1alpha1"
	zitadelClient "gitea.corredorconect.com/software-engineering/zitadel-k8s-operator/pkg/zitadel"
	apierrors "k8s.io/apimachinery/pkg/api/errors"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

type SystemFinalizer struct {
	Client      client.Client
	RefResolver *zitadelv1alpha1.RefResolver

	WrappedFinalizer WrappedSystemFinalizer
}

func NewSystemFinalizer(client client.Client, wf WrappedSystemFinalizer) Finalizer {
	return &SystemFinalizer{
		Client:           client,
		RefResolver:      zitadelv1alpha1.NewRefResolver(client),
		WrappedFinalizer: wf,
	}
}

func (tf *SystemFinalizer) AddFinalizer(ctx context.Context) error {
	if tf.WrappedFinalizer.ContainsFinalizer() {
		return nil
	}
	if err := tf.WrappedFinalizer.AddFinalizer(ctx); err != nil {
		return fmt.Errorf("error adding finalizer in TemplateFinalizer: %v", err)
	}
	return nil
}

func (tf *SystemFinalizer) Finalize(ctx context.Context, resource Resource) error {
	if !tf.WrappedFinalizer.ContainsFinalizer() {
		return nil
	}

	clusterRef, err := resource.ClusterRef(ctx, tf.RefResolver)
	if err != nil {
		return err
	}
	system, err := tf.RefResolver.Cluster(ctx, clusterRef, resource.GetNamespace())
	if err != nil {
		if apierrors.IsNotFound(err) {
			if err := tf.WrappedFinalizer.RemoveFinalizer(ctx); err != nil {
				return fmt.Errorf("error removing %s finalizer: %v", resource.GetName(), err)
			}
			return nil
		}
		return fmt.Errorf("error getting System: %v", err)
	}

	if err := waitForCluster(ctx, tf.Client, resource, system); err != nil {
		return fmt.Errorf("error waiting for System: %v", err)
	}

	ztdClient, err := zitadelClient.NewSystemClient(ctx, system, *tf.RefResolver)
	if err != nil {
		return fmt.Errorf("error connecting to System: %v", err)
	}
	defer ztdClient.Connection.Close()

	if err := tf.WrappedFinalizer.Reconcile(ctx, ztdClient); err != nil {
		return fmt.Errorf("error reconciling in TemplateFinalizer: %v", err)
	}

	if err := tf.WrappedFinalizer.RemoveFinalizer(ctx); err != nil {
		return fmt.Errorf("error removing finalizer in TemplateFinalizer: %v", err)
	}
	return nil
}