package lifted

import (
	"fmt"
	"reflect"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	appsv1 "k8s.io/api/apps/v1"
	corev1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/apiserver/pkg/storage/names"
	"k8s.io/utils/pointer"
)

// +lifted:source=https://github.com/kubernetes/kubernetes/blob/release-1.26/pkg/controller/deployment/util/deployment_util_test.go#L40-L49

func newDControllerRef(d *appsv1.Deployment) *metav1.OwnerReference {
	isController := true
	return &metav1.OwnerReference{
		APIVersion: "apps/v1",
		Kind:       "Deployment",
		Name:       d.GetName(),
		UID:        d.GetUID(),
		Controller: &isController,
	}
}

// +lifted:source=https://github.com/kubernetes/kubernetes/blob/release-1.26/pkg/controller/deployment/util/deployment_util_test.go#L51-L67
// +lifted:changed

// generateRS creates a replica set, with the input deployment's template as its template
func generateRS(deployment appsv1.Deployment) appsv1.ReplicaSet {
	template := deployment.Spec.Template.DeepCopy()
	return appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			UID:             "test",
			Name:            names.SimpleNameGenerator.GenerateName("replicaset"),
			Labels:          template.Labels,
			OwnerReferences: []metav1.OwnerReference{*newDControllerRef(&deployment)},
		},
		Spec: appsv1.ReplicaSetSpec{
			Replicas: new(int32),
			Template: *template,
			Selector: &metav1.LabelSelector{MatchLabels: template.Labels},
		},
	}
}

// +lifted:source=https://github.com/kubernetes/kubernetes/blob/release-1.26/pkg/controller/deployment/util/deployment_util_test.go#L73-L108

// generateDeployment creates a deployment, with the input image as its template
func generateDeployment(image string) appsv1.Deployment {
	podLabels := map[string]string{"name": image}
	terminationSec := int64(30)
	enableServiceLinks := corev1.DefaultEnableServiceLinks
	return appsv1.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Name:        image,
			Annotations: make(map[string]string),
		},
		Spec: appsv1.DeploymentSpec{
			Replicas: func(i int32) *int32 { return &i }(1),
			Selector: &metav1.LabelSelector{MatchLabels: podLabels},
			Template: corev1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Labels: podLabels,
				},
				Spec: corev1.PodSpec{
					Containers: []corev1.Container{
						{
							Name:                   image,
							Image:                  image,
							ImagePullPolicy:        corev1.PullAlways,
							TerminationMessagePath: corev1.TerminationMessagePathDefault,
						},
					},
					DNSPolicy:                     corev1.DNSClusterFirst,
					TerminationGracePeriodSeconds: &terminationSec,
					RestartPolicy:                 corev1.RestartPolicyAlways,
					SecurityContext:               &corev1.PodSecurityContext{},
					EnableServiceLinks:            &enableServiceLinks,
				},
			},
		},
	}
}

// +lifted:source=https://github.com/kubernetes/kubernetes/blob/release-1.26/pkg/controller/deployment/util/deployment_util_test.go#L110-L121

func generatePodTemplateSpec(name, nodeName string, annotations, labels map[string]string) corev1.PodTemplateSpec {
	return corev1.PodTemplateSpec{
		ObjectMeta: metav1.ObjectMeta{
			Name:        name,
			Annotations: annotations,
			Labels:      labels,
		},
		Spec: corev1.PodSpec{
			NodeName: nodeName,
		},
	}
}

func TestReplicaSetsByCreationTimestamp_Len(t *testing.T) {
	rs1 := &appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:              "rs1",
			CreationTimestamp: metav1.Now(),
		},
	}
	rs2 := &appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:              "rs2",
			CreationTimestamp: metav1.Now(),
		},
	}
	rs3 := &appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:              "rs3",
			CreationTimestamp: metav1.Now(),
		},
	}
	rsList := ReplicaSetsByCreationTimestamp{rs1, rs2, rs3}
	expectedLen := 3
	actualLen := rsList.Len()
	if actualLen != expectedLen {
		t.Errorf("Expected length to be %d, but got %d", expectedLen, actualLen)
	}
}

