package stackit_test

import (
	_ "embed"
	"fmt"
	"log/slog"
	"os"
	"regexp"
	"testing"

	"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
	"github.com/joho/godotenv"
	"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"
)

//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 setup() {
	err := godotenv.Load()
	if err != nil {
		slog.Info("could not find .env file - not loading .env")
		return
	}
	slog.Info("loaded .env file")

	testConfigProviderCredentials = config.Variables{
		"project_id":               config.StringVariable(os.Getenv("TF_ACC_PROJECT_ID")),
		"region":                   config.StringVariable(os.Getenv("TF_ACC_REGION")),
		"service_account_key_path": config.StringVariable(os.Getenv("TF_ACC_SERVICE_ACCOUNT_FILE")),
		"name": config.StringVariable(
			fmt.Sprintf(
				"tf-acc-prov%s",
				acctest.RandStringFromCharSet(3, acctest.CharSetAlphaNum),
			),
		),
	}
}

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

func TestAccEnvVarServiceAccountPathValid(t *testing.T) {
	// 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{
			{
				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) {
	// 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\.`),
			},
		},
	})
}