package openai_compat

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
	"sync"
	"testing"

	"go.uber.org/zap"

	"iop/apps/node/internal/runtime"
	"iop/packages/go/config"
)

type fakeSink struct {
	mu     sync.Mutex
	events []runtime.RuntimeEvent
}

func (s *fakeSink) Emit(_ context.Context, event runtime.RuntimeEvent) error {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.events = append(s.events, event)
	return nil
}

func (s *fakeSink) all() []runtime.RuntimeEvent {
	s.mu.Lock()
	defer s.mu.Unlock()
	return append([]runtime.RuntimeEvent(nil), s.events...)
}

func TestOpenAICompatCapabilitiesQueryModels(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/v1/models" {
			t.Fatalf("unexpected path %s", r.URL.Path)
		}
		_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"model-a"},{"id":"model-b"}]}`))
	}))
	defer server.Close()

	adapter := New(config.OpenAICompatConf{
		Provider:         "lemonade",
		Endpoint:         server.URL,
		Capacity:         10,
		MaxQueue:         20,
		QueueTimeoutMS:   5000,
		RequestTimeoutMS: 10000,
	}, zap.NewNop())
	caps, err := adapter.Capabilities(context.Background())
	if err != nil {
		t.Fatalf("Capabilities failed: %v", err)
	}
	if caps.AdapterName != Name {
		t.Fatalf("AdapterName: got %q want %q", caps.AdapterName, Name)
	}
	if got := strings.Join(caps.Targets, ","); got != "model-a,model-b" {
		t.Fatalf("targets: got %q", got)
	}
	if caps.MaxConcurrency != 10 {
		t.Fatalf("expected MaxConcurrency 10, got %d", caps.MaxConcurrency)
	}
	if caps.MaxQueue != 20 || caps.QueueTimeoutMS != 5000 || caps.RequestTimeoutMS != 10000 {
		t.Fatalf("queue config: got %+v", caps)
	}
	if caps.ProviderStatus != runtime.ProviderStatusAvailable {
		t.Fatalf("expected available, got %s", caps.ProviderStatus)
	}

	adapterDefault := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
	capsDefault, err := adapterDefault.Capabilities(context.Background())
	if err != nil {
		t.Fatalf("Capabilities failed: %v", err)
	}
	if capsDefault.MaxConcurrency != 8 {
		t.Fatalf("expected default MaxConcurrency 8, got %d", capsDefault.MaxConcurrency)
	}
}

func TestOpenAICompatProbeProviderAvailability(t *testing.T) {
	t.Run("200_ok_and_target_hit", func(t *testing.T) {
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.URL.Path != "/v1/models" {
				t.Fatalf("unexpected path %s", r.URL.Path)
			}
			_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"model-a"},{"id":"model-b"}]}`))
		}))
		defer server.Close()

		adapter := New(config.OpenAICompatConf{Provider: "lemonade", Endpoint: server.URL}, zap.NewNop())
		res, err := adapter.ProbeProvider(context.Background(), "model-a")
		if err != nil {
			t.Fatalf("ProbeProvider failed: %v", err)
		}
		if res.Status != runtime.ProviderStatusAvailable {
			t.Errorf("expected available, got %s", res.Status)
		}
		if len(res.Targets) != 2 || res.Targets[0] != "model-a" {
			t.Errorf("unexpected Targets: %+v", res.Targets)
		}
		if res.Metadata["provider"] != "lemonade" {
			t.Errorf("expected provider metadata, got %+v", res.Metadata)
		}
	})

	t.Run("200_ok_and_target_miss", func(t *testing.T) {
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"model-a"}]}`))
		}))
		defer server.Close()

		adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
		res, err := adapter.ProbeProvider(context.Background(), "model-b")
		if err != nil {
			t.Fatalf("ProbeProvider failed: %v", err)
		}
		if res.Status != runtime.ProviderStatusUnavailable {
			t.Errorf("expected unavailable, got %s", res.Status)
		}
		if !strings.Contains(res.Detail, "not found") {
			t.Errorf("expected 'not found' in detail, got %s", res.Detail)
		}
	})

	t.Run("500_internal_error", func(t *testing.T) {
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
			w.WriteHeader(http.StatusInternalServerError)
		}))
		defer server.Close()

		adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
		res, err := adapter.ProbeProvider(context.Background(), "model-a")
		if err != nil {
			t.Fatalf("ProbeProvider failed: %v", err)
		}
		if res.Status != runtime.ProviderStatusUnavailable {
			t.Errorf("expected unavailable, got %s", res.Status)
		}
	})

	t.Run("empty_target", func(t *testing.T) {
		server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
			_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"model-a"}]}`))
		}))
		defer server.Close()

		adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
		res, err := adapter.ProbeProvider(context.Background(), "")
		if err != nil {
			t.Fatalf("ProbeProvider failed: %v", err)
		}
		if res.Status != runtime.ProviderStatusAvailable {
			t.Errorf("expected available, got %s", res.Status)
		}
	})
}

