// Copyright 2019 syzkaller project authors. All rights reserved.
// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.

package bisect

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"math"
	"os"
	"strconv"
	"testing"

	"github.com/google/syzkaller/pkg/instance"
	"github.com/google/syzkaller/pkg/mgrconfig"
	"github.com/google/syzkaller/pkg/report"
	"github.com/google/syzkaller/pkg/vcs"
)

// testEnv will implement instance.BuilderTester. This allows us to
// set bisect.env.inst to a testEnv object.
type testEnv struct {
	repo        *vcs.TestRepo
	r           vcs.Repo
	t           *testing.T
	fix         bool
	brokenStart float64
	brokenEnd   float64
	culprit     float64
}

func (env *testEnv) BuildSyzkaller(repo, commit string) error {
	return nil
}

func (env *testEnv) BuildKernel(compilerBin, userspaceDir, cmdlineFile, sysctlFile string,
	kernelConfig []byte) (string, error) {
	return "", nil
}

func crashErrors(num int, title string) []error {
	var errors []error
	for i := 0; i < num; i++ {
		errors = append(errors, &instance.CrashError{
			Report: &report.Report{
				Title: fmt.Sprintf("crashes at %v", title),
			},
		})
	}
	return errors
}

func nilErrors(num int) []error {
	var errors []error
	for i := 0; i < num; i++ {
		errors = append(errors, nil)
	}
	return errors
}

func (env *testEnv) Test(numVMs int, reproSyz, reproOpts, reproC []byte) ([]error, error) {
	hc, err := env.r.HeadCommit()
	if err != nil {
		env.t.Fatal(err)
	}
	commit, err := strconv.ParseFloat(hc.Title, 64)
	if err != nil {
		env.t.Fatalf("invalid commit title: %v", hc.Title)
	}
	var e error
	var res []error
	if commit >= env.brokenStart && commit <= env.brokenEnd {
		e = fmt.Errorf("broken build")
	} else if commit < env.culprit && !env.fix || commit >= env.culprit && env.fix {
		res = nilErrors(numVMs)
	} else {
		res = crashErrors(numVMs, "crash occurs")
	}
	return res, e
}

type Ctx struct {
	t          *testing.T
	baseDir    string
	repo       *vcs.TestRepo
	r          vcs.Repo
	cfg        *Config
	inst       *testEnv
	originRepo *vcs.TestRepo
}

func NewCtx(t *testing.T, fix bool, brokenStart, brokenEnd, culprit float64, commit string) *Ctx {
	baseDir, err := ioutil.TempDir("", "syz-git-test")
	if err != nil {
		t.Fatal(err)
	}
	originRepo := vcs.CreateTestRepo(t, baseDir, "originRepo")
	for rv := 4; rv < 10; rv++ {
		for i := 0; i < 6; i++ {
			originRepo.CommitChange(fmt.Sprintf("%v", rv*100+i))
			if i == 0 {
				originRepo.SetTag(fmt.Sprintf("v%v.0", rv))
			}
		}
	}
	if !originRepo.SupportsBisection() {
		t.Skip("bisection is unsupported by git (probably too old version)")
	}
	repo := vcs.CloneTestRepo(t, baseDir, "repo", originRepo)
	r, err := vcs.NewRepo("test", "64", repo.Dir)
	if err != nil {
		t.Fatal(err)
	}
	sc, err := r.GetCommitByTitle(commit)
	if err != nil {
		t.Fatal(err)
	}
	cfg := &Config{
		Fix:   fix,
		Trace: new(bytes.Buffer),
		Manager: mgrconfig.Config{
			TargetOS:     "test",
			TargetVMArch: "64",
			Type:         "qemu",
			KernelSrc:    repo.Dir,
		},
		Kernel: KernelConfig{
			Repo:   originRepo.Dir,
			Commit: sc.Hash,
		},
	}
	inst := &testEnv{
		repo:        repo,
		r:           r,
		t:           t,
		fix:         fix,
		brokenStart: brokenStart,
		brokenEnd:   brokenEnd,
		culprit:     culprit,
	}
	c := &Ctx{
		t:          t,
		baseDir:    baseDir,
		repo:       repo,
		r:          r,
		cfg:        cfg,
		inst:       inst,
		originRepo: originRepo,
	}
	return c
}

type BisectionTests struct {
	// input environment
	name        string
	fix         bool
	startCommit string
	brokenStart float64
	brokenEnd   float64
	// expected output
	errIsNil     bool
	commitLen    int
	repIsNil     bool
	oldestLatest string
	// input and output
	culprit float64
}

