package integration_test

import (
	"github.com/udacity/graphb"

	"edge-infra.dev/pkg/edge/api/graph/model"
	sqlquery "edge-infra.dev/pkg/edge/api/sql"
	"edge-infra.dev/pkg/edge/api/utils"
	"edge-infra.dev/test/framework/integration"
)

func (s *Suite) TestCreateVirtualMachine() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachine *model.VirtualMachine }

	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053ba\",memory:\"1024\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType,disks{diskId,bootOrder}}}"

	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "error resolving vm mutation")

	s.NotNilf(response.CreateVirtualMachine, "returned vm is null")
	virtualMachine := response.CreateVirtualMachine

	s.Len(virtualMachine.Disks, 2)
	s.Equal(1, virtualMachine.Disks[0].BootOrder)
	s.Equal("618648c8-56f4-4578-a4ff-ae88782b0b9f", virtualMachine.ClusterEdgeID)
	s.Equal("ien-00005e0053ba", virtualMachine.Hostname)
	s.Equal(false, virtualMachine.TargetPowerState)
	s.Equal(1, virtualMachine.Cpus)
	s.Equal("1024", virtualMachine.Memory)
	s.Equal(model.MachineTypeQ35, virtualMachine.MachineType)
	_, err = s.DB.Exec(sqlquery.VirtualMachineDeleteQuery, virtualMachine.VirtualMachineID)
	s.NoError(err)
}

func (s *Suite) TestCreateVirtualMachineDefaults() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachine *model.VirtualMachine }
	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053bb\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
	err := ResolverClient.Post(mutation, &response)

	s.NoErrorf(err, "error resolving vm mutation")

	s.NotNilf(response.CreateVirtualMachine, "returned vm is null")
	virtualMachine := response.CreateVirtualMachine

	s.Equal(model.MachineTypeQ35, virtualMachine.MachineType)
	s.Equal(false, virtualMachine.TargetPowerState)
	s.Equal(1, virtualMachine.Cpus)
	s.Equal("1024Mi", virtualMachine.Memory)

	_, err = s.DB.Exec(sqlquery.VirtualMachineDeleteQuery, virtualMachine.VirtualMachineID)
	s.NoError(err)
}

func (s *Suite) TestCreateVirtualMachineInvalidMemoryOne() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachine *model.VirtualMachine }

	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053bc\",memory:\"1024Gb\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "should be an error resolving vm mutation")
	s.Nilf(response.CreateVirtualMachine, "returned vm is not null")
}

func (s *Suite) TestCreateVirtualMachineInvalidMemoryTwo() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachine *model.VirtualMachine }

	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053bc\",memory:\"1024mb\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
	err = ResolverClient.Post(mutation, &response)
	s.Errorf(err, "should be an error resolving vm mutation")
	s.Nilf(response.CreateVirtualMachine, "returned vm is not null")
}

func (s *Suite) TestCreateVirtualMachineHostnameExistsOnDifferentClusterNamespace() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachine *model.VirtualMachine }

	mutation := "mutation{createVirtualMachine(createVM:{namespaceEdgeId:\"31d51d8c-b580-4e1a-94f6-a970bae8c132\",clusterEdgeId:\"618648c8-56f4-4578-a4ff-ae88782b0b9f\",hostname:\"ien-00005e0053aa\",disks:[{bootOrder:1},{bootOrder:2}]}){virtualMachineId,namespace,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "error resolving vm mutation")
	s.NotNilf(response.CreateVirtualMachine, "returned vm is null")

	virtualMachine := response.CreateVirtualMachine
	s.Equal("618648c8-56f4-4578-a4ff-ae88782b0b9f", virtualMachine.ClusterEdgeID)
	s.Equal("test-namespace", virtualMachine.Namespace)

	_, err = s.DB.Exec(sqlquery.VirtualMachineDeleteQuery, virtualMachine.VirtualMachineID)
	s.NoError(err)
}

