// Copyright 2020 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"
	"errors"
	"os"
	"strings"
	"testing"

	"golang.org/x/mod/modfile"
	"golang.org/x/tools/internal/lsp/fake"
	"golang.org/x/tools/internal/lsp/source"
	"golang.org/x/tools/internal/span"
)

// osFileSource is a fileSource that just reads from the operating system.
type osFileSource struct {
	overlays map[span.URI]fakeOverlay
}

type fakeOverlay struct {
	source.VersionedFileHandle
	uri     span.URI
	content string
	err     error
	saved   bool
}

func (o fakeOverlay) Saved() bool { return o.saved }

func (o fakeOverlay) Read() ([]byte, error) {
	if o.err != nil {
		return nil, o.err
	}
	return []byte(o.content), nil
}

func (o fakeOverlay) URI() span.URI {
	return o.uri
}

// change updates the file source with the given file content. For convenience,
// empty content signals a deletion. If saved is true, these changes are
// persisted to disk.
func (s *osFileSource) change(ctx context.Context, uri span.URI, content string, saved bool) (*fileChange, error) {
	if content == "" {
		delete(s.overlays, uri)
		if saved {
			if err := os.Remove(uri.Filename()); err != nil {
				return nil, err
			}
		}
		fh, err := s.GetFile(ctx, uri)
		if err != nil {
			return nil, err
		}
		data, err := fh.Read()
		return &fileChange{exists: err == nil, content: data, fileHandle: &closedFile{fh}}, nil
	}
	if s.overlays == nil {
		s.overlays = map[span.URI]fakeOverlay{}
	}
	s.overlays[uri] = fakeOverlay{uri: uri, content: content, saved: saved}
	return &fileChange{
		exists:     content != "",
		content:    []byte(content),
		fileHandle: s.overlays[uri],
	}, nil
}

func (s *osFileSource) GetFile(ctx context.Context, uri span.URI) (source.FileHandle, error) {
	if overlay, ok := s.overlays[uri]; ok {
		return overlay, nil
	}
	fi, statErr := os.Stat(uri.Filename())
	if statErr != nil {
		return &fileHandle{
			err: statErr,
			uri: uri,
		}, nil
	}
	fh, err := readFile(ctx, uri, fi)
	if err != nil {
		return nil, err
	}
	return fh, nil
}

type wsState struct {
	source  workspaceSource
	modules []string
	dirs    []string
	sum     string
}

type wsChange struct {
	content string
	saved   bool
}

