package mapper

import (
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"
	corev1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime"
)

// Test ToSecrets
func TestToSecrets(t *testing.T) {
	secret1 := getTestSecret(testOrganization, "ssh-key", "secret1")
	secret2 := getTestSecret(testOrganization, "ssh-key", "secret2")

	secrets := []corev1.Secret{*secret1, *secret2}
	secretModels := ToSecrets(secrets)

	for i, secretModel := range secretModels {
		verifySecretEqualModel(&secrets[i], secretModel, t)
	}
}

// Test ToCreateSecretObject
func TestToCreateSecretObject(t *testing.T) {
	test, _ := ToCreateSecretObject("test-name", "test-namespace", testValsSuccess)
	actual, _ := ToCreateSecretObject("test-name", "test-namespace", testValsSuccess)
	verifySecretObjectEqualModel(test, actual, t)
}

// Test ToConvertSecretToUnstructured
func TestToConvertSecretToUnstructured(t *testing.T) {
	resource, _ := ToCreateSecretObject("test-name", "test-namespace", testValsSuccess)
	test, _ := ToTestConvertSecretToUnstructured(resource)
	actual, _ := ToConvertSecretToUnstructured(resource)
	assert.Equal(t, test, actual)
}

// Test ToConvertUnstructuredToSecret
func TestToConvertUnstructuredToSecret(t *testing.T) {
	test, _ := ToTestConvertUnstructuredToSecret(unstructarr)
	actual, _ := ToConvertUnstructuredToSecret(unstructarr)
	assert.Equal(t, test, actual)
}

// Test BuildSecret if isRedacted is true
func TestToBuildSecretRedactedTrue(t *testing.T) {
	model := BuildSecret(getSecret("test-namespace", "test", kubeconfig), "https://localhost", true)
	assert.Equal(t, model, fmt.Sprintf(sMock, "********"))
}

// Test BuildSecret if isRedacted is false
func TestToBuildSecretRedactedFalse(t *testing.T) {
	model := BuildSecret(getSecret("test-namespace", "test", kubeconfig), "https://localhost", false)
	assert.Equal(t, model, fmt.Sprintf(sMock, ""))
}

func ToTestConvertUnstructuredToSecret(resources *unstructured.UnstructuredList) ([]corev1.Secret, error) {
	resp := make([]corev1.Secret, 0)
	for _, item := range resources.Items {
		converted := &corev1.Secret{}
		err := runtime.DefaultUnstructuredConverter.
			FromUnstructured(item.UnstructuredContent(), &converted)
		if err != nil {
			return nil, err
		}
		resp = append(resp, *converted)
	}
	return resp, nil
}

func ToTestConvertSecretToUnstructured(secret *corev1.Secret) (*unstructured.Unstructured, error) {
	converted, err := runtime.DefaultUnstructuredConverter.ToUnstructured(secret)
	if err != nil {
		return nil, err
	}

	return &unstructured.Unstructured{Object: converted}, nil
}