package integration_test

import (
	"fmt"

	"github.com/udacity/graphb"

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

func (s *Suite) TestCreateNamespace() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateNamespace *model.Namespace }

	createNamespace := model.NamespaceCreateInput{
		BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a102",
		Name:         "test-namespace-A",
		Workload:     model.WorkloadTypeTenant,
	}

	mutation := createNamespaceMutation(&createNamespace)

	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "error resolving namespace mutation")

	s.NotNilf(response.CreateNamespace, "returned namespace is null")
	namespace := response.CreateNamespace
	s.Equal(createNamespace.BannerEdgeID, namespace.BannerEdgeID)
	s.Equal(createNamespace.Name, namespace.Name)
	s.Equal(createNamespace.Workload, namespace.Workload)

	args := []interface{}{
		createNamespace.BannerEdgeID,
		createNamespace.Name,
	}
	_, err = s.DB.Exec(sqlquery.NamespaceDeleteQuery, args...)
	s.NoError(err)
}

func (s *Suite) TestCreateNamespaceInvalidBanner() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateNamespace *model.Namespace }

	createNamespace := model.NamespaceCreateInput{
		BannerEdgeID: "banner",
		Name:         "some-namespace",
		Workload:     model.WorkloadTypeTenant,
	}

	mutation := createNamespaceMutation(&createNamespace)

	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "no error resolving namespace mutation")
	s.Nilf(response.CreateNamespace, "returned namespace is not null")
}

func (s *Suite) TestCreateNamespaceInvalidName() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateNamespace *model.Namespace }

	createNamespace := model.NamespaceCreateInput{
		BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a102",
		Name:         "",
		Workload:     model.WorkloadTypeTenant,
	}

	mutation := createNamespaceMutation(&createNamespace)

	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "no error resolving namespace mutation")
	s.Nilf(response.CreateNamespace, "returned namespace is not null")
}

func (s *Suite) TestCreateNamespaceExistingNameOnBanner() {
	integration.SkipIf(s.Framework)
	var response struct{ CreateNamespace *model.Namespace }

	createNamespace := model.NamespaceCreateInput{
		BannerEdgeID: "3396a52c-6a22-4049-9593-5a63b596a101",
		Name:         "test-namespace",
		Workload:     model.WorkloadTypeTenant,
	}

	mutation := createNamespaceMutation(&createNamespace)

	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "no error resolving namespace mutation")
	s.Nilf(response.CreateNamespace, "returned namespace is not null")
}

func (s *Suite) TestDeleteNamespace() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteNamespace bool }
	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101" //nolint
	name := "delete-namespace"
	mutation := deleteNamespaceMutation(bannerEdgeID, name)
	err := ResolverClient.Post(mutation, &response)
	s.NoErrorf(err, "resolver failed for delete namespace")
	s.Truef(response.DeleteNamespace, "resolver returned false for delete namespace")
}

// test deleting a namespace with clusters using it
func (s *Suite) TestDeleteNamespaceInUse() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteNamespace bool }
	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101" //nolint
	name := "delete-namespace-1"
	mutation := deleteNamespaceMutation(bannerEdgeID, name)
	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "resolver didn't fail for delete namespace")
	s.Falsef(response.DeleteNamespace, "resolver didn't return false for delete namespace")
}

// test deleting a namespace that doesn't exist (real bannerEdgeId, fake name)
func (s *Suite) TestDeleteNamespaceFakeOne() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteNamespace bool }
	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
	name := "fake-namespace"
	mutation := deleteNamespaceMutation(bannerEdgeID, name)
	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "resolver didn't fail for delete namespace (1)")
	s.False(response.DeleteNamespace, "resolver didn't return false for delete namespace (1)")
}

// test deleting a namespace that doesn't exist (fake bannerEdgeId, real name)
func (s *Suite) TestDeleteNamespaceFakeTwo() {
	integration.SkipIf(s.Framework)
	var response struct{ DeleteNamespace bool }
	bannerEdgeID := "ff2874b4-b9b1-4514-a2b0-58482f3d54fa"
	name := "delete-namespace"
	mutation := deleteNamespaceMutation(bannerEdgeID, name)
	err := ResolverClient.Post(mutation, &response)
	s.Errorf(err, "resolver didn't fail for delete namespace (2)")
	s.Falsef(response.DeleteNamespace, "resolver didn't return false for delete namespace (2)")
}

