package integration_test

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

	guuid "github.com/google/uuid"
	"github.com/udacity/graphb"
)

func (s *Suite) TestTenant() {
	var response struct {
		Tenant *model.Tenant
	}

	tenantEdgeID := guuid.New().String()
	orgID := guuid.New().String()
	orgName := guuid.New().String()
	_, err := s.DB.Exec("INSERT INTO tenants (tenant_edge_id, org_id, org_name) VALUES ($1, $2, $3);", tenantEdgeID, orgID, orgName)
	s.NoError(err)

	query := getTenantQuery(tenantEdgeID)
	ResolverClient.MustPost(query, &response, WithAuth(s.Resolver, orgID, s.Config.TestUsername, s.Config.TestPassword, string(model.RoleEdgeOrgAdmin)))
	s.NotNil(response.Tenant)

	s.Equal(tenantEdgeID, response.Tenant.TenantEdgeID)
	s.Equal(orgID, response.Tenant.TenantBSLId)
	s.Equal(orgName, response.Tenant.OrgName)

	if integration.IsIntegrationTest() {
		_, err := s.DB.Exec("DELETE FROM tenants WHERE tenant_edge_id = $1", tenantEdgeID)
		s.NoError(err)
	}
}

func (s *Suite) TestTenants() {
	var response struct {
		Tenants []*model.Tenant
	}

	tenantEdgeID := guuid.New().String()
	orgID := guuid.New().String()
	orgName := guuid.New().String()
	_, err := s.DB.Exec("INSERT INTO tenants (tenant_edge_id, org_id, org_name) VALUES ($1, $2, $3);", tenantEdgeID, orgID, orgName)
	s.NoError(err)

	query := getTenantsQuery()
	ResolverClient.MustPost(query, &response, WithAuth(s.Resolver, orgID, s.Config.TestUsername, s.Config.TestPassword, string(model.RoleEdgeOrgAdmin)))
	s.NotNil(response.Tenants)

	tenantExists := false
	for _, tenant := range response.Tenants {
		if tenant.TenantEdgeID == tenantEdgeID {
			tenantExists = true
			s.Equal(orgID, tenant.TenantBSLId)
			s.Equal(orgName, tenant.OrgName)
			break
		}
	}
	s.True(tenantExists)

	if integration.IsIntegrationTest() {
		_, err := s.DB.Exec("DELETE FROM tenants WHERE tenant_edge_id = $1", tenantEdgeID)
		s.NoError(err)
	}
}

func (s *Suite) TestGetOktaTenants() {
	testOktaToken := "test-okta-token"
	var response struct {
		TenantsForOktaToken []*model.Tenant
	}
	tenantsSeed := []struct {
		orgName string
		orgID   string
	}{
		{
			orgName: "test-bsl-org-1",
			orgID:   guuid.New().String(),
		},
		{
			orgName: "test-bsl-org-2",
			orgID:   guuid.New().String(),
		},
		{
			orgName: "test-bsl-org-3",
			orgID:   guuid.New().String(),
		},
	}
	for _, tenantSeed := range tenantsSeed {
		_, err := s.DB.Exec("INSERT INTO tenants (org_id, org_name) VALUES ($1, $2);", tenantSeed.orgID, tenantSeed.orgName)
		s.NoError(err)
	}
	query := getOktaTenantsQuery(testOktaToken)
	ResolverClient.MustPost(query, &response)
	s.NotNil(response.TenantsForOktaToken)
}

func getTenantQuery(tenantEdgeID string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "tenant",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("tenantEdgeId", tenantEdgeID),
				},
				Fields: graphb.Fields("orgName", "tenantBSLId", "tenantEdgeId"),
			},
		},
	})
}

func getTenantsQuery() string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name:   "tenants",
				Fields: graphb.Fields("orgName", "tenantBSLId", "tenantEdgeId"),
			},
		},
	})
}

func getOktaTenantsQuery(oktaToken string) string {
	return MustParse(graphb.Query{
		Type: graphb.TypeQuery,
		Fields: []*graphb.Field{
			{
				Name: "tenantsForOktaToken",
				Arguments: []graphb.Argument{
					graphb.ArgumentString("oktaToken", oktaToken),
				},
				Fields: graphb.Fields("orgName", "tenantBSLId", "tenantEdgeId"),
			},
		},
	})
}