package integration_test

import (
	"fmt"

	"github.com/udacity/graphb"

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

var terminalID = "c4aa6450-3b2a-11ed-a261-0242ac12c101"

func (s *Suite) TestCreateTerminal() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminal *model.Terminal }
	mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,class:touchpoint,discoverDisks:empty,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"178.102.156.9\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,class,discoverDisks,bootDisk,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
	err := ResolverClient.Post(mutation, &response)
	s.NoError(err)

	s.NotNil(response.CreateTerminal)
	terminal := response.CreateTerminal
	s.NotEmpty(terminal.Interfaces)
	s.Equal(1, len(terminal.Interfaces))
	terminalInterface := terminal.Interfaces[0]
	s.NotEmpty(terminalInterface.Addresses)
	s.Equal(1, len(terminalInterface.Addresses))
	terminalAddress := terminalInterface.Addresses[0]

	s.Equal("3396a52c-6a22-4049-9593-5a63b596a101", terminal.ClusterEdgeID)
	s.Equal(model.TerminalRoleTypeWorker, terminal.Role)
	s.Equal("lane01", *terminal.Lane)
	s.Equal(model.TerminalClassTypeTouchpoint, *terminal.Class)
	s.Equal(model.TerminalDiscoverDisksTypeEmpty, *terminal.DiscoverDisks)
	s.Nil(terminal.BootDisk)

	s.Equal("00:00:5e:00:53:bb", terminalInterface.MacAddress)
	s.False(terminalInterface.Dhcp4)
	s.True(terminalInterface.Dhcp6)

	s.Equal("192.168.2.10", *terminalAddress.IP)
	s.Equal(16, terminalAddress.PrefixLen)
	s.Equal(model.InetTypeInet, terminalAddress.Family)

	_, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
	s.NoError(err)
}

func (s *Suite) TestCreateTerminalWithSpecifiedBootDisk() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminal *model.Terminal }
	mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,class:touchpoint,discoverDisks:empty,bootDisk:\"/dev/sda\",clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"178.102.156.9\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,class,discoverDisks,bootDisk,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
	err := ResolverClient.Post(mutation, &response)
	s.NoError(err)

	s.NotNil(response.CreateTerminal)
	terminal := response.CreateTerminal
	s.NotEmpty(terminal.Interfaces)
	s.Equal(1, len(terminal.Interfaces))
	terminalInterface := terminal.Interfaces[0]
	s.NotEmpty(terminalInterface.Addresses)
	s.Equal(1, len(terminalInterface.Addresses))
	terminalAddress := terminalInterface.Addresses[0]

	s.Equal("3396a52c-6a22-4049-9593-5a63b596a101", terminal.ClusterEdgeID)
	s.Equal(model.TerminalRoleTypeWorker, terminal.Role)
	s.Equal("lane01", *terminal.Lane)
	s.Equal(model.TerminalClassTypeTouchpoint, *terminal.Class)
	s.Equal(model.TerminalDiscoverDisksTypeEmpty, *terminal.DiscoverDisks)
	s.Equal("/dev/sda", *terminal.BootDisk)

	s.Equal("00:00:5e:00:53:bb", terminalInterface.MacAddress)
	s.False(terminalInterface.Dhcp4)
	s.True(terminalInterface.Dhcp6)

	s.Equal("192.168.2.10", *terminalAddress.IP)
	s.Equal(16, terminalAddress.PrefixLen)
	s.Equal(model.InetTypeInet, terminalAddress.Family)

	_, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
	s.NoError(err)
}

func (s *Suite) TestCreateTerminalWithDefaultDiscoverDisks() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminal *model.Terminal }
	mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"178.102.156.9\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,class,discoverDisks,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
	err := ResolverClient.Post(mutation, &response)
	s.NoError(err)

	// assert terminal was created with default discoverDisks value (empty)
	s.NotNil(response.CreateTerminal)
	terminal := response.CreateTerminal
	s.Equal(model.TerminalDiscoverDisksTypeEmpty, *terminal.DiscoverDisks)

	_, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
	s.NoError(err)
}

