package resourcemanager

import (
	"context"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/tidbcloud/observability/pkg/common/constants"
	"github.com/tidbcloud/observability/pkg/common/errors"
	batchv1 "k8s.io/api/batch/v1"
	v1 "k8s.io/api/core/v1"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func Test_jobReaderWriter_Create(t *testing.T) {
	err := jobRW.Create(context.TODO(), &batchv1.Job{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: constants.EvaluationNamespace,
			Name:      "test-create",
		},
		Spec: batchv1.JobSpec{
			TTLSecondsAfterFinished: &constants.EvaluationTTLSecondsAfterFinished,
			Completions:             &constants.EvaluationCompletions,
			BackoffLimit:            &constants.EvaluationBackoffLimit,
			Template: v1.PodTemplateSpec{
				Spec: v1.PodSpec{
					RestartPolicy: v1.RestartPolicyNever,
					Containers: []v1.Container{
						{
							Args: []string{

								"--etype=all",
							},
							Name: "evaluation",
						},
					},
				},
			},
		},
	})
	assert.NoError(t, err)
	err = jobRW.Create(context.TODO(), &batchv1.Job{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: constants.EvaluationNamespace,
			Name:      "test-create",
		},
		Spec: batchv1.JobSpec{
			TTLSecondsAfterFinished: &constants.EvaluationTTLSecondsAfterFinished,
			Completions:             &constants.EvaluationCompletions,
			BackoffLimit:            &constants.EvaluationBackoffLimit,
			Template: v1.PodTemplateSpec{
				Spec: v1.PodSpec{
					RestartPolicy: v1.RestartPolicyNever,
					Containers: []v1.Container{
						{
							Args: []string{

								"--etype=all",
							},
							Name: "evaluation",
						},
					},
				},
			},
		},
	})
	assert.Error(t, err)
	assert.Equal(t, errors.DuplicatedEvaluationName, err.(errors.Error).Code())
}

func Test_jobReaderWriter_Delete(t *testing.T) {
	err := jobRW.Create(context.TODO(), &batchv1.Job{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: constants.EvaluationNamespace,
			Name:      "test-delete",
		},
		Spec: batchv1.JobSpec{
			TTLSecondsAfterFinished: &constants.EvaluationTTLSecondsAfterFinished,
			Completions:             &constants.EvaluationCompletions,
			BackoffLimit:            &constants.EvaluationBackoffLimit,
			Template: v1.PodTemplateSpec{
				Spec: v1.PodSpec{
					RestartPolicy: v1.RestartPolicyNever,
					Containers: []v1.Container{
						{
							Args: []string{

								"--etype=all",
							},
							Name: "evaluation",
						},
					},
				},
			},
		},
	})
	assert.NoError(t, err)
	_, err = jobRW.Delete(context.TODO(), constants.EvaluationNamespace, "test-delete")
	assert.NoError(t, err)
	_, err = jobRW.Delete(context.TODO(), constants.EvaluationNamespace, "test-delete")
	assert.Error(t, err)
}

func Test_jobReaderWriter_Get(t *testing.T) {
	err := jobRW.Create(context.TODO(), &batchv1.Job{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: constants.EvaluationNamespace,
			Name:      "test-get",
		},
		Spec: batchv1.JobSpec{
			TTLSecondsAfterFinished: &constants.EvaluationTTLSecondsAfterFinished,
			Completions:             &constants.EvaluationCompletions,
			BackoffLimit:            &constants.EvaluationBackoffLimit,
			Template: v1.PodTemplateSpec{
				Spec: v1.PodSpec{
					RestartPolicy: v1.RestartPolicyNever,
					Containers: []v1.Container{
						{
							Args: []string{

								"--etype=all",
							},
							Name: "evaluation",
						},
					},
				},
			},
		},
	})
	assert.NoError(t, err)
	job, err := jobRW.Get(context.TODO(), constants.EvaluationNamespace, "test-get")
	assert.NoError(t, err)
	assert.Equal(t, "test-get", job.Name)

	_, err = jobRW.Get(context.TODO(), constants.EvaluationNamespace, "ddddd")
	assert.Error(t, err)
	assert.Equal(t, errors.EvaluationNotFound, err.(errors.Error).Code())

	_, err = jobRW.Get(context.TODO(), "", "")
	assert.Error(t, err)
}

func Test_jobReaderWriter_IsJobExists(t *testing.T) {
	err := jobRW.Create(context.TODO(), &batchv1.Job{
		ObjectMeta: metav1.ObjectMeta{
			Namespace: constants.EvaluationNamespace,
			Name:      "test-exists",
		},
		Spec: batchv1.JobSpec{
			TTLSecondsAfterFinished: &constants.EvaluationTTLSecondsAfterFinished,
			Completions:             &constants.EvaluationCompletions,
			BackoffLimit:            &constants.EvaluationBackoffLimit,
			Template: v1.PodTemplateSpec{
				Spec: v1.PodSpec{
					RestartPolicy: v1.RestartPolicyNever,
					Containers: []v1.Container{
						{
							Args: []string{

								"--etype=all",
							},
							Name: "evaluation",
						},
					},
				},
			},
		},
	})
	assert.NoError(t, err)
	exist, err := jobRW.IsJobExists(context.TODO(), constants.EvaluationNamespace, "test-exists")
	assert.NoError(t, err)
	assert.Equal(t, true, exist)

	exist, err = jobRW.IsJobExists(context.TODO(), constants.EvaluationNamespace, "ddddd")
	assert.NoError(t, err)
	assert.Equal(t, false, exist)

}