package integration_test

import (
	"github.com/udacity/graphb"
	"k8s.io/utils/ptr"

	"edge-infra.dev/pkg/edge/api/graph/model"
	vmstatus "edge-infra.dev/pkg/edge/api/services/virtualmachine/status"
	"edge-infra.dev/test/framework/integration"
)

var (
	seededVMStatuses = []*model.VirtualMachineStatus{
		{
			Name:          "test-vm-0",
			ClusterEdgeID: "3396a52c-6a22-4049-9593-5a63b596a101",
			Namespace:     "edge-vm",
			Conditions: []*model.ObjStatusCondition{
				{
					Type:    "Ready",
					Status:  false,
					Message: ptr.To("VMI does not exist"),
					Reason:  ptr.To("VMINotExists"),
				},
			},
			LastObserved: "2024-07-04 09:09:38.791665 +0000 UTC",
		},
		{
			Name:          "test-vm-1",
			ClusterEdgeID: "3396a52c-6a22-4049-9593-5a63b596a101",
			Namespace:     "edge-vm",
			Conditions:    nil,
			LastObserved:  "2024-07-05 09:09:38.791665 +0000 UTC",
		},
		{
			Name:          "test-vm-2",
			ClusterEdgeID: "3396a52c-6a22-4049-9593-5a63b596a200",
			Namespace:     "edge-vm",
			Conditions:    nil,
			LastObserved:  "2024-07-06 09:09:38.791665 +0000 UTC",
		},
		{
			Name:          "test-vm-3",
			ClusterEdgeID: "3396a52c-6a22-4049-9593-5a63b596a101",
			Namespace:     "my-vms",
			Conditions: []*model.ObjStatusCondition{
				{
					Type:   "Ready",
					Status: true,
				},
			},
			LastObserved: "2024-07-06 09:14:38.791665 +0000 UTC",
		},
	}
)

func (s *Suite) TestGetVirtualMachineStatuses() {
	integration.SkipIf(s.Framework)
	testCaseList := []struct { // defines expected values for each test case
		description   string
		name          *string
		namespace     *string
		clusterEdgeID *string
		expectedList  []*model.VirtualMachineStatus
		err           error
	}{
		{
			description:   "Query by name, namespace and clusterEdgeID",
			name:          &seededVMStatuses[0].Name,
			namespace:     &seededVMStatuses[0].Namespace,
			clusterEdgeID: &seededVMStatuses[0].ClusterEdgeID,
			expectedList:  []*model.VirtualMachineStatus{seededVMStatuses[0]},
			err:           nil,
		},
		{
			description:   "Query by name and namespace only",
			name:          &seededVMStatuses[1].Name,
			namespace:     &seededVMStatuses[1].Namespace,
			clusterEdgeID: nil,
			expectedList:  []*model.VirtualMachineStatus{seededVMStatuses[1]},
			err:           nil,
		},
		{
			description:   "Query by clusterEdgeID only",
			name:          nil,
			namespace:     nil,
			clusterEdgeID: &seededVMStatuses[0].ClusterEdgeID,
			expectedList:  []*model.VirtualMachineStatus{seededVMStatuses[0], seededVMStatuses[1], seededVMStatuses[3]},
			err:           nil,
		},
		{
			description:   "Query with no filters",
			name:          nil,
			namespace:     nil,
			clusterEdgeID: nil,
			expectedList:  seededVMStatuses,
			err:           nil,
		},
		{
			description:   "Query by name only",
			name:          &seededVMStatuses[2].Name,
			namespace:     nil,
			clusterEdgeID: nil,
			expectedList:  []*model.VirtualMachineStatus{seededVMStatuses[2]},
			err:           nil,
		},
		{
			description:   "Query by namespace only",
			name:          nil,
			namespace:     &seededVMStatuses[3].Namespace,
			clusterEdgeID: nil,
			expectedList:  []*model.VirtualMachineStatus{seededVMStatuses[3]},
			err:           nil,
		},
	}
	for _, testCase := range testCaseList {
		query := getVirtualMachineStatusesQuery(testCase.name, testCase.namespace, testCase.clusterEdgeID)
		var response struct{ VirtualMachineStatuses []*model.VirtualMachineStatus }
		s.ErrorIsf(ResolverClient.Post(query, &response), testCase.err, testCase.description)
		actualList := response.VirtualMachineStatuses
		s.NotNilf(actualList, testCase.description)
		s.Truef(vmstatus.StatusesEqual(testCase.expectedList, actualList), testCase.description)
	}
}

func getVirtualMachineStatusesQuery(name *string, namespace *string, clusterEdgeID *string) string {
	args := []graphb.Argument{}
	if name != nil {
		args = append(args, graphb.ArgumentString("name", *name))
	}
	if namespace != nil {
		args = append(args, graphb.ArgumentString("namespace", *namespace))
	}
	if clusterEdgeID != nil {
		args = append(args, graphb.ArgumentString("clusterEdgeId", *clusterEdgeID))
	}
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name:      "virtualMachineStatuses",
				Arguments: args,
				Fields:    vmStatusFields,
			},
		},
	})
}

var vmStatusFields = []*graphb.Field{
	{Name: "name"},
	{Name: "clusterEdgeId"},
	{Name: "namespace"},
	{
		Name:   "conditions",
		Fields: conditionStatusFields,
	},
	{Name: "lastObserved"},
}

var conditionStatusFields = []*graphb.Field{
	{Name: "message"},
	{Name: "reason"},
	{Name: "status"},
	{Name: "lastTransitionTime"},
	{Name: "type"},
}