clerk @ master

package lsp

import (

	"fmt"

	"strings"

	"testing"

	"time"

	"go.lsp.dev/protocol"

	"go.lsp.dev/uri"

	"olexsmir.xyz/clerk/internal/lsp/lsputil"

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

	"olexsmir.xyz/clerk/journal"

)

func TestDetectCompletion_NoJournal(t *testing.T) {

	// detection must not depend on a parse

	i := strings.Index("    no^te foo\n", "^")

	content := "    note foo\n"

	ctx, _ := detectCompletionCtx(content, i)

	if ctx != cmplAccount {

		t.Errorf("ctx = %v, want account", ctx)

	}

}

func TestDateStyle(t *testing.T) {

	tests := map[string]struct {

		history []string

		sep     byte

		hasYear bool

	}{

		"empty":    {nil, '-', true},

		"dash":     {[]string{"2024-01-02"}, '-', true},

		"slash":    {[]string{"2024/01/20"}, '/', true},

		"yearless": {[]string{"6-10"}, '-', false},

	}

	for name, tt := range tests {

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

			sep, hasYear := dateStyle(tt.history)

			if sep != tt.sep || hasYear != tt.hasYear {

				t.Errorf("dateStyle = %q/%v, want %q/%v", sep, hasYear, tt.sep, tt.hasYear)

			}

		})

	}

}

func TestDateTokenEnd(t *testing.T) {

	tests := map[string]struct {

		content string

		start   int

		want    int

	}{

		"full date":            {"2024-01-02 x", 0, 10},

		"unpadded":             {"2024/1/2 x", 0, 8},

		"yearless":             {"6-10 x", 0, 4},

		"stops at =":           {"2024-01-02=2024-01-03", 0, 10},

		"stops at comment":     {"2024-01-02;x", 0, 10},

		"partial trailing sep": {"2024- x", 0, 5},

		"partial mid":          {"2024-0 x", 0, 6},

	}

	for name, tt := range tests {

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

			if got := dateTokenEnd(tt.content, tt.start); got != tt.want {

				t.Errorf("dateTokenEnd = %d, want %d", got, tt.want)

			}

		})

	}

}

func TestDatePatternMatch(t *testing.T) {

	tests := map[string]struct {

		pattern, canonical string

		want               bool

	}{

		"digit subsequence":   {"2024-01-0", "2024-01-05", true},

		"same sep":            {"2024/0", "2024/01/20", true},

		"other sep rejected":  {"2024/0", "2024-01-20", false},

		"yearless":            {"6-10", "6-10", true},

		"yearless padded rej": {"06-10", "6-10", false},

		"no match":            {"2025", "2024-01-20", false},

		"empty":               {"", "2024-01-20", true},

	}

	for name, tt := range tests {

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

			if got := datePatternMatch(tt.pattern, tt.canonical); got != tt.want {

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

			}

		})

	}

}

func TestGolden_Completion(t *testing.T) {

	for _, tt := range []string{"completion-contexts", "completion-journal", "completion-no-transactions"} {

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

			ar := golden.Read(t, tt)

			h := newTxtarHarness(t, ar)

			if err := h.srv.applySettings(t.Context(), []byte(`{"latin_to_cyrillic_completion": true}`)); err != nil {

				t.Fatal(err)

			}

			var b strings.Builder

			for i, c := range h.cursors {

				tdp := h.textDocumentPosition(i)

				res, err := h.srv.Completion(t.Context(), &protocol.CompletionParams{

					TextDocumentPositionParams: tdp,

				})

				if err != nil {

					t.Fatal(err)

				}

				ctx, start := detectCompletionCtx(h.content, c)

				fmt.Fprintf(&b, "%d:%d %s %q\n", tdp.Position.Line, tdp.Position.Character, ctx, h.content[start:c])

				list, ok := res.(*protocol.CompletionList)

				if !ok {

					t.Fatalf("Completion returned %T, want *protocol.CompletionList", res)

				}

				now := time.Now()

				var sep byte

				var hasYear bool

				if ctx == cmplDate {

					if an := h.srv.analysisFor(h.uri); an != nil {

						sep, hasYear = dateStyle(an.DateStrings)

					}

				}

				for _, item := range list.Items {

					label := item.Label

					if ctx == cmplDate {

						switch label {

						case renderDate(now, sep, hasYear):

							label = "today"

						case renderDate(now.AddDate(0, 0, -1), sep, hasYear):

							label = "yesterday"

						case renderDate(now.AddDate(0, 0, -2), sep, hasYear):

							label = "2 days ago"

						}

					}

					fmt.Fprintf(&b, "  %s\n", label)

				}

			}

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

		})

	}

}

