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) TestCreateVirtualMachineDisk() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{type:cdrom, bus:sata, bootOrder:4, size:\"3Gi\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
	err := ResolverClient.Post(mutation, &response)

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

	s.NotNilf(response.CreateVirtualMachineDisks, "returned vm disk is null")
	createdDisk := response.CreateVirtualMachineDisks[0]

	s.Equal("a1654bb6-6173-4e58-9385-4ac7c16332a7", createdDisk.VirtualMachineID)
	s.Equal(model.DiskTypeCdrom, createdDisk.Type)
	s.Equal(model.BusTypeSata, createdDisk.Bus)
	s.Equal(4, createdDisk.BootOrder)
	s.Equal("3Gi", createdDisk.Size)
	s.Equal("docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0", createdDisk.ContainerImageURL)

	_, err = s.DB.Exec(sqlquery.VirtualMachineDiskDeleteQuery, createdDisk.DiskID)
	s.NoError(err)
}

func (s *Suite) TestCreateVirtualMachineDiskDefaults() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{bootOrder:5}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
	err := ResolverClient.Post(mutation, &response)

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

	s.NotNilf(response.CreateVirtualMachineDisks, "returned vm disk is null")
	createdDisk := response.CreateVirtualMachineDisks[0]

	s.Equal("a1654bb6-6173-4e58-9385-4ac7c16332a7", createdDisk.VirtualMachineID)
	s.Equal(model.DiskTypeCdrom, createdDisk.Type)
	s.Equal(model.BusTypeSata, createdDisk.Bus)
	s.Equal(5, createdDisk.BootOrder)
	s.Equal("1Gi", createdDisk.Size)
	s.Empty(createdDisk.ContainerImageURL)

	_, err = s.DB.Exec(sqlquery.VirtualMachineDiskDeleteQuery, createdDisk.DiskID)
	s.NoError(err)
}

// test creating a VM disk when the specified VM does not exist
func (s *Suite) TestCreateVirtualMachineDiskNoVirtualMachine() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"082c8a63-7457-4c42-aad9-34623150cd9b\", createDisks:[{type:cdrom, bus:sata, bootOrder:1, size:\"3Gi\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "no error resolving vm disk mutation")
	s.Nilf(response.CreateVirtualMachineDisks, "returned vm disk is not null")
}

// test creating a VM disk with an invalid memory format
func (s *Suite) TestCreateVirtualMachineDiskInvalidMemoryOne() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }

	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{type:cdrom, bus:sata, bootOrder:4, size:\"10gb\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "should be an error resolving vm disk mutation (1)")
	s.Nilf(response.CreateVirtualMachineDisks, "returned vm disk is not null (1)")
}

// test creating a VM disk with an invalid memory format
func (s *Suite) TestCreateVirtualMachineDiskInvalidMemoryTwo() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }

	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{type:cdrom, bus:sata, bootOrder:4, size:\"18Gb\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.6.0\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
	err = ResolverClient.Post(mutation, &response)
	s.Errorf(err, "should be an error resolving vm disk mutation (2)")
	s.Nilf(response.CreateVirtualMachineDisks, "returned vm disk is not null (2)")
}

// test creating a VM disk when the specified VM does not exist
func (s *Suite) TestCreateVirtualMachineDiskDuplicateBootOrder() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateVirtualMachineDisks []*model.VirtualMachineDisk }
	mutation := "mutation{createVirtualMachineDisks(virtualMachineId:\"a1654bb6-6173-4e58-9385-4ac7c16332a7\", createDisks:[{type:cdrom, bus:sata, bootOrder:0, size:\"3Gi\"}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "no error resolving vm disk mutation")
	s.Nilf(response.CreateVirtualMachineDisks, "returned vm disk is not null")
}

// get a VM disk by its diskID
func (s *Suite) TestGetVirtualMachineDiskByID() {
	integration.SkipIf(s.Framework)

	var response struct{ VirtualMachineDisk *model.VirtualMachineDisk }
	diskID := "a8a8f270-5387-44ae-abda-6973906f3b46"
	query := getVirtualMachineDiskQuery(&diskID)
	err = ResolverClient.Post(query, &response)

	s.NoErrorf(err, "resolver failed for get VM disk by ID")
	s.NotEmptyf(response.VirtualMachineDisk, "resolver response empty for get VM disk by ID")
	s.Equalf(diskID, response.VirtualMachineDisk.DiskID, "incorrect VM disk returned for get VM disk by ID")
	s.Equalf("9a84dd25-da1c-455a-8100-3370050169c8", response.VirtualMachineDisk.VirtualMachineID, "incorrect VM disk returned for get VM disk by ID (VM IDs dont match)")
}

