// Copyright 2020 The Fuchsia 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 main

import (
	"context"
	"errors"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"runtime"
	"strings"
	"syscall"
	"testing"

	"go.fuchsia.dev/fuchsia/tools/lib/color"
	"go.fuchsia.dev/fuchsia/tools/lib/logger"
	"go.fuchsia.dev/fuchsia/tools/sdk-tools/sdkcommon"
)

// test argument pointing to the directory containing the testdata directory.
// This is configured in the BUILD.gn file.
var testrootFlag = flag.String("testroot", "", "Root directory of the files needed to execute the test.")

const hostaddr = "fe80::c0ff:eeee:fefe:c000%eth1"

type testSDKProperties struct {
	dataPath              string
	expectCustomSSHConfig bool
	expectPrivateKey      bool
	expectedSSHArgs       [][]string
}

func (testSDK testSDKProperties) GetToolsDir() (string, error) {
	return "fake-tools", nil
}

func (testSDK testSDKProperties) GetSDKDataPath() string {
	return testSDK.dataPath
}

func (testSDK testSDKProperties) GetAvailableImages(version string, bucket string) ([]sdkcommon.GCSImage, error) {
	return []sdkcommon.GCSImage{}, nil
}
func (testSDK testSDKProperties) GetAddressByName(deviceName string) (string, error) {
	return "::1", nil
}
func (testSDK testSDKProperties) GetDefaultPackageRepoDir() (string, error) {
	return filepath.Join(testSDK.dataPath, "default-target-name", "packages", "amber-files"), nil
}
func (testSDK testSDKProperties) RunSSHCommand(targetAddress string, sshConfig string, privateKey string, verbose bool, sshArgs []string) (string, error) {
	if testSDK.expectCustomSSHConfig && sshConfig == "" {
		return "", errors.New("Expected custom ssh config file")
	}
	if testSDK.expectPrivateKey && privateKey == "" {
		return "", errors.New("Expected private key file")
	}
	expectedArgs := []string{}

	for _, args := range testSDK.expectedSSHArgs {
		if sshArgs[0] == args[0] {
			expectedArgs = args
			break
		}
	}

	ok := len(expectedArgs) == len(sshArgs)
	if ok {
		for i, expected := range expectedArgs {
			if !ok {
				return "", fmt.Errorf("unexpected ssh args[%v]  %v expected[%v] %v",
					len(sshArgs), sshArgs, len(expectedArgs), expectedArgs)
			}
			if strings.Contains(expected, "*") {
				expectedPattern := regexp.MustCompile(expected)
				ok = expectedPattern.MatchString(sshArgs[i])
			} else {
				ok = expected == sshArgs[i]
			}
		}
	}
	if sshArgs[0] == "echo" {
		return fmt.Sprintf("%v 54545 fe80::c00f:f0f0:eeee:cccc 22\n", hostaddr), nil
	}
	return "", nil
}

// Context with a logger used to test.
func testingContext() context.Context {
	flags := log.Ltime | log.Lshortfile
	log := logger.NewLogger(logger.DebugLevel, color.NewColor(color.ColorAuto), os.Stdout, os.Stderr, "fserve_test ")
	log.SetFlags(flags)
	return logger.WithLogger(context.Background(), log)
}

// See exec_test.go for details, but effectively this runs the function called TestHelperProcess passing
// the args.
func helperCommandForFServe(command string, s ...string) (cmd *exec.Cmd) {
	cs := []string{"-test.run=TestFakeFServe", "--"}
	cs = append(cs, command)
	cs = append(cs, s...)

	cmd = exec.Command(os.Args[0], cs...)
	// Set this in the enviroment, so we can control the result.
	cmd.Env = append(os.Environ(), "GO_WANT_HELPER_PROCESS=1")
	return cmd
}

