// Copyright 2017 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 godata

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"os"
	"sort"
	"strings"
	"sync"
	"testing"
	"time"

	"cloud.google.com/go/compute/metadata"
	"golang.org/x/build/gerrit"
	"golang.org/x/build/internal/secret"
	"golang.org/x/build/maintner"
)

func BenchmarkGet(b *testing.B) {
	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_, err := Get(context.Background())
		if err != nil {
			b.Fatal(err)
		}
	}
}

var (
	corpusMu    sync.Mutex
	corpusCache *maintner.Corpus
)

func getGoData(tb testing.TB) *maintner.Corpus {
	if testing.Short() {
		tb.Skip("skipping test requiring large download in short mode")
	}
	corpusMu.Lock()
	defer corpusMu.Unlock()
	if corpusCache != nil {
		return corpusCache
	}
	var err error
	corpusCache, err = Get(context.Background())
	if err != nil {
		tb.Fatalf("getting corpus: %v", err)
	}
	return corpusCache
}

func TestCorpusCheck(t *testing.T) {
	c := getGoData(t)
	if err := c.Check(); err != nil {
		t.Fatal(err)
	}
}

func TestGerritForeachNonChangeRef(t *testing.T) {
	c := getGoData(t)
	c.Gerrit().ForeachProjectUnsorted(func(gp *maintner.GerritProject) error {
		t.Logf("%s:", gp.ServerSlashProject())
		gp.ForeachNonChangeRef(func(ref string, hash maintner.GitHash) error {
			t.Logf("  %s %s", hash, ref)
			return nil
		})
		return nil
	})
}

// In the past, some Gerrit ref changes came before the git in the log.
// This tests that we handle Gerrit meta changes that happen before
// the referenced git commit is known.
func TestGerritOutOfOrderMetaChanges(t *testing.T) {
	c := getGoData(t)

	// Merged:
	goProj := c.Gerrit().Project("go.googlesource.com", "go")
	cl := goProj.CL(38634)
	if cl == nil {
		t.Fatal("CL 38634 not found")
	}
	if g, w := cl.Status, "merged"; g != w {
		t.Errorf("CL status = %q; want %q", g, w)
	}

	// Deleted:
	gddo := c.Gerrit().Project("go.googlesource.com", "gddo")
	cl = gddo.CL(37452)
	if cl == nil {
		t.Fatal("CL 37452 not found")
	}
	t.Logf("Got: %+v", *cl)
}

func TestGerritSkipPrivateCLs(t *testing.T) {
	c := getGoData(t)
	proj := c.Gerrit().Project("go.googlesource.com", "gddo")
	proj.ForeachOpenCL(func(cl *maintner.GerritCL) error {
		if cl.Number == 37452 {
			t.Error("unexpected private CL 37452")
		}
		return nil
	})
}

func TestGerritMetaNonNil(t *testing.T) {
	c := getGoData(t)
	c.Gerrit().ForeachProjectUnsorted(func(gp *maintner.GerritProject) error {
		var maxCL int32
		gp.ForeachCLUnsorted(func(cl *maintner.GerritCL) error {
			if cl.Meta == nil {
				t.Errorf("%s: ForeachCLUnsorted-enumerated CL %d has nil Meta", gp.ServerSlashProject(), cl.Number)
			}
			if len(cl.Metas) == 0 {
				t.Errorf("%s: ForeachCLUnsorted-enumerated CL %d has empty Metas", gp.ServerSlashProject(), cl.Number)
			}
			if cl.Commit == nil {
				t.Errorf("%s: ForeachCLUnsorted-enumerated CL %d has nil Commit", gp.ServerSlashProject(), cl.Number)
			}
			if cl.Number > maxCL {
				maxCL = cl.Number
			}
			return nil
		})
		gp.ForeachOpenCL(func(cl *maintner.GerritCL) error {
			if cl.Meta == nil {
				t.Errorf("%s: ForeachOpenCL-enumerated CL %d has nil Meta", gp.ServerSlashProject(), cl.Number)
			}
			if len(cl.Metas) == 0 {
				t.Errorf("%s: ForeachOpenCL-enumerated CL %d has empty Metas", gp.ServerSlashProject(), cl.Number)
			}
			if cl.Commit == nil {
				t.Errorf("%s: ForeachOpenCL-enumerated CL %d has nil Commit", gp.ServerSlashProject(), cl.Number)
			}
			if cl.Number > maxCL {
				t.Fatalf("%s: ForeachOpenCL-enumerated CL %d higher than max CL %d from ForeachCLUnsorted", gp.ServerSlashProject(), cl.Number, maxCL)
			}
			return nil
		})

		// And test that CL won't yield an incomplete one either:
		for n := int32(0); n <= maxCL; n++ {
			cl := gp.CL(n)
			if cl == nil {
				continue
			}
			if cl.Meta == nil {
				t.Errorf("%s: CL(%d) has nil Meta", gp.ServerSlashProject(), cl.Number)
			}
			if len(cl.Metas) == 0 {
				t.Errorf("%s: CL(%d) has empty Metas", gp.ServerSlashProject(), cl.Number)
			}
			if cl.Commit == nil {
				t.Errorf("%s: CL(%d) has nil Commit", gp.ServerSlashProject(), cl.Number)
			}
		}
		return nil
	})
}

