package integration_test

import (
	"context"
	"database/sql"
	"errors"
	"flag"
	"fmt"
	"log"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"edge-infra.dev/pkg/edge/api/graph/model"
	"edge-infra.dev/pkg/edge/api/graph/resolver"
	testApi "edge-infra.dev/pkg/edge/api/graph/test"
	"edge-infra.dev/pkg/edge/api/sql/utils"
	"edge-infra.dev/pkg/edge/api/types"
	"edge-infra.dev/test/framework"
	"edge-infra.dev/test/framework/integration"

	gqlclient "github.com/99designs/gqlgen/client"
	"github.com/golang/mock/gomock"
	"github.com/joho/godotenv"
	"github.com/stretchr/testify/suite"
	"github.com/udacity/graphb"
	"google.golang.org/api/option"
	"k8s.io/apimachinery/pkg/util/wait"
	"k8s.io/client-go/util/retry"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

var (
	cfg            = &types.TestConfig{}
	err            error
	ResolverClient GraphqlClient

	testOrg                = "test-org"
	testRootOrg            = "/bsl-root/test-org/"
	testRegion             = "region-infra"
	testClusterNumNodes    = 3
	testClusterVersion     = "1.21.4-gke.2300"
	testClusterZone        = "us-east1-b"
	testClusterMachineType = "n1-standard-4"
	testUser               = "acct:emerald-edge-dev@testing"
	testEmail              = "jd250001@ncr.com"
	testUserName           = "testing"
	testUsername           = "emerald-edge-dev"

	testSiteID  = "test-site-id"
	badCluster  = "bad-cluster"
	projectID   = "test-project"
	testStore   = "test-store"
	testStoreID = "test-store-id"
	//testSyncType           = "flux"
	testLocation = "us-east1-b"
	testUserRole = "EDGE_ORG_ADMIN"

	jwtSecret      = "test-secret"
	totpSecret     = "totp-secret"
	superAdminRole = string(model.RoleEdgeOrgAdmin)
	edgeLeadsRole  = string(model.RoleEdgeEngineeringLeads)
	adminRole      = string(model.RoleEdgeBannerAdmin)

	errResourceNotYetReady = errors.New("resource not yet ready")
	defaultRetry           wait.Backoff // this share and configure by unit and integration tests

	testHelmRepoURL        = "https://charts.bitnami.com/bitnami"
	testHelmRepo           = "bitnami"
	testHelmChart          = "nginx"
	testHelmVersion        = "0.0.1"
	testHelmSecret         = "bitnami"
	testHelmUpdatedVersion = "0.02"
)

func TestMain(m *testing.M) {
	_ = godotenv.Load(filepath.Join("pkg", "edge", "api", "graph", "resolver", ".env"))
	flags := flag.NewFlagSet("ee-bff-golang", flag.ContinueOnError)
	cfg.BindFlags(flags)
	cfg.Config.BindKubeConfigFlag(flags)
	framework.HandleFlags()
	testApi.SetupBaseStructure(cfg)
	os.Exit(m.Run())
}

type Suite struct {
	*framework.Framework
	client        client.Client
	ctx           context.Context
	projectID     string
	testBannerEU  *utils.Banner
	testTime      string
	ChariotClient option.ClientOption
	Resolver      *resolver.Resolver
	DB            *sql.DB
	Config        *types.TestConfig
}

func TestResolversFramework(t *testing.T) {
	var s *Suite
	if integration.IsIntegrationTest() {
		s, err = setupIntegrationTest(cfg)
		if err != nil {
			t.Fatal(err)
		}
	} else {
		MockCtrl = gomock.NewController(t)
		s, err = setupUnitTest(cfg)
		if err != nil {
			t.Fatal(err)
		}
	}

	suite.Run(t, s)

	t.Cleanup(func() {
		if !integration.IsIntegrationTest() {
			cleanupUnitTest()
		}
	})
}

func MustParse(q graphb.Query) string {
	query, err := q.StringChan()
	if err != nil {
		log.Fatal(err)
	}
	return graphb.StringFromChan(query)
}

// SetHeader set a header to the outgoing request. This is useful for setting expected Authentication headers for example.
func SetHeader(key string, value string) gqlclient.Option {
	return func(bd *gqlclient.Request) {
		bd.HTTP.Header.Set(key, value)
	}
}

func isRetryable(err error) bool {
	// waiting for secrets to sync
	if strings.Contains(err.Error(), "is forbidden") ||
		strings.Contains(err.Error(), "connection refused") ||
		strings.Contains(err.Error(), "timeout") ||
		strings.Contains(err.Error(), "timed out") ||
		strings.Contains(err.Error(), "try again") ||
		strings.Contains(err.Error(), "502") ||
		strings.Contains(err.Error(), "an error on the server") ||
		strings.Contains(err.Error(), "client connection lost") {
		return true
	}
	return err == errResourceNotYetReady
}

func GraphqlRetry(query string, response interface{}, isReady func() bool) error {
	return graphqlRetry(defaultRetry, query, response, isReady)
}

func graphqlRetry(backOff wait.Backoff, query string, response interface{}, isReady func() bool) error {
	return retry.OnError(backOff, isRetryable, func() error {
		if err := ResolverClient.Post(query, response); err != nil {
			fmt.Printf("failed to retry for: %s\n %v\n", query, err)
			return err
		}
		if isReady() {
			return nil
		}
		return errResourceNotYetReady
	})
}