func TestReplicaSetsByCreationTimestamp_Swap(t *testing.T) {
	rs1 := &appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:              "rs1",
			CreationTimestamp: metav1.Now(),
		},
	}
	rs2 := &appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:              "rs2",
			CreationTimestamp: metav1.Now(),
		},
	}
	r := ReplicaSetsByCreationTimestamp{rs1, rs2}
	r.Swap(0, 1)
	if r[0] != rs2 || r[1] != rs1 {
		t.Errorf("Swap failed, expected %v, got %v", []*appsv1.ReplicaSet{rs2, rs1}, r)
	}
}

func TestReplicaSetsByCreationTimestamp_Less(t *testing.T) {
	now := time.Now()
	rs1 := &appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:              "rs1",
			CreationTimestamp: metav1.NewTime(now),
		},
	}
	rs2 := &appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:              "rs2",
			CreationTimestamp: metav1.NewTime(now.Add(time.Duration(-10) * time.Minute)),
		},
	}

	r := ReplicaSetsByCreationTimestamp{rs1, rs2}
	res := r.Less(0, 1)
	if res != false {
		t.Errorf("Expect false, but got true")
	}

	r = ReplicaSetsByCreationTimestamp{rs1, rs1}
	res = r.Less(0, 1)
	if res != false {
		t.Errorf("Expect false, but got true")
	}
}

func TestListReplicaSetsByDeployment(t *testing.T) {
	rs1 := &appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "rs1",
			Namespace: "test",
			Labels:    map[string]string{"key1": "value1"},
			OwnerReferences: []metav1.OwnerReference{
				{
					UID:        "test",
					Controller: pointer.Bool(true),
				},
			},
		},
	}
	err := fmt.Errorf("error")
	tests := []struct {
		name       string
		deployment *appsv1.Deployment
		rs         *appsv1.ReplicaSet
		rsListFunc RsListFunc
		wantErr    bool
		wantRS     bool
	}{
		{
			name: "get rs without error",
			deployment: &appsv1.Deployment{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "test",
					UID:       "test",
				},
				Spec: appsv1.DeploymentSpec{
					Selector: &metav1.LabelSelector{
						MatchLabels: map[string]string{
							"key1": "value1",
						},
					},
				},
			},
			rsListFunc: func(namespace string, selector labels.Selector) ([]*appsv1.ReplicaSet, error) {
				return []*appsv1.ReplicaSet{rs1}, nil
			},
			wantErr: false,
			wantRS:  true,
		},
		{
			name: "failed in LabelSelectorAsSelector",
			deployment: &appsv1.Deployment{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "test",
					UID:       "test",
				},
				Spec: appsv1.DeploymentSpec{
					Selector: &metav1.LabelSelector{
						MatchExpressions: []metav1.LabelSelectorRequirement{
							{
								Key:      "key1",
								Operator: "blah",
								Values:   []string{"value1"},
							},
						},
					},
				},
			},
			rsListFunc: func(namespace string, selector labels.Selector) ([]*appsv1.ReplicaSet, error) {
				return []*appsv1.ReplicaSet{rs1}, nil
			},
			wantErr: true,
			wantRS:  false,
		},
		{
			name: "failed in ReplicaSetListFunc",
			deployment: &appsv1.Deployment{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "test",
					UID:       "test",
				},
				Spec: appsv1.DeploymentSpec{
					Selector: &metav1.LabelSelector{
						MatchLabels: map[string]string{
							"key1": "value1",
						},
					},
				},
			},
			rsListFunc: func(namespace string, selector labels.Selector) ([]*appsv1.ReplicaSet, error) {
				return []*appsv1.ReplicaSet{rs1}, err
			},
			wantErr: true,
			wantRS:  false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			rss, err := ListReplicaSetsByDeployment(tt.deployment, tt.rsListFunc)
			if (err != nil) != tt.wantErr {
				t.Errorf("ListReplicaSetsByDeployment() error = %v, wantErr %v", err, tt.wantErr)
			}
			if tt.wantRS {
				assert.ObjectsAreEqual([]*appsv1.ReplicaSet{rs1}, rss)
			}
		})
	}
}

