package td

import (
	"context"
	"errors"
	"fmt"
	"os"
	"strings"
	"testing"

	assert "github.com/stretchr/testify/require"
	"go.skia.org/infra/go/deepequal"
	"go.skia.org/infra/go/exec"
	"go.skia.org/infra/go/testutils/unittest"
	"go.skia.org/infra/go/util"
)

// mockExec mocks out subprocesses named "true" with a success result and all
// others with a failure. Returns the new context and a counter indicating how
// many times the run function was called.
func mockExec(ctx context.Context) (context.Context, *int) {
	mockRun := &exec.CommandCollector{}
	runCount := 0
	mockRun.SetDelegateRun(func(ctx context.Context, cmd *exec.Command) error {
		runCount++
		if cmd.Name == "true" {
			return nil
		}
		return errors.New("Command exited with exit status 1: ")
	})
	return WithExecRunFn(ctx, mockRun.Run), &runCount
}

func TestDefer(t *testing.T) {
	unittest.MediumTest(t)

	// Verify that we handle panics properly.
	res := RunTestSteps(t, true, func(ctx context.Context) error {
		panic("halp")
	})
	assert.Equal(t, res.Result, STEP_RESULT_EXCEPTION)
	res = RunTestSteps(t, true, func(ctx context.Context) error {
		return Do(ctx, nil, func(ctx context.Context) error {
			return Do(ctx, nil, func(ctx context.Context) error {
				panic("halp")
			})
		})
	})
	got := 0
	res.Recurse(func(s *StepReport) bool {
		assert.Equal(t, s.Result, STEP_RESULT_EXCEPTION)
		assert.Equal(t, 1, len(s.Exceptions))
		assert.Equal(t, "Caught panic: halp", s.Exceptions[0])
		got++
		return true
	})
	assert.Equal(t, 3, got)

	// Verify that our defer works properly.
	var id string
	res = RunTestSteps(t, false, func(ctx context.Context) error {
		// This is an example of a function which runs as a step.
		return Do(ctx, Props("parent"), func(ctx context.Context) error {
			return func(ctx context.Context) error {
				ctx = StartStep(ctx, Props("should fail"))
				defer EndStep(ctx)

				// Actual work would go here.
				id = getCtx(ctx).step.Id
				err := fmt.Errorf("whoops")
				return FailStep(ctx, err)
			}(ctx)
		})
	})
	// The top-level step should not have inherited the sub-step result,
	// since we did not call FailStep for "parent".
	assert.Equal(t, STEP_RESULT_SUCCESS, res.Result)
	// Find the actual failed step, ensure that it has the error.
	s, err := res.findStep(id)
	assert.NoError(t, err)
	assert.Equal(t, STEP_RESULT_FAILURE, s.Result)
	assert.Equal(t, 1, len(s.Errors))
	assert.Equal(t, "whoops", s.Errors[0])
}

func TestExec(t *testing.T) {
	unittest.MediumTest(t)

	// Basic tests around executing subprocesses.
	_ = RunTestSteps(t, false, func(ctx context.Context) error {
		mockExecCtx, counter := mockExec(ctx)

		// Simple command.
		_, err := exec.RunSimple(mockExecCtx, "true")
		assert.NoError(t, err)
		assert.Equal(t, 1, *counter)

		// Verify that we get an error if the command fails.
		_, err = exec.RunCwd(mockExecCtx, ".", "false")
		assert.Contains(t, err.Error(), "Command exited with exit status 1: ")
		assert.Equal(t, 2, *counter)

		// Ensure that we collect stdout.
		out, err := exec.RunCwd(ctx, ".", "python", "-c", "print 'hello world'")
		assert.NoError(t, err)
		assert.True(t, strings.Contains(out, "hello world"))
		assert.Equal(t, 2, *counter) // Not using the mock for this test case.

		// Ensure that we collect stdout and stderr.
		out, err = exec.RunCwd(ctx, ".", "python", "-c", "import sys; print 'stdout'; print >> sys.stderr, 'stderr'")
		assert.NoError(t, err)
		assert.True(t, strings.Contains(out, "stdout"))
		assert.True(t, strings.Contains(out, "stderr"))
		assert.Equal(t, 2, *counter) // Not using the mock for this test case.
		return nil
	})
}