func TestOpenAICompatExecuteStreamsDeltasAndFinishReason(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/v1/chat/completions" {
			t.Fatalf("unexpected path %s", r.URL.Path)
		}
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"reasoning_content":"think "}}]}`)
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"hello "}}]}`)
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"world"},"finish_reason":"stop"}],"usage":{"prompt_tokens":5,"completion_tokens":2}}`)
		_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
	}))
	defer server.Close()

	adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
	sink := &fakeSink{}
	err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
		RunID:  "run-1",
		Target: "lemonade-model",
		Input:  map[string]any{"prompt": "say hello"},
	}, sink)
	if err != nil {
		t.Fatalf("Execute failed: %v", err)
	}

	events := sink.all()
	// start + reasoning_delta + delta + delta + complete
	if len(events) != 5 {
		t.Fatalf("expected 5 events, got %d: %+v", len(events), events)
	}
	if events[0].Type != runtime.EventTypeStart {
		t.Fatalf("expected start, got %+v", events[0])
	}
	if events[1].Type != runtime.EventTypeReasoningDelta || events[1].Delta != "think " {
		t.Fatalf("expected reasoning delta, got %+v", events[1])
	}
	if events[2].Delta+events[3].Delta != "hello world" {
		t.Fatalf("unexpected deltas: %q + %q", events[2].Delta, events[3].Delta)
	}
	complete := events[4]
	if complete.Type != runtime.EventTypeComplete {
		t.Fatalf("expected complete, got %+v", complete)
	}
	if complete.Metadata["finish_reason"] != "stop" {
		t.Fatalf("expected finish_reason stop, got %+v", complete.Metadata)
	}
	if complete.Usage == nil || complete.Usage.OutputTokens != 2 || complete.Usage.InputTokens != 5 {
		t.Fatalf("expected usage from chunk, got %+v", complete.Usage)
	}
}

func TestOpenAICompatExecuteSendsHeaders(t *testing.T) {
	var gotAuth, gotContentType string
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gotAuth = r.Header.Get("Authorization")
		gotContentType = r.Header.Get("Content-Type")
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"ok"}}]}`)
		_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
	}))
	defer server.Close()

	adapter := New(config.OpenAICompatConf{
		Endpoint: server.URL,
		Headers: map[string]string{
			"Authorization": "Bearer secret-token",
			// A user-provided Content-Type must not override the adapter-owned one.
			"Content-Type": "text/plain",
		},
	}, zap.NewNop())
	sink := &fakeSink{}
	if err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
		RunID:  "run-h",
		Target: "lemonade-model",
		Input:  map[string]any{"prompt": "hi"},
	}, sink); err != nil {
		t.Fatalf("Execute failed: %v", err)
	}
	if gotAuth != "Bearer secret-token" {
		t.Fatalf("expected Authorization header, got %q", gotAuth)
	}
	if gotContentType != "application/json" {
		t.Fatalf("expected adapter-owned content type, got %q", gotContentType)
	}
}