func TestWorkspaceModule(t *testing.T) {
	tests := []struct {
		desc         string
		initial      string // txtar-encoded
		legacyMode   bool
		initialState wsState
		updates      map[string]wsChange
		wantChanged  bool
		wantReload   bool
		finalState   wsState
	}{
		{
			desc: "legacy mode",
			initial: `
-- go.mod --
module mod.com
-- go.sum --
golang.org/x/mod v0.3.0 h1:deadbeef
-- a/go.mod --
module moda.com`,
			legacyMode: true,
			initialState: wsState{
				modules: []string{"./go.mod"},
				source:  legacyWorkspace,
				dirs:    []string{"."},
				sum:     "golang.org/x/mod v0.3.0 h1:deadbeef\n",
			},
		},
		{
			desc: "nested module",
			initial: `
-- go.mod --
module mod.com
-- a/go.mod --
module moda.com`,
			initialState: wsState{
				modules: []string{"./go.mod", "a/go.mod"},
				source:  fileSystemWorkspace,
				dirs:    []string{".", "a"},
			},
		},
		{
			desc: "removing module",
			initial: `
-- a/go.mod --
module moda.com
-- a/go.sum --
golang.org/x/mod v0.3.0 h1:deadbeef
-- b/go.mod --
module modb.com
-- b/go.sum --
golang.org/x/mod v0.3.0 h1:beefdead`,
			initialState: wsState{
				modules: []string{"a/go.mod", "b/go.mod"},
				source:  fileSystemWorkspace,
				dirs:    []string{".", "a", "b"},
				sum:     "golang.org/x/mod v0.3.0 h1:beefdead\ngolang.org/x/mod v0.3.0 h1:deadbeef\n",
			},
			updates: map[string]wsChange{
				"gopls.mod": {`module gopls-workspace

require moda.com v0.0.0-goplsworkspace
replace moda.com => $SANDBOX_WORKDIR/a`, true},
			},
			wantChanged: true,
			wantReload:  true,
			finalState: wsState{
				modules: []string{"a/go.mod"},
				source:  goplsModWorkspace,
				dirs:    []string{".", "a"},
				sum:     "golang.org/x/mod v0.3.0 h1:deadbeef\n",
			},
		},
		{
			desc: "adding module",
			initial: `
-- gopls.mod --
require moda.com v0.0.0-goplsworkspace
replace moda.com => $SANDBOX_WORKDIR/a
-- a/go.mod --
module moda.com
-- b/go.mod --
module modb.com`,
			initialState: wsState{
				modules: []string{"a/go.mod"},
				source:  goplsModWorkspace,
				dirs:    []string{".", "a"},
			},
			updates: map[string]wsChange{
				"gopls.mod": {`module gopls-workspace

require moda.com v0.0.0-goplsworkspace
require modb.com v0.0.0-goplsworkspace

replace moda.com => $SANDBOX_WORKDIR/a
replace modb.com => $SANDBOX_WORKDIR/b`, true},
			},
			wantChanged: true,
			wantReload:  true,
			finalState: wsState{
				modules: []string{"a/go.mod", "b/go.mod"},
				source:  goplsModWorkspace,
				dirs:    []string{".", "a", "b"},
			},
		},
		{
			desc: "deleting gopls.mod",
			initial: `
-- gopls.mod --
module gopls-workspace

require moda.com v0.0.0-goplsworkspace
replace moda.com => $SANDBOX_WORKDIR/a
-- a/go.mod --
module moda.com
-- b/go.mod --
module modb.com`,
			initialState: wsState{
				modules: []string{"a/go.mod"},
				source:  goplsModWorkspace,
				dirs:    []string{".", "a"},
			},
			updates: map[string]wsChange{
				"gopls.mod": {"", true},
			},
			wantChanged: true,
			wantReload:  true,
			finalState: wsState{
				modules: []string{"a/go.mod", "b/go.mod"},
				source:  fileSystemWorkspace,
				dirs:    []string{".", "a", "b"},
			},
		},
		{
			desc: "broken module parsing",
			initial: `
-- a/go.mod --
module moda.com

require gopls.test v0.0.0-goplsworkspace
replace gopls.test => ../../gopls.test // (this path shouldn't matter)
-- b/go.mod --
module modb.com`,
			initialState: wsState{
				modules: []string{"a/go.mod", "b/go.mod"},
				source:  fileSystemWorkspace,
				dirs:    []string{".", "a", "b", "../gopls.test"},
			},
			updates: map[string]wsChange{
				"a/go.mod": {`modul moda.com

require gopls.test v0.0.0-goplsworkspace
replace gopls.test => ../../gopls.test2`, false},
			},
			wantChanged: true,
			wantReload:  false,
			finalState: wsState{
				modules: []string{"a/go.mod", "b/go.mod"},
				source:  fileSystemWorkspace,
				// finalDirs should be unchanged: we should preserve dirs in the presence
				// of a broken modfile.
				dirs: []string{".", "a", "b", "../gopls.test"},
			},
		},
	}

	for _, test := range tests {
		t.Run(test.desc, func(t *testing.T) {
			ctx := context.Background()
			dir, err := fake.Tempdir(fake.UnpackTxt(test.initial))
			if err != nil {
				t.Fatal(err)
			}
			defer os.RemoveAll(dir)
			root := span.URIFromPath(dir)

			fs := &osFileSource{}
			excludeNothing := func(string) bool { return false }
			w, err := newWorkspace(ctx, root, "", fs, excludeNothing, false, !test.legacyMode)
			if err != nil {
				t.Fatal(err)
			}
			rel := fake.RelativeTo(dir)
			checkState(ctx, t, fs, rel, w, test.initialState)

			// Apply updates.
			if test.updates != nil {
				changes := make(map[span.URI]*fileChange)
				for k, v := range test.updates {
					content := strings.ReplaceAll(v.content, "$SANDBOX_WORKDIR", string(rel))
					uri := span.URIFromPath(rel.AbsPath(k))
					changes[uri], err = fs.change(ctx, uri, content, v.saved)
					if err != nil {
						t.Fatal(err)
					}
				}
				got, gotReinit := w.Clone(ctx, changes, fs)
				gotChanged := got != w
				if gotChanged != test.wantChanged {
					t.Errorf("w.invalidate(): got changed %t, want %t", gotChanged, test.wantChanged)
				}
				if gotReinit != test.wantReload {
					t.Errorf("w.invalidate(): got reload %t, want %t", gotReinit, test.wantReload)
				}
				checkState(ctx, t, fs, rel, got, test.finalState)
			}
		})
	}
}

