package gardener

import (
	"context"
	"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/apimachinery/pkg/util/intstr"
	"k8s.io/utils/pointer"
	"sigs.k8s.io/controller-runtime/pkg/client/fake"

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

func TestDeployDataflowAgent(t *testing.T) {
	g := NewGomegaWithT(t)
	infraCli := fake.NewClientBuilder().Build()
	shootCli := fake.NewClientBuilder().Build()
	ctx := context.Background()

	// check aws
	{
		awsNet := &cloudv1.Network{
			ObjectMeta: metav1.ObjectMeta{
				Name: "awsNet",
			},
			Spec: cloudv1.NetworkSpec{
				Provider: "aws",
				Region:   "us-west-2",
			},
		}

		_, err := deployDataflowAgent(ctx, infraCli, shootCli, "dataflow-agent", awsNet, []string{"0.0.0.0/0"})
		g.Expect(err).Should(Succeed())

		// just check duplicate call will not cause error
		_, err = deployDataflowAgent(ctx, infraCli, shootCli, "dataflow-agent", awsNet, []string{"0.0.0.0/0"})
		g.Expect(err).Should(Succeed())

		// check deployment
		labels := map[string]string{
			"app": dataflowAgentName,
		}

		deploy := &appsv1.Deployment{
			ObjectMeta: metav1.ObjectMeta{
				Name:      dataflowAgentName,
				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{
						ServiceAccountName: dataflowAgentName,
						Volumes: []corev1.Volume{
							{
								Name: "tls-certs",
								VolumeSource: corev1.VolumeSource{
									Secret: &corev1.SecretVolumeSource{
										SecretName:  "proxy-certificate-secret",
										DefaultMode: pointer.Int32(0422),
									},
								},
							},
						},
						Containers: []corev1.Container{
							{
								Name:    "agent",
								Image:   "dataflow-agent",
								Command: []string{"./dataflow-agent"},
								Resources: corev1.ResourceRequirements{
									Limits: corev1.ResourceList{
										corev1.ResourceCPU:    resource.MustParse("100m"),
										corev1.ResourceMemory: resource.MustParse("2Gi"),
									},
									Requests: corev1.ResourceList{
										corev1.ResourceCPU:    resource.MustParse("20m"),
										corev1.ResourceMemory: resource.MustParse("80Mi"),
									},
								},
								VolumeMounts: []corev1.VolumeMount{
									{
										Name:      "tls-certs",
										MountPath: "/proxy-tls",
									},
								},
							},
						},
					},
				},
			}}

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

		// check service
		svc := &corev1.Service{
			ObjectMeta: metav1.ObjectMeta{
				Name:      dataflowAgentSvcName,
				Namespace: consts.LocalOperatorNamespace,
			},
			Spec: corev1.ServiceSpec{
				Ports: []corev1.ServicePort{{
					Port:       443,
					TargetPort: intstr.FromInt(443),
					Protocol:   corev1.ProtocolTCP,
				}},
				Selector:                 labels,
				Type:                     corev1.ServiceTypeLoadBalancer,
				ExternalTrafficPolicy:    corev1.ServiceExternalTrafficPolicyTypeLocal,
				LoadBalancerSourceRanges: []string{"0.0.0.0/0"},
			},
		}

		getSvc := new(corev1.Service)
		err = shootCli.Get(ctx, types.NamespacedName{Namespace: consts.LocalOperatorNamespace, Name: dataflowAgentSvcName}, getSvc)
		g.Expect(err).Should(Succeed())
		diff = cmp.Diff(svc.Spec, getSvc.Spec)
		if diff != "" {
			t.Errorf("unexpected (-want, +got): %s", diff)
		}
	}

	// check gcp return err when gcp key not ready
	{
		{
			gcpNet := &cloudv1.Network{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "test",
					Name:      "gcpNet",
					Labels: map[string]string{
						v1.ProjectLabel: "project-test-error",
					},
				},
				Spec: cloudv1.NetworkSpec{
					Provider: "gcp",
					Region:   "us-west1",
				},
			}

			// mock empty gcp key
			saName := GetGCPAccessServiceAccountName(gcpNet.Spec.Region, gcpNet.GetProjectId())
			keyName := GetGCPAccessServiceAccountKeyName(saName)
			secretName := types.NamespacedName{Namespace: gcpNet.Namespace, Name: keyName}
			keySecret := &corev1.Secret{
				ObjectMeta: metav1.ObjectMeta{
					Name:      secretName.Name,
					Namespace: secretName.Namespace,
				},
				Data: map[string][]byte{
					gcpCredentialsKey: {},
				},
			}
			g.Expect(infraCli.Create(ctx, keySecret)).Should(Succeed())

			_, err := deployDataflowAgent(ctx, infraCli, shootCli, "dataflow-agent", gcpNet, []string{"0.0.0.0/0"})
			g.Expect(err).NotTo(BeNil())
		}
	}

	// check gcp
	{
		gcpNet := &cloudv1.Network{
			ObjectMeta: metav1.ObjectMeta{
				Namespace: "test",
				Name:      "gcpNet",
				Labels: map[string]string{
					v1.ProjectLabel: "project-test",
				},
			},
			Spec: cloudv1.NetworkSpec{
				Provider: "gcp",
				Region:   "us-west1",
			},
		}

		// mock for gcp
		saName := GetGCPAccessServiceAccountName(gcpNet.Spec.Region, gcpNet.GetProjectId())
		keyName := GetGCPAccessServiceAccountKeyName(saName)
		secretName := types.NamespacedName{Namespace: gcpNet.Namespace, Name: keyName}
		keySecret := &corev1.Secret{
			ObjectMeta: metav1.ObjectMeta{
				Name:      secretName.Name,
				Namespace: secretName.Namespace,
			},
			Data: map[string][]byte{
				gcpCredentialsKey: {byte(1)},
			},
		}
		g.Expect(infraCli.Create(ctx, keySecret)).Should(Succeed())

		_, err := deployDataflowAgent(ctx, infraCli, shootCli, "dataflow-agent", gcpNet, []string{"0.0.0.0/0"})
		g.Expect(err).Should(Succeed())

		// just check duplicate call will not cause error
		_, err = deployDataflowAgent(ctx, infraCli, shootCli, "dataflow-agent", gcpNet, []string{"0.0.0.0/0"})
		g.Expect(err).Should(Succeed())

		// check deployment
		labels := map[string]string{
			"app": dataflowAgentName,
		}

		deploy := &appsv1.Deployment{
			ObjectMeta: metav1.ObjectMeta{
				Name:      dataflowAgentName,
				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{
						ServiceAccountName: dataflowAgentName,
						Volumes: []corev1.Volume{
							{
								Name: "tls-certs",
								VolumeSource: corev1.VolumeSource{
									Secret: &corev1.SecretVolumeSource{
										SecretName:  "proxy-certificate-secret",
										DefaultMode: pointer.Int32(0422),
									},
								},
							},
							{
								Name: "gcp-credentials",
								VolumeSource: corev1.VolumeSource{
									Secret: &corev1.SecretVolumeSource{
										SecretName: dataflowAgentGcpSecretName,
										Items:      []corev1.KeyToPath{{Key: "privateKey", Path: "key.json"}},
									},
								},
							},
						},
						Containers: []corev1.Container{
							{
								Name:    "agent",
								Image:   "dataflow-agent",
								Command: []string{"./dataflow-agent"},
								Resources: corev1.ResourceRequirements{
									Limits: corev1.ResourceList{
										corev1.ResourceCPU:    resource.MustParse("100m"),
										corev1.ResourceMemory: resource.MustParse("2Gi"),
									},
									Requests: corev1.ResourceList{
										corev1.ResourceCPU:    resource.MustParse("20m"),
										corev1.ResourceMemory: resource.MustParse("80Mi"),
									},
								},
								VolumeMounts: []corev1.VolumeMount{
									{
										Name:      "tls-certs",
										MountPath: "/proxy-tls",
									},
									{
										Name:      "gcp-credentials",
										MountPath: "/root/gcp",
									},
								},
							},
						},
					},
				},
			}}

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

		// check service
		svc := &corev1.Service{
			ObjectMeta: metav1.ObjectMeta{
				Name:      dataflowAgentSvcName,
				Namespace: consts.LocalOperatorNamespace,
			},
			Spec: corev1.ServiceSpec{
				Ports: []corev1.ServicePort{{
					Port:       443,
					TargetPort: intstr.FromInt(443),
					Protocol:   corev1.ProtocolTCP,
				}},
				Selector:                 labels,
				Type:                     corev1.ServiceTypeLoadBalancer,
				ExternalTrafficPolicy:    corev1.ServiceExternalTrafficPolicyTypeLocal,
				LoadBalancerSourceRanges: []string{"0.0.0.0/0"},
			},
		}

		getSvc := new(corev1.Service)
		err = shootCli.Get(ctx, types.NamespacedName{Namespace: consts.LocalOperatorNamespace, Name: dataflowAgentSvcName}, getSvc)
		g.Expect(err).Should(Succeed())
		diff = cmp.Diff(svc.Spec, getSvc.Spec)
		if diff != "" {
			t.Errorf("unexpected (-want, +got): %s", diff)
		}
	}

}