func TestGitAncestor(t *testing.T) {
	c := getGoData(t)
	tests := []struct {
		subject, ancestor string
		want              bool
	}{
		{"3b5637ff2bd5c03479780995e7a35c48222157c1", "0bb0b61d6a85b2a1a33dcbc418089656f2754d32", true},
		{"0bb0b61d6a85b2a1a33dcbc418089656f2754d32", "3b5637ff2bd5c03479780995e7a35c48222157c1", false},

		{"8f06e217eac10bae4993ca371ade35fecd26270e", "22f1b56dab29d397d2bdbdd603d85e60fb678089", true},
		{"22f1b56dab29d397d2bdbdd603d85e60fb678089", "8f06e217eac10bae4993ca371ade35fecd26270e", false},

		// Was crashing. Issue 22753.
		{"3a181dc7bc8fd0c61d6090a85f87c934f1874802", "f65abf6ddc8d1f3d403a9195fd74eaffa022b07f", true},
		// The reverse of the above, to try to reproduce the
		// panic if I got the order backwards:
		{"f65abf6ddc8d1f3d403a9195fd74eaffa022b07f", "3a181dc7bc8fd0c61d6090a85f87c934f1874802", false},

		// Same on both sides:
		{"0bb0b61d6a85b2a1a33dcbc418089656f2754d32", "0bb0b61d6a85b2a1a33dcbc418089656f2754d32", false},
		{"3b5637ff2bd5c03479780995e7a35c48222157c1", "3b5637ff2bd5c03479780995e7a35c48222157c1", false},
	}
	for i, tt := range tests {
		subject := c.GitCommit(tt.subject)
		if subject == nil {
			t.Errorf("%d. missing subject commit %q", i, tt.subject)
			continue
		}
		anc := c.GitCommit(tt.ancestor)
		if anc == nil {
			t.Errorf("%d. missing ancestor commit %q", i, tt.ancestor)
			continue
		}
		got := subject.HasAncestor(anc)
		if got != tt.want {
			t.Errorf("HasAncestor(%q, %q) = %v; want %v", tt.subject, tt.ancestor, got, tt.want)
		}
	}
}

func BenchmarkGitAncestor(b *testing.B) {
	c := getGoData(b)
	subject := c.GitCommit("3b5637ff2bd5c03479780995e7a35c48222157c1")
	anc := c.GitCommit("0bb0b61d6a85b2a1a33dcbc418089656f2754d32")
	if subject == nil || anc == nil {
		b.Fatal("missing commit(s)")
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		if !subject.HasAncestor(anc) {
			b.Fatal("wrong answer")
		}
	}
}

// Issue 23007: a Gerrit CL can switch branches. Make sure we handle that.
func TestGerritCLChangingBranches(t *testing.T) {
	c := getGoData(t)

	tests := []struct {
		server, project string
		cl              int32
		want            string
	}{
		// Changed branch in the middle:
		// (Unsubmitted at the time of this test, so if it changes back, this test
		// may break.)
		{"go.googlesource.com", "go", 33776, "master"},

		// Submitted to boringcrypto:
		{"go.googlesource.com", "go", 82138, "dev.boringcrypto"},
		// Submitted to master:
		{"go.googlesource.com", "go", 83578, "master"},
	}

	for _, tt := range tests {
		cl := c.Gerrit().Project(tt.server, tt.project).CL(tt.cl)
		if got := cl.Branch(); got != tt.want {
			t.Errorf("%q, %q, CL %d = branch %q; want %q", tt.server, tt.project, tt.cl, got, tt.want)
		}
	}
}

