package integration_test

import (
	"github.com/udacity/graphb"

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

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

	var response struct{ Terminal *model.Terminal }
	terminalID := "6246c60b-9c8b-4510-b3bb-fb8fa1f9fbad"
	query := getTerminalWithDisksQuery(terminalID)
	err = ResolverClient.Post(query, &response)

	s.NoErrorf(err, "error posting to resolver client")
	s.NotEmptyf(response.Terminal, "returned terminal empty")
	s.Equalf(terminalID, response.Terminal.TerminalID, "incorrect terminalId")
	s.NotEmptyf(response.Terminal.Disks, "empty disks")
	disk := response.Terminal.Disks[0]
	s.NotNilf(disk, "nil disk")
	expectedDisk := &model.TerminalDisk{
		TerminalDiskID: "9dca53a3-7527-44d9-a7d4-fb704379c7a0",
		TerminalID:     terminalID,
		IncludeDisk:    true,
		ExpectEmpty:    true,
		DevicePath:     "/dev/sda",
		UsePart:        true,
	}
	s.Equalf(expectedDisk, disk, "incorrect disk")
}

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

	var response struct{ CreateTerminalDisk model.TerminalDisk }
	terminalID := "42742ecf-55fa-467a-a3b2-174015a8109f"
	includeDisk := false
	expectEmpty := false
	devicePath := "/dev/sdg"
	usePart := true
	newDisk := model.TerminalDiskCreateInput{
		IncludeDisk: includeDisk,
		ExpectEmpty: expectEmpty,
		DevicePath:  devicePath,
		UsePart:     usePart,
	}
	mutation := createTerminalDiskMutation(terminalID, newDisk)
	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "error posting to resolver client")
	s.Equalf(terminalID, response.CreateTerminalDisk.TerminalID, "incorrect terminalId")
	s.Equalf(includeDisk, response.CreateTerminalDisk.IncludeDisk, "incorrect includeDisk")
	s.Equalf(expectEmpty, response.CreateTerminalDisk.ExpectEmpty, "incorrect expectEmpty")
	s.Equalf(devicePath, response.CreateTerminalDisk.DevicePath, "incorrect devicePath")
	s.Equalf(usePart, response.CreateTerminalDisk.UsePart, "incorrect usePart")
}

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

	var response struct{ CreateTerminalDisk model.TerminalDisk }
	terminalID := "6246c60b-9c8b-4510-b3bb-fb8fa1f9fbad"
	includeDisk := true
	expectEmpty := true
	devicePath := "/dev/sda"
	usePart := true
	newDisk := model.TerminalDiskCreateInput{
		IncludeDisk: includeDisk,
		ExpectEmpty: expectEmpty,
		DevicePath:  devicePath,
		UsePart:     usePart,
	}
	mutation := createTerminalDiskMutation(terminalID, newDisk)
	err := ResolverClient.Post(mutation, &response)
	s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
}

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

	var response struct{ UpdateTerminalDisk model.TerminalDisk }
	terminalID := "42742ecf-55fa-467a-a3b2-174015a8109f"
	diskID := "ffd5d566-0569-4c8e-8fec-a283898fb487"
	includeDisk := false
	expectEmpty := true
	devicePath := "/dev/sde"
	usePart := true
	disk := model.TerminalDiskIDInput{
		TerminalDiskID: diskID,
		TerminalDiskValues: &model.TerminalDiskUpdateInput{
			IncludeDisk: &includeDisk,
			ExpectEmpty: &expectEmpty,
			DevicePath:  &devicePath,
			UsePart:     &usePart,
		},
	}
	mutation := updateTerminalDiskMutation(disk)
	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "error posting to resolver client")
	expectedDisk := model.TerminalDisk{
		TerminalDiskID: diskID,
		TerminalID:     terminalID,
		IncludeDisk:    includeDisk,
		ExpectEmpty:    expectEmpty,
		DevicePath:     devicePath,
		UsePart:        usePart,
	}
	s.Equalf(expectedDisk, response.UpdateTerminalDisk, "incorrect disk")
}

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

	var response struct{ UpdateTerminalDisk model.TerminalDisk }
	diskID := "9dca53a3-7527-44d9-a7d4-fb704379c7a0"
	includeDisk := true
	expectEmpty := true
	devicePath := "/dev/sda"
	usePart := true
	disk := model.TerminalDiskIDInput{
		TerminalDiskID: diskID,
		TerminalDiskValues: &model.TerminalDiskUpdateInput{
			IncludeDisk: &includeDisk,
			ExpectEmpty: &expectEmpty,
			DevicePath:  &devicePath,
			UsePart:     &usePart,
		},
	}
	mutation := updateTerminalDiskMutation(disk)
	err := ResolverClient.Post(mutation, &response)
	s.ErrorContains(err, services.ErrDuplicateTerminalDiskDevicePaths.Error())
}

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

	var response struct{ DeleteTerminalDisk bool }
	diskID := "45b47b4e-dae2-4bfb-a371-e1750517cf64"
	mutation := deleteTerminalDiskMutation(diskID)
	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "error posting to resolver client")
	s.Truef(response.DeleteTerminalDisk, "delete returned false")
}

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

func createTerminalDiskMutation(terminalID string, newDisk model.TerminalDiskCreateInput) string {
	newDiskArg := graphb.ArgumentCustomTypeSliceElem(
		graphb.ArgumentBool("includeDisk", newDisk.IncludeDisk),
		graphb.ArgumentBool("expectEmpty", newDisk.ExpectEmpty),
		graphb.ArgumentString("devicePath", newDisk.DevicePath),
		graphb.ArgumentBool("usePart", newDisk.UsePart),
	)
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "createTerminalDisk",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("terminalId", terminalID),
					graphb.ArgumentCustomType("newTerminalDisk", newDiskArg...),
				},
				Fields: terminalDiskFields,
			},
		},
	})
}

func updateTerminalDiskMutation(terminalDisk model.TerminalDiskIDInput) string {
	diskValuesArg := graphb.ArgumentCustomTypeSliceElem(
		graphb.ArgumentBool("includeDisk", utils.ConvertToBool(terminalDisk.TerminalDiskValues.IncludeDisk)),
		graphb.ArgumentBool("expectEmpty", utils.ConvertToBool(terminalDisk.TerminalDiskValues.ExpectEmpty)),
		graphb.ArgumentString("devicePath", utils.ConvertToString(terminalDisk.TerminalDiskValues.DevicePath)),
		graphb.ArgumentBool("usePart", utils.ConvertToBool(terminalDisk.TerminalDiskValues.UsePart)),
	)
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "updateTerminalDisk",
				Arguments: []graphb.Argument{
					graphb.ArgumentCustomType("terminalDisk",
						graphb.ArgumentString("terminalDiskId", terminalDisk.TerminalDiskID),
						graphb.ArgumentCustomType("terminalDiskValues", diskValuesArg...),
					),
				},
				Fields: terminalDiskFields,
			},
		},
	})
}

func deleteTerminalDiskMutation(terminalDiskID string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "deleteTerminalDisk",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("terminalDiskId", terminalDiskID),
				},
			},
		},
	})
}

var terminalFieldsWithDisks = []*graphb.Field{
	{
		Name: "terminalId",
	},
	{
		Name:   "disks",
		Fields: terminalDiskFields,
	},
}

var terminalDiskFields = []*graphb.Field{
	{
		Name: "terminalDiskId",
	},
	{
		Name: "terminalId",
	},
	{
		Name: "includeDisk",
	},
	{
		Name: "expectEmpty",
	},
	{
		Name: "devicePath",
	},
	{
		Name: "usePart",
	},
}