package mapper

import (
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

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

	v1ien "edge-infra.dev/pkg/sds/ien/k8s/apis/v1"
)

var (
	terminalID    = "0e38e7d7-1a2c-4cce-8b81-79a10f1b9765"
	clusterEdgeID = "b74a86c3-1294-44f6-8a1d-2934c06fac4d"
	edgeVersion   = "v0.18.0"
	clusterName   = "cluster-name-1"
	hostname      = "ien-a253ebb27439"
	lane01        = "lane1"
	swapEnabled   = false

	// workerRole      = model.TerminalRoleType(model.TerminalRoleTypeWorker.String())
	controlRole = model.TerminalClassType(model.TerminalRoleTypeControlplane.String())
	serverClass = model.TerminalClassType(model.TerminalClassTypeServer.String())
	// touchpointClass = model.TerminalClassTypeTouchpoint.String()
	terminalDiskID        = "96f7fb7a-e697-4a68-b6f9-a778db6c3610"
	terminalDiskTypeEmpty = model.TerminalDiscoverDisksTypeEmpty

	interfaceID  = "53154d95-a0c7-4be8-abb9-0c2aa2b0d98f"
	interfaceID2 = "0e5944bc-1633-44b6-aff9-79e6c63bb44a"
	macAddress   = "a2:53:eb:b2:74:39"
	macAddress2  = "90:74:c2:0f:d8:77"
	dhcp4False   = false
	dhcp4True    = true
	dhcp6False   = false
	dhcp6True    = true
	gateway4     = "34.48.218.56"
	gateway6     = "f45a:2064:3ad6:6e0d:9044:03ef:15b1:4ce1"

	addressID    = "d257bf51-dfb8-4a8b-bb4c-55eb54195f6c"
	addressID2   = "3248ae96-4f40-4269-8675-ad39d79f6011"
	ipv4         = "34.48.218.53"
	ipv6         = "5f17:a4ef:602a:4fb1:eedd:94e1:441a:086d"
	prefixLen16  = 16
	prefixLen24  = 24
	inetFamily   = model.InetTypeInet
	inet6Family  = model.InetTypeInet6
	kubeVipIP    = "10.0.0.1"
	customLabels = map[string]string{
		"custom.node.ncr.com/test1": "test-1-description",
		"custom.node.ncr.com/test2": "test-2-description",
	}
	emptyCustomLabels = make(map[string]string, 0)
)

func TestTerminalToIENodeWithoutDHCP(t *testing.T) {
	terminal := createDefaultTerminal(gateway4, ipv4)
	dnsService := &model.ClusterNetworkServiceInfo{
		ServiceType: "dns",
		Family:      "inet",
		IP:          "8.8.8.8",
	}

	ntpService := &model.ClusterNetworkServiceInfo{
		ServiceType: "ntp",
		Family:      "inet",
		IP:          "time.google.com",
	}

	kubeVip := &model.ClusterNetworkServiceInfo{
		ServiceType: "kube-vip",
		Family:      "inet",
		IP:          kubeVipIP,
	}

	clusterNetworkServices := []*model.ClusterNetworkServiceInfo{dnsService, ntpService, kubeVip}

	expectedIENode := v1ien.IENode{
		TypeMeta: metav1.TypeMeta{
			Kind:       v1ien.IENodeGVK.Kind,
			APIVersion: v1ien.IENodeGVK.GroupVersion().String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: utils.CreateIENodeHostname(terminal.Interfaces[0].MacAddress),
			Labels: map[string]string{
				"node.ncr.com/terminal-id": terminal.TerminalID,
			},
		},
		Spec: v1ien.IENodeSpec{
			Role:        v1ien.Role(terminal.Role),
			Lane:        *terminal.Lane,
			Class:       v1ien.Class(*terminal.Class),
			SwapEnabled: &swapEnabled,
			Network: []v1ien.Network{
				{
					DHCP4:      terminal.Interfaces[0].Dhcp4,
					DHCP6:      terminal.Interfaces[0].Dhcp6,
					MacAddress: terminal.Interfaces[0].MacAddress,
					Gateway4:   *terminal.Interfaces[0].Gateway4,
					Gateway6:   *terminal.Interfaces[0].Gateway6,
					Addresses: []string{
						fmt.Sprintf("%s/%d", *terminal.Interfaces[0].Addresses[0].IP, terminal.Interfaces[0].Addresses[0].PrefixLen),
						fmt.Sprintf("%s/%d", *terminal.Interfaces[0].Addresses[1].IP, terminal.Interfaces[0].Addresses[1].PrefixLen),
					},
				},
			},
			PrimaryInterface: &v1ien.PrimaryInterface{
				InterfaceID:  terminal.Interfaces[0].TerminalInterfaceID,
				MacAddresses: []string{terminal.Interfaces[0].MacAddress},
			},
			NetworkServices: v1ien.NetworkServices{
				NTPServers: []string{"time.google.com"},
				DNSServers: []string{"8.8.8.8"},
				KubeVip:    kubeVipIP,
			},
			CustomLabels: emptyCustomLabels,
		},
	}

	actualIENode := TerminalToIENode(terminal, clusterNetworkServices, emptyCustomLabels, edgeVersion)
	assert.Equal(t, expectedIENode, actualIENode)
}

