clerk @ f68a2c67d3b00aa4f5b556403ea30887c6eedf8c

package lsp

import (

	"fmt"

	"os"

	"slices"

	"strings"

	"testing"

	"go.lsp.dev/protocol"

	"go.lsp.dev/uri"

	"olexsmir.xyz/clerk/internal/testutil/golden"

)

func TestEncodeSemTokens(t *testing.T) {

	tests := map[string]struct {

		tokens []semanticToken

		want   []uint32

	}{

		"nil":   {nil, nil},

		"empty": {[]semanticToken{}, nil},

		"single": {[]semanticToken{

			{line: 0, col: 0, length: 4, tokenType: semDate},

		}, []uint32{0, 0, 4, semDate, 0}},

		"line 0 col 0": {[]semanticToken{

			{line: 0, col: 0, length: 1, tokenType: semDirective},

		}, []uint32{0, 0, 1, semDirective, 0}},

		"multiple": {[]semanticToken{

			{line: 0, col: 0, length: 10, tokenType: semDate},

			{line: 0, col: 11, length: 5, tokenType: semString},

			{line: 1, col: 4, length: 10, tokenType: semAccount},

		}, []uint32{

			0, 0, 10, semDate, 0,

			0, 11, 5, semString, 0,

			1, 4, 10, semAccount, 0,

		}},

		// input must be sorted by line and column (rawToSemanticTokens output);

		// deltas would underflow otherwise

		"sorted": {[]semanticToken{

			{line: 0, col: 0, length: 10, tokenType: semDate},

			{line: 0, col: 32, length: 2, tokenType: semAmount},

			{line: 0, col: 36, length: 3, tokenType: semCommodity},

			{line: 1, col: 4, length: 6, tokenType: semAccount},

		}, []uint32{

			0, 0, 10, semDate, 0,

			0, 32, 2, semAmount, 0,

			0, 4, 3, semCommodity, 0,

			1, 4, 6, semAccount, 0,

		}},

	}

	for tname, tt := range tests {

		t.Run(tname, func(t *testing.T) {

			if got := encodeSemTokens(tt.tokens); !slices.Equal(got, tt.want) {

				t.Errorf("encodeSemTokens() = %v, want %v", got, tt.want)

			}

		})

	}

}

func TestServer_Semantic_EmptyDocument(t *testing.T) {

	srv := NewServer("test")

	srv.server.openDoc(uri.URI("file:///empty.journal"), "", 1, "journal")

	result, err := srv.server.SemanticTokensFull(t.Context(), &protocol.SemanticTokensParams{

		TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///empty.journal")},

	})

	if err != nil {

		t.Fatal(err)

	}

	if len(result.Data) != 0 {

		t.Errorf("expected empty data for empty doc, got %d values", len(result.Data))

	}

}

func TestServer_Semantic_DocumentNotFound(t *testing.T) {

	result, err := NewServer("test").server.SemanticTokensFull(t.Context(), &protocol.SemanticTokensParams{

		TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///unknown.journal")},

	})

	if err != nil {

		t.Fatal(err)

	}

	if result == nil {

		t.Fatal("result is nil")

	}

	if result.Data != nil {

		t.Errorf("expected nil Data for unknown doc, got %v", result.Data)

	}

}

func TestServer_Semantic_Range(t *testing.T) {

	content := `2024-01-15 test

    expenses:food  $50

2024-01-16 other

  expenses:drinks  $20

`

	srv := NewServer("test")

	srv.server.openDoc(uri.URI("file:///test.journal"), content, 1, "journal")

	result, err := srv.server.SemanticTokensRange(t.Context(), &protocol.SemanticTokensRangeParams{

		TextDocument: protocol.TextDocumentIdentifier{URI: uri.URI("file:///test.journal")},

		Range: protocol.Range{

			Start: protocol.Position{Line: 0, Character: 0},

			End:   protocol.Position{Line: 1, Character: 50},

		},

	})

	if err != nil {

		t.Fatal(err)

	}

	if result == nil || len(result.Data) == 0 {

		t.Fatal("expected non-empty tokens for range")

	}

	// decode and assert every token is inside the requested line range

	line, col := 0, 0

	for i := 0; i+4 < len(result.Data); i += 5 {

		dl, dc := result.Data[i], result.Data[i+1]

		if dl > 0 {

			col = 0

		}

		line += int(dl)

		col += int(dc)

		if line > 1 {

			t.Fatalf("token at line %d outside requested range [0,1]", line)

		}

	}

}