func workspaceFromTxtar(t *testing.T, files string) (*workspace, func(), error) {
	ctx := context.Background()
	dir, err := fake.Tempdir(fake.UnpackTxt(files))
	if err != nil {
		return nil, func() {}, err
	}
	cleanup := func() {
		os.RemoveAll(dir)
	}
	root := span.URIFromPath(dir)

	fs := &osFileSource{}
	excludeNothing := func(string) bool { return false }
	workspace, err := newWorkspace(ctx, root, "", fs, excludeNothing, false, false)
	return workspace, cleanup, err
}

func TestWorkspaceParseError(t *testing.T) {
	w, cleanup, err := workspaceFromTxtar(t, `
-- go.work --
go 1.18

usa ./typo
-- typo/go.mod --
module foo
`)
	defer cleanup()
	if err != nil {
		t.Fatalf("error creating workspace: %v; want no error", err)
	}
	w.buildMu.Lock()
	built, buildErr := w.built, w.buildErr
	w.buildMu.Unlock()
	if !built || buildErr == nil {
		t.Fatalf("built, buildErr: got %v, %v; want true, non-nil", built, buildErr)
	}
	var errList modfile.ErrorList
	if !errors.As(buildErr, &errList) {
		t.Fatalf("expected error to be an errorlist; got %v", buildErr)
	}
	if len(errList) != 1 {
		t.Fatalf("expected errorList to have one element; got %v elements", len(errList))
	}
	parseErr := errList[0]
	if parseErr.Pos.Line != 3 {
		t.Fatalf("expected error to be on line 3; got %v", parseErr.Pos.Line)
	}
}

func TestWorkspaceMissingModFile(t *testing.T) {
	w, cleanup, err := workspaceFromTxtar(t, `
-- go.work --
go 1.18

use ./missing
`)
	defer cleanup()
	if err != nil {
		t.Fatalf("error creating workspace: %v; want no error", err)
	}
	w.buildMu.Lock()
	built, buildErr := w.built, w.buildErr
	w.buildMu.Unlock()
	if !built || buildErr == nil {
		t.Fatalf("built, buildErr: got %v, %v; want true, non-nil", built, buildErr)
	}
}

func checkState(ctx context.Context, t *testing.T, fs source.FileSource, rel fake.RelativeTo, got *workspace, want wsState) {
	t.Helper()
	if got.moduleSource != want.source {
		t.Errorf("module source = %v, want %v", got.moduleSource, want.source)
	}
	modules := make(map[span.URI]struct{})
	for k := range got.getActiveModFiles() {
		modules[k] = struct{}{}
	}
	for _, modPath := range want.modules {
		path := rel.AbsPath(modPath)
		uri := span.URIFromPath(path)
		if _, ok := modules[uri]; !ok {
			t.Errorf("missing module %q", uri)
		}
		delete(modules, uri)
	}
	for remaining := range modules {
		t.Errorf("unexpected module %q", remaining)
	}
	gotDirs := got.dirs(ctx, fs)
	gotM := make(map[span.URI]bool)
	for _, dir := range gotDirs {
		gotM[dir] = true
	}
	for _, dir := range want.dirs {
		path := rel.AbsPath(dir)
		uri := span.URIFromPath(path)
		if !gotM[uri] {
			t.Errorf("missing dir %q", uri)
		}
		delete(gotM, uri)
	}
	for remaining := range gotM {
		t.Errorf("unexpected dir %q", remaining)
	}
	gotSumBytes, err := got.sumFile(ctx, fs)
	if err != nil {
		t.Fatal(err)
	}
	if gotSum := string(gotSumBytes); gotSum != want.sum {
		t.Errorf("got final sum %q, want %q", gotSum, want.sum)
	}
}