func TestKillServers(t *testing.T) {
	ctx := testingContext()
	ExecCommand = helperCommandForFServe
	findProcess = mockedFindProcess
	defer func() {
		ExecCommand = exec.Command
		findProcess = defaultFindProcess
	}()

	// Test no existing servers
	os.Setenv("FSERVE_TEST_NO_SERVERS", "1")
	if err := killServers(ctx, ""); err != nil {
		t.Fatal(err)
	}
	// Test existing servers
	os.Setenv("FSERVE_TEST_NO_SERVERS", "0")
	if err := killServers(ctx, ""); err != nil {
		t.Fatal(err)
	}
	if err := killServers(ctx, "8083"); err != nil {
		t.Fatal(err)
	}
	os.Setenv("FSERVE_TEST_PGREP_ERROR", "1")
	err := killServers(ctx, "")
	if err == nil {
		t.Fatal("Expected error running pgrep, got no error.")
	}
	expected := "Error running pgrep: Expected error\n"
	actual := fmt.Sprintf("%v", err)
	if expected != actual {
		t.Fatalf("[%v], got [%v]", expected, actual)
	}

	os.Setenv("FSERVE_TEST_PGREP_ERROR", "0")
	os.Setenv("FSERVE_TEST_PS_ERROR", "1")
	err = killServers(ctx, "")
	if err == nil {
		t.Fatal("Expected error running ps, got no error.")
	}
	expected = "Error running ps: Expected error\n"
	actual = fmt.Sprintf("%v", err)
	if expected != actual {
		t.Fatalf("[%v], got [%v]", expected, actual)
	}
}

func TestStartServer(t *testing.T) {
	testSDK := testSDKProperties{
		dataPath: "/fake",
	}
	repoPath := "/fake/repo/path"
	repoPort := "8083"
	ExecCommand = helperCommandForFServe
	defer func() {
		ExecCommand = exec.Command
		syscallWait4 = defaultsyscallWait4
	}()

	tests := []struct {
		syscallWait4  func(pid int, wstatus *syscall.WaitStatus, flags int, usage *syscall.Rusage) (int, error)
		expectedError string
		logLevel      logger.LogLevel
		expectedArgs  []string
	}{

		{syscallWait4: mockWait4NoError,
			expectedError: "",
			logLevel:      logger.WarningLevel,
			expectedArgs:  []string{"serve", "-q", "-repo", "/fake/repo/path", "-l", ":8083"},
		},

		{syscallWait4: mockWait4NoError,
			expectedError: "",
			logLevel:      logger.DebugLevel,
			expectedArgs:  []string{"serve", "-repo", "/fake/repo/path", "-l", ":8083"},
		},

		{syscallWait4: mockWait4WithError,
			expectedError: "Server started then exited with code 1",
			logLevel:      logger.WarningLevel,
		},
	}

	for i, test := range tests {
		t.Run(fmt.Sprintf("TestStartServer case %d", i), func(t *testing.T) {
			syscallWait4 = test.syscallWait4
			level = test.logLevel
			os.Setenv("TEST_LOGLEVEL", level.String())
			cmd, err := startServer(testSDK, repoPath, repoPort)
			if err != nil {
				actual := fmt.Sprintf("%v", err)
				if test.expectedError != actual {
					t.Errorf("Actual error [%v] did not match expected [%v]", actual, test.expectedError)
				}
			} else if test.expectedError != "" {
				t.Errorf("Expected error %v, but got no error", test.expectedError)
			} else {
				actual := cmd.Args[4:]
				ok := len(actual) == len(test.expectedArgs)
				if ok {
					for i, arg := range test.expectedArgs {
						if arg != actual[i] {
							ok = false
							break
						}
					}
				}
				if !ok {
					t.Errorf("pm args %v do not match expected %v", actual, test.expectedArgs)
				}
			}
		})
		syscallWait4 = defaultsyscallWait4
	}
}

