// These tests check production message, tool, initialization, load, and error
// payloads against the pinned schema. One E2E conversation does not emit every
// variant.
package acp

import (
	"encoding/json"
	"os"
	"testing"

	"github.com/google/jsonschema-go/jsonschema"

	"albedo/cli/internal/app"
	"albedo/cli/internal/daemon"
)

func TestPinnedSchema(t *testing.T) {
	data, err := os.ReadFile("testdata/acp-schema-v1.27.0.json")
	if err != nil {
		t.Fatal(err)
	}
	var root map[string]json.RawMessage
	if err := json.Unmarshal(data, &root); err != nil {
		t.Fatal(err)
	}

	s, backend := testSession(t)
	s.models = app.ACPModels{Current: "fixture/model", Available: []string{"fixture/model", "other/model"}}
	s.adapter.respond(json.RawMessage("1"), initialize("test"), nil)
	for _, event := range []daemon.StreamEvent{
		{Type: daemon.EventUser, Source: "chat", EntryID: "user", Text: "question"},
		{Type: daemon.EventMessage, EntryID: "message", Text: "answer"},
		{Type: daemon.EventThinking, EntryID: "thought", Text: "thinking"},
		{Type: daemon.EventTool, ProgressCallID: "call", ToolName: "run", ToolStatus: "completed", ToolResult: "done"},
		{Type: daemon.EventTool, ProgressCallID: "failed", ToolName: "run", ToolStatus: "failed", ToolResult: "failed"},
	} {
		if err := s.replay(event); err != nil {
			t.Fatal(err)
		}
	}
	s.buffering = true
	if err := s.load(request{ID: json.RawMessage("2")}); err != nil {
		t.Fatal(err)
	}
	s.adapter.respond(json.RawMessage("3"), nil, problem(-32603, "observation_uncertain", "lost"))
	<-s.adapter.writer.flush()
	responseSchemas := map[float64]string{1: "InitializeResponse", 2: "LoadSessionResponse", 3: "Error"}
	for len(backend.written) > 0 {
		var wire map[string]any
		if err := json.Unmarshal(<-backend.written, &wire); err != nil {
			t.Fatal(err)
		}
		name := ""
		var value any
		switch wire["method"] {
		case "session/update":
			name = "SessionUpdate"
			value = wire["params"].(map[string]any)["update"]
		default:
			id, ok := wire["id"].(float64)
			if !ok {
				t.Fatalf("response has no numeric test ID: %v", wire)
			}
			name = responseSchemas[id]
			if name == "" {
				t.Fatalf("no expected response schema for ID %v", id)
			}
			if name == "Error" {
				value = wire["error"]
			} else {
				value = wire["result"]
			}
		}
		t.Run(name, func(t *testing.T) {
			wrapper := map[string]any{"$defs": root["$defs"], "$ref": "#/$defs/" + name}
			encoded, _ := json.Marshal(wrapper)
			var schema jsonschema.Schema
			if err := json.Unmarshal(encoded, &schema); err != nil {
				t.Fatal(err)
			}
			resolved, err := schema.Resolve(nil)
			if err != nil {
				t.Fatal(err)
			}
			if err := resolved.Validate(value); err != nil {
				t.Fatal(err)
			}
		})
	}
}