package config

import (
	"strings"
	"testing"
)

// validEnv enumerates the minimum environment required by Validate after
// LoadFromEnv. Tests start from this map and tweak individual entries.
func validEnv() map[string]string {
	return map[string]string{
		"BACKEND_POSTGRES_DSN":    "postgres://galaxy:galaxy@127.0.0.1:5432/galaxy?sslmode=disable",
		"BACKEND_SMTP_HOST":       "smtp.example.test",
		"BACKEND_SMTP_FROM":       "noreply@example.test",
		"BACKEND_DOCKER_NETWORK":  "galaxy",
		"BACKEND_GAME_STATE_ROOT": "/tmp/galaxy",
		"BACKEND_GEOIP_DB_PATH":   "/tmp/geoip.mmdb",
	}
}

func setEnv(t *testing.T, env map[string]string) {
	t.Helper()
	for name, value := range env {
		t.Setenv(name, value)
	}
}

func TestLoadFromEnvAcceptsValidEnv(t *testing.T) {
	setEnv(t, validEnv())

	cfg, err := LoadFromEnv()
	if err != nil {
		t.Fatalf("LoadFromEnv returned error: %v", err)
	}

	if cfg.HTTP.Addr != defaultHTTPListenAddr {
		t.Fatalf("HTTP.Addr = %q, want %q", cfg.HTTP.Addr, defaultHTTPListenAddr)
	}
	if cfg.GRPCPush.Addr != defaultGRPCPushListenAddr {
		t.Fatalf("GRPCPush.Addr = %q, want %q", cfg.GRPCPush.Addr, defaultGRPCPushListenAddr)
	}
	if cfg.Postgres.DSN == "" {
		t.Fatalf("Postgres.DSN must be populated from env")
	}
	if cfg.Telemetry.TracesExporter != defaultOTelTracesExporter {
		t.Fatalf("Telemetry.TracesExporter = %q, want %q", cfg.Telemetry.TracesExporter, defaultOTelTracesExporter)
	}
}

func TestLoadFromEnvFailsWithoutPostgresDSN(t *testing.T) {
	env := validEnv()
	delete(env, "BACKEND_POSTGRES_DSN")
	setEnv(t, env)

	if _, err := LoadFromEnv(); err == nil || !strings.Contains(err.Error(), "BACKEND_POSTGRES_DSN") {
		t.Fatalf("expected BACKEND_POSTGRES_DSN error, got %v", err)
	}
}

func TestValidateRejectsAdminUserWithoutPassword(t *testing.T) {
	env := validEnv()
	env["BACKEND_ADMIN_BOOTSTRAP_USER"] = "root"
	setEnv(t, env)

	if _, err := LoadFromEnv(); err == nil || !strings.Contains(err.Error(), "BACKEND_ADMIN_BOOTSTRAP_PASSWORD") {
		t.Fatalf("expected admin password requirement, got %v", err)
	}
}

func TestValidateRejectsUnknownTracesExporter(t *testing.T) {
	env := validEnv()
	env["BACKEND_OTEL_TRACES_EXPORTER"] = "kafka"
	setEnv(t, env)

	if _, err := LoadFromEnv(); err == nil || !strings.Contains(err.Error(), "BACKEND_OTEL_TRACES_EXPORTER") {
		t.Fatalf("expected traces-exporter validation error, got %v", err)
	}
}

func TestLoadFromEnvAcceptsDevFixedCode(t *testing.T) {
	env := validEnv()
	env["BACKEND_AUTH_DEV_FIXED_CODE"] = "123456"
	setEnv(t, env)

	cfg, err := LoadFromEnv()
	if err != nil {
		t.Fatalf("LoadFromEnv returned error: %v", err)
	}
	if cfg.Auth.DevFixedCode != "123456" {
		t.Fatalf("Auth.DevFixedCode = %q, want \"123456\"", cfg.Auth.DevFixedCode)
	}
}

func TestValidateRejectsDevFixedCodeWrongLength(t *testing.T) {
	env := validEnv()
	env["BACKEND_AUTH_DEV_FIXED_CODE"] = "12345"
	setEnv(t, env)

	if _, err := LoadFromEnv(); err == nil || !strings.Contains(err.Error(), "BACKEND_AUTH_DEV_FIXED_CODE") {
		t.Fatalf("expected DEV fixed-code length error, got %v", err)
	}
}

func TestValidateRejectsDevFixedCodeNonDecimal(t *testing.T) {
	env := validEnv()
	env["BACKEND_AUTH_DEV_FIXED_CODE"] = "abcdef"
	setEnv(t, env)

	if _, err := LoadFromEnv(); err == nil || !strings.Contains(err.Error(), "BACKEND_AUTH_DEV_FIXED_CODE") {
		t.Fatalf("expected DEV fixed-code decimal error, got %v", err)
	}
}

func TestValidateRejectsPrometheusWithoutAddr(t *testing.T) {
	cfg := DefaultConfig()
	cfg.Postgres.DSN = "postgres://x:y@127.0.0.1/galaxy"
	cfg.SMTP.Host = "smtp"
	cfg.SMTP.From = "from@x"
	cfg.Docker.Network = "galaxy"
	cfg.Game.StateRoot = "/tmp/galaxy"
	cfg.GeoIP.DBPath = "/tmp/geo"
	cfg.Telemetry.MetricsExporter = "prometheus"
	cfg.Telemetry.PrometheusListenAddr = ""

	if err := cfg.Validate(); err == nil || !strings.Contains(err.Error(), "BACKEND_OTEL_PROMETHEUS_LISTEN_ADDR") {
		t.Fatalf("expected prometheus address requirement, got %v", err)
	}
}