// nolint
func TestTerminalToIENodeWithDHCP(t *testing.T) {
	terminal0 := createDefaultTerminal(gateway4, ipv4)
	iface := terminal0.Interfaces[0]
	iface.Dhcp4 = dhcp4True
	iface.Gateway4 = nil
	iface.Addresses[0].IP = nil

	dnsService := &model.ClusterNetworkServiceInfo{
		ServiceType: "dns",
		Family:      "inet",
		IP:          "8.8.8.8",
	}

	ntpService := &model.ClusterNetworkServiceInfo{
		ServiceType: "ntp",
		Family:      "inet",
		IP:          "time.google.com",
	}

	clusterNetworkServices := []*model.ClusterNetworkServiceInfo{dnsService, ntpService}

	expectedIENode := v1ien.IENode{
		TypeMeta: metav1.TypeMeta{
			Kind:       v1ien.IENodeGVK.Kind,
			APIVersion: v1ien.GroupVersion.String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: utils.CreateIENodeHostname(terminal0.Interfaces[0].MacAddress),
			Labels: map[string]string{
				"node.ncr.com/terminal-id": terminal0.TerminalID,
			},
		},
		Spec: v1ien.IENodeSpec{
			Role:        v1ien.Role(terminal0.Role),
			Lane:        *terminal0.Lane,
			Class:       v1ien.Class(*terminal0.Class),
			SwapEnabled: &swapEnabled,
			Network: []v1ien.Network{
				{
					DHCP4:      terminal0.Interfaces[0].Dhcp4,
					DHCP6:      terminal0.Interfaces[0].Dhcp6,
					MacAddress: terminal0.Interfaces[0].MacAddress,
					Gateway6:   *terminal0.Interfaces[0].Gateway6,
					Addresses: []string{fmt.Sprintf("%s/%d", *terminal0.Interfaces[0].Addresses[1].IP,
						terminal0.Interfaces[0].Addresses[1].PrefixLen)},
				},
			},
			PrimaryInterface: &v1ien.PrimaryInterface{
				InterfaceID:  terminal0.Interfaces[0].TerminalInterfaceID,
				MacAddresses: []string{terminal0.Interfaces[0].MacAddress},
			},
			NetworkServices: v1ien.NetworkServices{
				NTPServers: []string{"time.google.com"},
				DNSServers: []string{"8.8.8.8"},
			},
			CustomLabels: emptyCustomLabels,
		},
	}

	actualIENode := TerminalToIENode(terminal0, clusterNetworkServices, emptyCustomLabels, edgeVersion)
	assert.Equal(t, expectedIENode, actualIENode)

	terminal1 := createDefaultTerminal(gateway4, ipv4)
	iface = terminal1.Interfaces[0]
	iface.Dhcp6 = dhcp6True
	iface.Gateway6 = nil
	iface.Addresses[1].IP = nil

	dnsService = &model.ClusterNetworkServiceInfo{
		ServiceType: "dns",
		Family:      "inet",
		IP:          "8.8.8.8",
	}

	ntpService = &model.ClusterNetworkServiceInfo{
		ServiceType: "ntp",
		Family:      "inet",
		IP:          "time.google.com",
	}

	clusterNetworkServices = []*model.ClusterNetworkServiceInfo{dnsService, ntpService}

	expectedIENode = v1ien.IENode{
		TypeMeta: metav1.TypeMeta{
			Kind:       v1ien.IENodeGVK.Kind,
			APIVersion: v1ien.IENodeGVK.GroupVersion().String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: utils.CreateIENodeHostname(terminal1.Interfaces[0].MacAddress),
			Labels: map[string]string{
				"node.ncr.com/terminal-id": terminal1.TerminalID,
			},
		},
		Spec: v1ien.IENodeSpec{
			Role:        v1ien.Role(terminal0.Role),
			Lane:        *terminal0.Lane,
			Class:       v1ien.Class(*terminal0.Class),
			SwapEnabled: &swapEnabled,
			Network: []v1ien.Network{
				{
					DHCP4:      terminal1.Interfaces[0].Dhcp4,
					DHCP6:      terminal1.Interfaces[0].Dhcp6,
					MacAddress: terminal1.Interfaces[0].MacAddress,
					Gateway4:   *terminal1.Interfaces[0].Gateway4,
					Addresses: []string{fmt.Sprintf("%s/%d", *terminal1.Interfaces[0].Addresses[0].IP,
						terminal1.Interfaces[0].Addresses[0].PrefixLen)},
				},
			},
			PrimaryInterface: &v1ien.PrimaryInterface{
				InterfaceID:  terminal0.Interfaces[0].TerminalInterfaceID,
				MacAddresses: []string{terminal0.Interfaces[0].MacAddress},
			},
			NetworkServices: v1ien.NetworkServices{
				NTPServers: []string{"time.google.com"},
				DNSServers: []string{"8.8.8.8"},
			},
			CustomLabels: emptyCustomLabels,
		},
	}

	actualIENode = TerminalToIENode(terminal1, clusterNetworkServices, emptyCustomLabels, edgeVersion)
	assert.Equal(t, expectedIENode, actualIENode)

	terminal2 := createDefaultTerminal(gateway4, ipv4)
	iface = terminal2.Interfaces[0]
	iface.Dhcp4, iface.Dhcp6 = dhcp4True, dhcp6True
	iface.Gateway4, iface.Gateway6 = nil, nil
	iface.Addresses[0].IP, iface.Addresses[1].IP = nil, nil

	dnsService = &model.ClusterNetworkServiceInfo{
		ServiceType: "dns",
		Family:      "inet",
		IP:          "8.8.8.8",
	}

	ntpService = &model.ClusterNetworkServiceInfo{
		ServiceType: "ntp",
		Family:      "inet",
		IP:          "time.google.com",
	}

	clusterNetworkServices = []*model.ClusterNetworkServiceInfo{dnsService, ntpService}

	expectedIENode = v1ien.IENode{
		TypeMeta: metav1.TypeMeta{
			Kind:       v1ien.IENodeGVK.Kind,
			APIVersion: v1ien.IENodeGVK.GroupVersion().String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: utils.CreateIENodeHostname(terminal2.Interfaces[0].MacAddress),
			Labels: map[string]string{
				"node.ncr.com/terminal-id": terminal2.TerminalID,
			},
		},
		Spec: v1ien.IENodeSpec{
			Role:        v1ien.Role(terminal0.Role),
			Lane:        *terminal0.Lane,
			Class:       v1ien.Class(*terminal0.Class),
			SwapEnabled: &swapEnabled,
			Network: []v1ien.Network{
				{
					DHCP4:      terminal2.Interfaces[0].Dhcp4,
					DHCP6:      terminal2.Interfaces[0].Dhcp6,
					MacAddress: terminal2.Interfaces[0].MacAddress,
				},
			},
			PrimaryInterface: &v1ien.PrimaryInterface{
				InterfaceID:  terminal0.Interfaces[0].TerminalInterfaceID,
				MacAddresses: []string{terminal0.Interfaces[0].MacAddress},
			},
			NetworkServices: v1ien.NetworkServices{
				NTPServers: []string{"time.google.com"},
				DNSServers: []string{"8.8.8.8"},
			},
			CustomLabels: emptyCustomLabels,
		},
	}

	actualIENode = TerminalToIENode(terminal2, clusterNetworkServices, emptyCustomLabels, edgeVersion)
	assert.Equal(t, expectedIENode, actualIENode)
}

