package mapper

import (
	"fmt"
	"strconv"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	appsv1 "k8s.io/api/apps/v1"
	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/intstr"

	"edge-infra.dev/pkg/edge/api/graph/model"
)

const (
	RestartCount     = 1
	PeriodSeconds    = 2
	TimeoutSeconds   = 3
	SuccessThreshold = 4
	FailureThreshold = 5
	Ready            = true
	Started          = true
	ConditionStatus  = v1.ConditionTrue
	ConditionType    = v1.PodReady
	DepName          = "test-deployment-1"
	SSName           = "test-statefulset-1"
	DSName           = "test-daemonset-1"
	PodName          = "test-pod-1"
	HTTPPath         = "test-path"
	HTTPHost         = "test-host"
	HTTPScheme       = "test-scheme"
	ReleaseName      = "test-release"
	ReleaseNS        = "default"
)

func GetTestWorkloadDeployment(httpPort intstr.IntOrString) *appsv1.Deployment { //nolint test types
	return &appsv1.Deployment{
		TypeMeta: metav1.TypeMeta{
			APIVersion: appsv1.SchemeGroupVersion.Version,
			Kind:       "Deployment",
		},
		ObjectMeta: metav1.ObjectMeta{Name: DepName,
			Annotations: map[string]string{
				"meta.helm.sh/release-name":      fmt.Sprintf("%s-%s", ReleaseNS, ReleaseName),
				"meta.helm.sh/release-namespace": ReleaseNS,
			},
		},
		Spec: appsv1.DeploymentSpec{
			Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"name": "test-app", "helm": "test-helm"}},
			Template: v1.PodTemplateSpec{
				Spec: v1.PodSpec{
					Containers: []v1.Container{
						{
							LivenessProbe: &v1.Probe{
								ProbeHandler: v1.ProbeHandler{
									HTTPGet: &v1.HTTPGetAction{
										Path:   HTTPPath,
										Port:   httpPort,
										Host:   HTTPHost,
										Scheme: HTTPScheme,
									},
								},
								TimeoutSeconds:   TimeoutSeconds,
								PeriodSeconds:    PeriodSeconds,
								SuccessThreshold: SuccessThreshold,
								FailureThreshold: FailureThreshold,
							},
							ReadinessProbe: &v1.Probe{
								ProbeHandler: v1.ProbeHandler{
									HTTPGet: &v1.HTTPGetAction{
										Path:   HTTPPath,
										Port:   httpPort,
										Host:   HTTPHost,
										Scheme: HTTPScheme,
									},
								},
								TimeoutSeconds:   TimeoutSeconds,
								PeriodSeconds:    PeriodSeconds,
								SuccessThreshold: SuccessThreshold,
								FailureThreshold: FailureThreshold,
							},
						},
					},
				},
			},
		},
	}
}

func GetTestWorkloadStatefulSet(httpPort intstr.IntOrString) *appsv1.StatefulSet { //nolint test types
	return &appsv1.StatefulSet{
		TypeMeta: metav1.TypeMeta{
			APIVersion: appsv1.SchemeGroupVersion.Version,
			Kind:       "StatefulSet",
		},
		ObjectMeta: metav1.ObjectMeta{Name: SSName,
			Annotations: map[string]string{
				"meta.helm.sh/release-name":      fmt.Sprintf("%s-%s", ReleaseNS, ReleaseName),
				"meta.helm.sh/release-namespace": ReleaseNS,
			},
		},
		Spec: appsv1.StatefulSetSpec{
			Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"name": "test-app", "helm": "test-helm"}},
			Template: v1.PodTemplateSpec{
				Spec: v1.PodSpec{
					Containers: []v1.Container{
						{
							LivenessProbe: &v1.Probe{
								ProbeHandler: v1.ProbeHandler{
									HTTPGet: &v1.HTTPGetAction{
										Path:   HTTPPath,
										Port:   httpPort,
										Host:   HTTPHost,
										Scheme: HTTPScheme,
									},
								},
								TimeoutSeconds:   TimeoutSeconds,
								PeriodSeconds:    PeriodSeconds,
								SuccessThreshold: SuccessThreshold,
								FailureThreshold: FailureThreshold,
							},
							ReadinessProbe: &v1.Probe{
								ProbeHandler: v1.ProbeHandler{
									HTTPGet: &v1.HTTPGetAction{
										Path:   HTTPPath,
										Port:   httpPort,
										Host:   HTTPHost,
										Scheme: HTTPScheme,
									},
								},
								TimeoutSeconds:   TimeoutSeconds,
								PeriodSeconds:    PeriodSeconds,
								SuccessThreshold: SuccessThreshold,
								FailureThreshold: FailureThreshold,
							},
						},
					},
				},
			},
		},
	}
}