func (s *Suite) TestCreateTerminalAddress() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminalAddress *model.TerminalAddress }
	mutation := "mutation{createTerminalAddress(terminalInterfaceId:\"3396a52c-6a22-4049-9593-5a63b596a203\",newTerminalAddress:{ip:\"192.168.2.10\",prefixLen:16,family:inet}){family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}"
	err := ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.Equal("3396a52c-6a22-4049-9593-5a63b596a203", response.CreateTerminalAddress.TerminalInterfaceID)
	s.Equal("192.168.2.10", *response.CreateTerminalAddress.IP)

	_, err = s.DB.Exec(sqlquery.TerminalAddressDeleteQuery, response.CreateTerminalAddress.TerminalAddressID)
	s.NoError(err)
}

func (s *Suite) TestCreateTerminalError() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminal *model.Terminal }

	mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"x.x.x.x\",gateway6:\"x.x.x.x\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
	err := ResolverClient.Post(mutation, &response)
	s.Error(err)
	s.Nil(response.CreateTerminal)
}

func (s *Suite) TestCreateTerminalInterface() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminalInterface *model.TerminalInterface }
	mutation := "mutation{createTerminalInterface(terminalId:\"c4aa6450-3b2a-11ed-a261-0242ac12c101\",newTerminalInterface:{macAddress:\"00:00:5e:00:53:bb\",dhcp4:true,dhcp6:true,addresses:[]}){dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId}}"
	err := ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.Equal(terminalID, response.CreateTerminalInterface.TerminalID)
	s.Equal("00:00:5e:00:53:bb", response.CreateTerminalInterface.MacAddress)

	_, err = s.DB.Exec(sqlquery.TerminalInterfaceDeleteQuery, response.CreateTerminalInterface.TerminalInterfaceID)
	s.NoError(err)
}

func (s *Suite) TestCreateTerminalInterfaceError() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminalInterface *model.TerminalInterface }
	mutation := "mutation{createTerminalInterface(terminalId:\"c4aa6450-3b2a-11ed-a261-0242ac12c101\",newTerminalInterface:{macAddress:\"0000:5e:00:53:bb\",dhcp4:false,dhcp6:false,gateway4:\"178.102.156.9\",gateway6:\"22.234.148.200\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}){dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}"
	err := ResolverClient.Post(mutation, &response)
	s.Error(err)
}

func (s *Suite) TestCreateTerminalInvalidCIDR() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminal *model.Terminal }

	mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"1.1.1.1\",gateway6:\"2.2.2.2\",addresses:[{ip:\"192.168.2.10\",prefixLen:-1,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
	err := ResolverClient.Post(mutation, &response)
	s.Error(err)
	s.Nil(response.CreateTerminal)
}

func (s *Suite) TestCreateTerminalInvalidIP() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminal *model.Terminal }

	mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"x.x.x.x\",gateway6:\"x.x.x.x\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
	err := ResolverClient.Post(mutation, &response)
	s.Error(err)
	s.Nil(response.CreateTerminal)
}

func (s *Suite) TestCreateTerminalInvalidMac() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminal *model.Terminal }

	mutation := "mutation{createTerminal(newTerminal:{lane:\"\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"005e:00:53:bb\",dhcp4:false,dhcp6:true,gateway4:\"1.1.1.1\",gateway6:\"2.2.2.2\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
	err := ResolverClient.Post(mutation, &response)
	s.Error(err)
	s.Nil(response.CreateTerminal)
}

func (s *Suite) TestCreateTerminalDHCPNotSet() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminal *model.Terminal }
	mutation := "mutation{createTerminal(newTerminal:{lane:\"lane01\",role:worker,discoverDisks:all,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:bb\",dhcp4:false,dhcp6:false,gateway4:\"178.102.156.9\",gateway6:\"f886:c601:c61b:8eb1:ae5b:a21e:4332:f119\",addresses:[{ip:\"192.168.2.10\",prefixLen:16,family:inet},{ip:\"a8ec:2b0c:05ac:27be:88e2:de7a:3c81:f439\",prefixLen:24,family:inet}]}]}){clusterEdgeId,lane,role,terminalId,interfaces{dhcp4,dhcp6,gateway4,gateway6,macAddress,terminalId,terminalInterfaceId,addresses{family,terminalInterfaceId,ip,prefixLen,terminalAddressId}}}}"
	err := ResolverClient.Post(mutation, &response)
	s.NoError(err)
	terminal := response.CreateTerminal

	s.NotEmpty(terminal.Interfaces)
	s.Equal(1, len(terminal.Interfaces))
	s.False(terminal.Interfaces[0].Dhcp4)
	s.False(terminal.Interfaces[0].Dhcp6)
	s.NotEmpty(terminal.Interfaces[0].Addresses)
	s.Equal(2, len(terminal.Interfaces[0].Addresses))
	s.Equal("192.168.2.10", *terminal.Interfaces[0].Addresses[0].IP)
	s.Equal("a8ec:2b0c:05ac:27be:88e2:de7a:3c81:f439", *terminal.Interfaces[0].Addresses[1].IP)

	_, err = s.DB.Exec(sqlquery.TerminalDeleteQuery, terminal.TerminalID)
	s.NoError(err)
}