func TestFatal(t *testing.T) {
	unittest.SmallTest(t)

	err := errors.New("FATAL")
	checkErr := func(s *StepReport) {
		assert.Equal(t, 1, len(s.Errors))
		assert.EqualError(t, err, s.Errors[0])
	}
	checkErrs := func(s *StepReport) {
		checkErr(s)
		s.Recurse(func(s *StepReport) bool {
			checkErr(s)
			return true
		})
	}
	checkExc := func(s *StepReport) {
		assert.Equal(t, 1, len(s.Exceptions))
		assert.EqualError(t, err, s.Exceptions[0])
	}
	checkExcs := func(s *StepReport) {
		checkExc(s)
		s.Recurse(func(s *StepReport) bool {
			checkExc(s)
			return true
		})
	}

	// When Fatal is called in a non-infra step, all parent steps get an error.
	s := RunTestSteps(t, true, func(ctx context.Context) error {
		return Do(ctx, nil, func(ctx context.Context) error {
			return Do(ctx, Props("non-infra step"), func(ctx context.Context) error {
				Fatal(ctx, err)
				return nil
			})
		})
	})
	checkErrs(s)

	// When Fatal is called in an infra step, all parent steps get an exception.
	s = RunTestSteps(t, true, func(ctx context.Context) error {
		return Do(ctx, nil, func(ctx context.Context) error {
			return Do(ctx, Props("infra step").Infra(), func(ctx context.Context) error {
				Fatal(ctx, err)
				return nil
			})
		})
	})
	checkExcs(s)

	// Check the case where we call Fatal() after a failed subprocess but
	// still want to perform deferred cleanup.
	ranCleanup := false
	s = RunTestSteps(t, true, func(ctx context.Context) error {
		defer func() {
			util.LogErr(Do(ctx, Props("cleanup").Infra(), func(ctx context.Context) error {
				ranCleanup = true
				return nil
			}))
		}()
		ctx, _ = mockExec(ctx)
		if _, err := exec.RunSimple(ctx, "false"); err != nil {
			Fatal(ctx, err)
			return err
		}
		return nil
	})
	assert.Equal(t, 1, len(s.Errors))
	assert.Contains(t, s.Errors[0], "Command exited with exit status 1: ")
	assert.True(t, ranCleanup)

	// Check the case where we call Fatal() after an infra step failed whose
	// parent is not an infra step.
	s = RunTestSteps(t, true, func(ctx context.Context) error {
		return Do(ctx, Props("non-infra step"), func(ctx context.Context) error {
			if err := Do(ctx, Props("infra step").Infra(), func(ctx context.Context) error {
				return errors.New("Infra Failure")
			}); err != nil {
				Fatal(ctx, err)
			}
			return nil
		})
	})
	assert.Equal(t, 1, len(s.Exceptions))
	assert.Equal(t, "Infra Failure", s.Exceptions[0])
}

func TestEnv(t *testing.T) {
	unittest.MediumTest(t)

	// Verify that each step inherits the environment of its parent.
	s := RunTestSteps(t, false, func(ctx context.Context) error {
		return Do(ctx, Props("a").Env([]string{"a=a"}), func(ctx context.Context) error {
			return Do(ctx, Props("b").Env([]string{"b=b"}), func(ctx context.Context) error {
				_, err := exec.RunCommand(ctx, &exec.Command{
					Name: "python",
					Args: []string{"-c", "print 'hello world'"},
					Env:  []string{"c=c"},
				})
				return err
			})
		})
	})
	var leaf *StepReport
	s.Recurse(func(s *StepReport) bool {
		if len(s.Steps) == 0 {
			leaf = s
			return false
		}
		return true
	})
	assert.NotNil(t, leaf)
	expect := MergeEnv(os.Environ(), BASE_ENV)
	expect = append(expect, "a=a", "b=b", "c=c")
	deepequal.AssertDeepEqual(t, expect, leaf.StepProperties.Environ)

	var data *ExecData
	for _, d := range leaf.Data {
		ed, ok := d.(*ExecData)
		if ok {
			data = ed
			break
		}
	}
	assert.NotNil(t, data)
	deepequal.AssertDeepEqual(t, data.Env, expect)
}

