package utils

import (
	"os"
	"testing"
	"time"
)

func TestFormatTime(t *testing.T) {
	testTime := time.Date(2024, 8, 20, 15, 30, 45, 0, time.UTC)
	expected := "2024-08-20T15:30:45Z"
	
	result := FormatTime(testTime)
	
	if result != expected {
		t.Errorf("FormatTime() = %v, want %v", result, expected)
	}
}

func TestGetEnvOrDefault(t *testing.T) {
	tests := []struct {
		name         string
		key          string
		envValue     string
		defaultValue string
		expected     string
		setEnv       bool
	}{
		{
			name:         "Environment variable exists",
			key:          "TEST_VAR_EXISTS",
			envValue:     "env_value",
			defaultValue: "default_value",
			expected:     "env_value",
			setEnv:       true,
		},
		{
			name:         "Environment variable doesn't exist",
			key:          "TEST_VAR_NOT_EXISTS",
			defaultValue: "default_value",
			expected:     "default_value",
			setEnv:       false,
		},
		{
			name:         "Environment variable is empty string",
			key:          "TEST_VAR_EMPTY",
			envValue:     "",
			defaultValue: "default_value",
			expected:     "default_value",
			setEnv:       true,
		},
		{
			name:         "Environment variable has whitespace",
			key:          "TEST_VAR_WHITESPACE",
			envValue:     "   value   ",
			defaultValue: "default_value",
			expected:     "   value   ",
			setEnv:       true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Clean up environment
			os.Unsetenv(tt.key)
			
			// Set environment variable if needed
			if tt.setEnv {
				os.Setenv(tt.key, tt.envValue)
				defer os.Unsetenv(tt.key)
			}
			
			result := GetEnvOrDefault(tt.key, tt.defaultValue)
			
			if result != tt.expected {
				t.Errorf("GetEnvOrDefault(%q, %q) = %v, want %v", tt.key, tt.defaultValue, result, tt.expected)
			}
		})
	}
}

func TestGetEnvOrDefaultInt(t *testing.T) {
	tests := []struct {
		name         string
		key          string
		envValue     string
		defaultValue int
		expected     int
		setEnv       bool
	}{
		{
			name:         "Valid integer environment variable",
			key:          "TEST_INT_VALID",
			envValue:     "42",
			defaultValue: 10,
			expected:     42,
			setEnv:       true,
		},
		{
			name:         "Invalid integer environment variable",
			key:          "TEST_INT_INVALID",
			envValue:     "not_a_number",
			defaultValue: 10,
			expected:     10,
			setEnv:       true,
		},
		{
			name:         "Environment variable doesn't exist",
			key:          "TEST_INT_NOT_EXISTS",
			defaultValue: 10,
			expected:     10,
			setEnv:       false,
		},
		{
			name:         "Negative integer",
			key:          "TEST_INT_NEGATIVE",
			envValue:     "-123",
			defaultValue: 10,
			expected:     -123,
			setEnv:       true,
		},
		{
			name:         "Zero value",
			key:          "TEST_INT_ZERO",
			envValue:     "0",
			defaultValue: 10,
			expected:     0,
			setEnv:       true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Clean up environment
			os.Unsetenv(tt.key)
			
			// Set environment variable if needed
			if tt.setEnv {
				os.Setenv(tt.key, tt.envValue)
				defer os.Unsetenv(tt.key)
			}
			
			result := GetEnvOrDefaultInt(tt.key, tt.defaultValue)
			
			if result != tt.expected {
				t.Errorf("GetEnvOrDefaultInt(%q, %d) = %v, want %v", tt.key, tt.defaultValue, result, tt.expected)
			}
		})
	}
}

func TestGetEnvOrDefaultBool(t *testing.T) {
	tests := []struct {
		name         string
		key          string
		envValue     string
		defaultValue bool
		expected     bool
		setEnv       bool
	}{
		{
			name:         "True boolean",
			key:          "TEST_BOOL_TRUE",
			envValue:     "true",
			defaultValue: false,
			expected:     true,
			setEnv:       true,
		},
		{
			name:         "False boolean",
			key:          "TEST_BOOL_FALSE",
			envValue:     "false",
			defaultValue: true,
			expected:     false,
			setEnv:       true,
		},
		{
			name:         "1 as true",
			key:          "TEST_BOOL_ONE",
			envValue:     "1",
			defaultValue: false,
			expected:     true,
			setEnv:       true,
		},
		{
			name:         "0 as false",
			key:          "TEST_BOOL_ZERO",
			envValue:     "0",
			defaultValue: true,
			expected:     false,
			setEnv:       true,
		},
		{
			name:         "Invalid boolean",
			key:          "TEST_BOOL_INVALID",
			envValue:     "maybe",
			defaultValue: true,
			expected:     true,
			setEnv:       true,
		},
		{
			name:         "Environment variable doesn't exist",
			key:          "TEST_BOOL_NOT_EXISTS",
			defaultValue: false,
			expected:     false,
			setEnv:       false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Clean up environment
			os.Unsetenv(tt.key)
			
			// Set environment variable if needed
			if tt.setEnv {
				os.Setenv(tt.key, tt.envValue)
				defer os.Unsetenv(tt.key)
			}
			
			result := GetEnvOrDefaultBool(tt.key, tt.defaultValue)
			
			if result != tt.expected {
				t.Errorf("GetEnvOrDefaultBool(%q, %v) = %v, want %v", tt.key, tt.defaultValue, result, tt.expected)
			}
		})
	}
}

