package config

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

func TestPlaylistPath(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected string
	}{
		{"default", "", "/app/playlist/playlist.txt"},
		{"custom", "/custom/playlist.txt", "/custom/playlist.txt"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("PLAYLIST_PATH", tt.env)
				defer os.Unsetenv("PLAYLIST_PATH")
			} else {
				os.Unsetenv("PLAYLIST_PATH")
			}
			if got := PlaylistPath(); got != tt.expected {
				t.Errorf("PlaylistPath() = %q, want %q", got, tt.expected)
			}
		})
	}
}

func TestMediaDir(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected string
	}{
		{"default", "", "/app/media"},
		{"custom", "/data/media", "/data/media"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("MEDIA_DIR", tt.env)
				defer os.Unsetenv("MEDIA_DIR")
			} else {
				os.Unsetenv("MEDIA_DIR")
			}
			if got := MediaDir(); got != tt.expected {
				t.Errorf("MediaDir() = %q, want %q", got, tt.expected)
			}
		})
	}
}

func TestAdminUsername(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected string
	}{
		{"default", "", "admin"},
		{"custom", "superadmin", "superadmin"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("ADMIN_USERNAME", tt.env)
				defer os.Unsetenv("ADMIN_USERNAME")
			} else {
				os.Unsetenv("ADMIN_USERNAME")
			}
			if got := AdminUsername(); got != tt.expected {
				t.Errorf("AdminUsername() = %q, want %q", got, tt.expected)
			}
		})
	}
}

func TestAdminPassword(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected string
	}{
		{"default", "", "admin"},
		{"custom", "secret123", "secret123"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("ADMIN_PASSWORD", tt.env)
				defer os.Unsetenv("ADMIN_PASSWORD")
			} else {
				os.Unsetenv("ADMIN_PASSWORD")
			}
			if got := AdminPassword(); got != tt.expected {
				t.Errorf("AdminPassword() = %q, want %q", got, tt.expected)
			}
		})
	}
}

func TestAdminSessionTTL(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected time.Duration
	}{
		{"default", "", 12 * time.Hour},
		{"custom", "24", 24 * time.Hour},
		{"zero", "0", 12 * time.Hour},
		{"negative", "-5", 12 * time.Hour},
		{"invalid", "abc", 12 * time.Hour},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("ADMIN_SESSION_TTL_HOURS", tt.env)
				defer os.Unsetenv("ADMIN_SESSION_TTL_HOURS")
			} else {
				os.Unsetenv("ADMIN_SESSION_TTL_HOURS")
			}
			if got := AdminSessionTTL(); got != tt.expected {
				t.Errorf("AdminSessionTTL() = %v, want %v", got, tt.expected)
			}
		})
	}
}

func TestRateLimitMax(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected int
	}{
		{"default", "", 10},
		{"custom", "20", 20},
		{"zero", "0", 10},
		{"negative", "-5", 10},
		{"invalid", "abc", 10},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("CHAT_RATE_LIMIT_MAX", tt.env)
				defer os.Unsetenv("CHAT_RATE_LIMIT_MAX")
			} else {
				os.Unsetenv("CHAT_RATE_LIMIT_MAX")
			}
			if got := RateLimitMax(); got != tt.expected {
				t.Errorf("RateLimitMax() = %d, want %d", got, tt.expected)
			}
		})
	}
}

func TestRateLimitWindow(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected time.Duration
	}{
		{"default", "", 10 * time.Second},
		{"custom", "30", 30 * time.Second},
		{"zero", "0", 10 * time.Second},
		{"negative", "-5", 10 * time.Second},
		{"invalid", "abc", 10 * time.Second},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("CHAT_RATE_LIMIT_WINDOW_S", tt.env)
				defer os.Unsetenv("CHAT_RATE_LIMIT_WINDOW_S")
			} else {
				os.Unsetenv("CHAT_RATE_LIMIT_WINDOW_S")
			}
			if got := RateLimitWindow(); got != tt.expected {
				t.Errorf("RateLimitWindow() = %v, want %v", got, tt.expected)
			}
		})
	}
}

func TestChatPort(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected string
	}{
		{"default", "", "3000"},
		{"custom", "8080", "8080"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("CHAT_PORT", tt.env)
				defer os.Unsetenv("CHAT_PORT")
			} else {
				os.Unsetenv("CHAT_PORT")
			}
			if got := ChatPort(); got != tt.expected {
				t.Errorf("ChatPort() = %q, want %q", got, tt.expected)
			}
		})
	}
}

func TestRedisAddress(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected string
	}{
		{"default", "", "redis:6379"},
		{"custom", "redis.example.com:6380", "redis.example.com:6380"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("REDIS_URL", tt.env)
				defer os.Unsetenv("REDIS_URL")
			} else {
				os.Unsetenv("REDIS_URL")
			}
			if got := RedisAddress(); got != tt.expected {
				t.Errorf("RedisAddress() = %q, want %q", got, tt.expected)
			}
		})
	}
}

func TestDatabaseURL(t *testing.T) {
	tests := []struct {
		name     string
		env      string
		expected string
	}{
		{"default", "", ""},
		{"sqlite", "sqlite://test.db", "sqlite://test.db"},
		{"postgres", "postgres://user:pass@localhost/db", "postgres://user:pass@localhost/db"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.env != "" {
				os.Setenv("DATABASE_URL", tt.env)
				defer os.Unsetenv("DATABASE_URL")
			} else {
				os.Unsetenv("DATABASE_URL")
			}
			if got := DatabaseURL(); got != tt.expected {
				t.Errorf("DatabaseURL() = %q, want %q", got, tt.expected)
			}
		})
	}
}