func TestTerminalToIENodeWithoutAddress(t *testing.T) { //nolint
	terminal := createDefaultTerminal(gateway4, ipv4)
	terminal.Interfaces[0].Dhcp4, terminal.Interfaces[0].Dhcp6 = true, true
	terminal.Interfaces[0].Gateway4, terminal.Interfaces[0].Gateway6 = nil, nil
	terminal.Interfaces[0].Addresses = nil

	dnsService := &model.ClusterNetworkServiceInfo{
		ServiceType: "dns",
		Family:      "inet",
		IP:          "8.8.8.8",
	}
	ntpService := &model.ClusterNetworkServiceInfo{
		ServiceType: "ntp",
		Family:      "inet",
		IP:          "time.google.com",
	}
	clusterNetworkServices := []*model.ClusterNetworkServiceInfo{dnsService, ntpService}

	expectedIENode := v1ien.IENode{
		TypeMeta: metav1.TypeMeta{
			Kind:       v1ien.IENodeGVK.Kind,
			APIVersion: v1ien.IENodeGVK.GroupVersion().String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: utils.CreateIENodeHostname(terminal.Interfaces[0].MacAddress),
			Labels: map[string]string{
				"node.ncr.com/terminal-id": terminal.TerminalID,
			},
		},
		Spec: v1ien.IENodeSpec{
			Role:        v1ien.Role(terminal.Role),
			Lane:        *terminal.Lane,
			Class:       v1ien.Class(*terminal.Class),
			SwapEnabled: &swapEnabled,
			Network: []v1ien.Network{
				{
					DHCP4:      terminal.Interfaces[0].Dhcp4,
					DHCP6:      terminal.Interfaces[0].Dhcp6,
					MacAddress: terminal.Interfaces[0].MacAddress,
				},
			},
			NetworkServices: v1ien.NetworkServices{
				NTPServers: []string{"time.google.com"},
				DNSServers: []string{"8.8.8.8"},
			},
			PrimaryInterface: &v1ien.PrimaryInterface{
				InterfaceID:  terminal.Interfaces[0].TerminalInterfaceID,
				MacAddresses: []string{terminal.Interfaces[0].MacAddress},
			},
			CustomLabels: emptyCustomLabels,
		},
	}

	actualIENode := TerminalToIENode(terminal, clusterNetworkServices, emptyCustomLabels, edgeVersion)
	assert.Equal(t, expectedIENode, actualIENode)
}

