package promptkit

import (
	"reflect"
	"strings"
	"testing"

	"gitea.maximumdirect.net/eric/promptkit/internal/domain"
)

func TestToDomainAppendedMessages(t *testing.T) {
	tests := []struct {
		name        string
		messages    []RenderedMessage
		want        []domain.RenderedMessage
		wantErr     string
		privateRole string
		privateText string
	}{
		{
			name: "normalizes supported roles",
			messages: []RenderedMessage{
				{Role: " DeVeLoPeR ", Content: "developer"},
				{Role: "SyStEm", Content: "system"},
				{Role: "\tUsEr\n", Content: "user"},
				{Role: "assistant", Content: "assistant"},
			},
			want: []domain.RenderedMessage{
				{Role: domain.RoleDeveloper, Content: "developer"},
				{Role: domain.RoleSystem, Content: "system"},
				{Role: domain.RoleUser, Content: "user"},
				{Role: domain.RoleAssistant, Content: "assistant"},
			},
		},
		{
			name:     "invalid role UTF-8",
			messages: []RenderedMessage{{Role: string([]byte{0xff}), Content: "private-content"}},
			wantErr:  "appended message 0 role",
		},
		{
			name:     "invalid content UTF-8",
			messages: []RenderedMessage{{Role: "private-role", Content: string([]byte{0xff})}},
			wantErr:  "appended message 0 content",
		},
		{
			name:        "unsupported role",
			messages:    []RenderedMessage{{Role: "private-role", Content: "private-content"}},
			wantErr:     "appended message 0 role",
			privateRole: "private-role",
			privateText: "private-content",
		},
		{
			name:        "invalid cache control",
			messages:    []RenderedMessage{{Role: RoleUser, Content: "private-content", CacheControl: &CacheControl{Type: "private-cache"}}},
			wantErr:     "appended message 0 cache_control",
			privateText: "private-content",
		},
		{
			name: "empty and whitespace content",
			messages: []RenderedMessage{
				{Role: RoleUser, Content: ""},
				{Role: RoleAssistant, Content: " \t\n "},
			},
			want: []domain.RenderedMessage{
				{Role: domain.RoleUser, Content: ""},
				{Role: domain.RoleAssistant, Content: " \t\n "},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			got, err := toDomainAppendedMessages(test.messages)
			if test.wantErr != "" {
				if err == nil || !strings.Contains(err.Error(), test.wantErr) {
					t.Fatalf("error = %v, want %q", err, test.wantErr)
				}
				for _, privateValue := range []string{test.privateRole, test.privateText} {
					if privateValue != "" && strings.Contains(err.Error(), privateValue) {
						t.Fatalf("error exposed appended message data %q: %v", privateValue, err)
					}
				}
				return
			}
			if err != nil {
				t.Fatalf("toDomainAppendedMessages() error = %v", err)
			}
			if !reflect.DeepEqual(got, test.want) {
				t.Fatalf("toDomainAppendedMessages() = %#v, want %#v", got, test.want)
			}
		})
	}
}

func TestToDomainAppendedMessagesCopiesCacheControl(t *testing.T) {
	cacheControl := &CacheControl{Type: CacheControlEphemeral, TTL: "1h"}
	messages := []RenderedMessage{{Role: RoleUser, Content: "content", CacheControl: cacheControl}}
	request, err := toDomainRunRequest(RunRequest{AppendedMessages: messages})
	if err != nil {
		t.Fatalf("toDomainRunRequest() error = %v", err)
	}

	messages[0].Content = "changed"
	cacheControl.TTL = ""
	if request.AppendedMessages[0].Content != "content" || request.AppendedMessages[0].CacheControl.TTL != "1h" {
		t.Fatalf("domain request did not retain an independent appended-message copy: %#v", request.AppendedMessages)
	}
}