func TestCompletionEditReplacesWholeWord(t *testing.T) {

	// mid-word completion: accepting replaces the whole typed word, leaving no suffix

	cases := map[string]struct{ journal, cursorLine, item, wantLine string }{

		"account": {

			journal: `account assets:bank

2024-01-15 x

  assets:bank $10

  assets:cash

`,

			cursorLine: "  assets:b^nk $10\n",

			item:       "assets:bank",

			wantLine:   "  assets:bank $10\n",

		},

		"payee": {

			journal: `account assets:cash

2024-01-15 Grocery Store

  assets:cash

2024-01-15 Grocery

  assets:cash

`,

			cursorLine: "2024-01-15 Groc^ery Store\n",

			item:       "Grocery",

			wantLine:   "2024-01-15 Grocery Store\n",

		},

		"tag value": {

			journal: `account assets:cash

2024-01-15 x

  assets:cash

; client:acme

`,

			cursorLine: "; client:a^cme\n",

			item:       "acme",

			wantLine:   "; client:acme\n",

		},

	}

	for name, tt := range cases {

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

			cur := strings.Index(tt.cursorLine, "^") + len(tt.journal)

			content := strings.Replace(tt.journal+tt.cursorLine, "^", "", 1)

			srv := newServer(t).server

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

			line, col := lsputil.LineCol(content, cur)

			res, err := srv.Completion(t.Context(), &protocol.CompletionParams{

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

				Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

			})

			if err != nil {

				t.Fatal(err)

			}

			list := res.(*protocol.CompletionList)

			var edit *protocol.TextEdit

			for _, it := range list.Items {

				if it.Label == tt.item {

					edit = it.TextEdit.(*protocol.TextEdit)

				}

			}

			if edit == nil {

				t.Fatalf("item %q not offered (got %v)", tt.item, labelsOf(list))

			}

			s := lsputil.Offset(content, int(edit.Range.Start.Line), int(edit.Range.Start.Character))

			e := lsputil.Offset(content, int(edit.Range.End.Line), int(edit.Range.End.Character))

			got := content[:s] + edit.NewText + content[e:]

			lines := strings.Split(got, "\n")

			if lines[edit.Range.Start.Line] != strings.TrimSuffix(tt.wantLine, "\n") {

				t.Errorf("edited line = %q, want %q", lines[edit.Range.Start.Line], strings.TrimSuffix(tt.wantLine, "\n"))

			}

		})

	}

}

func labelsOf(list *protocol.CompletionList) []string {

	labels := make([]string, 0, len(list.Items))

	for _, it := range list.Items {

		labels = append(labels, it.Label)

	}

	return labels

}

func (c cmplCtx) String() string {

	switch c {

	case cmplNone:

		return "none"

	case cmplAccount:

		return "account"

	case cmplPayee:

		return "payee"

	case cmplCommodity:

		return "commodity"

	case cmplTagName:

		return "tag"

	case cmplTagValue:

		return "tag-value"

	case cmplDate:

		return "date"

	case cmplDirective:

		return "directive"

	default:

		return "?"

	}

}

func BenchmarkCompletion(b *testing.B) {

	path := "../../journal/testdata/journals/actual-1ktxns-100accts.journal"

	rj, err := journal.NewLoader().Resolve(path)

	if err != nil {

		b.Fatal(err)

	}

	content := string(rj.Occurrences[0].Src)

	srv := newServer(b)

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

	srv.server.analysisFor(uri.URI("file:///test.journal")) // warm the per-doc cache

	for tname, tt := range map[string]int{

		"1k txns, account":        strings.Index(content, "\n  1:2:3 ") + len("\n  ") + 2,

		"1k txns, empty payee":    strings.Index(content, "transaction 1") + len("transaction "),

		"1k txns, commodity":      strings.Index(content, "2 B @@") + len("2 B"),

		"1k txns, date":           strings.Index(content, "2000-01-0") + len("2000-01-0"),

		"1k txns, price date":     strings.Index(content, "P 2000-01-0") + len("P 2000-01-0"),

		"1k txns, price quantity": strings.Index(content, "P 2000-01-01 A  0.70") + len("P 2000-01-01 A  0.70"),

	} {

		b.Run(tname, func(b *testing.B) {

			line, col := lsputil.LineCol(content, tt)

			params := &protocol.CompletionParams{

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

				Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

			}

			// warm up

			if _, err := srv.server.Completion(b.Context(), params); err != nil {

				b.Fatal(err)

			}

			b.ReportAllocs()

			b.ResetTimer()

			for b.Loop() {

				if _, err := srv.server.Completion(b.Context(), params); err != nil {

					b.Fatal(err)

				}

			}

			// guard: line-local lexing must stay far below the old whole-file

			// relex (~3ms on this file); the measured target is sub-ms

			if avg := b.Elapsed() / time.Duration(b.N); avg > 2*time.Millisecond {

				b.Fatalf("completion %v/op: whole-file relex regression", avg)

			}

		})

	}

}

func BenchmarkCompletionTransliteration(b *testing.B) {

	tails := []string{"а", "б", "в", "г", "д", "е", "є", "ж", "з", "и", "і", "ї", "й", "к", "л", "м", "н", "о", "п", "р"}

	var sb strings.Builder

	for _, n := range []string{"Витрати", "Доходи", "Активи", "Капітал", "Зобовязання"} {

		for _, t := range tails {

			fmt.Fprintf(&sb, "account %s:%s%s\n", n, n, t)

		}

	}

	sb.WriteString("account vyt")

	content := sb.String()

	srv := newServer(b)

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

	srv.server.analysisFor(uri.URI("file:///test.journal")) // warm the per-doc cache

	if err := srv.server.applySettings(b.Context(), []byte(`{"latin_to_cyrillic_completion": true}`)); err != nil {

		b.Fatal(err)

	}

	line, col := lsputil.LineCol(content, len(content))

	params := &protocol.CompletionParams{

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

		Position:     protocol.Position{Line: uint32(line), Character: uint32(col)},

	}

	warm, err := srv.server.Completion(b.Context(), params)

	if err != nil {

		b.Fatal(err)

	}

	// Guard: the Cyrillic corpus completes only through the transliterated

	// pattern; without it the list collapses to the latin "vyt" placeholder.

	if got := len(warm.(*protocol.CompletionList).Items); got <= 1 {

		b.Fatalf("transliteration matching did not engage (items: %d)", got)

	}

	b.ReportAllocs()

	b.ResetTimer()

	for b.Loop() {

		if _, err := srv.server.Completion(b.Context(), params); err != nil {

			b.Fatal(err)

		}

	}

}