clerk @ 8dcac8b50c40fbb802c43d17d2c91e46b7087850

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_SimpleTransaction(t *testing.T) {

	content := `2024-01-15 test

    expenses:food  $50

    assets:cash

`

	srv := NewServer("test")

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

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

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

	})

	if err != nil {

		t.Fatal(err)

	}

	if result == nil {

		t.Fatal("result is nil")

	}

	if len(result.Data) == 0 {

		t.Fatal("expected non-empty token data")

	}

	if len(result.Data)%5 != 0 {

		t.Fatalf("token data length %d is not a multiple of 5", len(result.Data))

	}

	// first token is the transaction date at line 0, col 0: deltas are 0, 0

	if result.Data[0] != 0 || result.Data[1] != 0 {

		t.Errorf("first token deltas = %d,%d, want 0,0", result.Data[0], result.Data[1])

	}

}

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)

		}

	}

}

// Golden

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) {

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

			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)

	}

}

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

	t.Helper()

	src, err := os.ReadFile(path)

	if err != nil {

		t.Fatal(err)

	}

	return string(src)

}