package utils

import (
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"

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

var (
	terminalID               = "efd9fae5-dddf-4c98-8a4c-5ddabecc3f05"
	clusterEdgeID            = "d5354303-9d3d-4411-a638-dce63c4c2b9c"
	lane                     = "lane1"
	terminalRoleControlPlane = model.TerminalRoleTypeControlplane
	terminalClassServer      = model.TerminalClassTypeServer
	terminalDiscoverDisksAll = model.TerminalDiscoverDisksTypeAll
	terminalExistingEfiPart  = "/dev/sda1"
	terminalBootDisk         = "/dev/sdb"
	terminalSwapEnabled      = false
	clusterName              = "testing-cluster1"
	hostname                 = "gas-station-terminal1"

	terminalIfaceID = "79d63a8c-a6a8-4a3e-8ec6-d860d5499304"
	macAddress      = "72:46:16:ee:5c:5c"
	dhcp4True       = true
	dhcp4False      = false
	dhcp6True       = true
	dhcp6False      = false
	gateway4        = "129.164.1.112"
	gateway6        = "58c7:0b4c:0e7b:889c:d591:ebb6:5017:76d3"

	terminalAddressID = "499d02af-e528-48c7-8d98-4f787a4d8087"
	ipv4              = "231.207.251.140"
	familyInet        = model.InetTypeInet
	familyInet6       = model.InetTypeInet6

	ipv6        = "3899:217d:ff5f:8048:6722:57a7:5cf3:959f"
	prefixLen24 = 24
)

func TestValidateTerminal(t *testing.T) {
	terminal := CreateTerminalModel(terminalID, clusterEdgeID, &lane, terminalRoleControlPlane, &terminalClassServer, &terminalDiscoverDisksAll, &terminalBootDisk, clusterName, hostname, &terminalExistingEfiPart, terminalSwapEnabled)
	err := ValidateTerminal(&terminal)
	assert.NoError(t, err)
}

func TestValidateInterfaceInputMacAddressError(t *testing.T) {
	invalidMac := "INVALID"
	ifaceCreate := &model.TerminalInterfaceCreateInput{
		MacAddress: invalidMac,
	}
	err := ValidateTerminalInterfaceCreateInput(ifaceCreate)
	assert.Error(t, err)
}

func TestValidateTerminalIfaceDhcp4True(t *testing.T) {
	// gateway4 and IPv4 not provided
	iface := CreateTerminalIfaceModel(terminalIfaceID, macAddress, dhcp4True, dhcp6True, nil, nil, terminalID)
	err := ValidateTerminalIface(&iface)
	assert.NoError(t, err)

	// gateway4 provided
	iface.Gateway4 = &gateway4
	err = ValidateTerminalIface(&iface)
	assert.NoError(t, err)

	// IPv4 provided
	address := CreateTerminalAddressModel(terminalAddressID, &ipv4, prefixLen24, familyInet, terminalIfaceID)
	iface.Addresses = append(iface.Addresses, &address)
	err = ValidateTerminalIface(&iface)
	assert.NoError(t, err)
}

func TestValidateTerminalIfaceDhcp4False(t *testing.T) {
	// gateway4 must be provided
	iface := CreateTerminalIfaceModel(terminalIfaceID, macAddress, dhcp4False, dhcp6True, &gateway4, nil, terminalID)
	address := CreateTerminalAddressModel(terminalAddressID, &ipv4, prefixLen24, familyInet, terminalIfaceID)
	iface.Addresses = append(iface.Addresses, &address)
	err := ValidateTerminalIface(&iface)
	assert.NoError(t, err)
}

func TestValidateTerminalIfaceDhcp4FalseError(t *testing.T) {
	// no gateway4
	iface := CreateTerminalIfaceModel(terminalIfaceID, macAddress, dhcp4False, dhcp6True, nil, nil, terminalID)

	// invalid gateway4
	invalidGateway4 := "invalidGateway4"
	iface.Gateway4 = &invalidGateway4
	err := ValidateTerminalIface(&iface)
	assert.Error(t, err)
	expectedErrMsg := fmt.Sprintf("invalid gateway4 address: %s", invalidGateway4)
	assert.Equal(t, expectedErrMsg, err.Error())
}

func TestValidateTerminalIfaceDhcp6True(t *testing.T) {
	// gateway6 not provided
	iface := CreateTerminalIfaceModel(terminalIfaceID, macAddress, dhcp4True, dhcp6True, nil, nil, terminalID)
	err := ValidateTerminalIface(&iface)
	assert.NoError(t, err)

	// gateway6 provided
	iface.Gateway6 = &gateway6
	err = ValidateTerminalIface(&iface)
	assert.NoError(t, err)

	// IPv6 provided
	address := CreateTerminalAddressModel(terminalAddressID, &ipv6, prefixLen24, familyInet6, terminalIfaceID)
	iface.Addresses = append(iface.Addresses, &address)
	err = ValidateTerminalIface(&iface)
	assert.NoError(t, err)
}

func TestValidateTerminalIfaceDhcp6False(t *testing.T) {
	// gateway6 not provided
	iface := CreateTerminalIfaceModel(terminalIfaceID, macAddress, dhcp4True, dhcp6False, nil, nil, terminalID)
	err := ValidateTerminalIface(&iface)
	assert.NoError(t, err)

	// gateway6 provided
	iface.Gateway6 = &gateway6
	err = ValidateTerminalIface(&iface)
	assert.NoError(t, err)

	// IPv6 provided
	address := CreateTerminalAddressModel(terminalAddressID, &ipv6, prefixLen24, familyInet6, terminalIfaceID)
	iface.Addresses = append(iface.Addresses, &address)
	err = ValidateTerminalIface(&iface)
	assert.NoError(t, err)
}

func TestValidateTerminalAddress(t *testing.T) {
	// IPv4
	address := CreateTerminalAddressModel(terminalAddressID, &ipv4, prefixLen24, familyInet, terminalIfaceID)
	err := ValidateTerminalAddress(&address)
	assert.NoError(t, err)

	// IPv6
	address = CreateTerminalAddressModel(terminalAddressID, &ipv6, prefixLen24, familyInet6, terminalIfaceID)
	err = ValidateTerminalAddress(&address)
	assert.NoError(t, err)
}

func TestValidateTerminalAddressIpError(t *testing.T) {
	invalidIP := "invalidIP"
	address := CreateTerminalAddressModel(terminalAddressID, &invalidIP, prefixLen24, familyInet, terminalIfaceID)
	err := ValidateTerminalAddress(&address)
	assert.Error(t, err)
	expectedErrMsg := fmt.Sprintf("invalid address ip: %s", invalidIP)
	assert.Equal(t, expectedErrMsg, err.Error())
}

func TestValidateTerminalAddressCidrError(t *testing.T) {
	invalidPrefixLen := -12
	address := CreateTerminalAddressModel(terminalAddressID, &ipv4, invalidPrefixLen, familyInet, terminalIfaceID)
	err := ValidateTerminalAddress(&address)
	assert.Error(t, err)
	expectedErrMsg := fmt.Sprintf("invalid prefix: %d", invalidPrefixLen)
	assert.Equal(t, expectedErrMsg, err.Error())
}

func TestMatchMacAddresses(t *testing.T) {
	addrID, ip, ifaceID, terminalID, clusterEdgeID := "1d88738d-dae1-4bfe-839b-f31bc3809606", "83.25.121.197", "ff674589-500a-4a27-b42f-5cb2478a9cfe",
		"64cfc839-d7b6-4d2b-8eee-210873ba56c9", "4f725ad2-1b1e-43f8-8a3f-38bbd0892571"
	gateway4, terminalClass, mac := "223.54.203.117", model.TerminalClassTypeServer, "56:21:a1:f2:63:bf"
	addr := CreateTerminalAddressModel(addrID, &ip, 16, model.InetTypeInet, ifaceID)
	iface := CreateTerminalIfaceModel(ifaceID, mac, false, true, &gateway4, nil, terminalID)
	iface.Addresses = []*model.TerminalAddress{&addr}
	terminalDiskType := model.TerminalDiscoverDisksTypeEmpty
	terminal := CreateTerminalModel(terminalID, clusterEdgeID, nil, model.TerminalRoleTypeControlplane, &terminalClass, &terminalDiskType, &terminalBootDisk, "test", "hostname", &terminalExistingEfiPart, terminalSwapEnabled)
	terminal.Interfaces = []*model.TerminalInterface{&iface}

	macs := []string{"66:96:83:7f:8c:09", mac}
	macMatch, err := MatchTerminalMacAddresses(macs, &terminal)
	assert.NoError(t, err)
	assert.True(t, macMatch)
}

func TestConvertMacAddresses(t *testing.T) {
	macs := []string{"ce:d7:2e:27:b9:66", "12-6f-cb-16-62-f4", "9A-80-53-6D-C0-1F"}
	normMacs := []string{"ce:d7:2e:27:b9:66", "12:6f:cb:16:62:f4", "9a:80:53:6d:c0:1f"}
	normOutput, err := FormatMacAddresses(macs)
	assert.NoError(t, err)
	assert.Equal(t, normMacs, normOutput)

	nilOutput, err := FormatMacAddresses(nil)
	assert.NoError(t, err)
	assert.Nil(t, nilOutput)
}

func TestConvertMacAddressesError(t *testing.T) {
	macs := []string{"ce:d7:2e:27:b9:66", "12:6fcb:16:62"}
	_, err := FormatMacAddresses(macs)
	assert.EqualError(t, err, "address 12:6fcb:16:62: invalid MAC address")

	macs = []string{"12:6f:cb:16:f4:6x"}
	_, err = FormatMacAddresses(macs)
	assert.EqualError(t, err, "address 12:6f:cb:16:f4:6x: invalid MAC address")
}