func (s *Suite) TestCreateTerminalWithDuplicateDiskPaths() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateTerminal *model.Terminal }
	mutation := "mutation{createTerminal(newTerminal:{role:worker,discoverDisks:empty,clusterEdgeId:\"3396a52c-6a22-4049-9593-5a63b596a101\",interfaces:[{macAddress:\"00:00:5e:00:53:cc\",dhcp4:true,dhcp6:false}],disks:[{devicePath:\"/dev/sda1\",expectEmpty:true,includeDisk:true},{devicePath:\"/dev/sda1\",expectEmpty:true,includeDisk:true}]}){clusterEdgeId,disks{usePart,terminalId,terminalDiskId,includeDisk,expectEmpty,devicePath}}}"
	err := ResolverClient.Post(mutation, &response)
	s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
}

func (s *Suite) TestDeleteTerminal() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteTerminal bool }
	terminalID := "c4aa6450-3b2a-11ed-a261-0242ac12c201"
	mutation := deleteTerminalMutation(&terminalID)
	err := ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.True(response.DeleteTerminal)
}

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

	createAddressArgs := []interface{}{
		"523f8d69-c76e-4592-a9bf-442fdb15e474",
		"203.236.49.66",
		16,
		model.InetTypeInet.String(),
		"3396a52c-6a22-4049-9593-5a63b596a203",
	}
	_, err := s.DB.Exec(sqlquery.TerminalAddressCreateQuery, createAddressArgs...)
	s.NoError(err)

	createAddressArgsv6 := []interface{}{
		"3a291185-286d-4693-8792-f1a719d0f442",
		"0538:928e:a40b:9529:f72c:599a:6e6e:cfe9",
		16,
		model.InetTypeInet.String(),
		"3396a52c-6a22-4049-9593-5a63b596a203",
	}
	_, err = s.DB.Exec(sqlquery.TerminalAddressCreateQuery, createAddressArgsv6...)
	s.NoError(err)

	var response struct{ DeleteTerminalAddress bool }
	addressID := "523f8d69-c76e-4592-a9bf-442fdb15e474"
	mutation := deleteTerminalAddressMutation(&addressID)
	err = ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.True(response.DeleteTerminalAddress)

	// leave test db unchanged
	_, err = s.DB.Exec(sqlquery.TerminalAddressDeleteQuery, createAddressArgsv6[0])
	s.NoError(err)
}

func (s *Suite) TestDeleteTerminalError() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteTerminal bool }
	query := deleteTerminalMutation(nil)
	err := ResolverClient.Post(query, &response)
	s.Error(err)
}

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

	createIfaceArgs := []interface{}{
		"55fb8510-3d78-4f8d-a43a-cae429109c6c",
		"02:e8:55:57:bd:80",
		false,
		true,
		"213.170.59.248",
		"252.51.27.170",
		terminalID,
	}
	_, err := s.DB.Exec(sqlquery.TerminalInterfaceCreateQuery, createIfaceArgs...)
	s.NoError(err)

	var response struct{ DeleteTerminalInterface bool }
	ifaceID := "55fb8510-3d78-4f8d-a43a-cae429109c6c"
	mutation := deleteTerminalInterfaceMutation(&ifaceID)
	err = ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.True(response.DeleteTerminalInterface)
}

