package mapper

import (
	"testing"

	"github.com/stretchr/testify/assert"
	corev1 "k8s.io/api/core/v1"
	kr "k8s.io/apimachinery/pkg/api/resource"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	virtv1 "kubevirt.io/api/core/v1"
	virtbeta "kubevirt.io/containerized-data-importer-api/pkg/apis/core/v1beta1"

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

var (
	virtualMachineID       = "fa9c24ac-f280-498b-bf98-a2af101fba23"
	virtualMachineHostname = "ien-asdfghjkl"
)

func TestVirtualMachineToKubeVirtualMachine(t *testing.T) {
	virtualMachine := createGenericVirtualMachine()
	disks := virtualMachine.Disks
	assert.NotNil(t, disks)
	memoryQuantity, err := kr.ParseQuantity(virtualMachine.Memory)
	assert.NoError(t, err)

	sizeQuantity1, err := kr.ParseQuantity(disks[0].Size)
	assert.NoError(t, err)
	sizeQuantity2, err := kr.ParseQuantity(disks[1].Size)
	assert.NoError(t, err)
	bootOrders := []uint{uint(disks[0].BootOrder), uint(disks[1].BootOrder)} /* #nosec G115 */
	volumeNames := []string{"ien-asdfghjkl-c65c92ef-6109-4814-a1e7-ddb8db64b7d9", "ien-asdfghjkl-e782f667-b50d-4044-9421-99b5c71c28ee"}
	pullMethod := virtbeta.RegistryPullNode

	expectedKubeVM := virtv1.VirtualMachine{
		TypeMeta: metav1.TypeMeta{
			Kind:       "VirtualMachine",
			APIVersion: "kubevirt.io/v1",
		},
		ObjectMeta: metav1.ObjectMeta{
			Name:      virtualMachine.Hostname,
			Namespace: virtualMachine.Namespace,
			Annotations: map[string]string{
				"linkerd.io/inject": "disabled",
			},
		},
		Spec: virtv1.VirtualMachineSpec{
			Running: &virtualMachine.TargetPowerState,
			Template: &virtv1.VirtualMachineInstanceTemplateSpec{
				ObjectMeta: metav1.ObjectMeta{
					Labels: map[string]string{
						"kubevirt.io/domain": virtualMachine.Hostname,
					},
					Annotations: map[string]string{
						"linkerd.io/inject": "disabled",
					},
				},
				Spec: virtv1.VirtualMachineInstanceSpec{
					Domain: virtv1.DomainSpec{
						CPU: &virtv1.CPU{
							Cores: uint32(virtualMachine.Cpus), /* #nosec G115 */
						},
						Memory: &virtv1.Memory{
							Guest: &memoryQuantity,
						},
						Devices: virtv1.Devices{
							ClientPassthrough: &virtv1.ClientPassthroughDevices{},
							Disks: []virtv1.Disk{
								{
									Name: volumeNames[0],
									DiskDevice: virtv1.DiskDevice{
										CDRom: &virtv1.CDRomTarget{
											Bus: virtv1.DiskBusSATA,
										},
									},
									BootOrder: &bootOrders[0],
								},
								{
									Name: volumeNames[1],
									DiskDevice: virtv1.DiskDevice{
										Disk: &virtv1.DiskTarget{
											Bus: virtv1.DiskBusVirtio,
										},
									},
									BootOrder: &bootOrders[1],
								},
							},
							Interfaces: []virtv1.Interface{
								{
									Model: "e1000",
									Name:  "default",
									InterfaceBindingMethod: virtv1.InterfaceBindingMethod{
										Masquerade: &virtv1.InterfaceMasquerade{},
									},
								},
							},
						},
						Machine: &virtv1.Machine{
							Type: "i440fx",
						},
					},
					Networks: []virtv1.Network{
						{
							Name: "default",
							NetworkSource: virtv1.NetworkSource{
								Pod: &virtv1.PodNetwork{},
							},
						},
					},
					Volumes: []virtv1.Volume{
						{
							Name: volumeNames[0],
							VolumeSource: virtv1.VolumeSource{
								DataVolume: &virtv1.DataVolumeSource{
									Name: volumeNames[0],
								},
							},
						},
						{
							Name: volumeNames[1],
							VolumeSource: virtv1.VolumeSource{
								DataVolume: &virtv1.DataVolumeSource{
									Name: volumeNames[1],
								},
							},
						},
					},
					Affinity: &corev1.Affinity{
						NodeAffinity: &corev1.NodeAffinity{
							RequiredDuringSchedulingIgnoredDuringExecution: &corev1.NodeSelector{
								NodeSelectorTerms: []corev1.NodeSelectorTerm{
									{
										MatchExpressions: []corev1.NodeSelectorRequirement{
											{
												Key:      "node.ncr.com/class",
												Operator: corev1.NodeSelectorOpIn,
												Values: []string{
													"touchpoint",
												},
											},
										},
									},
								},
							},
						},
					},
				},
			},
			DataVolumeTemplates: []virtv1.DataVolumeTemplateSpec{
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: volumeNames[0],
						Annotations: map[string]string{
							"linkerd.io/inject": "disabled",
						},
					},
					Spec: virtbeta.DataVolumeSpec{
						PVC: &corev1.PersistentVolumeClaimSpec{
							AccessModes: []corev1.PersistentVolumeAccessMode{
								corev1.ReadWriteOnce,
							},
							StorageClassName: &storageTypeVM,
							Resources: corev1.VolumeResourceRequirements{
								Requests: map[corev1.ResourceName]kr.Quantity{
									corev1.ResourceStorage: sizeQuantity1,
								},
							},
						},
						Source: &virtbeta.DataVolumeSource{
							Blank: &virtbeta.DataVolumeBlankImage{},
						},
					},
				},
				{
					ObjectMeta: metav1.ObjectMeta{
						Name: volumeNames[1],
						Annotations: map[string]string{
							"linkerd.io/inject": "disabled",
						},
					},
					Spec: virtbeta.DataVolumeSpec{
						PVC: &corev1.PersistentVolumeClaimSpec{
							AccessModes: []corev1.PersistentVolumeAccessMode{
								corev1.ReadWriteOnce,
							},
							StorageClassName: &storageTypeVM,
							Resources: corev1.VolumeResourceRequirements{
								Requests: map[corev1.ResourceName]kr.Quantity{
									corev1.ResourceStorage: sizeQuantity2,
								},
							},
						},
						Source: &virtbeta.DataVolumeSource{
							Registry: &virtbeta.DataVolumeSourceRegistry{
								URL:        &disks[1].ContainerImageURL,
								PullMethod: &pullMethod,
							},
						},
					},
				},
			},
		},
		Status: virtv1.VirtualMachineStatus{},
	}

	actualKubeVM, err := VirtualMachineToKubeVirtualMachine(virtualMachine)
	assert.NoError(t, err)
	assert.Equal(t, expectedKubeVM, actualKubeVM)
}

