package v1alpha1

import (
	"context"
	"fmt"
	corev1 "k8s.io/api/core/v1"
	v1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/types"
	"sigs.k8s.io/controller-runtime/pkg/client"

	cloudnativepgv1 "github.com/cloudnative-pg/cloudnative-pg/api/v1"
)

// +kubebuilder:object:generate=false
type RefResolver struct {
	client client.Client
}

func NewRefResolver(client client.Client) *RefResolver {
	return &RefResolver{
		client: client,
	}
}

func (r *RefResolver) Instance(ctx context.Context, ref *InstanceRef,
	namespace string) (*Instance, error) {
	if ref.Kind != "" && ref.Kind != "Instance" {
		return nil, fmt.Errorf("Unsupported reference kind: '%s'", ref.Kind)
	}

	key := types.NamespacedName{
		Name:      ref.Name,
		Namespace: namespace,
	}
	if ref.Namespace != "" {
		key.Namespace = ref.Namespace
	}

	var zitadel Instance
	if err := r.client.Get(ctx, key, &zitadel); err != nil {
		return nil, err
	}
	return &zitadel, nil
}

func (r *RefResolver) Cluster(ctx context.Context, ref *ClusterRef,
	namespace string) (*Cluster, error) {
	if ref.Kind != "" && ref.Kind != "Cluster" {
		return nil, fmt.Errorf("Unsupported reference kind: '%s'", ref.Kind)
	}

	key := types.NamespacedName{
		Name:      ref.Name,
		Namespace: namespace,
	}
	if ref.Namespace != "" {
		key.Namespace = ref.Namespace
	}

	var zitadel Cluster
	if err := r.client.Get(ctx, key, &zitadel); err != nil {
		return nil, err
	}
	return &zitadel, nil
}

func (r *RefResolver) PostgreSQLClusterRef(ctx context.Context, ref *PostgreSQLClusterRef, namespace string) (*cloudnativepgv1.Cluster, error) {
	if ref.Kind != "" && ref.Kind != "Cluster" {
		return nil, fmt.Errorf("Unsupported reference kind: '%s'", ref.Kind)
	}
	key := types.NamespacedName{
		Name:      ref.Name,
		Namespace: namespace,
	}
	if ref.Namespace != "" {
		key.Namespace = ref.Namespace
	}

	var postgres cloudnativepgv1.Cluster
	if err := r.client.Get(ctx, key, &postgres); err != nil {
		return nil, err
	}
	return &postgres, nil
}

func (r *RefResolver) SecretKeyRef(ctx context.Context, selector corev1.SecretKeySelector,
	namespace string) (string, error) {
	nn := types.NamespacedName{
		Name:      selector.Name,
		Namespace: namespace,
	}
	var secret v1.Secret
	if err := r.client.Get(ctx, nn, &secret); err != nil {
		return "", fmt.Errorf("error getting secret: %v", err)
	}

	data, ok := secret.Data[selector.Key]
	if !ok {
		return "", fmt.Errorf("secret key \"%s\" not found", selector.Key)
	}

	return string(data), nil
}