func GetTestWorkloadDaemonSet(httpPort intstr.IntOrString) *appsv1.DaemonSet { //nolint test types
	return &appsv1.DaemonSet{
		TypeMeta: metav1.TypeMeta{
			APIVersion: appsv1.SchemeGroupVersion.Version,
			Kind:       "DaemonSet",
		},
		ObjectMeta: metav1.ObjectMeta{Name: DSName,
			Annotations: map[string]string{
				"meta.helm.sh/release-name":      fmt.Sprintf("%s-%s", ReleaseNS, ReleaseName),
				"meta.helm.sh/release-namespace": ReleaseNS,
			},
		},
		Spec: appsv1.DaemonSetSpec{
			Selector: &metav1.LabelSelector{MatchLabels: map[string]string{"name": "test-app", "helm": "test-helm"}},
			Template: v1.PodTemplateSpec{
				Spec: v1.PodSpec{
					Containers: []v1.Container{
						{
							LivenessProbe: &v1.Probe{
								ProbeHandler: v1.ProbeHandler{
									HTTPGet: &v1.HTTPGetAction{
										Path:   HTTPPath,
										Port:   httpPort,
										Host:   HTTPHost,
										Scheme: HTTPScheme,
									},
								},
								TimeoutSeconds:   TimeoutSeconds,
								PeriodSeconds:    PeriodSeconds,
								SuccessThreshold: SuccessThreshold,
								FailureThreshold: FailureThreshold,
							},
							ReadinessProbe: &v1.Probe{
								ProbeHandler: v1.ProbeHandler{
									HTTPGet: &v1.HTTPGetAction{
										Path:   HTTPPath,
										Port:   httpPort,
										Host:   HTTPHost,
										Scheme: HTTPScheme,
									},
								},
								TimeoutSeconds:   TimeoutSeconds,
								PeriodSeconds:    PeriodSeconds,
								SuccessThreshold: SuccessThreshold,
								FailureThreshold: FailureThreshold,
							},
						},
					},
				},
			},
		},
	}
}

func GetTestWorkloadPodList(conditionTime time.Time, startedPointer bool) *v1.PodList {
	return &v1.PodList{
		Items: []v1.Pod{
			{
				ObjectMeta: metav1.ObjectMeta{
					Name:   PodName,
					Labels: map[string]string{"name": "test-app", "helm": "test-helm"},
				},
				Status: v1.PodStatus{
					Conditions: []v1.PodCondition{
						{
							LastProbeTime:      metav1.Time{Time: conditionTime},
							LastTransitionTime: metav1.Time{Time: conditionTime},
							Status:             ConditionStatus,
							Type:               ConditionType,
						},
					},
					ContainerStatuses: []v1.ContainerStatus{
						{
							RestartCount: RestartCount,
							Ready:        Ready,
							Started:      &startedPointer,
						},
					},
				},
			},
		},
	}
}

func ComapreLivenessReadinessModel(model *model.LivenessReadinessResponse, port intstr.IntOrString, conditionTime time.Time, t *testing.T) {
	startedPointer := Started
	timeString := conditionTime.Format(TimeFormat)
	assert.Equal(t, model.ReadinessProbe.HTTPGet.Scheme, HTTPScheme)
	assert.Equal(t, model.ReadinessProbe.HTTPGet.Port, int(port.IntVal))
	assert.Equal(t, model.ReadinessProbe.HTTPGet.Path, HTTPPath)
	assert.Equal(t, model.ReadinessProbe.TimeoutSeconds, TimeoutSeconds)
	assert.Equal(t, model.ReadinessProbe.SuccessThreshold, SuccessThreshold)
	assert.Equal(t, model.ReadinessProbe.PeriodSeconds, PeriodSeconds)
	assert.Equal(t, model.ReadinessProbe.FailureThreshold, strconv.Itoa(FailureThreshold))
	assert.Equal(t, model.LivenessProbe.HTTPGet.Scheme, HTTPScheme)
	assert.Equal(t, model.LivenessProbe.HTTPGet.Port, int(port.IntVal))
	assert.Equal(t, model.LivenessProbe.HTTPGet.Path, HTTPPath)
	assert.Equal(t, model.LivenessProbe.TimeoutSeconds, TimeoutSeconds)
	assert.Equal(t, model.LivenessProbe.SuccessThreshold, SuccessThreshold)
	assert.Equal(t, model.LivenessProbe.PeriodSeconds, PeriodSeconds)
	assert.Equal(t, model.LivenessProbe.FailureThreshold, strconv.Itoa(FailureThreshold))
	for _, podStatus := range model.PodStatus {
		assert.Equal(t, podStatus.Started, startedPointer)
		assert.Equal(t, podStatus.Ready, Ready)
		assert.Equal(t, podStatus.RestartCount, RestartCount)
		for _, condition := range podStatus.Conditions {
			assert.Equal(t, condition.Type, string(ConditionType))
			assert.Equal(t, condition.Status, string(ConditionStatus))
			assert.Equal(t, condition.LastTransitionTime, timeString)
			assert.Equal(t, condition.LastProbeTime, &timeString)
		}
	}
}