package core

import (
	"context"
	"fmt"
	"time"

	zitadelv1alpha1 "gitea.corredorconect.com/software-engineering/zitadel-resources-operator/api/v1alpha1"
	condition "gitea.corredorconect.com/software-engineering/zitadel-resources-operator/pkg/condition"
	zitadelClient "gitea.corredorconect.com/software-engineering/zitadel-resources-operator/pkg/zitadel"
	"github.com/hashicorp/go-multierror"
	ctrl "sigs.k8s.io/controller-runtime"
	"sigs.k8s.io/controller-runtime/pkg/client"
	"sigs.k8s.io/controller-runtime/pkg/log"
)

type CoreReconciler struct {
	Client         client.Client
	RefResolver    *zitadelv1alpha1.RefResolver
	ConditionReady *condition.Ready

	WrappedReconciler WrappedCoreReconciler
	Finalizer         Finalizer
	RequeueInterval   time.Duration
}

func NewCoreReconciler(client client.Client, cr *condition.Ready, wr WrappedCoreReconciler, f Finalizer,
	requeueInterval time.Duration) Reconciler {
	return &CoreReconciler{
		Client:            client,
		RefResolver:       zitadelv1alpha1.NewRefResolver(client),
		ConditionReady:    cr,
		WrappedReconciler: wr,
		Finalizer:         f,
		RequeueInterval:   requeueInterval,
	}
}

func (r *CoreReconciler) Reconcile(ctx context.Context, resource Resource) (ctrl.Result, error) {
	if resource.IsBeingDeleted() {
		if err := r.Finalizer.Finalize(ctx, resource); err != nil {
			return ctrl.Result{}, fmt.Errorf("error finalizing %s: %v", resource.GetName(), err)
		}
		return ctrl.Result{}, nil
	}
	connectionRef, err := resource.ConnectionRef(ctx, r.RefResolver)
	if err != nil {
		return ctrl.Result{}, err
	}
	fmt.Println(connectionRef.ObjectReference.Name)
	connection, err := r.RefResolver.ConnectionRef(ctx, connectionRef, resource.GetNamespace())

	if err != nil {
		var errBundle *multierror.Error
		errBundle = multierror.Append(errBundle, err)

		err = r.WrappedReconciler.PatchStatus(ctx, r.ConditionReady.PatcherRefResolver(err, connection))
		errBundle = multierror.Append(errBundle, err)

		return ctrl.Result{}, fmt.Errorf("error getting Connection: %v", errBundle)
	}

	ztdClient, err := zitadelClient.NewV2Client(ctx, connection, *r.RefResolver)
	if err != nil {
		var errBundle *multierror.Error
		errBundle = multierror.Append(errBundle, err)

		msg := fmt.Sprintf("Error connecting to Zitadel: %v", err)
		err = r.WrappedReconciler.PatchStatus(ctx, r.ConditionReady.PatcherFailed(msg))
		errBundle = multierror.Append(errBundle, err)

		return r.retryResult(ctx, resource, errBundle)
	}

	defer ztdClient.Close()

	err = r.WrappedReconciler.Reconcile(ctx, ztdClient)
	var errBundle *multierror.Error
	errBundle = multierror.Append(errBundle, err)

	if err := errBundle.ErrorOrNil(); err != nil {
		msg := fmt.Sprintf("Error creating %s: %v", resource.GetName(), err)
		err = r.WrappedReconciler.PatchStatus(ctx, r.ConditionReady.PatcherFailed(msg))
		errBundle = multierror.Append(errBundle, err)

		return r.retryResult(ctx, resource, errBundle)
	}

	if err = r.Finalizer.AddFinalizer(ctx); err != nil {
		errBundle = multierror.Append(errBundle, fmt.Errorf("error adding finalizer to %s: %v", resource.GetName(), err))
	}

	err = r.WrappedReconciler.PatchStatus(ctx, r.ConditionReady.PatcherWithError(errBundle.ErrorOrNil()))
	errBundle = multierror.Append(errBundle, err)

	if err := errBundle.ErrorOrNil(); err != nil {
		return ctrl.Result{}, err
	}
	return r.requeueResult(ctx, resource)
}

func (r *CoreReconciler) retryResult(ctx context.Context, resource Resource, err error) (ctrl.Result, error) {
	return ctrl.Result{}, err
}

func (r *CoreReconciler) requeueResult(ctx context.Context, resource Resource) (ctrl.Result, error) {
	if r.RequeueInterval > 0 {
		log.FromContext(ctx).V(1).Info("Requeuing CORE resource")
		return ctrl.Result{RequeueAfter: r.RequeueInterval}, nil
	}
	return ctrl.Result{}, nil
}