func TestOpenAICompatExecutePassesOptionsAsTopLevelFields(t *testing.T) {
	var body map[string]any
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			t.Fatalf("decode: %v", err)
		}
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"ok"}}]}`)
		_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
	}))
	defer server.Close()

	adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
	sink := &fakeSink{}
	if err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
		RunID:  "run-o",
		Target: "lemonade-model",
		Input: map[string]any{
			"prompt": "hi",
			"options": map[string]any{
				"temperature": 0.2,
				"max_tokens":  float64(8),
				// adapter-owned fields must not be overridden by options
				"model":  "evil",
				"stream": false,
			},
		},
	}, sink); err != nil {
		t.Fatalf("Execute failed: %v", err)
	}
	if body["temperature"] != 0.2 {
		t.Fatalf("expected temperature top-level, got %v", body["temperature"])
	}
	if body["max_tokens"] != float64(8) {
		t.Fatalf("expected max_tokens top-level, got %v", body["max_tokens"])
	}
	if body["model"] != "lemonade-model" {
		t.Fatalf("options must not override model, got %v", body["model"])
	}
	if body["stream"] != true {
		t.Fatalf("options must not override stream, got %v", body["stream"])
	}
}

func TestOpenAICompatExecutePassesToolsAndToolChoice(t *testing.T) {
	var body map[string]any
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			t.Fatalf("decode: %v", err)
		}
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"ok"}}]}`)
		_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
	}))
	defer server.Close()

	adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
	sink := &fakeSink{}
	if err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
		RunID:  "run-t",
		Target: "qwen3.6:35b",
		Input: map[string]any{
			"prompt":      "hi",
			"tools":       []any{map[string]any{"type": "function"}},
			"tool_choice": "none",
		},
	}, sink); err != nil {
		t.Fatalf("Execute failed: %v", err)
	}
	if tools, ok := body["tools"].([]any); !ok || len(tools) != 1 {
		t.Fatalf("tools not passed: %+v", body["tools"])
	}
	if body["tool_choice"] != "none" {
		t.Fatalf("tool_choice not passed: %+v", body["tool_choice"])
	}
}