func TestListPodsByRS(t *testing.T) {
	pod := &corev1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "pod1",
			Namespace: "test",
			Labels:    map[string]string{"key1": "value1"},
			OwnerReferences: []metav1.OwnerReference{
				{
					UID:        "test",
					Controller: pointer.Bool(true),
				},
			},
		},
	}
	err := fmt.Errorf("error")
	tests := []struct {
		name        string
		deployment  *appsv1.Deployment
		rsList      []*appsv1.ReplicaSet
		podListFunc PodListFunc
		wantErr     bool
		wantPod     bool
	}{
		{
			name: "get pods without error",
			deployment: &appsv1.Deployment{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "test",
					UID:       "test",
				},
				Spec: appsv1.DeploymentSpec{
					Selector: &metav1.LabelSelector{
						MatchLabels: map[string]string{
							"key1": "value1",
						},
					},
				},
			},
			rsList: []*appsv1.ReplicaSet{
				{
					ObjectMeta: metav1.ObjectMeta{
						Name:      "rs1",
						Namespace: "test",
						Labels:    map[string]string{"key1": "value1"},
						OwnerReferences: []metav1.OwnerReference{
							{
								UID:        "test",
								Controller: pointer.Bool(true),
							},
						},
					},
				},
			},
			podListFunc: func(s string, selector labels.Selector) ([]*corev1.Pod, error) {
				return []*corev1.Pod{pod}, nil
			},
			wantErr: false,
			wantPod: true,
		},
		{
			name: "failed in LabelSelectorAsSelector",
			deployment: &appsv1.Deployment{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "test",
					UID:       "test",
				},
				Spec: appsv1.DeploymentSpec{
					Selector: &metav1.LabelSelector{
						MatchExpressions: []metav1.LabelSelectorRequirement{
							{
								Key:      "key1",
								Operator: "blah",
								Values:   []string{"value1"},
							},
						},
					},
				},
			},
			rsList: []*appsv1.ReplicaSet{
				{
					ObjectMeta: metav1.ObjectMeta{
						Name:      "rs1",
						Namespace: "test",
						Labels:    map[string]string{"key1": "value1"},
						OwnerReferences: []metav1.OwnerReference{
							{
								UID:        "test",
								Controller: pointer.Bool(true),
							},
						},
					},
				},
			},
			podListFunc: func(s string, selector labels.Selector) ([]*corev1.Pod, error) {
				return []*corev1.Pod{pod}, nil
			},
			wantErr: true,
			wantPod: false,
		},
		{
			name: "failed in ReplicaSetListFunc",
			deployment: &appsv1.Deployment{
				ObjectMeta: metav1.ObjectMeta{
					Namespace: "test",
					UID:       "test",
				},
				Spec: appsv1.DeploymentSpec{
					Selector: &metav1.LabelSelector{
						MatchLabels: map[string]string{
							"key1": "value1",
						},
					},
				},
			},
			rsList: []*appsv1.ReplicaSet{
				{
					ObjectMeta: metav1.ObjectMeta{
						Name:      "rs1",
						Namespace: "test",
						Labels:    map[string]string{"key1": "value1"},
						OwnerReferences: []metav1.OwnerReference{
							{
								UID:        "test",
								Controller: pointer.Bool(true),
							},
						},
					},
				},
			},
			podListFunc: func(s string, selector labels.Selector) ([]*corev1.Pod, error) {
				return []*corev1.Pod{pod}, err
			},
			wantErr: true,
			wantPod: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			pods, err := ListPodsByRS(tt.deployment, tt.rsList, tt.podListFunc)
			if (err != nil) != tt.wantErr {
				t.Errorf("ListPodsByRS() error = %v, wantErr %v", err, tt.wantErr)
			}
			if tt.wantPod {
				assert.ObjectsAreEqual([]*corev1.Pod{pod}, pods)
			}
		})
	}
}

