package session

import (
	"context"
	"strings"
	"testing"

	"agentu/internal/agent"
	"agentu/internal/config"
	"agentu/internal/llm"
)

type recordingProvider struct {
	req llm.ChatRequest
}

func (p *recordingProvider) ChatStream(ctx context.Context, req llm.ChatRequest, emit func(llm.StreamEvent) error) error {
	p.req = req
	return emit(llm.StreamEvent{Content: "ok"})
}

func TestManagerSwitchesModelAndThinking(t *testing.T) {
	cfg := &config.Config{
		Providers: map[string]config.ProviderConfig{
			"one": {
				Name:               "one",
				BaseURL:            "https://one.example.com",
				APIKey:             "sk-test",
				Model:              "model-a",
				Models:             []string{"model-a", "model-b"},
				Thinking:           "none",
				ThinkingParam:      "thinking",
				ThinkingConfigured: true,
			},
		},
	}
	provider := &recordingProvider{}
	assistant := agent.New(agent.Options{
		Provider:        provider,
		ProviderName:    "one",
		Model:           "model-a",
		Thinking:        "none",
		ThinkingParam:   "thinking",
		ThinkingEnabled: true,
	})
	manager, err := NewManager(cfg, assistant, nil)
	if err != nil {
		t.Fatal(err)
	}

	if _, err := manager.SetModel("model-b"); err != nil {
		t.Fatal(err)
	}
	if _, err := manager.SetThinking("high"); err != nil {
		t.Fatal(err)
	}
	var out strings.Builder
	if err := assistant.RunTurn(context.Background(), "hi", &out, nil); err != nil {
		t.Fatal(err)
	}

	if provider.req.Model != "model-b" {
		t.Fatalf("model = %q", provider.req.Model)
	}
	if provider.req.Extra["thinking"] != "high" {
		t.Fatalf("thinking = %#v", provider.req.Extra["thinking"])
	}
}

func TestManagerRejectsUnknownModelAndThinking(t *testing.T) {
	cfg := &config.Config{
		Providers: map[string]config.ProviderConfig{
			"one": {
				Name:    "one",
				BaseURL: "https://one.example.com",
				APIKey:  "sk-test",
				Model:   "model-a",
				Models:  []string{"model-a"},
			},
		},
	}
	assistant := agent.New(agent.Options{Provider: &recordingProvider{}, Model: "model-a"})
	manager, err := NewManager(cfg, assistant, nil)
	if err != nil {
		t.Fatal(err)
	}

	if _, err := manager.SetModel("model-b"); err == nil {
		t.Fatal("expected unknown model error")
	}
	if _, err := manager.SetThinking("huge"); err == nil {
		t.Fatal("expected invalid thinking error")
	}
}