package executor

import (
	"context"
	"encoding/json"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"os"
	"sync/atomic"
	"testing"

	"github.com/thepeterstone/claudomator/internal/llm"
	"github.com/thepeterstone/claudomator/internal/provider/openaicompat"
)

// TestPool_Submit_GroqAgentType_RoutesThroughOpenAICompatProvider is the
// Part A wiring-level confirmation (verification item 5) that Groq — one of
// the three providers that docs/api-keys-setup.md documented as "works once
// configured" but was never actually registered by internal/cli/serve.go or
// run.go before this phase — is a real, usable runner once wired up. Groq is
// OpenAI-wire-compatible, so this reuses the existing Phase 1
// internal/provider/openaicompat adapter (internal/llm.Client) exactly the
// way internal/cli/cloudrunners.go's registerCloudRunners constructs it: no
// new adapter package, purely config-driven construction pointed at Groq's
// endpoint.
func TestPool_Submit_GroqAgentType_RoutesThroughOpenAICompatProvider(t *testing.T) {
	var calls int32
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		atomic.AddInt32(&calls, 1)
		if r.URL.Path != "/chat/completions" {
			t.Errorf("unexpected path %q", r.URL.Path)
		}
		if got := r.Header.Get("Authorization"); got != "Bearer test-groq-key" {
			t.Errorf("wrong Authorization header: %q", got)
		}
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{
			"choices": []map[string]any{
				{
					"message":       map[string]any{"role": "assistant", "content": "## Summary\ndone"},
					"finish_reason": "stop",
				},
			},
			"model": "llama-3.3-70b-versatile",
			"usage": map[string]any{"prompt_tokens": 10, "completion_tokens": 3},
		})
	}))
	defer srv.Close()

	// Mirrors registerCloudRunners' construction for groq/openrouter/openai:
	// openaicompat.New(&llm.Client{...}) wrapped in a NativeRunner registered
	// under the "groq" runner-map key, SandboxKind "docker" for the real
	// wiring (irrelevant here since the task has no ProjectDir/sandbox use).
	client := &llm.Client{
		Endpoint: srv.URL,
		Model:    "llama-3.3-70b-versatile",
		APIKey:   "test-groq-key",
	}
	runners := map[string]Runner{
		"groq": &NativeRunner{
			Provider: openaicompat.New(client),
			Logger:   slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelError})),
			LogDir:   t.TempDir(),
		},
	}

	store := testStore(t)
	logger := slog.New(slog.NewTextHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelError}))
	pool := NewPool(2, runners, store, logger)

	tk := makeTask("groq-routing-1")
	tk.Agent.Type = "groq"
	tk.Agent.Model = "llama-3.3-70b-versatile"
	tk.Agent.SkipPlanning = true
	if err := store.CreateTask(tk); err != nil {
		t.Fatalf("CreateTask: %v", err)
	}

	if err := pool.Submit(context.Background(), tk); err != nil {
		t.Fatalf("Submit: %v", err)
	}

	result := <-pool.Results()
	if result.Err != nil {
		t.Fatalf("expected no error, got: %v", result.Err)
	}
	if got := atomic.LoadInt32(&calls); got != 1 {
		t.Fatalf("expected exactly 1 call to the fake Groq server, got %d", got)
	}
	if result.Execution.Agent != "groq" {
		t.Errorf("execution.Agent: want %q, got %q", "groq", result.Execution.Agent)
	}
	if result.Execution.TokensIn != 10 || result.Execution.TokensOut != 3 {
		t.Errorf("tokens should come from the openaicompat provider's usage: got in=%d out=%d",
			result.Execution.TokensIn, result.Execution.TokensOut)
	}
}