func TestDownloadImageIfNeeded(t *testing.T) {
	testSDK := testSDKProperties{
		dataPath: t.TempDir(),
	}
	ctx := testingContext()
	ExecCommand = helperCommandForFServe
	sdkcommon.ExecCommand = helperCommandForFServe
	sdkcommon.ExecLookPath = func(cmd string) (string, error) { return filepath.Join("mocked", cmd), nil }
	defer func() {
		ExecCommand = exec.Command
		sdkcommon.ExecCommand = exec.Command
		sdkcommon.ExecLookPath = exec.LookPath
	}()
	version := "any-version"
	bucket := "test-bucket"
	srcPath := "gs://test-bucket/path/on/GCS/theImage.tgz"
	imageFilename := "theImage.tgz"
	repoPath, err := testSDK.GetDefaultPackageRepoDir()
	if err != nil {
		t.Fatal(err)
	}

	executable, _ := os.Executable()
	fmt.Fprintf(os.Stderr, "Running test executable %v\n", executable)
	fmt.Fprintf(os.Stderr, "testrootFlag value   is %v\n", *testrootFlag)
	testrootPath := filepath.Join(filepath.Dir(executable), *testrootFlag)
	os.Setenv("FSERVE_TEST_TESTROOT", testrootPath)

	if err := downloadImageIfNeeded(ctx, testSDK, version, bucket, srcPath, imageFilename, repoPath); err != nil {
		t.Fatal(err)
	}
	// Run the test again, and it should skip the download
	os.Setenv("FSERVE_TEST_ASSERT_NO_DOWNLOAD", "1")
	if err := downloadImageIfNeeded(ctx, testSDK, version, bucket, srcPath, imageFilename, repoPath); err != nil {
		t.Fatal(err)
	}
}

func TestDownloadImageIfNeededCopiedFails(t *testing.T) {
	testSDK := testSDKProperties{
		dataPath: "/fake",
	}
	ctx := testingContext()
	ExecCommand = helperCommandForFServe
	sdkcommon.ExecCommand = helperCommandForFServe
	sdkcommon.ExecLookPath = func(cmd string) (string, error) { return filepath.Join("mocked", cmd), nil }
	defer func() {
		ExecCommand = exec.Command
		sdkcommon.ExecCommand = exec.Command
		sdkcommon.ExecLookPath = exec.LookPath
	}()
	version := "any-version"
	bucket := "test-bucket"
	srcPath := "gs://test-bucket/path/on/GCS/theImage.tgz"
	imageFilename := "theImage.tgz"
	repoPath, err := testSDK.GetDefaultPackageRepoDir()
	if err != nil {
		t.Fatal(err)
	}

	// Run the test again, and it should skip the download
	os.Setenv("FSERVE_TEST_ASSERT_NO_DOWNLOAD", "")
	os.Setenv("FSERVE_TEST_COPY_FAILS", "1")
	if err := downloadImageIfNeeded(ctx, testSDK, version, bucket, srcPath, imageFilename, repoPath); err != nil {
		destPath := filepath.Join(testSDK.GetSDKDataPath(), imageFilename)
		expected := fmt.Sprintf("Could not copy image from %v to %v: BucketNotFoundException: 404 %v bucket does not exist.: exit status 2",
			srcPath, destPath, srcPath)
		actual := fmt.Sprintf("%v", err)
		if expected != actual {
			t.Fatalf("[%v], got [%v]", expected, actual)
		}
	} else {
		t.Fatal("Expected error downloading, got no error.")
	}
}

const resolvedAddr = "fe80::c0ff:eee:fe00:4444%en0"

