package gardener

import (
	"context"
	"fmt"
	"testing"

	"github.com/google/go-cmp/cmp"
	. "github.com/onsi/gomega"
	appsv1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/resource"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/utils/pointer"
	"sigs.k8s.io/controller-runtime/pkg/client/fake"
	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"

	"github.com/tidbcloud/infra-api/pkg/consts"
)

const (
	imageRepoPrefix       = "imageprefix"
	reporterRoleARN       = "reporterRole"
	deliveryStreamName    = "deliveryStream"
	deliveryStreamRoleArn = "deliveryStreamRole"
	region                = "us-west-2"
	identityImage         = "identityImage"
)

func TestDeployTiDBClusterSLIReporter(t *testing.T) {
	imageName := "sli-reporter"
	labels := map[string]string{
		"app": localSLIReporter,
	}
	cases := map[string]struct {
		provider string
		deploy   *appsv1.Deployment
	}{
		"Deploy the SLI reporter to AWS shoot": {
			provider: consts.ProviderTypeAWS,
			deploy: &appsv1.Deployment{
				ObjectMeta: metav1.ObjectMeta{
					Name:      localSLIReporter,
					Namespace: consts.LocalOperatorNamespace,
				},
				Spec: appsv1.DeploymentSpec{
					Replicas: pointer.Int32(1),
					Selector: &metav1.LabelSelector{
						MatchLabels: labels,
					},
					Template: corev1.PodTemplateSpec{
						ObjectMeta: metav1.ObjectMeta{
							Labels: labels,
						},
						Spec: corev1.PodSpec{
							RestartPolicy:      corev1.RestartPolicyAlways,
							ServiceAccountName: localSLIReporter,
							Containers: []corev1.Container{
								{
									Name:    localSLIReporter,
									Image:   fmt.Sprintf("%s/%s", imageRepoPrefix, imageName),
									Command: []string{"/sli-reporter"},
									Env: []corev1.EnvVar{
										{
											Name:  "AWS_REGION",
											Value: region,
										},
										{
											Name:  "AWS_DELIVERY_STREAM_NAME",
											Value: deliveryStreamName,
										},
										{
											Name:  "AWS_DELIVERY_STREAM_ROLE_ARN",
											Value: deliveryStreamRoleArn,
										},
									},
									Resources: corev1.ResourceRequirements{
										Limits: corev1.ResourceList{
											corev1.ResourceCPU:    resource.MustParse("1"),
											corev1.ResourceMemory: resource.MustParse("1024Mi"),
										},
										Requests: corev1.ResourceList{
											corev1.ResourceCPU:    resource.MustParse("0.1"),
											corev1.ResourceMemory: resource.MustParse("80Mi"),
										},
									},
								},
							},
						},
					},
				}},
		},
		"Deploy the SLI reporter to GCP shoot": {
			provider: consts.ProviderTypeGCP,
			deploy: &appsv1.Deployment{
				ObjectMeta: metav1.ObjectMeta{
					Name:      localSLIReporter,
					Namespace: consts.LocalOperatorNamespace,
				},
				Spec: appsv1.DeploymentSpec{
					Replicas: pointer.Int32(1),
					Selector: &metav1.LabelSelector{
						MatchLabels: labels,
					},
					Template: corev1.PodTemplateSpec{
						ObjectMeta: metav1.ObjectMeta{
							Labels: labels,
						},
						Spec: corev1.PodSpec{
							RestartPolicy:      corev1.RestartPolicyAlways,
							ServiceAccountName: localSLIReporter,
							Containers: []corev1.Container{
								{
									Name:  "auth",
									Image: "identityImage",
									VolumeMounts: []corev1.VolumeMount{
										{
											Name:      "identity",
											MountPath: "/identity",
										},
									},
									Env: []corev1.EnvVar{
										{
											Name:  "AWS_WEB_IDENTITY_TOKEN_FILE",
											Value: "/identity/token",
										},
									},
								},
								{
									Name:    localSLIReporter,
									Image:   fmt.Sprintf("%s/%s", imageRepoPrefix, imageName),
									Command: []string{"/sli-reporter"},
									Env: []corev1.EnvVar{
										{
											Name:  "AWS_REGION",
											Value: region,
										},
										{
											Name:  "AWS_DELIVERY_STREAM_NAME",
											Value: deliveryStreamName,
										},
										{
											Name:  "AWS_DELIVERY_STREAM_ROLE_ARN",
											Value: deliveryStreamRoleArn,
										},
										{
											Name:  "AWS_WEB_IDENTITY_TOKEN_FILE",
											Value: "/identity/token",
										},
										{
											Name:  "AWS_ROLE_ARN",
											Value: reporterRoleARN,
										},
									},
									Resources: corev1.ResourceRequirements{
										Limits: corev1.ResourceList{
											corev1.ResourceCPU:    resource.MustParse("1000m"),
											corev1.ResourceMemory: resource.MustParse("1024Mi"),
										},
										Requests: corev1.ResourceList{
											corev1.ResourceCPU:    resource.MustParse("100m"),
											corev1.ResourceMemory: resource.MustParse("80Mi"),
										},
									},
									VolumeMounts: []corev1.VolumeMount{
										{
											Name:      "identity",
											MountPath: "/identity",
										},
									},
								},
							},
							Volumes: []corev1.Volume{
								{
									Name: "identity",
									VolumeSource: corev1.VolumeSource{
										EmptyDir: &corev1.EmptyDirVolumeSource{
											Medium: "",
										},
									},
								},
							},
						},
					},
				}},
		},
	}

	g := NewGomegaWithT(t)
	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			ctx := context.Background()
			client := fake.NewClientBuilder().Build()

			op, err := deployTiDBClusterSLIReporter(
				ctx,
				client,
				imageRepoPrefix,
				imageName,
				tc.provider,
				reporterRoleARN,
				deliveryStreamName,
				deliveryStreamRoleArn,
				region,
				identityImage,
			)
			g.Expect(err).Should(Succeed())
			g.Expect(op).To(Equal(controllerutil.OperationResultCreated))

			// check deployment
			getDeploy := new(appsv1.Deployment)
			err = client.Get(ctx, types.NamespacedName{Namespace: consts.LocalOperatorNamespace, Name: localSLIReporter}, getDeploy)
			g.Expect(err).Should(Succeed())
			diff := cmp.Diff(tc.deploy.Spec, getDeploy.Spec)
			if diff != "" {
				t.Errorf("unexpected (-want, +got): %s", diff)
			}
		})
	}
}