func createGenericVirtualMachine() *model.VirtualMachine {
	return &model.VirtualMachine{
		VirtualMachineID: virtualMachineID,
		ClusterEdgeID:    "1b79cb14-c00a-48a3-8e6c-9f741e7419e7",
		ClusterName:      "cluster-name",
		Hostname:         virtualMachineHostname,
		TargetPowerState: true,
		Cpus:             2,
		Memory:           "8Gi",
		MachineType:      model.MachineTypeI440fx,
		Disks:            createGenericVirtualMachineDisks(),
	}
}

func createGenericVirtualMachineDisks() []*model.VirtualMachineDisk {
	return []*model.VirtualMachineDisk{
		{
			DiskID:            "c65c92ef-6109-4814-a1e7-ddb8db64b7d9",
			VirtualMachineID:  virtualMachineID,
			Type:              model.DiskTypeCdrom,
			Bus:               model.BusTypeSata,
			BootOrder:         0,
			Size:              "128Gi",
			ContainerImageURL: "",
		},
		{
			DiskID:            "e782f667-b50d-4044-9421-99b5c71c28ee",
			VirtualMachineID:  virtualMachineID,
			Type:              model.DiskTypeDisk,
			Bus:               model.BusTypeVirtio,
			BootOrder:         1,
			Size:              "256Gi",
			ContainerImageURL: "docker://us-east1-docker.pkg.dev/ret-edge-pltf-infra/workloads/ien-image:v1.7.1",
		},
	}
}