// nolint
func TestTerminalToIENodeWithLabels(t *testing.T) {
	terminal := createDefaultTerminal(gateway4, ipv4)
	terminal.Interfaces[0].Dhcp4, terminal.Interfaces[0].Dhcp6 = true, true
	terminal.Interfaces[0].Gateway4, terminal.Interfaces[0].Gateway6 = nil, nil
	terminal.Interfaces[0].Addresses = nil

	dnsService := &model.ClusterNetworkServiceInfo{
		ServiceType: "dns",
		Family:      "inet",
		IP:          "8.8.8.8",
	}
	ntpService := &model.ClusterNetworkServiceInfo{
		ServiceType: "ntp",
		Family:      "inet",
		IP:          "time.google.com",
	}
	clusterNetworkServices := []*model.ClusterNetworkServiceInfo{dnsService, ntpService}

	expectedIENode := v1ien.IENode{
		TypeMeta: metav1.TypeMeta{
			Kind:       v1ien.IENodeGVK.Kind,
			APIVersion: v1ien.IENodeGVK.GroupVersion().String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: utils.CreateIENodeHostname(terminal.Interfaces[0].MacAddress),
			Labels: map[string]string{
				"node.ncr.com/terminal-id": terminal.TerminalID,
			},
		},
		Spec: v1ien.IENodeSpec{
			Role:        v1ien.Role(terminal.Role),
			Lane:        *terminal.Lane,
			Class:       v1ien.Class(*terminal.Class),
			SwapEnabled: &swapEnabled,
			Network: []v1ien.Network{
				{
					DHCP4:      terminal.Interfaces[0].Dhcp4,
					DHCP6:      terminal.Interfaces[0].Dhcp6,
					MacAddress: terminal.Interfaces[0].MacAddress,
				},
			},
			PrimaryInterface: &v1ien.PrimaryInterface{
				InterfaceID:  terminal.Interfaces[0].TerminalInterfaceID,
				MacAddresses: []string{terminal.Interfaces[0].MacAddress},
			},
			NetworkServices: v1ien.NetworkServices{
				NTPServers: []string{"time.google.com"},
				DNSServers: []string{"8.8.8.8"},
			},
			CustomLabels: customLabels,
		},
	}

	actualIENode := TerminalToIENode(terminal, clusterNetworkServices, customLabels, edgeVersion)
	assert.Equal(t, expectedIENode, actualIENode)
}