func (s *Suite) TestDeleteTerminalInterfaceError() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteTerminalInterface bool }
	ifaceID := "3396a52c-6a22-4049-9593-5a63b596a203"
	mutation := deleteTerminalInterfaceMutation(&ifaceID)
	err = ResolverClient.Post(mutation, &response)
	s.Error(err)
	s.False(response.DeleteTerminalInterface)
}

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

	var response struct{ Terminal *model.Terminal }
	query := getTerminalQuery(&terminalID)
	err = ResolverClient.Post(query, &response)

	s.NoError(err)
	s.NotEmpty(response.Terminal)
	s.Equal(terminalID, response.Terminal.TerminalID)
	s.NotEmpty(response.Terminal.Interfaces)
	terminalInterface := response.Terminal.Interfaces[0]
	s.Equal("3396a52c-6a22-4049-9593-5a63b596a203", terminalInterface.TerminalInterfaceID)
	s.NotEmpty(terminalInterface.Addresses)
	terminalAddress := terminalInterface.Addresses[0]
	s.Equal("1ad40dca-3b2d-11ed-a261-0242ac12a101", terminalAddress.TerminalAddressID)
}

func (s *Suite) TestGetTerminalError() {
	integration.SkipIf(s.Framework)
	var response struct{ Terminal *model.Terminal }
	terminalID := "does-not-exist"
	query := getTerminalQuery(&terminalID)
	err := ResolverClient.Post(query, &response)
	s.Error(err)
}

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

	var response struct{ Terminals []*model.Terminal }
	clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a200"
	query := getTerminalsQuery(&clusterEdgeID, nil)
	err = ResolverClient.Post(query, &response)
	s.NoError(err)
	s.NotEmpty(response.Terminals)
	s.Equal(1, len(response.Terminals))
	terminal := response.Terminals[0]
	s.Equal(terminalID, terminal.TerminalID)
	terminalInterface := terminal.Interfaces[0]
	s.NotEmpty(terminalInterface.Addresses)
	s.Equal(clusterEdgeID, terminal.ClusterEdgeID)
	s.Equal("lane01", *terminal.Lane)
	s.Equal("00:00:5e:00:53:af", terminal.Interfaces[0].MacAddress)
	s.Equal("192.168.1.1", *terminal.Interfaces[0].Addresses[0].IP)

	query = getTerminalsQuery(nil, nil)
	err = ResolverClient.Post(query, &response)
	s.NoError(err)
	s.NotEmpty(response.Terminals)
	s.Equal(6, len(response.Terminals))
	s.Equal(terminalID, response.Terminals[0].TerminalID)
}