func TestOpenAICompatExecuteRetriesSingleToolWhenAutoUnsupported(t *testing.T) {
	attempts := 0
	var retryBody map[string]any
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		attempts++
		if attempts == 1 {
			w.WriteHeader(http.StatusBadRequest)
			_, _ = w.Write([]byte(`{"error":{"message":"\"auto\" tool choice requires --enable-auto-tool-choice and --tool-call-parser to be set"}}`))
			return
		}
		if err := json.NewDecoder(r.Body).Decode(&retryBody); err != nil {
			t.Fatalf("decode retry: %v", err)
		}
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"ok"}}]}`)
		_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
	}))
	defer server.Close()

	adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
	sink := &fakeSink{}
	if err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
		RunID:  "run-retry",
		Target: "qwen3.6:35b",
		Input: map[string]any{
			"prompt": "status",
			"tools": []any{map[string]any{
				"type": "function",
				"function": map[string]any{
					"name": "run_commands",
				},
			}},
		},
	}, sink); err != nil {
		t.Fatalf("Execute failed: %v", err)
	}
	if attempts != 2 {
		t.Fatalf("attempts: got %d, want 2", attempts)
	}
	choice, ok := retryBody["tool_choice"].(map[string]any)
	if !ok {
		t.Fatalf("retry tool_choice missing: %+v", retryBody)
	}
	fn := choice["function"].(map[string]any)
	if choice["type"] != "function" || fn["name"] != "run_commands" {
		t.Fatalf("retry tool_choice: %+v", choice)
	}
}

func TestOpenAICompatExecuteFallsBackToTextToolsWhenNativeToolsUnsupported(t *testing.T) {
	attempts := 0
	var fallbackBody map[string]any
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		attempts++
		switch attempts {
		case 1:
			w.WriteHeader(http.StatusBadRequest)
			_, _ = w.Write([]byte(`{"error":{"message":"\"auto\" tool choice requires --enable-auto-tool-choice and --tool-call-parser to be set"}}`))
			return
		case 2:
			w.WriteHeader(http.StatusBadRequest)
			_, _ = w.Write([]byte(`{"error":{"message":"tool_choice=\"function=ChatCompletionNamedFunction(name='run_commands') type='function'\" requires --tool-call-parser to be set"}}`))
			return
		}
		if err := json.NewDecoder(r.Body).Decode(&fallbackBody); err != nil {
			t.Fatalf("decode fallback: %v", err)
		}
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"<tool_call>\n<function=run_commands>\n<parameter=commands>[\"git status\"]</parameter>\n</function>\n</tool_call>"}}]}`)
		_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
	}))
	defer server.Close()

	adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
	sink := &fakeSink{}
	if err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
		RunID:  "run-text-fallback",
		Target: "qwen3.6:35b",
		Input: map[string]any{
			"messages": []any{
				map[string]any{"role": "system", "content": "Existing Cline system prompt."},
				map[string]any{"role": "user", "content": "status"},
			},
			"tools": []any{map[string]any{
				"type": "function",
				"function": map[string]any{
					"name": "run_commands",
					"parameters": map[string]any{
						"type": "object",
						"properties": map[string]any{
							"commands": map[string]any{"type": "array", "items": map[string]any{"type": "string"}},
						},
					},
				},
			}},
		},
	}, sink); err != nil {
		t.Fatalf("Execute failed: %v", err)
	}
	if attempts != 3 {
		t.Fatalf("attempts: got %d, want 3", attempts)
	}
	if _, ok := fallbackBody["tools"]; ok {
		t.Fatalf("fallback must omit tools: %+v", fallbackBody["tools"])
	}
	if _, ok := fallbackBody["tool_choice"]; ok {
		t.Fatalf("fallback must omit tool_choice: %+v", fallbackBody["tool_choice"])
	}
	messages := fallbackBody["messages"].([]any)
	first := messages[0].(map[string]any)
	if first["role"] != "system" || !strings.Contains(first["content"].(string), "<tool_call>") || !strings.Contains(first["content"].(string), "run_commands") {
		t.Fatalf("fallback system instruction missing tool format/name: %+v", first)
	}
	if !strings.Contains(first["content"].(string), "client workspace root") || !strings.Contains(first["content"].(string), "Do not prepend cd") {
		t.Fatalf("fallback system instruction missing workspace-root guidance: %+v", first)
	}
	if !strings.Contains(first["content"].(string), "Existing Cline system prompt.") {
		t.Fatalf("fallback system instruction did not preserve existing system content: %+v", first)
	}
	if len(messages) != 2 || messages[1].(map[string]any)["role"] != "user" {
		t.Fatalf("fallback should keep a single leading system message: %+v", messages)
	}
	events := sink.all()
	complete := events[len(events)-1]
	if complete.Metadata[runtimeMetadataOpenAITextToolFallback] != "true" {
		t.Fatalf("fallback metadata missing: %+v", complete.Metadata)
	}
}