func TestSemanticTokensEdits(t *testing.T) {

	tests := map[string]struct{ old, new []uint32 }{

		"identical":      {[]uint32{1, 2, 3}, []uint32{1, 2, 3}},

		"both empty":     {},

		"empty to non":   {nil, []uint32{1, 2}},

		"non to empty":   {[]uint32{1, 2}, nil},

		"pure insert":    {[]uint32{1, 2}, []uint32{1, 2, 3, 4}},

		"pure delete":    {[]uint32{1, 2, 3, 4}, []uint32{1, 2}},

		"replace middle": {[]uint32{1, 2, 3, 4, 5}, []uint32{1, 2, 9, 4, 5}},

		"replace all":    {[]uint32{1, 2}, []uint32{3, 4}},

		"replace tail":   {[]uint32{1, 2, 3, 4, 5}, []uint32{1, 2, 3, 4, 6}},

	}

	for tname, tt := range tests {

		t.Run(tname, func(t *testing.T) {

			edits := semanticTokensEdits(tt.old, tt.new)

			if got := applySemEdits(tt.old, edits); !slices.Equal(got, tt.new) {

				t.Errorf("apply(%v, %v) = %v, want %v", tt.old, edits, got, tt.new)

			}

			for _, e := range edits {

				if e.Start+e.DeleteCount > uint32(len(tt.old)) {

					t.Errorf("edit %+v out of bounds for old length %d", e, len(tt.old))

				}

			}

		})

	}

}

// applySemEdits applies LSP semantic token edits to a client-side copy of data.

func applySemEdits(data []uint32, edits []protocol.SemanticTokensEdit) []uint32 {

	out := slices.Clone(data)

	for _, e := range edits {

		out = append(append(out[:e.Start], e.Data...), out[e.Start+e.DeleteCount:]...)

	}

	return out

}

func TestGolden_SemanticTokens(t *testing.T) {

	for _, tt := range []string{"semantic-empty", "semantic-journal", "semantic-directives", "semantic-unparseable", "semantic-with-errors"} {

		ar := golden.Read(t, tt)

		t.Run(tt+"_golden", func(t *testing.T) {

			toks := renderSemanticTokens(tokSem(ar.Get("in.journal")))

			golden.Assert(t, ar, toks)

		})

		t.Run(tt+"_no-overlap", func(t *testing.T) {

			assertGoldenNoOverlap(t, tt, ar)

		})

	}

}

func TestGolden_SemanticTokensDelta(t *testing.T) {

	for _, tt := range []string{"semantic-delta-edit", "semantic-delta-nochange", "semantic-delta-stale"} {

		ar := golden.Read(t, tt)

		t.Run(tt+"_no-overlap", func(t *testing.T) {

			assertGoldenNoOverlap(t, tt, ar)

		})

		t.Run(tt, func(t *testing.T) {

			in := ar.Get("in.journal")

			u := uri.URI("file:///test.journal")

			srv := NewServer("test")

			srv.server.openDoc(u, string(in), 1, "journal")

			full, err := srv.server.SemanticTokensFull(t.Context(), &protocol.SemanticTokensParams{

				TextDocument: protocol.TextDocumentIdentifier{URI: u},

			})

			if err != nil {

				t.Fatal(err)

			}

			if full.ResultID == nil || *full.ResultID == "" {

				t.Fatal("expected a resultId on the full result")

			}

			finalText := in

			if ed := ar.Get("edited.journal"); ed != nil {

				srv.server.updateDoc(u, 2, []protocol.TextDocumentContentChangeEvent{

					&protocol.TextDocumentContentChangeWholeDocument{Text: string(ed)},

				})

				finalText = ed

			}

			prev := *full.ResultID

			if p := ar.Get("prev-id"); p != nil {

				prev = strings.TrimSpace(string(p))

			}

			res, err := srv.server.SemanticTokensFullDelta(t.Context(), &protocol.SemanticTokensDeltaParams{

				TextDocument:     protocol.TextDocumentIdentifier{URI: u},

				PreviousResultID: prev,

			})

			if err != nil {

				t.Fatal(err)

			}

			var client []uint32

			var out strings.Builder

			switch r := res.(type) {

			case *protocol.SemanticTokensDelta:

				fmt.Fprintf(&out, "delta resultId %s\n", *r.ResultID)

				client = applySemEdits(full.Data, r.Edits)

			case *protocol.SemanticTokens:

				fmt.Fprintf(&out, "full resultId %s\n", *r.ResultID)

				client = r.Data

			default:

				t.Fatalf("unexpected result type %T", res)

			}

			// The client's token state must equal the final text's tokens: an

			// independent reference that keeps the golden from capturing bugs.

			if want := encodeSemTokens(tokSem(finalText)); !slices.Equal(client, want) {

				t.Errorf("delta flow produced %d elems, want %d", len(client), len(want))

			}

			out.WriteString(renderSemanticTokens(tokSem(finalText)))

			golden.Assert(t, ar, out.String())

		})

	}

}