// try getting a VM disk that does not exist
func (s *Suite) TestGetVirtualMachineDiskNoDisk() {
	integration.SkipIf(s.Framework)

	var response struct{ VirtualMachineDisk *model.VirtualMachineDisk }
	diskID := "d5fffebf-855f-4940-ae37-fa0aab530e01"
	query := getVirtualMachineDiskQuery(&diskID)
	err = ResolverClient.Post(query, &response)

	s.Errorf(err, "resolver didn't fail to get VM disk by ID")
	s.Emptyf(response.VirtualMachineDisk, "resolver response not empty for get VM disk by ID")
}

// get a VM's disks with the virtualMachineID
func (s *Suite) TestGetVirtualMachineDisksByVirtualMachineID() {
	integration.SkipIf(s.Framework)

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

	s.NoErrorf(err, "resolver failed for get VM disks by VM ID")
	s.NotEmptyf(response.VirtualMachineDisks, "resolver response empty for get VM disks by VM ID")
	s.Equalf("a8a8f270-5387-44ae-abda-6973906f3b46", response.VirtualMachineDisks[0].DiskID, "incorrect VM disk returned for get VM disks by VM ID (1)")
}

// try getting a VM's disks on a VM that does not exist
func (s *Suite) TestGetVirtualMachineDisksNoVirtualMachine() {
	integration.SkipIf(s.Framework)

	var response struct{ VirtualMachineDisks []*model.VirtualMachineDisk }
	virtualMachineID := "2263b06e-17d0-4710-a9fd-33f39a7f1828"
	query := getVirtualMachineDisksQuery(&virtualMachineID)
	err = ResolverClient.Post(query, &response)

	s.Errorf(err, "resolver didn't fail to get VM disks by VM ID")
	s.Emptyf(response.VirtualMachineDisks, "resolver response not empty for get VM disks by VM ID")
}

// update the values of a VM disk
func (s *Suite) TestUpdateVirtualMachineDisk() {
	integration.SkipIf(s.Framework)
	var response struct{ UpdateVirtualMachineDisks []*model.VirtualMachineDisk }

	mutation := "mutation{updateVirtualMachineDisks(updateDisks:[{diskId:\"cbb62d9b-21b5-445d-a0e6-fce31b7257ca\",virtualMachineDiskValues:{type:cdrom, bus:virtio, bootOrder:3, size:\"16Gi\", containerImageUrl:\"docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2\"}}]){diskId, virtualMachineId, type, bus, bootOrder, size, containerImageUrl}}"
	err := ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.NotNil(response.UpdateVirtualMachineDisks)
	updatedDisk := response.UpdateVirtualMachineDisks[0]
	s.Equalf("cbb62d9b-21b5-445d-a0e6-fce31b7257ca", updatedDisk.DiskID, "vm disk ID update incorrect")
	s.Equalf(model.DiskTypeCdrom, updatedDisk.Type, "vm disk type update incorrect")
	s.Equalf(model.BusTypeVirtio, updatedDisk.Bus, "vm disk bus type update incorrect")
	s.Equalf(3, updatedDisk.BootOrder, "vm disk boot order update incorrect")
	s.Equalf("16Gi", updatedDisk.Size, "vm disk size update incorrect")
	s.Equalf("docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.2", updatedDisk.ContainerImageURL, "vm disk container image URL update incorrect")
}

// delete a VM's disk
func (s *Suite) TestDeleteVirtualMachineDisk() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteVirtualMachineDisk bool }
	diskID := "6de1f847-4171-444f-9792-715bd7a10b2e"
	mutation := deleteVirtualMachineDiskMutation(&diskID)
	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "resolver failed for delete VM disk")
	s.Truef(response.DeleteVirtualMachineDisk, "resolver returned false for delete VM disk")
}

// try delete a VM's last disk
func (s *Suite) TestDeleteVirtualMachineDiskLast() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteVirtualMachineDisk bool }
	diskID := "74ad9fdb-836b-49ae-a3c6-0ffd77c08e4d"
	mutation := deleteVirtualMachineDiskMutation(&diskID)
	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "resolver didn't fail for delete VM disk")
	s.Falsef(response.DeleteVirtualMachineDisk, "resolver returned true for delete VM disk")
}

func deleteVirtualMachineDiskMutation(diskID *string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "deleteVirtualMachineDisk",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("diskId", utils.ConvertToString(diskID)),
				},
			},
		},
	})
}

func getVirtualMachineDiskQuery(diskID *string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "virtualMachineDisk",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("diskId", utils.ConvertToString(diskID)),
				},
				Fields: virtualMachineDiskFields,
			},
		},
	})
}

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

var virtualMachineDiskFields = []*graphb.Field{
	{
		Name: "diskId",
	},
	{
		Name: "virtualMachineId",
	},
	{
		Name: "type",
	},
	{
		Name: "bus",
	},
	{
		Name: "bootOrder",
	},
	{
		Name: "size",
	},
	{
		Name: "containerImageUrl",
	},
}