package enemyevents

import (
	"context"
	"io/fs"
	"strings"
	"testing"
	"time"

	"gitea.maximumdirect.net/eric/notarius/internal/framework/llm"
	"gitea.maximumdirect.net/eric/promptkit"
)

func TestRegisterPromptAssetsAndPrepareEnemyEventPrompt(t *testing.T) {
	registry := llm.NewAssetRegistry()
	if err := RegisterPromptAssets(registry); err != nil {
		t.Fatal(err)
	}
	schemaFS, err := registry.SchemaFS()
	if err != nil {
		t.Fatal(err)
	}
	if _, err := fs.ReadFile(schemaFS, "dnd_enemy_events_llm.v1.json"); err != nil {
		t.Fatalf("response schema asset: %v", err)
	}

	prepared := prepareEnemyEventPrompt(t)
	if prepared.PromptID != PromptID || prepared.OutputContract.SchemaPath != "dnd_enemy_events_llm.v1.json" || prepared.SelectedProfileID != "dnd-extraction" {
		t.Fatalf("prepared prompt = %#v", prepared)
	}
	transcriptIndex := -1
	for index, message := range prepared.Messages {
		if strings.Contains(message.Content, "enemy-transcript") {
			transcriptIndex = index
			break
		}
	}
	if transcriptIndex != 3 {
		t.Fatalf("transcript message index = %d, want shared-prefix index 3", transcriptIndex)
	}
	for index, role := range []string{"system", "user", "user", "user"} {
		if prepared.Messages[index].Role != role {
			t.Fatalf("message %d role = %q, want %q", index, prepared.Messages[index].Role, role)
		}
	}
	for _, index := range []int{2, 3} {
		if cache := prepared.Messages[index].CacheControl; cache == nil || cache.Type != promptkit.CacheControlEphemeral {
			t.Fatalf("message %d cache control = %#v", index, cache)
		}
	}
	for _, index := range []int{0, 1} {
		if prepared.Messages[index].CacheControl != nil {
			t.Fatalf("message %d cache control = %#v, want nil", index, prepared.Messages[index].CacheControl)
		}
	}
	if !strings.Contains(prepared.Messages[transcriptIndex+3].Content, "enemy-turn") || !strings.Contains(prepared.Messages[transcriptIndex+3].Content, "enemy-opponent") {
		t.Fatalf("combat grounding message = %q", prepared.Messages[transcriptIndex+3].Content)
	}
}

func TestEnemyEventPromptRequiresGroundingInputs(t *testing.T) {
	registry := llm.NewAssetRegistry()
	if err := RegisterPromptAssets(registry); err != nil {
		t.Fatal(err)
	}
	options, err := registry.PromptKitOptions()
	if err != nil {
		t.Fatal(err)
	}
	options = append(options, promptkit.WithProfiles(promptkit.OpenAICompatibleProfile(promptkit.OpenAICompatibleProfileConfig{
		ID: "dnd-extraction", Endpoint: "http://127.0.0.1:1/v1", Model: "enemy-test-model",
	})))
	engine, err := promptkit.NewEngine(promptkit.Config{Timeout: time.Second}, options...)
	if err != nil {
		t.Fatal(err)
	}
	_, err = engine.Prepare(context.Background(), promptkit.RunRequest{
		PromptID: PromptID, PromptVersion: SchemaVersion, ProfileID: "dnd-extraction",
		Inputs: map[string]promptkit.ArtifactRef{
			"transcript":       promptkit.Inline(`{"value":"enemy-transcript"}`),
			"players":          promptkit.Inline(" "),
			"party":            promptkit.Inline(" "),
			"glossary":         promptkit.Inline(" "),
			"npcs":             promptkit.Inline(`{"npcs":[]}`),
			"npc_interactions": promptkit.Inline(`{"npc_interactions":[]}`),
		},
	})
	if err == nil || !strings.Contains(err.Error(), "combat_turns") {
		t.Fatalf("Prepare() error = %v, want required combat-turn input", err)
	}
}

func prepareEnemyEventPrompt(t *testing.T) *promptkit.PreparedRun {
	t.Helper()
	registry := llm.NewAssetRegistry()
	if err := RegisterPromptAssets(registry); err != nil {
		t.Fatal(err)
	}
	options, err := registry.PromptKitOptions()
	if err != nil {
		t.Fatal(err)
	}
	options = append(options, promptkit.WithProfiles(promptkit.OpenAICompatibleProfile(promptkit.OpenAICompatibleProfileConfig{
		ID: "dnd-extraction", Endpoint: "http://127.0.0.1:1/v1", Model: "enemy-test-model",
	})))
	engine, err := promptkit.NewEngine(promptkit.Config{Timeout: time.Second}, options...)
	if err != nil {
		t.Fatal(err)
	}
	prepared, err := engine.Prepare(context.Background(), promptkit.RunRequest{
		PromptID: PromptID, PromptVersion: SchemaVersion, ProfileID: "dnd-extraction",
		Inputs: map[string]promptkit.ArtifactRef{
			"transcript":       promptkit.Inline(`{"value":"enemy-transcript"}`),
			"players":          promptkit.Inline("enemy-player"),
			"party":            promptkit.Inline("enemy-party"),
			"glossary":         promptkit.Inline("enemy-glossary"),
			"npcs":             promptkit.Inline(`{"npcs":[{"name":"enemy-npc"}]}`),
			"combat_turns":     promptkit.Inline(`{"combat_turns":[{"actor":"enemy-turn","turn_kind":"turn"}]}`),
			"npc_interactions": promptkit.Inline(`{"npc_interactions":[{"name":"enemy-opponent","kind":"combat_opponent"}]}`),
		},
	})
	if err != nil {
		t.Fatal(err)
	}
	return prepared
}