func (s *Suite) TestGetTerminalsError() {
	integration.SkipIf(s.Framework)
	var response struct{ Terminals []*model.Terminal }
	clusterEdgeID := "does-not-exist"
	query := getTerminalsQuery(&clusterEdgeID, nil)
	err := ResolverClient.Post(query, &response)
	s.Error(err)
}

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

	var response struct{ UpdateTerminal *model.Terminal }
	terminalArgs := []interface{}{
		terminalID,
		"lane01",
		model.TerminalRoleTypeWorker.String(),
		model.TerminalClassTypeTouchpoint,
		model.TerminalDiscoverDisksTypeEmpty,
		nil,
		nil,
		nil,
		false,
		"3396a52c-6a22-4049-9593-5a63b596a200",
	}

	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{lane:\"lane20\",class:touchpoint,discoverDisks:empty}}){terminalId,lane,role,class,discoverDisks,clusterEdgeId}}", terminalArgs[0])
	err = ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.Equal(terminalArgs[0], response.UpdateTerminal.TerminalID)
	s.Equal("lane20", *response.UpdateTerminal.Lane)
	s.Equal(terminalArgs[2], response.UpdateTerminal.Role.String())
	s.Equal(terminalArgs[3], *response.UpdateTerminal.Class)
	s.Equal(terminalArgs[4], *response.UpdateTerminal.DiscoverDisks)
	s.Nil(response.UpdateTerminal.BootDisk)
	s.Nil(response.UpdateTerminal.PrimaryInterface)
	s.Equal(terminalArgs[8], response.UpdateTerminal.SwapEnabled)
	s.Equal(terminalArgs[9], response.UpdateTerminal.ClusterEdgeID)

	_, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
	s.NoError(err)
}

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

	var response struct{ UpdateTerminal *model.Terminal }
	terminalArgs := []interface{}{
		terminalID,
		"lane01",
		model.TerminalRoleTypeWorker.String(),
		model.TerminalClassTypeTouchpoint,
		model.TerminalDiscoverDisksTypeEmpty,
		"/dev/sdx",
		nil,
		nil,
		false,
	}

	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{bootDisk:\"%s\"}}){bootDisk}}", terminalArgs[0], terminalArgs[5])
	err = ResolverClient.Post(mutation, &response)
	s.NoError(err)
	s.Equal(terminalArgs[5], *response.UpdateTerminal.BootDisk)

	_, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
	s.NoError(err)
}

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

	var response struct{ UpdateTerminal *model.Terminal }
	terminalArgs := []interface{}{
		terminalID,
		"lane01",
		model.TerminalRoleTypeWorker.String(),
		model.TerminalClassTypeTouchpoint,
		model.TerminalDiscoverDisksTypeEmpty,
		nil,
		"3396a52c-6a22-4049-9593-5a63b596a203",
		nil,
		false,
	}
	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{primaryInterface:\"%s\"}}){primaryInterface}}", terminalArgs[0], terminalArgs[6])
	err = ResolverClient.Post(mutation, &response)
	s.NoError(err)

	s.Equal(terminalArgs[6], *response.UpdateTerminal.PrimaryInterface)

	_, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
	s.NoError(err)
}

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

	ifaceID := "55fb8510-3d78-4f8d-a43a-cae429109c6c"

	createIfaceArgs := []interface{}{
		ifaceID,
		"02:e8:55:57:bd:80",
		false,
		true,
		"213.170.59.248",
		"252.51.27.170",
		terminalID,
	}
	_, err = s.DB.Exec(sqlquery.TerminalInterfaceCreateQuery, createIfaceArgs...)
	s.NoError(err)

	var updateResponse struct{ UpdateTerminal *model.Terminal }
	terminalArgs := []interface{}{
		terminalID,
		"lane01",
		model.TerminalRoleTypeWorker.String(),
		model.TerminalClassTypeTouchpoint,
		model.TerminalDiscoverDisksTypeEmpty,
		nil,
		ifaceID,
		nil,
		false,
	}
	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{primaryInterface:\"%s\"}}){primaryInterface}}", terminalArgs[0], terminalArgs[6])
	err = ResolverClient.Post(mutation, &updateResponse)
	s.NoError(err)

	_, err := s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
	s.NoError(err)

	var deleteResponse struct{ DeleteTerminalInterface bool }
	mutation = deleteTerminalInterfaceMutation(&ifaceID)
	err = ResolverClient.Post(mutation, &deleteResponse)
	s.NoError(err)
	s.True(deleteResponse.DeleteTerminalInterface)

	_, err = s.DB.Exec(sqlquery.TerminalInterfaceDeleteQuery, ifaceID)
	s.NoError(err)

	var response struct{ Terminal *model.Terminal }
	query := getTerminalQuery(&terminalID)
	err = ResolverClient.Post(query, &response)
	s.NoError(err)
	s.Nil(response.Terminal.PrimaryInterface)
}

func (s *Suite) TestUpdateTerminalWithInvalidInterface() {
	integration.SkipIf(s.Framework)
	var response struct{ UpdateTerminal *model.Terminal }
	terminalArgs := []interface{}{
		terminalID,
		"lane01",
		model.TerminalRoleTypeWorker.String(),
		model.TerminalClassTypeTouchpoint,
		model.TerminalDiscoverDisksTypeEmpty,
		nil,
		"3396a52f-6a22-4049-9593-5a63b596a204",
		nil,
		false,
	}
	mutation := fmt.Sprintf("mutation{updateTerminal(terminal:{terminalId:\"%s\",terminalValues:{primaryInterface:\"%s\"}}){primaryInterface}}", terminalArgs[0], terminalArgs[6])
	err = ResolverClient.Post(mutation, &response)
	s.Error(err)

	_, err = s.DB.Exec(sqlquery.TerminalUpdateQuery, terminalArgs[2], terminalArgs[2], terminalArgs[3], terminalArgs[4], terminalArgs[5], terminalArgs[6], terminalArgs[7], terminalArgs[8], terminalArgs[0])
	s.Error(err)
}