func (s *Suite) TestGetVirtualMachineByID() {
	integration.SkipIf(s.Framework)

	var response struct{ VirtualMachine *model.VirtualMachine }
	virtualMachineID := "9a84dd25-da1c-455a-8100-3370050169c8"
	query := getVirtualMachineQuery(&virtualMachineID)
	err := ResolverClient.Post(query, &response)

	s.NoErrorf(err, "resolver failed for get VM by ID")
	s.NotEmptyf(response.VirtualMachine, "resolver response empty for get VM by ID")
	s.NotEmptyf(response.VirtualMachine.Disks, "failed to return VM's disks")
	s.Equalf(virtualMachineID, response.VirtualMachine.VirtualMachineID, "incorrect VM returned for get VM by ID")
}

func (s *Suite) TestGetVirtualMachinesByClusterEdgeID() {
	integration.SkipIf(s.Framework)
	var response struct{ VirtualMachines []*model.VirtualMachine }
	clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
	query := getVirtualMachinesQuery(&clusterEdgeID, nil)
	err := ResolverClient.Post(query, &response)
	s.NoErrorf(err, "resolver failed for get VMs by clusterEdgeID")
	s.NotEmpty(response.VirtualMachines, "resolver response empty for get VMs by clusterEdgeID")
	s.Equalf(2, len(response.VirtualMachines), "resolver response != 2 for get VMs by clusterEdgeID")
}

func (s *Suite) TestGetVirtualMachines() {
	integration.SkipIf(s.Framework)
	var response struct{ VirtualMachines []*model.VirtualMachine }
	query := getVirtualMachinesQuery(nil, nil)
	err := ResolverClient.Post(query, &response)
	s.NoErrorf(err, "resolver failed for get VMs without input")
	s.NotEmptyf(response.VirtualMachines, "resolver response empty for get VMs without input")
}

func (s *Suite) TestGetVirtualMachinesByHostname() {
	integration.SkipIf(s.Framework)
	var response struct{ VirtualMachines []*model.VirtualMachine }
	virtualMachineHostname := "ien-00005e0053ab"
	query := getVirtualMachinesQuery(nil, &virtualMachineHostname)
	err := ResolverClient.Post(query, &response)
	s.NoErrorf(err, "resolver failed for get VMs by hostname")
	s.NotEmptyf(response.VirtualMachines, "resolver response empty for get VMs by hostname")
	s.Equalf(1, len(response.VirtualMachines), "resolver response != 1 for get VMs by hostname")
	virtualMachine := response.VirtualMachines[0]
	s.Equal("d4d79814-149c-4120-892e-b2a38b4dca21", virtualMachine.VirtualMachineID, "incorrect VM returned for get VMs by hostname")
}

func (s *Suite) TestGetVirtualMachinesByClusterEdgeIDAndHostname() {
	integration.SkipIf(s.Framework)
	var response struct{ VirtualMachines []*model.VirtualMachine }
	clusterEdgeID := "6e04c043-89ca-4dc2-a2ea-4605dbdd4c65"
	virtualMachineHostname := "ien-00005e0053ac"
	query := getVirtualMachinesQuery(&clusterEdgeID, &virtualMachineHostname)
	err := ResolverClient.Post(query, &response)
	s.NoErrorf(err, "resolver failed for get VMs by clusterEdgeID and hostname")
	s.NotEmptyf(response.VirtualMachines, "resolver response empty for get VMs by clusterEdgeID and hostname")
	s.Equalf(1, len(response.VirtualMachines), "resolver response != 1 for get VMs by clusterEdgeID and hostname")
	virtualMachine := response.VirtualMachines[0]
	s.Equalf("830389ef-186f-405b-b3e4-44875a624604", virtualMachine.VirtualMachineID, "incorrect VM returned for get VMs by clusterEdgeID and hostname")
}

