package lsp

import (
	"context"
	"path/filepath"
	"slices"
	"sync"
	"testing"
	"time"

	"go.lsp.dev/protocol"
	"go.lsp.dev/uri"

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

func TestAnalysisFor_CachedAndRebuilt(t *testing.T) {
	u := uri.File(filepath.Join(t.TempDir(), "a.journal"))
	srv := NewServer("test")
	srv.server.openDoc(u, "2024-01-01 t\n    expenses:food  $10\n    assets:cash\n", 1, "journal")

	a1 := srv.server.analysisFor(u)
	if a1 == nil {
		t.Fatal("analysisFor returned nil")
	}
	if a2 := srv.server.analysisFor(u); a2 != a1 {
		t.Error("cached analysis not reused")
	}

	srv.server.updateDoc(u, 2, []protocol.TextDocumentContentChangeEvent{
		&protocol.TextDocumentContentChangeWholeDocument{Text: "2024-01-02 t\n    expenses:travel  $20\n    assets:cash\n"},
	})
	a3 := srv.server.analysisFor(u)
	if a3 == a1 {
		t.Error("edit did not rebuild the analysis")
	}
	if !slices.Contains(a3.AccountNames, "expenses:travel") || slices.Contains(a3.AccountNames, "expenses:food") {
		t.Errorf("stale accounts after edit: %v", a3.AccountNames)
	}
}

func TestAnalysisFor_DependentDirty(t *testing.T) {
	dir := t.TempDir()
	base := filepath.Join(dir, "base.journal")
	main := filepath.Join(dir, "main.journal")
	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:cash\n"))
	testutil.WriteFile(t, main, []byte("include base.journal\n"))

	srv := NewServer("test")
	uMain, uBase := uri.File(main), uri.File(base)
	srv.server.openDoc(uMain, "include base.journal\n", 1, "journal")
	srv.server.openDoc(uBase, "2024-01-01 t\n    expenses:food  $10\n    assets:cash\n", 1, "journal")

	aMain := srv.server.analysisFor(uMain)
	if !slices.Contains(aMain.AccountNames, "assets:cash") {
		t.Fatalf("main analysis missing included account: %v", aMain.AccountNames)
	}

	srv.server.updateDoc(uBase, 2, []protocol.TextDocumentContentChangeEvent{
		&protocol.TextDocumentContentChangeWholeDocument{Text: "2024-01-01 t\n    expenses:food  $10\n    assets:bank\n"},
	})
	aMain2 := srv.server.analysisFor(uMain)
	if !slices.Contains(aMain2.AccountNames, "assets:bank") {
		t.Errorf("dependent analysis not rebuilt with new buffer content: %v", aMain2.AccountNames)
	}
}

func TestServer_Diagnostics(t *testing.T) {
	dir := t.TempDir()
	a := uri.File(filepath.Join(dir, "a.journal"))
	b := uri.File(filepath.Join(dir, "b.journal"))

	aContent := "account expenses:food\naccount assets:cash\ncommodity $\npayee test\n\n2024-01-01 * test\n    expenses:food  $10.00\n    assets:cash  $5.00\n"
	bContent := "include a.journal\n"
	testutil.WriteFile(t, a.Path(), []byte(aContent))
	testutil.WriteFile(t, b.Path(), []byte(bContent))

	srv := NewServer("test")
	capture := &captureClient{}
	srv.server.client = capture

	open := func(u uri.URI, content string) {
		t.Helper()
		if err := srv.server.DidOpen(t.Context(), &protocol.DidOpenTextDocumentParams{
			TextDocument: protocol.TextDocumentItem{URI: u, LanguageID: "journal", Version: 1, Text: content},
		}); err != nil {
			t.Fatalf("didOpen %s: %v", u, err)
		}
	}
	open(a, aContent)
	open(b, bContent)

	waitFor(t, "diagnostics for the unbalanced transaction", func() bool {
		da, _ := capture.lastDiags(a)
		return len(da) != 0
	})

	aEdited := "account expenses:food\naccount assets:cash\naccount assets:bank\ncommodity $\npayee test\n\n2024-01-01 * test\n    expenses:food  $20.00\n    assets:cash  $-10.00\n    assets:bank  $-10.00\n"
	if err := srv.server.DidChange(t.Context(), &protocol.DidChangeTextDocumentParams{
		TextDocument: protocol.VersionedTextDocumentIdentifier{
			TextDocumentIdentifier: protocol.TextDocumentIdentifier{URI: a},
			Version:                2,
		},
		ContentChanges: []protocol.TextDocumentContentChangeEvent{
			&protocol.TextDocumentContentChangeWholeDocument{Text: aEdited},
		},
	}); err != nil {
		t.Fatalf("didChange a: %v", err)
	}

	waitFor(t, "a diagnostics to clear after the edit", func() bool {
		da, _ := capture.lastDiags(a)
		return len(da) == 0
	})

	if err := srv.server.DidClose(t.Context(), &protocol.DidCloseTextDocumentParams{
		TextDocument: protocol.TextDocumentIdentifier{URI: a},
	}); err != nil {
		t.Fatalf("didClose a: %v", err)
	}
	if da, _ := capture.lastDiags(a); len(da) != 0 {
		t.Errorf("diagnostics not cleared on close: %v", da)
	}
}

func TestServer_DidChangeWatchedFiles_SkipsOpenDocuments(t *testing.T) {
	dir := t.TempDir()
	base := filepath.Join(dir, "base.journal")
	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:cash\n"))

	srv := NewServer("test")
	uBase := uri.File(base)
	srv.server.openDoc(uBase, "2024-01-01 t\n    expenses:food  $10\n    assets:cash\n", 1, "journal")

	a1 := srv.server.analysisFor(uBase)

	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:bank\n"))
	if err := srv.server.DidChangeWatchedFiles(context.Background(), &protocol.DidChangeWatchedFilesParams{
		Changes: []protocol.FileEvent{{URI: uBase, Type: protocol.FileChangeTypeChanged}},
	}); err != nil {
		t.Fatalf("didChangeWatchedFiles: %v", err)
	}

	if a2 := srv.server.analysisFor(uBase); a2 != a1 {
		t.Error("open document rebuilt from disk; buffer is authoritative")
	}
}

func TestServer_DidChangeWatchedFiles_DiskChangeDirtiesDependents(t *testing.T) {
	dir := t.TempDir()
	base := filepath.Join(dir, "base.journal")
	main := filepath.Join(dir, "main.journal")
	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:cash\n"))
	testutil.WriteFile(t, main, []byte("include base.journal\n"))

	srv := NewServer("test")
	srv.server.client = &captureClient{}
	uMain := uri.File(main)
	if err := srv.server.DidOpen(context.Background(), &protocol.DidOpenTextDocumentParams{
		TextDocument: protocol.TextDocumentItem{URI: uMain, LanguageID: "journal", Version: 1, Text: "include base.journal\n"},
	}); err != nil {
		t.Fatalf("didOpen: %v", err)
	}

	a1 := srv.server.analysisFor(uMain)
	if !slices.Contains(a1.AccountNames, "assets:cash") {
		t.Fatalf("initial analysis missing included account: %v", a1.AccountNames)
	}

	// base changes on disk, outside the editor
	testutil.WriteFile(t, base, []byte("2024-01-01 t\n    expenses:food  $10\n    assets:bank\n"))
	if err := srv.server.DidChangeWatchedFiles(context.Background(), &protocol.DidChangeWatchedFilesParams{
		Changes: []protocol.FileEvent{{URI: uri.File(base), Type: protocol.FileChangeTypeChanged}},
	}); err != nil {
		t.Fatalf("didChangeWatchedFiles: %v", err)
	}

	a2 := srv.server.analysisFor(uMain)
	if a2 == a1 {
		t.Error("disk change did not rebuild the dependent analysis")
	}
	if !slices.Contains(a2.AccountNames, "assets:bank") {
		t.Errorf("stale included content after disk change: %v", a2.AccountNames)
	}
}

type captureClient struct {
	protocol.Client
	mu   sync.Mutex
	diag []protocol.PublishDiagnosticsParams
}

func (c *captureClient) PublishDiagnostics(_ context.Context, params *protocol.PublishDiagnosticsParams) error {
	c.mu.Lock()
	c.diag = append(c.diag, *params)
	c.mu.Unlock()
	return nil
}

func (c *captureClient) lastDiags(u uri.URI) ([]protocol.Diagnostic, bool) {
	c.mu.Lock()
	defer c.mu.Unlock()
	for _, v := range slices.Backward(c.diag) {
		if v.URI == u {
			return v.Diagnostics, true
		}
	}
	return nil, false
}

func waitFor(t *testing.T, what string, cond func() bool) {
	t.Helper()
	deadline := time.Now().Add(5 * time.Second)
	for time.Now().Before(deadline) {
		if cond() {
			return
		}
		time.Sleep(10 * time.Millisecond)
	}
	t.Fatalf("timed out waiting for %s", what)
}