package headless_test

import (
	"context"
	"os"
	"path/filepath"
	"testing"

	"github.com/flothus/tmux-xterm-research/server-go/internal/harness/envelope"
	"github.com/flothus/tmux-xterm-research/server-go/internal/harness/event"
	"github.com/flothus/tmux-xterm-research/server-go/internal/harness/orchestrator"
	"github.com/flothus/tmux-xterm-research/server-go/internal/harness/runtime"
	"github.com/flothus/tmux-xterm-research/server-go/internal/harness/runtime/headless"
	"github.com/flothus/tmux-xterm-research/server-go/internal/harness/store"
	"github.com/flothus/tmux-xterm-research/server-go/internal/harness/transport"
)

// TestRealClaudeSmoke runs the misbehaving-LLM smoke against the actual
// Anthropic API. Gated on ANTHROPIC_API_KEY so default test runs are
// hermetic. Even when the env var is set, this is a *smoke* test — we check
// that the harness completes a turn without crashing and records token
// usage, not that the model behaves any specific way.
//
// Run manually:
//
//	ANTHROPIC_API_KEY=sk-... go test ./internal/harness/runtime/headless/ -run TestRealClaudeSmoke -v
func TestRealClaudeSmoke(t *testing.T) {
	if os.Getenv("ANTHROPIC_API_KEY") == "" {
		t.Skip("ANTHROPIC_API_KEY not set; skipping real-LLM smoke")
	}
	rt, err := headless.NewFromEnv()
	if err != nil {
		t.Fatal(err)
	}

	tmp := t.TempDir()
	st, err := store.Open(filepath.Join(tmp, "harness.db"))
	if err != nil {
		t.Fatal(err)
	}
	defer st.Close()
	bus := event.NewBus(st)
	q := transport.New(st, bus)
	orch := orchestrator.New(st, bus)
	ctx := context.Background()

	_ = orch.CreateRun(ctx, "run-real", "real smoke")
	_, _ = st.DB().Exec(`INSERT INTO agents(id, run_id, status, spawned_at, heartbeat_at) VALUES('real-a','run-real','running',?,?)`,
		store.FmtTime(store.Now()), store.FmtTime(store.Now()),
	)
	_, _ = rt.Spawn(ctx, runtime.SpawnSpec{
		AgentID: "real-a", RunID: "run-real",
		Tools:     []string{"introspect", "write_file"},
		ZoneScope: []string{"client/**/*"},
	})

	agent := runtime.NewAgent(rt, st, bus, q, "real-a", "tester", "run-real",
		[]string{"client/**/*"}, []string{"introspect", "write_file"}, "anthropic", 0.005)

	// Send a delegate and run one turn.
	e := &envelope.Envelope{
		ID: "m-real-1", RunID: "run-real",
		From: "master", To: "real-a", Type: envelope.TypeDelegate, TTLMs: 60000,
		Payload: envelope.Payload{
			Intent:  "Say hello and then call the introspect tool. After that, you may finish.",
			Expects: envelope.ExpectsReport,
		},
	}
	if err := q.Send(ctx, e); err != nil {
		t.Fatal(err)
	}
	handled, err := agent.HandleOne(ctx)
	if err != nil {
		t.Fatalf("HandleOne: %v", err)
	}
	if !handled {
		t.Fatal("expected HandleOne to handle a message")
	}

	if agent.TokensTotal() <= 0 {
		t.Errorf("expected tokens > 0, got %d", agent.TokensTotal())
	}
	var rt_tokens int64
	_ = st.DB().QueryRow(`SELECT tokens_total FROM runs WHERE id='run-real'`).Scan(&rt_tokens)
	if rt_tokens <= 0 {
		t.Errorf("runs.tokens_total = %d, want >0", rt_tokens)
	}
}