package executor

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

	"github.com/thepeterstone/claudomator/internal/provider/anthropic"
)

// TestPool_Submit_AnthropicAgentType_RoutesThroughAnthropicProvider is the
// NativeRunner-level confirmation (Phase 2 verification item 5) that a task
// with agent.type: "anthropic" is actually routed through the new
// internal/provider/anthropic.Provider when the pool is wired with an
// "anthropic" runner — exactly how internal/cli/serve.go and
// internal/cli/run.go register it from cfg.Providers["anthropic"] when a
// non-empty APIKey is configured. This exercises the full path: Pool.Submit
// -> execute() -> NativeRunner.Run() -> agentloop.Loop.Run() ->
// anthropic.Provider.Chat() -> HTTP POST to the (fake) Anthropic Messages
// API endpoint.
func TestPool_Submit_AnthropicAgentType_RoutesThroughAnthropicProvider(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 != "/v1/messages" {
			t.Errorf("unexpected path %q", r.URL.Path)
		}
		if r.Header.Get("x-api-key") != "test-anthropic-key" {
			t.Errorf("wrong x-api-key: %q", r.Header.Get("x-api-key"))
		}
		w.Header().Set("Content-Type", "application/json")
		w.Write([]byte(`{
			"content": [{"type": "text", "text": "## Summary\ndone"}],
			"stop_reason": "end_turn",
			"model": "claude-sonnet-5",
			"usage": {"input_tokens": 12, "output_tokens": 4}
		}`))
	}))
	defer srv.Close()

	// Mirrors the exact construction in internal/cli/serve.go's
	// cfg.Providers["anthropic"] wiring block: anthropic.New(apiKey,
	// endpoint, timeout) wrapped in a NativeRunner registered under the
	// "anthropic" runner-map key.
	runners := map[string]Runner{
		"anthropic": &NativeRunner{
			Provider: anthropic.New("test-anthropic-key", srv.URL, 0),
			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("anthropic-routing-1")
	tk.Agent.Type = "anthropic"
	tk.Agent.Model = "claude-sonnet-5"
	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 Anthropic server, got %d", got)
	}
	if result.Execution.Agent != "anthropic" {
		t.Errorf("execution.Agent: want %q, got %q", "anthropic", result.Execution.Agent)
	}
	if result.Execution.TokensIn != 12 || result.Execution.TokensOut != 4 {
		t.Errorf("tokens should come from the anthropic provider's usage: got in=%d out=%d",
			result.Execution.TokensIn, result.Execution.TokensOut)
	}
}