func TestOpenAICompatExecutePreservesToolCallMessages(t *testing.T) {
	var body map[string]any
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			t.Fatalf("decode: %v", err)
		}
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"ok"}}]}`)
		_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
	}))
	defer server.Close()

	adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
	sink := &fakeSink{}
	if err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
		RunID:  "run-tool-turn",
		Target: "qwen3.6:35b",
		Input: map[string]any{
			"messages": []any{
				map[string]any{
					"role":    "assistant",
					"content": "",
					"tool_calls": []any{map[string]any{
						"id":   "call_iop_1",
						"type": "function",
						"function": map[string]any{
							"name":      "run_commands",
							"arguments": `{"commands":["git status"]}`,
						},
					}},
				},
				map[string]any{
					"role":         "tool",
					"content":      "clean",
					"tool_call_id": "call_iop_1",
				},
			},
		},
	}, sink); err != nil {
		t.Fatalf("Execute failed: %v", err)
	}
	messages, ok := body["messages"].([]any)
	if !ok || len(messages) != 2 {
		t.Fatalf("messages not preserved: %+v", body["messages"])
	}
	assistantMsg := messages[0].(map[string]any)
	if calls, ok := assistantMsg["tool_calls"].([]any); !ok || len(calls) != 1 {
		t.Fatalf("assistant tool_calls not preserved: %+v", assistantMsg)
	}
	toolMsg := messages[1].(map[string]any)
	if toolMsg["tool_call_id"] != "call_iop_1" {
		t.Fatalf("tool_call_id not preserved: %+v", toolMsg)
	}
}

func TestOpenAICompatExecutePreservesNativeToolCalls(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_1","type":"function","function":{"name":"run_commands","arguments":"{\"commands\":"}}]}}]}`)
		_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"[\"git status\"]}"}}]},"finish_reason":"tool_calls"}]}`)
		_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
	}))
	defer server.Close()

	adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
	sink := &fakeSink{}
	if err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
		RunID:  "run-native-tools",
		Target: "qwen3.6:35b",
		Input:  map[string]any{"prompt": "status"},
	}, sink); err != nil {
		t.Fatalf("Execute failed: %v", err)
	}
	events := sink.all()
	complete := events[len(events)-1]
	if complete.Metadata["finish_reason"] != "tool_calls" {
		t.Fatalf("finish_reason: %+v", complete.Metadata)
	}
	var toolCalls []map[string]any
	if err := json.Unmarshal([]byte(complete.Metadata[runtimeMetadataOpenAIToolCalls]), &toolCalls); err != nil {
		t.Fatalf("tool_calls metadata JSON: %v", err)
	}
	if len(toolCalls) != 1 || toolCalls[0]["id"] != "call_1" {
		t.Fatalf("tool_calls: %+v", toolCalls)
	}
	fn := toolCalls[0]["function"].(map[string]any)
	if fn["name"] != "run_commands" || fn["arguments"] != `{"commands":["git status"]}` {
		t.Fatalf("function: %+v", fn)
	}
}

func TestOpenAICompatExecuteRejectsEmptyEndpointOrModel(t *testing.T) {
	t.Run("empty_endpoint", func(t *testing.T) {
		adapter := New(config.OpenAICompatConf{}, zap.NewNop())
		err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
			RunID: "r", Target: "m", Input: map[string]any{"prompt": "hi"},
		}, &fakeSink{})
		if err == nil || !strings.Contains(err.Error(), "endpoint is required") {
			t.Fatalf("expected endpoint error, got %v", err)
		}
	})

	t.Run("empty_model", func(t *testing.T) {
		adapter := New(config.OpenAICompatConf{Endpoint: "http://localhost:8000"}, zap.NewNop())
		err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
			RunID: "r", Input: map[string]any{"prompt": "hi"},
		}, &fakeSink{})
		if err == nil || !strings.Contains(err.Error(), "target/model is required") {
			t.Fatalf("expected model error, got %v", err)
		}
	})
}

func TestOpenAICompatJoinOpenAIPathNoDuplicateV1(t *testing.T) {
	cases := []struct {
		endpoint string
		path     string
		wantTail string
	}{
		{"http://host:8000", "/v1/models", "/v1/models"},
		{"http://host:8000/", "/v1/chat/completions", "/v1/chat/completions"},
		{"http://host:8000/v1", "/v1/models", "/v1/models"},
		{"http://host:8000/v1/", "/v1/chat/completions", "/v1/chat/completions"},
	}
	for _, c := range cases {
		got := joinOpenAIPath(strings.TrimRight(c.endpoint, "/"), c.path)
		if !strings.HasSuffix(got, c.wantTail) || strings.Contains(got, "/v1/v1") {
			t.Errorf("joinOpenAIPath(%q,%q)=%q want suffix %q without /v1/v1", c.endpoint, c.path, got, c.wantTail)
		}
	}
}