func TestGerritHashTags(t *testing.T) {
	c := getGoData(t)
	cl := c.Gerrit().Project("go.googlesource.com", "go").CL(81778)
	want := `added "bar, foo" = "bar,foo"
removed "bar" = "foo"
removed "foo" = ""
added "bar, foo" = "bar,foo"
removed "bar" = "foo"
added "bar" = "bar,foo"
added "blarf, quux" removed "foo" = "bar,quux,blarf"
removed "bar" = "quux,blarf"
`

	var log bytes.Buffer
	for _, meta := range cl.Metas {
		added, removed, ok := meta.HashtagEdits()
		if ok {
			if added != "" {
				fmt.Fprintf(&log, "added %q ", added)
			}
			if removed != "" {
				fmt.Fprintf(&log, "removed %q ", removed)
			}
			fmt.Fprintf(&log, "= %q\n", meta.Hashtags())
		}
	}
	got := log.String()
	if !strings.HasPrefix(got, want) {
		t.Errorf("got:\n%s\n\nwant prefix:\n%s", got, want)
	}
}

// getSecret retrieves a secret by name from the secret manager service.
func getSecret(name string) (string, error) {
	sc, err := secret.NewClient()
	if err != nil {
		return "", err
	}
	defer sc.Close()

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	return sc.Retrieve(ctx, name)
}

func getGerritAuth() (username string, password string, err error) {
	var slurp string
	if metadata.OnGCE() {
		slurp, _ = getSecret(secret.NameGobotPassword)
	}
	if slurp == "" {
		var ok bool
		slurp, ok = os.LookupEnv("TEST_GERRIT_AUTH")
		if !ok {
			return "", "", errors.New("environment variable TEST_GERRIT_AUTH is not set")
		}
	}
	f := strings.SplitN(strings.TrimSpace(slurp), ":", 2)
	if len(f) == 1 {
		// assume the whole thing is the token
		return "git-gobot.golang.org", f[0], nil
	}
	if len(f) != 2 || f[0] == "" || f[1] == "" {
		return "", "", fmt.Errorf("Expected Gerrit token %q to be of form <git-email>:<token>", slurp)
	}
	return f[0], f[1], nil
}

// Hit the Gerrit API and compare its computation of CLs' hashtags against what maintner thinks.
// Off by default unless $TEST_GERRIT_AUTH is defined with "user:token", or we're running in the
// prod project.
func TestGerritHashtags(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping in short mode")
	}
	c := getGoData(t)
	user, pass, err := getGerritAuth()
	if err != nil {
		t.Skipf("no Gerrit auth defined, skipping: %v", err)
	}
	gc := gerrit.NewClient("https://go-review.googlesource.com", gerrit.BasicAuth(user, pass))
	ctx := context.Background()
	more := true
	n := 0
	for more {
		// We search Gerrit for "hashtag", which seems to also
		// search auto-generated gerrit meta (notedb) texts,
		// so this has the effect of searching for all Gerrit
		// changes that have ever had hashtags added or
		// removed:
		cis, err := gc.QueryChanges(ctx, "hashtag", gerrit.QueryChangesOpt{
			Start: n,
		})
		if err != nil {
			t.Fatal(err)
		}
		for _, ci := range cis {
			n++
			cl := c.Gerrit().Project("go.googlesource.com", ci.Project).CL(int32(ci.ChangeNumber))
			if cl == nil {
				t.Logf("Ignoring not-in-maintner %s/%v", ci.Project, ci.ChangeNumber)
				continue
			}
			sort.Strings(ci.Hashtags)
			want := strings.Join(ci.Hashtags, ", ")
			got := canonicalTagList(string(cl.Meta.Hashtags()))
			if got != want {
				t.Errorf("ci: https://golang.org/cl/%d (%s) -- maintner = %q; want gerrit value %q", ci.ChangeNumber, ci.Project, got, want)
			}
			more = ci.MoreChanges
		}
	}
	t.Logf("N = %v", n)
}

func canonicalTagList(s string) string {
	var sl []string
	for _, v := range strings.Split(s, ",") {
		sl = append(sl, strings.TrimSpace(v))
	}
	sort.Strings(sl)
	return strings.Join(sl, ", ")
}