// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package cache

import (
	"context"
	"fmt"
	"go/token"
	"testing"

	"golang.org/x/tools/gopls/internal/lsp/source"
	"golang.org/x/tools/gopls/internal/span"
)

func TestParseCache(t *testing.T) {
	ctx := context.Background()
	uri := span.URI("file:///myfile")
	fh := makeFakeFileHandle(uri, []byte("package p\n\nconst _ = \"foo\""))

	var cache parseCache
	pgfs1, _, err := cache.parseFiles(ctx, source.ParseFull, fh)
	if err != nil {
		t.Fatal(err)
	}
	pgf1 := pgfs1[0]
	pgfs2, _, err := cache.parseFiles(ctx, source.ParseFull, fh)
	pgf2 := pgfs2[0]
	if err != nil {
		t.Fatal(err)
	}
	if pgf1.File != pgf2.File {
		t.Errorf("parseFiles(%q): unexpected cache miss on repeated call", uri)
	}

	// Fill up the cache with other files, but don't evict the file above.
	files := []source.FileHandle{fh}
	files = append(files, dummyFileHandles(parseCacheMaxFiles-1)...)
	pgfs3, fset, err := cache.parseFiles(ctx, source.ParseFull, files...)
	pgf3 := pgfs3[0]
	if pgf3.File != pgf1.File {
		t.Errorf("parseFiles(%q, ...): unexpected cache miss", uri)
	}
	if pgf3.Tok == pgf1.Tok {
		t.Errorf("parseFiles(%q, ...): unexpectedly matching token file", uri)
	}
	if pgf3.Tok.Base() != pgf1.Tok.Base() || pgf3.Tok.Size() != pgf1.Tok.Size() {
		t.Errorf("parseFiles(%q, ...): result.Tok has base: %d, size: %d, want (%d, %d)", uri, pgf3.Tok.Base(), pgf3.Tok.Size(), pgf1.Tok.Base(), pgf1.Tok.Size())
	}
	if tok := fset.File(token.Pos(pgf3.Tok.Base())); tok != pgf3.Tok {
		t.Errorf("parseFiles(%q, ...): result.Tok not contained in FileSet", uri)
	}

	// Now overwrite the cache, after which we should get new results.
	files = dummyFileHandles(parseCacheMaxFiles)
	_, _, err = cache.parseFiles(ctx, source.ParseFull, files...)
	if err != nil {
		t.Fatal(err)
	}
	pgfs4, _, err := cache.parseFiles(ctx, source.ParseFull, fh)
	if err != nil {
		t.Fatal(err)
	}
	if pgfs4[0].File == pgf1.File {
		t.Errorf("parseFiles(%q): unexpected cache hit after overwriting cache", uri)
	}
}

func TestParseCache_Reparsing(t *testing.T) {
	defer func(padding int) {
		parsePadding = padding
	}(parsePadding)
	parsePadding = 0

	files := dummyFileHandles(parseCacheMaxFiles)
	danglingSelector := []byte("package p\nfunc _() {\n\tx.\n}")
	files = append(files, makeFakeFileHandle("file:///bad1", danglingSelector))
	files = append(files, makeFakeFileHandle("file:///bad2", danglingSelector))

	// Parsing should succeed even though we overflow the padding.
	var cache parseCache
	_, _, err := cache.parseFiles(context.Background(), source.ParseFull, files...)
	if err != nil {
		t.Fatal(err)
	}
}

func TestParseCache_Duplicates(t *testing.T) {
	ctx := context.Background()
	uri := span.URI("file:///myfile")
	fh := makeFakeFileHandle(uri, []byte("package p\n\nconst _ = \"foo\""))

	var cache parseCache
	pgfs, _, err := cache.parseFiles(ctx, source.ParseFull, fh, fh)
	if err != nil {
		t.Fatal(err)
	}
	if pgfs[0].File != pgfs[1].File {
		t.Errorf("parseFiles(fh, fh): = [%p, %p], want duplicate files", pgfs[0].File, pgfs[1].File)
	}
}

func dummyFileHandles(n int) []source.FileHandle {
	var fhs []source.FileHandle
	for i := 0; i < n; i++ {
		uri := span.URI(fmt.Sprintf("file:///_%d", i))
		src := []byte(fmt.Sprintf("package p\nvar _ = %d", i))
		fhs = append(fhs, makeFakeFileHandle(uri, src))
	}
	return fhs
}

func makeFakeFileHandle(uri span.URI, src []byte) fakeFileHandle {
	return fakeFileHandle{
		uri:  uri,
		data: src,
		hash: source.HashOf(src),
	}
}

type fakeFileHandle struct {
	source.FileHandle
	uri  span.URI
	data []byte
	hash source.Hash
}

func (h fakeFileHandle) URI() span.URI {
	return h.uri
}

func (h fakeFileHandle) Content() ([]byte, error) {
	return h.data, nil
}

func (h fakeFileHandle) FileIdentity() source.FileIdentity {
	return source.FileIdentity{
		URI:  h.uri,
		Hash: h.hash,
	}
}