func assertGoldenNoOverlap(t *testing.T, tt string, ar *golden.Archive) {

	t.Helper()

	for _, f := range ar.Files {

		if strings.HasSuffix(f.Name, ".journal") {

			assertNoOverlap(t, tt, tokSem(f.Data))

		}

	}

}

func assertNoOverlap(t *testing.T, tt string, toks []semanticToken) {

	t.Helper()

	slices.SortFunc(toks, func(a, b semanticToken) int {

		if a.line != b.line {

			return int(a.line) - int(b.line)

		}

		return int(a.col) - int(b.col)

	})

	for i := 1; i < len(toks); i++ {

		prev, cur := toks[i-1], toks[i]

		if prev.line != cur.line {

			continue

		}

		if cur.col < prev.col+prev.length {

			t.Errorf("%s: overlapping tokens on line %d: %s@%d+%d then %s@%d+%d",

				tt, prev.line, tokenTypeStrings[prev.tokenType], prev.col, prev.length,

				tokenTypeStrings[cur.tokenType], cur.col, cur.length)

		}

	}

}

func renderSemanticTokens(tokens []semanticToken) string {

	slices.SortFunc(tokens, func(a, b semanticToken) int {

		if a.line != b.line {

			return int(a.line) - int(b.line)

		}

		return int(a.col) - int(b.col)

	})

	var b strings.Builder

	for _, tok := range tokens {

		fmt.Fprintf(&b, "%d:%d+%d %s", tok.line, tok.col, tok.length, tokenTypeStrings[tok.tokenType])

		for i, m := range modifierStrings {

			if tok.modifiers&(1<<uint(i)) != 0 {

				b.WriteByte(' ')

				b.WriteString(m)

			}

		}

		b.WriteByte('\n')

	}

	return b.String()

}

func tokSem(content []byte) []semanticToken {

	c := string(content)

	return tokenizeForSemantics(c, parseJournalStr(c))

}

func BenchmarkSemanticTokens(b *testing.B) {

	content := openJournal(b, "../../journal/testdata/journals/actual-1ktxns-100accts.journal")

	// Cold path: each iteration re-parses and re-encodes, as after an edit.

	b.ReportAllocs()

	b.ResetTimer()

	for b.Loop() {

		tokens := tokenizeForSemantics(content, parseJournalStr(content))

		_ = encodeSemTokens(tokens)

	}

}

// BenchmarkSemanticTokensDelta measures the cost of one dela response after an edit.

func BenchmarkSemanticTokensDelta(b *testing.B) {

	content := openJournal(b, "../../journal/testdata/journals/actual-1ktxns-100accts.journal")

	prev := encodeSemTokens(tokenizeForSemantics(content, parseJournalStr(content)))

	edited := content + "\n2000-06-15 transaction 2501\n  expenses:new  1 C\n  assets:cash\n"

	b.ReportAllocs()

	b.ResetTimer()

	for b.Loop() {

		data := encodeSemTokens(tokenizeForSemantics(edited, parseJournalStr(edited)))

		_ = semanticTokensEdits(prev, data)

	}

}

func BenchmarkSemanticTokensEdits(b *testing.B) {

	content := openJournal(b, "../../journal/testdata/journals/actual-1ktxns-100accts.journal")

	old := encodeSemTokens(tokenizeForSemantics(content, parseJournalStr(content)))

	new := encodeSemTokens(tokenizeForSemantics(

		content+"\n2000-06-15 transaction 2501\n  expenses:new  1 C\n  assets:cash\n",

		parseJournalStr(content+"\n2000-06-15 transaction 2501\n  expenses:new  1 C\n  assets:cash\n"),

	))

	b.ReportAllocs()

	b.ResetTimer()

	for b.Loop() {

		_ = semanticTokensEdits(old, new)

	}

}

func openJournal(t testing.TB, path string) string {

	t.Helper()

	src, err := os.ReadFile(path)

	if err != nil {

		t.Fatal(err)

	}

	return string(src)

}