package stackit_test

import (
	"context"
	_ "embed"
	"os"
	"reflect"
	"regexp"
	"testing"

	"github.com/google/go-cmp/cmp"

	sqlserverflexalphaDatabase "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/database"

	//nolint:staticcheck // used for acceptance testing
	postgresFlexAlphaFlavor "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/flavor"

	"github.com/hashicorp/terraform-plugin-framework/datasource"
	tfResource "github.com/hashicorp/terraform-plugin-framework/resource"

	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit"
	postgresFlexAlphaDatabase "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/database"
	postgresflexalphaFlavors "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/flavors"
	postgresFlexAlphaInstance "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance"
	postgresFlexAlphaUser "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/user"
	sqlserverFlexAlphaInstance "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/instance"
	sqlserverFlexAlphaUser "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/user"
	sqlserverflexBetaDatabase "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/database"
	sqlserverFlexBetaInstance "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/instance"
	sqlserverFlexBetaUser "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/user"

	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/internal/testutils"

	"github.com/hashicorp/terraform-plugin-testing/config"
	"github.com/hashicorp/terraform-plugin-testing/helper/resource" //nolint:staticcheck // used for acceptance testing
)

//go:embed testdata/provider-credentials.tf
var providerCredentialConfig string

//go:embed testdata/provider-invalid-attribute.tf
var providerInvalidAttribute string

//go:embed testdata/provider-all-attributes.tf
var providerValidAttributes string

var testConfigProviderCredentials config.Variables

func TestMain(m *testing.M) {
	testutils.Setup()
	code := m.Run()
	// shutdown()
	os.Exit(code)
}

func TestUnitProviderHasChildDataSources_Basic(t *testing.T) {
	expectedDataSources := []datasource.DataSource{
		postgresFlexAlphaFlavor.NewFlavorDataSource(),
		// postgresFlexAlphaFlavor.NewFlavorListDataSource,
		postgresFlexAlphaDatabase.NewDatabaseDataSource(),
		postgresFlexAlphaInstance.NewInstanceDataSource(),
		postgresFlexAlphaUser.NewUserDataSource(),
		postgresflexalphaFlavors.NewFlavorsDataSource(),

		// sqlserverFlexAlphaFlavor.NewFlavorDataSource(),
		sqlserverFlexAlphaInstance.NewInstanceDataSource(),
		sqlserverFlexAlphaUser.NewUserDataSource(),
		sqlserverflexalphaDatabase.NewDatabaseDataSource(),

		sqlserverflexBetaDatabase.NewDatabaseDataSource(),
		sqlserverFlexBetaInstance.NewInstanceDataSource(),
		sqlserverFlexBetaUser.NewUserDataSource(),
		// sqlserverFlexBetaFlavor.NewFlavorDataSource(),
	}
	provider, ok := stackit.New("testing")().(*stackit.Provider)
	if !ok {
		t.Fatal("could not assert provider type")
	}
	datasources := provider.DataSources(context.Background())

	expectedMap := map[string]struct{}{}
	for _, d := range expectedDataSources {
		expectedMap[reflect.TypeOf(d).String()] = struct{}{}
	}

	actualMap := map[string]struct{}{}
	for _, d := range datasources {
		actualMap[reflect.TypeOf(d()).String()] = struct{}{}
	}

	if diff := cmp.Diff(expectedMap, actualMap); diff != "" {
		t.Errorf("DataSources mismatch (-expected +actual):\n%s", diff)
	}
}

func TestUnitProviderHasChildResources_Basic(t *testing.T) {
	expectedResources := []tfResource.Resource{
		postgresFlexAlphaInstance.NewInstanceResource(),
		postgresFlexAlphaUser.NewUserResource(),
		postgresFlexAlphaDatabase.NewDatabaseResource(),

		sqlserverFlexAlphaInstance.NewInstanceResource(),
		sqlserverFlexAlphaUser.NewUserResource(),
		sqlserverflexalphaDatabase.NewDatabaseResource(),

		sqlserverFlexBetaInstance.NewInstanceResource(),
		sqlserverFlexBetaUser.NewUserResource(),
		sqlserverflexBetaDatabase.NewDatabaseResource(),
	}
	provider, ok := stackit.New("testing")().(*stackit.Provider)
	if !ok {
		t.Fatal("could not assert provider type")
	}
	resources := provider.Resources(context.Background())

	expectedMap := map[string]struct{}{}
	for _, r := range expectedResources {
		expectedMap[reflect.TypeOf(r).String()] = struct{}{}
	}

	actualMap := map[string]struct{}{}
	for _, r := range resources {
		actualMap[reflect.TypeOf(r()).String()] = struct{}{}
	}

	if diff := cmp.Diff(expectedMap, actualMap); diff != "" {
		t.Errorf("Resources mismatch (-expected +actual):\n%s", diff)
	}
}

