package settings

import (
	"encoding/base64"
	"os"
	"path/filepath"
	"testing"
)

func TestResolveDirDefault(t *testing.T) {
	t.Setenv(ConfigDirEnvVar, "")

	resolved, err := ResolveDir("")
	if err != nil {
		t.Fatalf("ResolveDir: %v", err)
	}
	if resolved != DefaultConfigDir {
		t.Fatalf("got %q, want %q", resolved, DefaultConfigDir)
	}
}

func TestResolveDirFlagOverridesEnv(t *testing.T) {
	tempDir := t.TempDir()
	flagDir := filepath.Join(tempDir, "from-flag")
	envDir := filepath.Join(tempDir, "from-env")
	t.Setenv(ConfigDirEnvVar, envDir)

	resolved, err := ResolveDir(flagDir)
	if err != nil {
		t.Fatalf("ResolveDir: %v", err)
	}
	if resolved != flagDir {
		t.Fatalf("got %q, want flag dir %q", resolved, flagDir)
	}
}

func TestResolveDirEnvOverridesDefault(t *testing.T) {
	tempDir := t.TempDir()
	envDir := filepath.Join(tempDir, "from-env")
	t.Setenv(ConfigDirEnvVar, envDir)

	resolved, err := ResolveDir("")
	if err != nil {
		t.Fatalf("ResolveDir: %v", err)
	}
	if resolved != envDir {
		t.Fatalf("got %q, want env dir %q", resolved, envDir)
	}
}

func TestResolveDirExpandsTilde(t *testing.T) {
	homeDirectory, err := os.UserHomeDir()
	if err != nil {
		t.Fatalf("UserHomeDir: %v", err)
	}
	t.Setenv(ConfigDirEnvVar, "")

	resolved, err := ResolveDir("~/myconfigs")
	if err != nil {
		t.Fatalf("ResolveDir: %v", err)
	}
	want := filepath.Join(homeDirectory, "myconfigs")
	if resolved != want {
		t.Fatalf("got %q, want %q", resolved, want)
	}
}

func TestSettingsRoundTrip(t *testing.T) {
	dir := t.TempDir()
	original := Settings{LogLevel: "debug"}

	if err := SaveSettings(dir, original); err != nil {
		t.Fatalf("SaveSettings: %v", err)
	}

	loaded, err := LoadSettings(dir)
	if err != nil {
		t.Fatalf("LoadSettings: %v", err)
	}
	if loaded.LogLevel != original.LogLevel {
		t.Fatalf("got log_level %q, want %q", loaded.LogLevel, original.LogLevel)
	}
}

func testKey(t *testing.T) []byte {
	t.Helper()
	key := make([]byte, 32)
	for index := range key {
		key[index] = byte(index + 1)
	}
	return key
}

func TestSecretsRoundTrip(t *testing.T) {
	dir := t.TempDir()
	key := testKey(t)
	original := Secrets{}

	if err := SaveSecrets(dir, original, key); err != nil {
		t.Fatalf("SaveSecrets: %v", err)
	}

	loaded, err := LoadSecrets(dir, key)
	if err != nil {
		t.Fatalf("LoadSecrets: %v", err)
	}
	_ = loaded
}

func TestSecretsWrongKeyFails(t *testing.T) {
	dir := t.TempDir()
	goodKey := testKey(t)
	if err := SaveSecrets(dir, Secrets{}, goodKey); err != nil {
		t.Fatalf("SaveSecrets: %v", err)
	}

	badKey := make([]byte, 32)
	for index := range badKey {
		badKey[index] = 0xff
	}

	if _, err := LoadSecrets(dir, badKey); err == nil {
		t.Fatal("expected decrypt failure with wrong key")
	}
}

func TestKeyFromEnvMissing(t *testing.T) {
	t.Setenv(ConfigKeyEnvVar, "")
	if _, err := KeyFromEnv(); err == nil {
		t.Fatal("expected error when key env is unset")
	}
}

func TestKeyFromEnvValid(t *testing.T) {
	key := testKey(t)
	t.Setenv(ConfigKeyEnvVar, base64.StdEncoding.EncodeToString(key))

	decoded, err := KeyFromEnv()
	if err != nil {
		t.Fatalf("KeyFromEnv: %v", err)
	}
	if len(decoded) != 32 {
		t.Fatalf("got key length %d, want 32", len(decoded))
	}
}

func TestKeyFromEnvInvalidLength(t *testing.T) {
	t.Setenv(ConfigKeyEnvVar, base64.StdEncoding.EncodeToString([]byte("short")))
	if _, err := KeyFromEnv(); err == nil {
		t.Fatal("expected error for invalid key length")
	}
}