// nolint
func (s *Suite) TestUpdateTerminalInvalidIP() {
	integration.SkipIf(s.Framework)
	var response struct{ UpdateTerminal *model.Terminal }

	var (
		prefixLen     = 16
		dhcp4         = true
		terminalLane  = "lane20"
		discoverDisks = model.TerminalDiscoverDisksTypeEmpty
		macAddress    = "de:fa:37:f8:6a:b2"
		ip            = ""
	)
	terminalAddressUpdateValues := []*model.TerminalAddressIDInput{
		{
			TerminalAddressID: "1ad40dca-3b2d-11ed-a261-0242ac12a101",
			TerminalAddressValues: &model.TerminalAddressUpdateInput{
				PrefixLen: &prefixLen,
				IP:        &ip,
			},
		},
	}
	terminalInterfaceUpdateValues := []*model.TerminalInterfaceIDInput{
		{
			TerminalInterfaceID: "3396a52c-6a22-4049-9593-5a63b596a203",
			TerminalInterfaceValues: &model.TerminalInterfaceUpdateInput{
				Dhcp4:      &dhcp4,
				MacAddress: &macAddress,
				Addresses:  terminalAddressUpdateValues,
			},
		},
	}
	terminalUpdateValues := model.TerminalIDInput{
		TerminalID: terminalID,
		TerminalValues: &model.TerminalUpdateInput{
			Lane:          &terminalLane,
			DiscoverDisks: &discoverDisks,
			Interfaces:    terminalInterfaceUpdateValues,
		},
	}

	mutation := updateTerminalMutation(&terminalUpdateValues)
	err := ResolverClient.Post(mutation, &response)
	s.Error(err)
	s.Nil(response.UpdateTerminal)
}

// nolint
func (s *Suite) TestUpdateTerminalInvalidMac() {
	integration.SkipIf(s.Framework)
	var response struct{ UpdateTerminal *model.Terminal }

	var (
		prefixLen     = 16
		dhcp4         = true
		terminalLane  = "lane20"
		discoverDisks = model.TerminalDiscoverDisksTypeEmpty
		macAddress    = ""
		ip            = "252.227.220.89"
	)
	terminalAddressUpdateValues := []*model.TerminalAddressIDInput{
		{
			TerminalAddressID: "1ad40dca-3b2d-11ed-a261-0242ac12a101",
			TerminalAddressValues: &model.TerminalAddressUpdateInput{
				PrefixLen: &prefixLen,
				IP:        &ip,
			},
		},
	}
	terminalInterfaceUpdateValues := []*model.TerminalInterfaceIDInput{
		{
			TerminalInterfaceID: "3396a52c-6a22-4049-9593-5a63b596a203",
			TerminalInterfaceValues: &model.TerminalInterfaceUpdateInput{
				Dhcp4:      &dhcp4,
				MacAddress: &macAddress,
				Addresses:  terminalAddressUpdateValues,
			},
		},
	}
	terminalUpdateValues := model.TerminalIDInput{
		TerminalID: terminalID,
		TerminalValues: &model.TerminalUpdateInput{
			Lane:          &terminalLane,
			DiscoverDisks: &discoverDisks,
			Interfaces:    terminalInterfaceUpdateValues,
		},
	}

	mutation := updateTerminalMutation(&terminalUpdateValues)
	err := ResolverClient.Post(mutation, &response)
	s.Error(err)
	s.Nil(response.UpdateTerminal)
}

func (s *Suite) TestUpdateTerminalError() {
	integration.SkipIf(s.Framework)
	var response struct{ UpdateTerminal *model.Terminal }

	terminalAddressUpdateValues := []*model.TerminalAddressIDInput{
		{
			TerminalAddressID:     "f0984590-40b7-11ed-b878-0242ac120002",
			TerminalAddressValues: &model.TerminalAddressUpdateInput{},
		},
	}
	terminalInterfaceUpdateValues := []*model.TerminalInterfaceIDInput{
		{
			TerminalInterfaceID: "e9958cf8-40b7-11ed-b878-0242ac120002",
			TerminalInterfaceValues: &model.TerminalInterfaceUpdateInput{
				Addresses: terminalAddressUpdateValues,
			},
		},
	}
	terminalLane := "lane05"
	discoverDisks := model.TerminalDiscoverDisksTypeEmpty
	terminalUpdateValues := model.TerminalIDInput{
		TerminalID: "e856e784-40b6-11ed-b878-0242ac120002",
		TerminalValues: &model.TerminalUpdateInput{
			Lane:          &terminalLane,
			DiscoverDisks: &discoverDisks,
			Interfaces:    terminalInterfaceUpdateValues,
		},
	}

	mutation := updateTerminalMutation(&terminalUpdateValues)
	err := ResolverClient.Post(mutation, &response)
	s.Error(err)
	s.Empty(response.UpdateTerminal)
}