func TestSetPackageSource(t *testing.T) {
	testSDK := testSDKProperties{
		dataPath: t.TempDir(),
	}
	homeDir := filepath.Join(testSDK.GetSDKDataPath(), "_TEMP_HOME")
	if err := os.MkdirAll(homeDir, 0o700); err != nil {
		t.Fatal(err)
	}
	ctx := testingContext()
	ExecCommand = helperCommandForFServe
	sdkcommon.ExecCommand = helperCommandForFServe
	sdkcommon.GetUserHomeDir = func() (string, error) { return homeDir, nil }
	sdkcommon.GetUsername = func() (string, error) { return "testuser", nil }
	sdkcommon.GetHostname = func() (string, error) { return "testhost", nil }
	defer func() {
		ExecCommand = exec.Command
		sdkcommon.ExecCommand = exec.Command
		sdkcommon.GetUserHomeDir = sdkcommon.DefaultGetUserHomeDir
		sdkcommon.GetUsername = sdkcommon.DefaultGetUsername
		sdkcommon.GetHostname = sdkcommon.DefaultGetHostname
	}()

	tests := []struct {
		repoPort        string
		targetAddress   string
		sshConfig       string
		name            string
		privateKey      string
		expectedSSHArgs [][]string
	}{
		{
			repoPort:      "8083",
			targetAddress: resolvedAddr,
			sshConfig:     "",
			privateKey:    "",
			name:          "devhost",
			expectedSSHArgs: [][]string{
				{"echo", "$SSH_CONNECTION"},
				{"amber_ctl", "add_src", "-n", "devhost", "-f", "http://[fe80::c0ff:eeee:fefe:c000%25eth1]:8083/config.json"},
			},
		},
		{
			repoPort:      "8083",
			targetAddress: resolvedAddr,
			sshConfig:     "custom-sshconfig",
			privateKey:    "",
			name:          "devhost",
			expectedSSHArgs: [][]string{
				{"echo", "$SSH_CONNECTION"},
				{"amber_ctl", "add_src", "-n", "devhost", "-f", "http://[fe80::c0ff:eeee:fefe:c000%25eth1]:8083/config.json"},
			},
		},
		{
			repoPort:      "8083",
			targetAddress: resolvedAddr,
			sshConfig:     "",
			privateKey:    "private-key",
			name:          "devhost",
			expectedSSHArgs: [][]string{
				{"echo", "$SSH_CONNECTION"},
				{"amber_ctl", "add_src", "-n", "devhost", "-f", "http://[fe80::c0ff:eeee:fefe:c000%25eth1]:8083/config.json"},
			},
		},
	}

	for _, test := range tests {
		testSDK := testSDKProperties{expectedSSHArgs: test.expectedSSHArgs,
			expectCustomSSHConfig: test.sshConfig != "",
			expectPrivateKey:      test.privateKey != ""}

		if err := setPackageSource(ctx, testSDK, test.repoPort, test.name, test.targetAddress, test.sshConfig, test.privateKey); err != nil {
			t.Fatal(err)
		}
	}
}

/*
This "test" is used to mock the command line tools invoked by fserve.
The method "helperCommandForFServe" replaces exec.Command and runs
this test inplace of the command.

This approach to mocking out executables is  based on  exec_test.go.

*/
func TestFakeFServe(t *testing.T) {
	t.Helper()
	if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
		return
	}
	defer os.Exit(0)

	args := os.Args
	for len(args) > 0 {
		if args[0] == "--" {
			args = args[1:]
			break
		}
		args = args[1:]
	}
	if len(args) == 0 {
		fmt.Fprintf(os.Stderr, "No command\n")
		os.Exit(2)
	}
	// Check the command line
	cmd, args := args[0], args[1:]
	switch filepath.Base(cmd) {
	case "pgrep":
		fakePgrep(args)
	case "ps":
		fakePS(args)
	case "pm":
		fakePM(args)
	case "gsutil":
		fakeGSUtil(args)
	default:
		fmt.Fprintf(os.Stderr, "Unexpected command %v", cmd)
		os.Exit(1)
	}
}

func fakeGSUtil(args []string) {
	expected := []string{}
	expectedLS := []string{"ls", "gs://test-bucket/path/on/GCS/theImage.tgz"}
	expectedCP := []string{"cp", "gs://test-bucket/path/on/GCS/theImage.tgz", "/.*/theImage.tgz"}

	if len(args) == 0 {
		fmt.Fprintf(os.Stderr, "Expected arguments to gsutil\n")
		os.Exit(1)
	}
	switch args[0] {
	case "ls":
		expected = expectedLS
	case "cp":
		if os.Getenv("FSERVE_TEST_ASSERT_NO_DOWNLOAD") != "" {
			fmt.Fprintf(os.Stderr, "Unexpected call to gsutil cp: %v\n", args)
			os.Exit(1)
		}
		if os.Getenv("FSERVE_TEST_COPY_FAILS") != "" {
			fmt.Fprintf(os.Stderr, "BucketNotFoundException: 404 %v bucket does not exist.", args[1])
			os.Exit(2)
		}
		expected = expectedCP
		// Copy the test data to the expected path.
		testRoot := os.Getenv("FSERVE_TEST_TESTROOT")
		testdata := filepath.Join(testRoot, "testdata", "testdata.tgz")
		if !sdkcommon.FileExists(testdata) {
			testdata = filepath.Join("..", "testdata", "testdata.tgz")
		}
		if err := os.MkdirAll(filepath.Dir(args[2]), 0755); err != nil {
			fmt.Fprintf(os.Stderr, "Error getting mkdir temp dir: %v\n", err)
			os.Exit(1)
		}
		if err := copyFile(testdata, args[2]); err != nil {
			fmt.Fprintf(os.Stderr, "Error linking testdata: %v\n", err)
			os.Exit(1)
		}

	}

	ok := len(args) == len(expected)
	if ok {
		for i := range args {
			if strings.Contains(expected[i], "*") {
				expectedPattern := regexp.MustCompile(expected[i])
				ok = ok && expectedPattern.MatchString(args[i])
			} else {
				ok = ok && args[i] == expected[i]
			}
		}
	}
	if !ok {
		fmt.Fprintf(os.Stderr, "unexpected gsutil args  %v. Expected %v", args, expected)
		os.Exit(1)
	}
}