// +lifted:source=https://github.com/kubernetes/kubernetes/blob/release-1.26/pkg/controller/deployment/util/deployment_util_test.go#L123-L214

func TestEqualIgnoreHash(t *testing.T) {
	tests := []struct {
		Name           string
		former, latter corev1.PodTemplateSpec
		expected       bool
	}{
		{
			"Same spec, same labels",
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-1", "something": "else"}),
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-1", "something": "else"}),
			true,
		},
		{
			"Same spec, only pod-template-hash label value is different",
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-1", "something": "else"}),
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-2", "something": "else"}),
			true,
		},
		{
			"Same spec, the former doesn't have pod-template-hash label",
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{"something": "else"}),
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-2", "something": "else"}),
			true,
		},
		{
			"Same spec, the label is different, the former doesn't have pod-template-hash label, same number of labels",
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{"something": "else"}),
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-2"}),
			false,
		},
		{
			"Same spec, the label is different, the latter doesn't have pod-template-hash label, same number of labels",
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-1"}),
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{"something": "else"}),
			false,
		},
		{
			"Same spec, the label is different, and the pod-template-hash label value is the same",
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-1"}),
			generatePodTemplateSpec("foo", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-1", "something": "else"}),
			false,
		},
		{
			"Different spec, same labels",
			generatePodTemplateSpec("foo", "foo-node", map[string]string{"former": "value"}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-1", "something": "else"}),
			generatePodTemplateSpec("foo", "foo-node", map[string]string{"latter": "value"}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-1", "something": "else"}),
			false,
		},
		{
			"Different spec, different pod-template-hash label value",
			generatePodTemplateSpec("foo-1", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-1", "something": "else"}),
			generatePodTemplateSpec("foo-2", "foo-node", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-2", "something": "else"}),
			false,
		},
		{
			"Different spec, the former doesn't have pod-template-hash label",
			generatePodTemplateSpec("foo-1", "foo-node-1", map[string]string{}, map[string]string{"something": "else"}),
			generatePodTemplateSpec("foo-2", "foo-node-2", map[string]string{}, map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value-2", "something": "else"}),
			false,
		},
		{
			"Different spec, different labels",
			generatePodTemplateSpec("foo", "foo-node-1", map[string]string{}, map[string]string{"something": "else"}),
			generatePodTemplateSpec("foo", "foo-node-2", map[string]string{}, map[string]string{"nothing": "else"}),
			false,
		},
	}

	for _, test := range tests {
		t.Run(test.Name, func(t *testing.T) {
			runTest := func(t1, t2 *corev1.PodTemplateSpec, reversed bool) {
				reverseString := ""
				if reversed {
					reverseString = " (reverse order)"
				}
				// Run
				equal := EqualIgnoreHash(t1, t2)
				if equal != test.expected {
					t.Errorf("%q%s: expected %v", test.Name, reverseString, test.expected)
					return
				}
				if t1.Labels == nil || t2.Labels == nil {
					t.Errorf("%q%s: unexpected labels becomes nil", test.Name, reverseString)
				}
			}

			runTest(&test.former, &test.latter, false)
			// Test the same case in reverse order
			runTest(&test.latter, &test.former, true)
		})
	}
}

func TestGetNewReplicaSet(t *testing.T) {
	rs := &appsv1.ReplicaSet{
		ObjectMeta: metav1.ObjectMeta{
			Name:      "rs1",
			Namespace: "test",
			Labels:    map[string]string{"key1": "value1"},
			OwnerReferences: []metav1.OwnerReference{
				{
					UID:        "test",
					Controller: pointer.Bool(true),
				},
			},
		},
		Spec: appsv1.ReplicaSetSpec{
			Template: corev1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "pod1",
					Namespace: "test",
					Labels:    map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value2"},
				},
			},
		},
	}

	deployment := &appsv1.Deployment{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: "test",
			UID:       "test",
		},
		Spec: appsv1.DeploymentSpec{
			Selector: &metav1.LabelSelector{
				MatchLabels: map[string]string{
					"key1": "value1",
				},
			},
			Template: corev1.PodTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "pod1",
					Namespace: "test",
					Labels:    map[string]string{appsv1.DefaultDeploymentUniqueLabelKey: "value1"},
				},
			},
		},
	}
	err := fmt.Errorf("error")

	t.Run("no error", func(t *testing.T) {
		rsListFunc := func(namespace string, selector labels.Selector) ([]*appsv1.ReplicaSet, error) {
			return []*appsv1.ReplicaSet{rs}, nil
		}
		gotRS, gotErr := GetNewReplicaSet(deployment, rsListFunc)
		if gotErr != nil {
			t.Errorf("Expect no error but got %v", err)
		}

		if gotRS != rs {
			t.Errorf("Got wrong rs %+v", gotRS)
		}
	})

	t.Run("have error", func(t *testing.T) {
		rsListFunc := func(namespace string, selector labels.Selector) ([]*appsv1.ReplicaSet, error) {
			return []*appsv1.ReplicaSet{rs}, err
		}
		gotRS, gotErr := GetNewReplicaSet(deployment, rsListFunc)
		if gotErr == nil {
			t.Errorf("Expect error but got %v", err)
		}

		if gotRS != nil {
			t.Errorf("Expect empty rs, but got %+v", gotRS)
		}
	})
}