// Try (and fail) to update disks with values that are the same, but are not the same as any existing disks on the terminal
func (s *Suite) TestUpdateTerminalWithDuplicateDiskPaths_One() {
	integration.SkipIf(s.Framework)

	var response struct{ UpdateTerminal *model.Terminal }
	mutation := "mutation{updateTerminal(terminal:{terminalId:\"42742ecf-55fa-467a-a3b2-174015a8109f\",terminalValues:{disks:[{terminalDiskId:\"ffd5d566-0569-4c8e-8fec-a283898fb487\",terminalDiskValues:{devicePath:\"/dev/sdd123\"}},{terminalDiskId:\"7d36aec7-dfda-49ce-8700-aa337fe74cbf\",terminalDiskValues:{devicePath:\"/dev/sdd123\"}}]}}){terminalId}}"
	err = ResolverClient.Post(mutation, &response)
	s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
}

// Try (and fail) to update disks with value that is the same as existing disk
func (s *Suite) TestUpdateTerminalWithDuplicateDiskPaths_Two() {
	integration.SkipIf(s.Framework)

	var response struct{ UpdateTerminal *model.Terminal }
	mutation := "mutation{updateTerminal(terminal:{terminalId:\"42742ecf-55fa-467a-a3b2-174015a8109f\",terminalValues:{disks:[{terminalDiskId:\"ffd5d566-0569-4c8e-8fec-a283898fb487\",terminalDiskValues:{devicePath:\"/dev/sdz\"}}]}}){terminalId}}"
	err = ResolverClient.Post(mutation, &response)
	s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
}

func (s *Suite) TestGetBannerTerminals() {
	integration.SkipIf(s.Framework)
	var response struct{ BannerTerminals []*model.Terminal }

	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
	query := getBannerTerminalsQuery(&bannerEdgeID)
	err := ResolverClient.Post(query, &response)

	s.NoError(err)
	s.Equal(6, len(response.BannerTerminals))
}

func (s *Suite) TestGetBannerTerminalsError() {
	integration.SkipIf(s.Framework)
	var response struct {
		BannerTerminals []*model.Terminal
	}
	query := getBannerTerminalsQuery(nil)
	err := ResolverClient.Post(query, &response)
	s.Error(err)
	s.Empty(response.BannerTerminals)
}

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

	var response struct{ TerminalDevices *model.TerminalDevices }
	query := getTerminalDevicesQuery(&terminalID)
	err = ResolverClient.Post(query, &response)
	s.NoError(err)

	s.NotEmpty(response.TerminalDevices)
	s.Len(response.TerminalDevices.Classes, 1)
	s.Len(response.TerminalDevices.Classes[0].Devices, 1)
	s.Equal(response.TerminalDevices.Classes[0].Devices[0].Name, "card0-VGA-1 ACR-2199")
}

var terminalFields = []*graphb.Field{
	{
		Name: "clusterEdgeId",
	},
	{
		Name: "clusterName",
	},
	{
		Name: "hostname",
	},
	{
		Name: "lane",
	},
	{
		Name: "role",
	},
	{
		Name: "terminalId",
	},
	{
		Name: "class",
	},
	{
		Name: "discoverDisks",
	},
	{
		Name: "interfaces",
		Fields: []*graphb.Field{
			{
				Name: "dhcp4",
			},
			{
				Name: "dhcp6",
			},
			{
				Name: "gateway4",
			},
			{
				Name: "gateway6",
			},
			{
				Name: "macAddress",
			},
			{
				Name: "terminalId",
			},
			{
				Name: "terminalInterfaceId",
			},
			{
				Name: "addresses",
				Fields: []*graphb.Field{
					{
						Name: "family",
					},
					{
						Name: "terminalInterfaceId",
					},
					{
						Name: "ip",
					},
					{
						Name: "prefixLen",
					},
					{
						Name: "terminalAddressId",
					},
				},
			},
		},
	},
}