func fakePM(args []string) {
	expected := []string{"serve"}
	logLevel := os.Getenv("TEST_LOGLEVEL")
	// only debug and trace have non-quiet mode.
	if logLevel != "debug" && logLevel != "trace" {
		expected = append(expected, "-q")
	}
	expected = append(expected, "-repo", "/fake/repo/path", "-l", ":8083")
	ok := len(args) == len(expected)
	if ok {
		for i := range args {
			ok = ok && args[i] == expected[i]
		}
	}
	if !ok {
		fmt.Fprintf(os.Stderr, "unexpected pm args  %v. Expected %v\n", args, expected)
		os.Exit(1)
	}
}

func fakePgrep(args []string) {
	if os.Getenv("FSERVE_TEST_PGREP_ERROR") == "1" {
		fmt.Fprintf(os.Stderr, "Expected error\n")
		os.Exit(1)
	}
	if args[0] == "pm" {
		if os.Getenv("FSERVE_TEST_NO_SERVERS") == "1" {
			// mac exits with 1
			if runtime.GOOS == "darwin" {
				os.Exit(1)
			}
			os.Exit(0)
		} else {
			// return 3 pm instances
			fmt.Printf(`1000
		2000
		3000`)
			os.Exit(0)
		}
	}
	fmt.Fprintf(os.Stderr, "unexpected pgrep args  %v", args)
	os.Exit(1)
}

func fakePS(args []string) {
	if os.Getenv("FSERVE_TEST_PS_ERROR") == "1" {
		fmt.Fprintf(os.Stderr, "Expected error\n")
		os.Exit(1)
	}
	fmt.Println("    PID TTY      STAT   TIME COMMAND")
	for _, arg := range args {
		switch arg {
		case "1000":
			// some internal process
			fmt.Println("1000 ?       I<     0:00  [tpm_dev_wq]")
		case "2000":
			// pm on port 8083
			fmt.Println("2000  pts/0    Sl     0:00 /sdk/path/tools/x64/pm serve -repo /home/developer/.fuchsia/packages/amber-files -l :8083")
		case "3000":
			// pm on port 8084
			fmt.Println("3000  pts/0    Sl     0:00 /sdk/path/tools/x64/pm serve -repo /home/developer/.fuchsia/packages/amber-files -l :8084 -q")
		}
	}
}

type testProcess struct {
	Pid int
}

func (proc testProcess) Kill() error {
	// This mock only kills pid == 2000
	if proc.Pid != 2000 {
		return fmt.Errorf("Unexpected pid %v in Kill", proc.Pid)
	}
	return nil
}

func mockedFindProcess(pid int) (osProcess, error) {
	proc := testProcess{Pid: pid}

	return &proc, nil
}

func mockWait4NoError(pid int, wstatus *syscall.WaitStatus, flags int, usage *syscall.Rusage) (int, error) {
	return 0, nil
}

func mockWait4WithError(pid int, wstatus *syscall.WaitStatus, flags int, usage *syscall.Rusage) (int, error) {
	// set wstatus to exited with code 1.
	*wstatus = syscall.WaitStatus(0x100)
	return 0, nil
}

func copyFile(src, dst string) error {
	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()

	out, err := os.Create(dst)
	if err != nil {
		return err
	}
	defer out.Close()

	_, err = io.Copy(out, in)
	if err != nil {
		return err
	}
	return out.Close()
}