func TestEnvMerge(t *testing.T) {
	unittest.SmallTest(t)

	tc := []struct {
		a      []string
		b      []string
		expect []string
	}{
		// Unrelated variables both show up.
		{
			expect: []string{"a=a", "b=b"},
			a:      []string{"a=a"},
			b:      []string{"b=b"},
		},
		// The second env takes precedence over the first.
		{
			expect: []string{"k=v2"},
			a:      []string{"k=v1"},
			b:      []string{"k=v2"},
		},

		// PATH gets special treatment.

		// If only one is specified, it gets preserved.
		{
			expect: []string{"PATH=p2"},
			a:      []string{},
			b:      []string{"PATH=p2"},
		},
		{
			expect: []string{"PATH=p1"},
			a:      []string{"PATH=p1"},
			b:      []string{},
		},
		// The second env takes precedence over the first.
		{
			expect: []string{"PATH=p2"},
			a:      []string{"PATH=p1"},
			b:      []string{"PATH=p2"},
		},
		// ... even if the second env defines it to be empty.
		{
			expect: []string{"PATH="},
			a:      []string{"PATH=p1"},
			b:      []string{"PATH="},
		},
		// If provided, PATH_PLACEHOLDER gets replaced by PATH from the first.
		{
			expect: []string{"PATH=p1:p2"},
			a:      []string{"PATH=p1"},
			b:      []string{fmt.Sprintf("PATH=%s:p2", PATH_PLACEHOLDER)},
		},
		{
			expect: []string{"PATH=p2:p1"},
			a:      []string{"PATH=p1"},
			b:      []string{fmt.Sprintf("PATH=p2:%s", PATH_PLACEHOLDER)},
		},
		// There's no good reason to do this, but it would work.
		{
			expect: []string{"PATH=p1:p1"},
			a:      []string{"PATH=p1"},
			b:      []string{fmt.Sprintf("PATH=%s:%s", PATH_PLACEHOLDER, PATH_PLACEHOLDER)},
		},
	}

	for _, c := range tc {
		assert.Equal(t, c.expect, MergeEnv(c.a, c.b))
	}
}

func TestEnvInheritance(t *testing.T) {
	unittest.SmallTest(t)

	// Set up exec mock and expectations.
	runCount := 0
	expect := MergeEnv(os.Environ(), BASE_ENV)
	expect = append(expect, "a=a", "b=b", "c=c", "d=d")
	mockRun := &exec.CommandCollector{}
	mockRun.SetDelegateRun(func(ctx context.Context, cmd *exec.Command) error {
		runCount++
		assert.Equal(t, expect, cmd.Env)
		return nil
	})

	// Verify that environments are inherited properly.
	assert.Equal(t, 0, runCount)
	s := RunTestSteps(t, false, func(ctx context.Context) error {
		ctx = WithExecRunFn(ctx, mockRun.Run)
		return Do(ctx, Props("a").Env([]string{"a=a", "b=a"}), func(ctx context.Context) error {
			ctx = WithEnv(ctx, []string{"b=b", "c=b"})
			return Do(ctx, Props("c").Env([]string{"c=c", "d=c"}), func(ctx context.Context) error {
				_, err := exec.RunCommand(ctx, &exec.Command{
					Name: "true",
					Env:  []string{"d=d"},
				})
				return err
			})
		})
	})
	assert.Equal(t, 1, runCount)
	var leaf *StepReport
	s.Recurse(func(s *StepReport) bool {
		if len(s.Steps) == 0 {
			leaf = s
			return false
		}
		return true
	})
	assert.NotNil(t, leaf)
	deepequal.AssertDeepEqual(t, expect, leaf.StepProperties.Environ)

	var data *ExecData
	for _, d := range leaf.Data {
		ed, ok := d.(*ExecData)
		if ok {
			data = ed
			break
		}
	}
	assert.NotNil(t, data)
	deepequal.AssertDeepEqual(t, data.Env, expect)

	// Verify that multiple invocations of WithEnv get merged.
	assert.Equal(t, 1, runCount)
	s = RunTestSteps(t, false, func(ctx context.Context) error {
		ctx = WithExecRunFn(ctx, mockRun.Run)
		ctx = WithEnv(ctx, []string{"a=a", "b=a"})
		ctx = WithEnv(ctx, []string{"b=b", "c=b"})
		ctx = WithEnv(ctx, []string{"c=c", "d=c"})
		_, err := exec.RunCommand(ctx, &exec.Command{
			Name: "true",
			Env:  []string{"d=d"},
		})
		return err
	})
	assert.Equal(t, 2, runCount)
	leaf = nil
	s.Recurse(func(s *StepReport) bool {
		if len(s.Steps) == 0 {
			leaf = s
			return false
		}
		return true
	})
	assert.NotNil(t, leaf)
	deepequal.AssertDeepEqual(t, expect, leaf.StepProperties.Environ)

	data = nil
	for _, d := range leaf.Data {
		ed, ok := d.(*ExecData)
		if ok {
			data = ed
			break
		}
	}
	assert.NotNil(t, data)
	deepequal.AssertDeepEqual(t, data.Env, expect)
}