// +lifted:source=https://github.com/kubernetes/kubernetes/blob/release-1.26/pkg/controller/deployment/util/deployment_util_test.go#L216-L267

func TestFindNewReplicaSet(t *testing.T) {
	now := metav1.Now()
	later := metav1.Time{Time: now.Add(time.Minute)}

	deployment := generateDeployment("nginx")
	newRS := generateRS(deployment)
	newRS.Labels[appsv1.DefaultDeploymentUniqueLabelKey] = "hash"
	newRS.CreationTimestamp = later

	newRSDup := generateRS(deployment)
	newRSDup.Labels[appsv1.DefaultDeploymentUniqueLabelKey] = "different-hash"
	newRSDup.CreationTimestamp = now

	oldDeployment := generateDeployment("nginx")
	oldDeployment.Spec.Template.Spec.Containers[0].Name = "nginx-old-1"
	oldRS := generateRS(oldDeployment)
	oldRS.Status.FullyLabeledReplicas = *(oldRS.Spec.Replicas)

	tests := []struct {
		Name       string
		deployment appsv1.Deployment
		rsList     []*appsv1.ReplicaSet
		expected   *appsv1.ReplicaSet
	}{
		{
			Name:       "Get new ReplicaSet with the same template as Deployment spec but different pod-template-hash value",
			deployment: deployment,
			rsList:     []*appsv1.ReplicaSet{&newRS, &oldRS},
			expected:   &newRS,
		},
		{
			Name:       "Get the oldest new ReplicaSet when there are more than one ReplicaSet with the same template",
			deployment: deployment,
			rsList:     []*appsv1.ReplicaSet{&newRS, &oldRS, &newRSDup},
			expected:   &newRSDup,
		},
		{
			Name:       "Get nil new ReplicaSet",
			deployment: deployment,
			rsList:     []*appsv1.ReplicaSet{&oldRS},
			expected:   nil,
		},
	}

	for _, test := range tests {
		t.Run(test.Name, func(t *testing.T) {
			if rs := FindNewReplicaSet(&test.deployment, test.rsList); !reflect.DeepEqual(rs, test.expected) {
				t.Errorf("In test case %q, expected %#v, got %#v", test.Name, test.expected, rs)
			}
		})
	}
}