package tracing

import (
	"context"
	"testing"
	"time"

	"go.opentelemetry.io/otel"
	sdktrace "go.opentelemetry.io/otel/sdk/trace"
	"go.opentelemetry.io/otel/trace/noop"
)

const testOTLPEndpoint = "http://localhost:4318"

// clearOTelEnv pins every env var Setup reads, so developer shells with
// OTEL_* set can't change test outcomes. Not parallel-safe by design
// (t.Setenv forbids t.Parallel).
func clearOTelEnv(t *testing.T) {
	t.Helper()
	for _, k := range []string{
		envSDKDisabled,
		envTracesExporter,
		envOTLPEndpoint,
		envOTLPTracesEndpoint,
		envOTLPProtocol,
		envOTLPTracesProtocol,
	} {
		t.Setenv(k, "")
	}
}

func TestSetup_envGating(t *testing.T) {
	tests := []struct {
		name        string
		env         map[string]string
		wantEnabled bool
		wantErr     bool
	}{
		{name: "no env means disabled", env: nil, wantEnabled: false},
		{
			name:        "endpoint enables otlp",
			env:         map[string]string{envOTLPEndpoint: testOTLPEndpoint},
			wantEnabled: true,
		},
		{
			name:        "traces endpoint enables otlp",
			env:         map[string]string{envOTLPTracesEndpoint: testOTLPEndpoint},
			wantEnabled: true,
		},
		{
			name:        "explicit console exporter",
			env:         map[string]string{envTracesExporter: exporterConsole},
			wantEnabled: true,
		},
		{
			name:        "grpc protocol",
			env:         map[string]string{envTracesExporter: exporterOTLP, envOTLPProtocol: "grpc"},
			wantEnabled: true,
		},
		{
			name: "exporter none wins over endpoint",
			env: map[string]string{
				envTracesExporter: exporterNone,
				envOTLPEndpoint:   testOTLPEndpoint,
			},
			wantEnabled: false,
		},
		{
			name: "OTEL_SDK_DISABLED wins over everything",
			env: map[string]string{
				envSDKDisabled:  "true",
				envOTLPEndpoint: testOTLPEndpoint,
			},
			wantEnabled: false,
		},
		{
			name:    "unsupported exporter errors",
			env:     map[string]string{envTracesExporter: "jaeger"},
			wantErr: true,
		},
		{
			name: "unsupported protocol errors",
			env: map[string]string{
				envTracesExporter: exporterOTLP,
				envOTLPProtocol:   "http/json",
			},
			wantErr: true,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			clearOTelEnv(t)
			for k, v := range tc.env {
				t.Setenv(k, v)
			}
			// Fresh noop global per case: disabled paths must leave it
			// untouched, and resetting avoids leaking one case's SDK
			// provider into the next (or warning-prone restores of the
			// process-default delegate).
			before := noop.NewTracerProvider()
			otel.SetTracerProvider(before)

			shutdown, err := Setup(context.Background(), "test-svc", "abc123")
			if tc.wantErr {
				if err == nil {
					t.Fatal("want error, got nil")
				}
				return
			}
			if err != nil {
				t.Fatalf("Setup: %v", err)
			}

			_, isSDK := otel.GetTracerProvider().(*sdktrace.TracerProvider)
			if isSDK != tc.wantEnabled {
				t.Errorf("global provider is SDK = %v, want %v", isSDK, tc.wantEnabled)
			}
			if tc.wantEnabled && otel.GetTracerProvider() == before {
				t.Error("enabled Setup must install a new global provider")
			}

			ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
			defer cancel()
			if err := shutdown(ctx); err != nil {
				t.Errorf("shutdown: %v", err)
			}
		})
	}
}