func TestTerminalToIENodeWithDefinedPrimaryInterface(t *testing.T) {
	terminal := createDefaultTerminal(gateway4, ipv4)

	terminal.Interfaces[0].Addresses = nil
	terminal.Interfaces[0].Gateway4 = nil
	terminal.Interfaces[0].Gateway6 = nil

	terminal.Interfaces = append(terminal.Interfaces,
		&model.TerminalInterface{
			TerminalInterfaceID: interfaceID2,
			TerminalID:          terminalID,
			MacAddress:          macAddress2,
			Dhcp4:               dhcp4True,
			Dhcp6:               dhcp6False,
		},
	)

	terminal.PrimaryInterface = &interfaceID2

	dnsService := &model.ClusterNetworkServiceInfo{
		ServiceType: "dns",
		Family:      "inet",
		IP:          "8.8.8.8",
	}

	ntpService := &model.ClusterNetworkServiceInfo{
		ServiceType: "ntp",
		Family:      "inet",
		IP:          "time.google.com",
	}

	kubeVip := &model.ClusterNetworkServiceInfo{
		ServiceType: "kube-vip",
		Family:      "inet",
		IP:          kubeVipIP,
	}

	clusterNetworkServices := []*model.ClusterNetworkServiceInfo{dnsService, ntpService, kubeVip}

	expectedIENode := v1ien.IENode{
		TypeMeta: metav1.TypeMeta{
			Kind:       v1ien.IENodeGVK.Kind,
			APIVersion: v1ien.IENodeGVK.GroupVersion().String(),
		},
		ObjectMeta: metav1.ObjectMeta{
			Name: utils.CreateIENodeHostname(terminal.Interfaces[0].MacAddress),
			Labels: map[string]string{
				"node.ncr.com/terminal-id": terminal.TerminalID,
			},
		},
		Spec: v1ien.IENodeSpec{
			Role:        v1ien.Role(terminal.Role),
			Lane:        *terminal.Lane,
			Class:       v1ien.Class(*terminal.Class),
			SwapEnabled: &swapEnabled,
			Network: []v1ien.Network{
				{
					DHCP4:      terminal.Interfaces[0].Dhcp4,
					DHCP6:      terminal.Interfaces[0].Dhcp6,
					MacAddress: terminal.Interfaces[0].MacAddress,
				},
				{
					DHCP4:      terminal.Interfaces[1].Dhcp4,
					DHCP6:      terminal.Interfaces[1].Dhcp6,
					MacAddress: terminal.Interfaces[1].MacAddress,
				},
			},
			PrimaryInterface: &v1ien.PrimaryInterface{
				InterfaceID:  terminal.Interfaces[1].TerminalInterfaceID,
				MacAddresses: []string{terminal.Interfaces[1].MacAddress},
			},
			NetworkServices: v1ien.NetworkServices{
				NTPServers: []string{"time.google.com"},
				DNSServers: []string{"8.8.8.8"},
				KubeVip:    kubeVipIP,
			},
			CustomLabels: emptyCustomLabels,
		},
	}

	actualIENode := TerminalToIENode(terminal, clusterNetworkServices, emptyCustomLabels, edgeVersion)
	assert.Equal(t, expectedIENode, actualIENode)
}

// Allows you to create a default terminal which you can modify from where you called
// this function
func createDefaultTerminal(gw4 string, addr4 string) *model.Terminal {
	return &model.Terminal{
		TerminalID:    terminalID,
		ClusterEdgeID: clusterEdgeID,
		Role:          model.TerminalRoleType(controlRole),
		Lane:          &lane01,
		Hostname:      hostname,
		ClusterName:   clusterName,
		Class:         &serverClass,
		SwapEnabled:   swapEnabled,
		DiscoverDisks: &terminalDiskTypeEmpty,
		Disks: []*model.TerminalDisk{
			{
				TerminalDiskID: terminalDiskID,
				TerminalID:     terminalID,
				ExpectEmpty:    false,
				IncludeDisk:    true,
				UsePart:        false,
			},
		},
		PrimaryInterface: &interfaceID,
		Interfaces: []*model.TerminalInterface{
			{
				TerminalInterfaceID: interfaceID,
				TerminalID:          terminalID,
				MacAddress:          macAddress,
				Dhcp4:               dhcp4False,
				Dhcp6:               dhcp6False,
				Gateway4:            &gw4,
				Gateway6:            &gateway6,
				Addresses: []*model.TerminalAddress{
					{
						TerminalAddressID:   addressID,
						TerminalInterfaceID: interfaceID,
						IP:                  &addr4,
						PrefixLen:           prefixLen16,
						Family:              inetFamily,
					},
					{
						TerminalAddressID:   addressID2,
						TerminalInterfaceID: interfaceID,
						IP:                  &ipv6,
						PrefixLen:           prefixLen24,
						Family:              inet6Family,
					},
				},
			},
		},
	}
}