func updateTerminalMutation(updateTerminal *model.TerminalIDInput) string {
	terminalValues := updateTerminal.TerminalValues
	terminalInterfaceValues := terminalValues.Interfaces[0].TerminalInterfaceValues
	terminalAddressValues := terminalInterfaceValues.Addresses[0].TerminalAddressValues
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "updateTerminal",
				Arguments: []graphb.Argument{
					graphb.ArgumentCustomType("terminal",
						graphb.ArgumentString("terminalId", updateTerminal.TerminalID),
						graphb.ArgumentCustomType("terminalValues",
							graphb.ArgumentString("lane", utils.ConvertToString(terminalValues.Lane)),
							graphb.ArgumentString("discoverDisks", terminalValues.DiscoverDisks.String()),
							graphb.ArgumentCustomTypeSlice("interfaces",
								graphb.ArgumentCustomTypeSliceElem(
									graphb.ArgumentString("terminalInterfaceId", terminalValues.Interfaces[0].TerminalInterfaceID),
									graphb.ArgumentCustomType("terminalInterfaceValues",
										graphb.ArgumentString("macAddress", utils.ConvertToString(terminalInterfaceValues.MacAddress)),
										graphb.ArgumentBool("dhcp4", utils.ConvertToBool(terminalInterfaceValues.Dhcp4)),
										graphb.ArgumentCustomTypeSlice("addresses",
											graphb.ArgumentCustomTypeSliceElem(
												graphb.ArgumentString("terminalAddressId", terminalInterfaceValues.Addresses[0].TerminalAddressID),
												graphb.ArgumentCustomType("terminalAddressValues",
													graphb.ArgumentString("ip", utils.ConvertToString(terminalAddressValues.IP)),
													graphb.ArgumentInt("prefixLen", utils.ConvertToInt(terminalAddressValues.PrefixLen)),
												),
											),
										),
									),
								),
							),
						),
					),
				},
				Fields: terminalFields,
			},
		},
	})
}

func deleteTerminalMutation(terminalID *string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "deleteTerminal",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("terminalId", utils.ConvertToString(terminalID)),
				},
			},
		},
	})
}

func deleteTerminalInterfaceMutation(terminalInterfaceID *string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "deleteTerminalInterface",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("terminalInterfaceId", utils.ConvertToString(terminalInterfaceID)),
				},
			},
		},
	})
}

func deleteTerminalAddressMutation(terminalAddressID *string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "deleteTerminalAddress",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("terminalAddressId", utils.ConvertToString(terminalAddressID)),
				},
			},
		},
	})
}

func getTerminalQuery(terminalID *string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "terminal",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("terminalId", utils.ConvertToString(terminalID)),
				},
				Fields: terminalFields,
			},
		},
	})
}

func getTerminalDevicesQuery(terminalID *string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "terminalDevices",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("terminalId", utils.ConvertToString(terminalID)),
				},
				Fields: terminalDeviceFields(),
			},
		},
	})
}

func terminalDeviceFields() []*graphb.Field {
	return []*graphb.Field{
		{
			Name: "classes",
			Fields: []*graphb.Field{
				{
					Name: "devices",
					Fields: []*graphb.Field{
						{
							Name: "name",
						},
					},
				},
				{
					Name: "name",
				},
			},
		},
	}
}

func getTerminalsQuery(clusterEdgeID *string, terminalHostname *string) string {
	getTerminalsArg := []graphb.Argument{}
	if clusterEdgeID != nil {
		getTerminalsArg = append(getTerminalsArg, graphb.ArgumentString("clusterEdgeId", utils.ConvertToString(clusterEdgeID)))
	}
	if terminalHostname != nil {
		getTerminalsArg = append(getTerminalsArg, graphb.ArgumentString("hostname", utils.ConvertToString(terminalHostname)))
	}
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name:      "terminals",
				Arguments: getTerminalsArg,
				Fields:    terminalFields,
			},
		},
	})
}

func getBannerTerminalsQuery(bannerEdgeID *string) string {
	getBannerTerminalsArg := []graphb.Argument{}
	if bannerEdgeID != nil {
		getBannerTerminalsArg = append(getBannerTerminalsArg, graphb.ArgumentString("bannerEdgeId", utils.ConvertToString(bannerEdgeID)))
	}
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name:      "bannerTerminals",
				Arguments: getBannerTerminalsArg,
				Fields:    terminalFields,
			},
		},
	})
}