package outputschema

import (
	"encoding/json"
	"reflect"
	"strings"
	"testing"

	"gitea.maximumdirect.net/eric/audita/internal/core/schema"
)

func tinyTranscript() *schema.Transcript {
	return &schema.Transcript{Segments: []schema.Segment{
		{ID: 1, Speaker: "A", Start: 0, End: 1, Text: "hello"},
	}}
}

func TestResolveBareSegments(t *testing.T) {
	def, err := Resolve(SchemaBareSegments)
	if err != nil {
		t.Fatalf("Resolve error: %v", err)
	}
	raw, err := def.Encoder(tinyTranscript())
	if err != nil {
		t.Fatalf("encode error: %v", err)
	}
	if !strings.HasPrefix(strings.TrimSpace(string(raw)), "[") {
		t.Fatalf("expected bare-segments array output, got %s", string(raw))
	}
}

func TestResolveAuditaV1(t *testing.T) {
	def, err := Resolve(SchemaAuditaV1)
	if err != nil {
		t.Fatalf("Resolve error: %v", err)
	}
	raw, err := def.Encoder(tinyTranscript())
	if err != nil {
		t.Fatalf("encode error: %v", err)
	}
	var out struct {
		Schema   string           `json:"schema"`
		Version  string           `json:"version"`
		Segments []map[string]any `json:"segments"`
	}
	if err := json.Unmarshal(raw, &out); err != nil {
		t.Fatalf("unmarshal error: %v", err)
	}
	if out.Schema != "audita-v1" || out.Version != "v1" || len(out.Segments) != 1 {
		t.Fatalf("unexpected audita-v1 output: %+v", out)
	}
}

func TestResolveUnknown(t *testing.T) {
	_, err := Resolve("seriatim-intermediate")
	if err == nil || !strings.Contains(err.Error(), "unsupported output schema") {
		t.Fatalf("expected unsupported output schema error, got %v", err)
	}
}

func TestSupportedKeysAndIsSupported(t *testing.T) {
	want := []string{SchemaBareSegments, SchemaAuditaV1}
	if got := SupportedKeys(); !reflect.DeepEqual(got, want) {
		t.Fatalf("unexpected supported schema keys: got=%v want=%v", got, want)
	}

	for _, key := range want {
		if !IsSupported(key) {
			t.Fatalf("expected schema key %q to be supported", key)
		}
	}
	if IsSupported("seriatim-intermediate") {
		t.Fatalf("did not expect unsupported schema to be reported as supported")
	}
}