func TestGetEnvOrDefaultDuration(t *testing.T) {
	tests := []struct {
		name         string
		key          string
		envValue     string
		defaultValue time.Duration
		expected     time.Duration
		setEnv       bool
	}{
		{
			name:         "Valid duration in seconds",
			key:          "TEST_DURATION_SECONDS",
			envValue:     "30s",
			defaultValue: 10 * time.Second,
			expected:     30 * time.Second,
			setEnv:       true,
		},
		{
			name:         "Valid duration in minutes",
			key:          "TEST_DURATION_MINUTES",
			envValue:     "5m",
			defaultValue: 1 * time.Minute,
			expected:     5 * time.Minute,
			setEnv:       true,
		},
		{
			name:         "Valid duration in hours",
			key:          "TEST_DURATION_HOURS",
			envValue:     "2h",
			defaultValue: 1 * time.Hour,
			expected:     2 * time.Hour,
			setEnv:       true,
		},
		{
			name:         "Invalid duration format",
			key:          "TEST_DURATION_INVALID",
			envValue:     "not_a_duration",
			defaultValue: 10 * time.Second,
			expected:     10 * time.Second,
			setEnv:       true,
		},
		{
			name:         "Environment variable doesn't exist",
			key:          "TEST_DURATION_NOT_EXISTS",
			defaultValue: 5 * time.Minute,
			expected:     5 * time.Minute,
			setEnv:       false,
		},
		{
			name:         "Complex duration",
			key:          "TEST_DURATION_COMPLEX",
			envValue:     "1h30m45s",
			defaultValue: 1 * time.Second,
			expected:     1*time.Hour + 30*time.Minute + 45*time.Second,
			setEnv:       true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Clean up environment
			os.Unsetenv(tt.key)
			
			// Set environment variable if needed
			if tt.setEnv {
				os.Setenv(tt.key, tt.envValue)
				defer os.Unsetenv(tt.key)
			}
			
			result := GetEnvOrDefaultDuration(tt.key, tt.defaultValue)
			
			if result != tt.expected {
				t.Errorf("GetEnvOrDefaultDuration(%q, %v) = %v, want %v", tt.key, tt.defaultValue, result, tt.expected)
			}
		})
	}
}

func TestMustGetEnv(t *testing.T) {
	t.Run("Environment variable exists", func(t *testing.T) {
		key := "TEST_MUST_EXISTS"
		value := "required_value"
		
		os.Setenv(key, value)
		defer os.Unsetenv(key)
		
		result := MustGetEnv(key)
		
		if result != value {
			t.Errorf("MustGetEnv(%q) = %v, want %v", key, result, value)
		}
	})
	
	t.Run("Environment variable doesn't exist - should panic", func(t *testing.T) {
		key := "TEST_MUST_NOT_EXISTS"
		
		// Ensure the environment variable doesn't exist
		os.Unsetenv(key)
		
		defer func() {
			if r := recover(); r == nil {
				t.Errorf("MustGetEnv(%q) should have panicked but didn't", key)
			} else {
				expectedMsg := "Required environment variable not set: " + key
				if r != expectedMsg {
					t.Errorf("MustGetEnv(%q) panic message = %v, want %v", key, r, expectedMsg)
				}
			}
		}()
		
		MustGetEnv(key)
	})
	
	t.Run("Environment variable is empty - should panic", func(t *testing.T) {
		key := "TEST_MUST_EMPTY"
		
		os.Setenv(key, "")
		defer os.Unsetenv(key)
		
		defer func() {
			if r := recover(); r == nil {
				t.Errorf("MustGetEnv(%q) should have panicked for empty value but didn't", key)
			}
		}()
		
		MustGetEnv(key)
	})
}

func TestIsEnvSet(t *testing.T) {
	tests := []struct {
		name     string
		key      string
		envValue string
		expected bool
		setEnv   bool
	}{
		{
			name:     "Environment variable exists with value",
			key:      "TEST_IS_SET_VALUE",
			envValue: "some_value",
			expected: true,
			setEnv:   true,
		},
		{
			name:     "Environment variable exists but empty",
			key:      "TEST_IS_SET_EMPTY",
			envValue: "",
			expected: true,
			setEnv:   true,
		},
		{
			name:     "Environment variable doesn't exist",
			key:      "TEST_IS_SET_NOT_EXISTS",
			expected: false,
			setEnv:   false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Clean up environment
			os.Unsetenv(tt.key)
			
			// Set environment variable if needed
			if tt.setEnv {
				os.Setenv(tt.key, tt.envValue)
				defer os.Unsetenv(tt.key)
			}
			
			result := IsEnvSet(tt.key)
			
			if result != tt.expected {
				t.Errorf("IsEnvSet(%q) = %v, want %v", tt.key, result, tt.expected)
			}
		})
	}
}

// BenchmarkGetEnvOrDefault benchmarks the GetEnvOrDefault function
func BenchmarkGetEnvOrDefault(b *testing.B) {
	key := "BENCHMARK_TEST_VAR"
	value := "benchmark_value"
	defaultValue := "default_value"
	
	os.Setenv(key, value)
	defer os.Unsetenv(key)
	
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		GetEnvOrDefault(key, defaultValue)
	}
}

// BenchmarkGetEnvOrDefaultInt benchmarks the GetEnvOrDefaultInt function
func BenchmarkGetEnvOrDefaultInt(b *testing.B) {
	key := "BENCHMARK_TEST_INT_VAR"
	value := "42"
	defaultValue := 10
	
	os.Setenv(key, value)
	defer os.Unsetenv(key)
	
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		GetEnvOrDefaultInt(key, defaultValue)
	}
}