func TestAccEnvVarServiceAccountPathValid(t *testing.T) {
	t.Skip("needs refactoring")
	// Check if acceptance tests should be run
	if v := os.Getenv(resource.EnvTfAcc); v == "" {
		t.Skipf(
			"Acceptance tests skipped unless env '%s' set",
			resource.EnvTfAcc,
		)
		return
	}

	tempHomeFolder := testutils.CreateTemporaryHome(true, t)
	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
	resource.Test(
		t, resource.TestCase{
			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
			Steps: []resource.TestStep{
				{
					PreConfig:       func() { testutils.SetTemporaryHome(tempHomeFolder) },
					ConfigVariables: testConfigProviderCredentials,
					Config:          providerCredentialConfig,
				},
			},
		},
	)
}

func TestAccEnvVarServiceAccountPathInvalid(t *testing.T) {
	t.Skip("needs refactoring")
	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
	tempHomeFolder := testutils.CreateTemporaryHome(false, t)
	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
	resource.Test(
		t, resource.TestCase{
			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
			Steps: []resource.TestStep{
				{
					PreConfig:       func() { testutils.SetTemporaryHome(tempHomeFolder) },
					ConfigVariables: testConfigProviderCredentials,
					Config:          providerCredentialConfig,
					ExpectError:     regexp.MustCompile(`undefined response type, status code 401`),
				},
			},
		},
	)
}

func TestAccCredentialsFileValid(t *testing.T) {
	t.Skip("needs refactoring")
	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
	tempHomeFolder := testutils.CreateTemporaryHome(true, t)
	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
	resource.Test(
		t, resource.TestCase{
			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
			Steps: []resource.TestStep{
				{
					PreConfig:       func() { testutils.SetTemporaryHome(tempHomeFolder) },
					ConfigVariables: testConfigProviderCredentials,
					Config:          providerCredentialConfig,
				},
			},
		},
	)
}

func TestAccCredentialsFileInvalid(t *testing.T) {
	t.Skip("needs refactoring")
	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
	tempHomeFolder := testutils.CreateTemporaryHome(false, t)
	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
	resource.Test(
		t, resource.TestCase{
			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
			Steps: []resource.TestStep{
				{
					PreConfig:       func() { testutils.SetTemporaryHome(tempHomeFolder) },
					ConfigVariables: testConfigProviderCredentials,
					Config:          providerCredentialConfig,
					ExpectError:     regexp.MustCompile(`Jwt is not in(\r\n|\r|\n)the form of Header.Payload.Signature`),
				},
			},
		},
	)
}

func TestAccProviderConfigureValidValues(t *testing.T) {
	t.Skip("needs refactoring")
	// Check if acceptance tests should be run
	if v := os.Getenv(resource.EnvTfAcc); v == "" {
		t.Skipf(
			"Acceptance tests skipped unless env '%s' set",
			resource.EnvTfAcc,
		)
		return
	}
	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
	tempHomeFolder := testutils.CreateTemporaryHome(true, t)
	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
	resource.Test(
		t, resource.TestCase{
			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
			Steps: []resource.TestStep{
				{
					// valid provider attributes
					ConfigVariables: testConfigProviderCredentials,
					Config:          providerValidAttributes,
				},
			},
		},
	)
}

func TestAccProviderConfigureAnInvalidValue(t *testing.T) {
	t.Skip("needs refactoring")
	// Check if acceptance tests should be run
	if v := os.Getenv(resource.EnvTfAcc); v == "" {
		t.Skipf(
			"Acceptance tests skipped unless env '%s' set",
			resource.EnvTfAcc,
		)
		return
	}

	t.Setenv("STACKIT_CREDENTIALS_PATH", "")
	tempHomeFolder := testutils.CreateTemporaryHome(true, t)
	defer testutils.CleanupTemporaryHome(tempHomeFolder, t)
	resource.Test(
		t, resource.TestCase{
			ProtoV6ProviderFactories: testutils.TestAccProtoV6ProviderFactories,
			Steps: []resource.TestStep{
				{
					// invalid test attribute should throw an error
					ConfigVariables: testConfigProviderCredentials,
					Config:          providerInvalidAttribute,
					ExpectError:     regexp.MustCompile(`An argument named "test" is not expected here\.`),
				},
			},
		},
	)
}