// get namespaces by bannerEdgeId and name
func (s *Suite) TestGetBannerNamespaces() {
	integration.SkipIf(s.Framework)
	var response struct{ BannerNamespaces []*model.Namespace }
	bannerEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
	name := "test-namespace"
	query := getBannerNamespacesQuery(bannerEdgeID, &name)
	err := ResolverClient.Post(query, &response)

	s.NoErrorf(err, "resolver failed for get namespaces by bannerEdgeID and name")
	s.NotNilf(response.BannerNamespaces, "resolver response nil for get namespaces by bannerEdgeID and name")
	s.Equalf(1, len(response.BannerNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID and name")
	s.Equalf("31d51d8c-b580-4e1a-94f6-a970bae8c132", response.BannerNamespaces[0].NamespaceEdgeID, "returned namespaceEdgeId incorrect")
}

// get namespaces by bannerEdgeId
func (s *Suite) TestGetAllBannerNamespaces() {
	integration.SkipIf(s.Framework)
	var response struct{ BannerNamespaces []*model.Namespace }
	bannerEdgeID := "98ef1fcb-dc88-4c9f-9980-c09a04564a48"
	query := getBannerNamespacesQuery(bannerEdgeID, nil)
	err := ResolverClient.Post(query, &response)

	s.NoErrorf(err, "resolver failed for get namespaces by bannerEdgeID")
	s.NotNilf(response.BannerNamespaces, "resolver response nil for get namespaces by bannerEdgeID")
	s.Equalf(2, len(response.BannerNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID")
}

// get namespaces by clusterEdgeId and namespace name
func (s *Suite) TestGetClusterNamespaces() {
	integration.SkipIf(s.Framework)
	var response struct{ ClusterNamespaces []*model.Namespace }
	clusterEdgeID := "3396a52c-6a22-4049-9593-5a63b596a101"
	name := "test-namespace"
	query := getClusterNamespacesQuery(clusterEdgeID, &name)
	err := ResolverClient.Post(query, &response)

	s.NoErrorf(err, "resolver failed for get namespaces by clusterEdgeID and name")
	s.NotNilf(response.ClusterNamespaces, "resolver response nil for get namespaces by clusterEdgeID and name")
	s.Equalf(1, len(response.ClusterNamespaces), "resolver response != 1 for get namespaces by clusterEdgeID and name")
	s.Equalf("31d51d8c-b580-4e1a-94f6-a970bae8c132", response.ClusterNamespaces[0].NamespaceEdgeID, "returned clusterNamespaceEdgeId incorrect")
}

// get namespaces by clusterEdgeId
func (s *Suite) TestGetAllClusterNamespaces() {
	integration.SkipIf(s.Framework)
	var response struct{ ClusterNamespaces []*model.Namespace }
	clusterEdgeID := "6e04c043-89ca-4dc2-a2ea-4605dbdd4c65"
	query := getClusterNamespacesQuery(clusterEdgeID, nil)
	err := ResolverClient.Post(query, &response)

	s.NoErrorf(err, "resolver failed for get namespaces by clusterEdgeID")
	s.NotNilf(response.ClusterNamespaces, "resolver response nil for get namespaces by bannerEdgeID")
	s.Equalf(2, len(response.ClusterNamespaces), "resolver response != 2 for get namespaces by bannerEdgeID")
}

func createNamespaceMutation(createNamespace *model.NamespaceCreateInput) string {
	return fmt.Sprintf(
		"mutation{createNamespace(createNamespace:{bannerEdgeId:\"%s\",name:\"%s\",workload:%s}){namespaceEdgeId,bannerEdgeId,name,workload}}",
		createNamespace.BannerEdgeID, createNamespace.Name, createNamespace.Workload.String(),
	)
}

func deleteNamespaceMutation(bannerEdgeID string, name string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeMutation,
		Fields: []*graphb.Field{
			{
				Name: "deleteNamespace",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
					graphb.ArgumentString("name", name),
				},
			},
		},
	})
}

func getBannerNamespacesQuery(bannerEdgeID string, name *string) string {
	getNamespacesArg := []graphb.Argument{
		graphb.ArgumentString("bannerEdgeId", bannerEdgeID),
	}
	if name != nil {
		getNamespacesArg = append(getNamespacesArg, graphb.ArgumentString("name", *name))
	}
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name:      "bannerNamespaces",
				Arguments: getNamespacesArg,
				Fields:    namespaceFields,
			},
		},
	})
}

func getClusterNamespacesQuery(clusterEdgeID string, name *string) string {
	getClusterNamespacesArg := []graphb.Argument{
		graphb.ArgumentString("clusterEdgeId", clusterEdgeID),
	}
	if name != nil {
		getClusterNamespacesArg = append(getClusterNamespacesArg, graphb.ArgumentString("name", *name))
	}
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name:      "clusterNamespaces",
				Arguments: getClusterNamespacesArg,
				Fields:    namespaceFields,
			},
		},
	})
}

var namespaceFields = []*graphb.Field{
	{
		Name: "namespaceEdgeId",
	},
	{
		Name: "bannerEdgeId",
	},
	{
		Name: "name",
	},
	{
		Name: "workload",
	},
}