package config_test

import (
	"fmt"
	"os"
	"path"
	"reflect"
	"strings"
	"testing"

	"coopcloud.tech/abra/pkg/config"
	"coopcloud.tech/abra/pkg/recipe"
)

var TestFolder = os.ExpandEnv("$PWD/../../tests/resources/test_folder")
var ValidAbraConf = os.ExpandEnv("$PWD/../../tests/resources/valid_abra_config")

// make sure these are in alphabetical order
var TFolders = []string{"folder1", "folder2"}
var TFiles = []string{"bar.env", "foo.env"}

var AppName = "ecloud"
var ServerName = "evil.corp"

var ExpectedAppEnv = config.AppEnv{
	"DOMAIN": "ecloud.evil.corp",
	"RECIPE": "ecloud",
}

var ExpectedApp = config.App{
	Name:   AppName,
	Recipe: ExpectedAppEnv["RECIPE"],
	Domain: ExpectedAppEnv["DOMAIN"],
	Env:    ExpectedAppEnv,
	Path:   ExpectedAppFile.Path,
	Server: ExpectedAppFile.Server,
}

var ExpectedAppFile = config.AppFile{
	Path:   path.Join(ValidAbraConf, "servers", ServerName, AppName+".env"),
	Server: ServerName,
}

var ExpectedAppFiles = map[string]config.AppFile{
	AppName: ExpectedAppFile,
}

func TestGetAllFoldersInDirectory(t *testing.T) {
	folders, err := config.GetAllFoldersInDirectory(TestFolder)
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(folders, TFolders) {
		t.Fatalf("did not get expected folders. Expected: (%s), Got: (%s)", strings.Join(TFolders, ","), strings.Join(folders, ","))
	}
}

func TestGetAllFilesInDirectory(t *testing.T) {
	files, err := config.GetAllFilesInDirectory(TestFolder)
	if err != nil {
		t.Fatal(err)
	}
	var fileNames []string
	for _, file := range files {
		fileNames = append(fileNames, file.Name())
	}
	if !reflect.DeepEqual(fileNames, TFiles) {
		t.Fatalf("did not get expected files. Expected: (%s), Got: (%s)", strings.Join(TFiles, ","), strings.Join(fileNames, ","))
	}
}

func TestReadEnv(t *testing.T) {
	env, err := config.ReadEnv(ExpectedAppFile.Path)
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(env, ExpectedAppEnv) {
		t.Fatalf(
			"did not get expected application settings. Expected: DOMAIN=%s RECIPE=%s; Got: DOMAIN=%s RECIPE=%s",
			ExpectedAppEnv["DOMAIN"],
			ExpectedAppEnv["RECIPE"],
			env["DOMAIN"],
			env["RECIPE"],
		)
	}
}

func TestReadAbraShEnvVars(t *testing.T) {
	offline := true
	r, err := recipe.Get("abra-test-recipe", offline)
	if err != nil {
		t.Fatal(err)
	}

	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, r.Name, "abra.sh")
	abraShEnv, err := config.ReadAbraShEnvVars(abraShPath)
	if err != nil {
		t.Fatal(err)
	}

	if len(abraShEnv) == 0 {
		t.Error("at least one env var should be exported")
	}

	if _, ok := abraShEnv["INNER_FOO"]; ok {
		t.Error("INNER_FOO should not be exported")
	}

	if _, ok := abraShEnv["INNER_BAZ"]; ok {
		t.Error("INNER_BAZ should not be exported")
	}

	if _, ok := abraShEnv["OUTER_FOO"]; !ok {
		t.Error("OUTER_FOO should be exported")
	}
}