func TestBisectionResults(t *testing.T) {
	t.Parallel()
	var tests = []BisectionTests{
		// Tests that bisection returns the correct cause commit.
		{
			name:        "bisect cause finds cause",
			fix:         false,
			startCommit: "905",
			brokenStart: math.Inf(0),
			brokenEnd:   0,
			errIsNil:    true,
			commitLen:   1,
			repIsNil:    false,
			culprit:     602,
		},
		// Tests that cause bisection returns error when crash does not reproduce
		// on the original commit.
		{
			name:        "bisect cause does not repro",
			fix:         false,
			startCommit: "400",
			brokenStart: math.Inf(0),
			brokenEnd:   0,
			errIsNil:    false,
			commitLen:   0,
			repIsNil:    true,
			culprit:     math.Inf(0),
		},
		// Tests that no commits are returned when crash occurs on oldest commit
		// for cause bisection.
		{
			name:         "bisect cause crashes oldest",
			fix:          false,
			startCommit:  "905",
			brokenStart:  math.Inf(0),
			brokenEnd:    0,
			errIsNil:     true,
			commitLen:    0,
			repIsNil:     false,
			culprit:      0,
			oldestLatest: "400",
		},
		// Tests that more than 1 commit is returned when cause bisection is
		// inconclusive.
		{
			name:        "bisect cause inconclusive",
			fix:         false,
			startCommit: "802",
			brokenStart: 500,
			brokenEnd:   700,
			errIsNil:    true,
			commitLen:   14,
			repIsNil:    true,
			culprit:     605,
		},
		// Tests that bisection returns the correct fix commit.
		{
			name:        "bisect fix finds fix",
			fix:         true,
			startCommit: "400",
			brokenStart: math.Inf(0),
			brokenEnd:   0,
			errIsNil:    true,
			commitLen:   1,
			repIsNil:    true,
			culprit:     500,
		},
		// Tests that fix bisection returns error when crash does not reproduce
		// on the original commit.
		{
			name:        "bisect fix does not repro",
			fix:         true,
			startCommit: "905",
			brokenStart: math.Inf(0),
			brokenEnd:   0,
			errIsNil:    false,
			commitLen:   0,
			repIsNil:    true,
			culprit:     0,
		},
		// Tests that no commits are returned when crash occurs on HEAD
		// for fix bisection.
		{
			name:         "bisect fix crashes HEAD",
			fix:          true,
			startCommit:  "400",
			brokenStart:  math.Inf(0),
			brokenEnd:    0,
			errIsNil:     true,
			commitLen:    0,
			repIsNil:     false,
			culprit:      1000,
			oldestLatest: "905",
		},
		// Tests that more than 1 commit is returned when fix bisection is
		// inconclusive.
		{
			name:        "bisect fix inconclusive",
			fix:         true,
			startCommit: "400",
			brokenStart: 500,
			brokenEnd:   600,
			errIsNil:    true,
			commitLen:   8,
			repIsNil:    true,
			culprit:     501,
		},
	}
	for _, test := range tests {
		t.Run(fmt.Sprintf("%v", test.name), func(t *testing.T) {
			c := NewCtx(t, test.fix, test.brokenStart, test.brokenEnd, test.culprit, test.startCommit)
			defer os.RemoveAll(c.baseDir)
			commits, rep, com, err := runImpl(c.cfg, c.r, c.r.(vcs.Bisecter), c.inst)
			if test.errIsNil && err != nil || !test.errIsNil && err == nil {
				t.Fatalf("returned error: '%v'", err)
			}
			if len(commits) != test.commitLen {
				t.Fatalf("expected %d commits got %d commits", test.commitLen, len(commits))
			}
			expectedTitle := fmt.Sprintf("%v", test.culprit)
			if len(commits) == 1 && expectedTitle != commits[0].Title {
				t.Fatalf("expected commit '%v' got '%v'", expectedTitle, commits[0].Title)
			}
			if test.repIsNil && rep != nil || !test.repIsNil && rep == nil {
				t.Fatalf("returned rep: '%v'", err)
			}
			if test.oldestLatest != "" && test.oldestLatest != com.Title ||
				test.oldestLatest == "" && com != nil {
				t.Fatalf("expected latest/oldest: '%v' got '%v'", test.oldestLatest, com.Title)
			}
		})
	}
}