func (s *Suite) TestUpdateVirtualMachine() {
	integration.SkipIf(s.Framework)
	var response struct{ UpdateVirtualMachine *model.VirtualMachine }

	mutation := "mutation{updateVirtualMachine(updateVM:{virtualMachineId:\"9297e9b5-d5f5-43a7-a517-e8c4f3cdb166\",virtualMachineValues:{targetPowerState:true,cpus:2,memory:\"1024Mi\",machineType:i440fx}}){virtualMachineId,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType}}"
	err := ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.NotNil(response.UpdateVirtualMachine)
	virtualMachine := response.UpdateVirtualMachine
	s.Equal("9297e9b5-d5f5-43a7-a517-e8c4f3cdb166", virtualMachine.VirtualMachineID)
	s.Equal(true, virtualMachine.TargetPowerState)
	s.Equal(2, virtualMachine.Cpus)
	s.Equal("1024Mi", virtualMachine.Memory)
	s.Equal(model.MachineTypeI440fx, virtualMachine.MachineType)
	s.Nil(virtualMachine.Disks) // shouldn't be returning disks when we don't ask for them
}

func (s *Suite) TestUpdateVirtualMachineWithDisks() {
	integration.SkipIf(s.Framework)
	var response struct{ UpdateVirtualMachine *model.VirtualMachine }

	mutation := "mutation{updateVirtualMachine(updateVM:{virtualMachineId:\"9297e9b5-d5f5-43a7-a517-e8c4f3cdb166\",virtualMachineValues:{disks:{diskId:\"cbb62d9b-21b5-445d-a0e6-fce31b7257ca\",virtualMachineDiskValues:{containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2\"}}}}){virtualMachineId,clusterEdgeId,clusterName,hostname,targetPowerState,cpus,memory,machineType,disks{diskId,containerImageUrl}}}"

	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "error resolving vm mutation")

	s.NotNilf(response.UpdateVirtualMachine, "returned vm is null")
	virtualMachine := response.UpdateVirtualMachine

	s.NotNil(virtualMachine.Disks)
	s.Equal("cbb62d9b-21b5-445d-a0e6-fce31b7257ca", virtualMachine.Disks[0].DiskID)
	s.Equal("docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2", virtualMachine.Disks[0].ContainerImageURL)
}

func (s *Suite) TestDeleteVirtualMachine() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteVirtualMachine bool }
	virtualMachineID := "cda453a6-1773-4161-8959-21c3c9586c7b"
	mutation := deleteVirtualMachineMutation(&virtualMachineID)
	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "resolver failed for delete VM")
	s.Truef(response.DeleteVirtualMachine, "resolver returned false for delete VM")
}

func deleteVirtualMachineMutation(virtualMachineID *string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "deleteVirtualMachine",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("virtualMachineId", utils.ConvertToString(virtualMachineID)),
				},
			},
		},
	})
}

func getVirtualMachineQuery(virtualMachineID *string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "virtualMachine",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("virtualMachineId", utils.ConvertToString(virtualMachineID)),
				},
				Fields: virtualMachineFields,
			},
		},
	})
}

func getVirtualMachinesQuery(clusterEdgeID *string, virtualMachineHostname *string) string {
	getVirtualMachinesArg := []graphb.Argument{}
	if clusterEdgeID != nil {
		getVirtualMachinesArg = append(getVirtualMachinesArg, graphb.ArgumentString("clusterEdgeId", utils.ConvertToString(clusterEdgeID)))
	}
	if virtualMachineHostname != nil {
		getVirtualMachinesArg = append(getVirtualMachinesArg, graphb.ArgumentString("hostname", utils.ConvertToString(virtualMachineHostname)))
	}
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name:      "virtualMachines",
				Arguments: getVirtualMachinesArg,
				Fields:    virtualMachineFields,
			},
		},
	})
}

var virtualMachineFields = []*graphb.Field{
	{
		Name: "virtualMachineId",
	},
	{
		Name: "namespace",
	},
	{
		Name: "clusterEdgeId",
	},
	{
		Name: "clusterName",
	},
	{
		Name: "hostname",
	},
	{
		Name: "targetPowerState",
	},
	{
		Name: "cpus",
	},
	{
		Name: "memory",
	},
	{
		Name: "machineType",
	},
	{
		Name:   "disks",
		Fields: virtualMachineDiskFields,
	},
}