package integration_test

import (
	"github.com/udacity/graphb"

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

func (s *Suite) TestZones() {
	integration.SkipIf(s.Framework)
	var resp struct{ Zones []string }
	ResolverClient.MustPost(`{zones}`, &resp)
	s.True(len(resp.Zones) > 0)
}

func (s *Suite) TestGKEZonesValid() {
	integration.SkipIf(s.Framework)
	var gkeVersionsResponse struct{ GKEVersions []string }
	getGKEVersionsQuery := gkeVersionsQuery(testClusterZone)
	ResolverClient.MustPost(getGKEVersionsQuery, &gkeVersionsResponse)
	s.True(len(gkeVersionsResponse.GKEVersions) > 0)
}

func (s *Suite) TestGKEZonesFail() {
	integration.SkipIf(s.Framework)
	var gkeVersionsResponse struct{ GKEVersions []string }
	getGKEVersionsQuery := gkeVersionsQuery("bad-zone")
	err := ResolverClient.Post(getGKEVersionsQuery, &gkeVersionsResponse)
	s.Error(err)
}

func (s *Suite) TestMachineTypesValid() {
	integration.SkipIf(s.Framework)
	var machineTypesQueryResponse struct{ MachineTypes []*model.MachineTypeInfo }
	getMachineTypesQuery := machineTypesQuery(testClusterZone)
	ResolverClient.MustPost(getMachineTypesQuery, &machineTypesQueryResponse)
	s.True(len(machineTypesQueryResponse.MachineTypes) > 0)
}

func (s *Suite) TestMachineTypesFail() {
	integration.SkipIf(s.Framework)
	var machineTypesQueryResponse struct{ MachineTypes []*model.MachineTypeInfo }
	getMachineTypesQuery := machineTypesQuery("bad-zone")
	err := ResolverClient.Post(getMachineTypesQuery, &machineTypesQueryResponse)
	s.Error(err)
}

func (s *Suite) TestMachineTypeValid() {
	integration.SkipIf(s.Framework)
	var machineTypeQueryResponse struct{ MachineType *model.MachineTypeInfo }
	machineTypeQuery := machineTypeQuery(testClusterZone, testClusterMachineType)
	ResolverClient.MustPost(machineTypeQuery, &machineTypeQueryResponse)
	s.NotNil(machineTypeQueryResponse.MachineType)
	s.NotNil(machineTypeQueryResponse.MachineType.Name)
	s.True(machineTypeQueryResponse.MachineType.GuestCPUs > 0)
	s.True(machineTypeQueryResponse.MachineType.MemoryGb > 0)
}

func (s *Suite) TestMachineTypeFail() {
	integration.SkipIf(s.Framework)
	var machineTypeQueryResponse struct{ MachineType *model.MachineTypeInfo }
	machineTypeQuery := machineTypeQuery(testClusterZone, "bad-machine-type")
	err := ResolverClient.Post(machineTypeQuery, &machineTypeQueryResponse)
	s.Error(err)
}

func gkeVersionsQuery(zone string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name:      "gkeVersions",
				Arguments: []graphb.Argument{graphb.ArgumentString("zone", zone)},
			},
		},
	})
}

func machineTypesQuery(zone string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name:      "machineTypes",
				Arguments: []graphb.Argument{graphb.ArgumentString("zone", zone)},
				Fields:    graphb.Fields("name", "guestCPUs", "memoryGB"),
			},
		},
	})
}

func machineTypeQuery(zone, machineType string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "machineType",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("zone", zone),
					graphb.ArgumentString("machineType", machineType),
				},
				Fields: graphb.Fields("name", "guestCPUs", "memoryGB"),
			},
		},
	})
}