// +build ignore

package main

import (
	"bufio"
	"bytes"
	"errors"
	"flag"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"runtime"
	"strings"
)

// ForbiddenImports are the packages from the stdlib that should not be used in
// our code.
var ForbiddenImports = map[string]bool{
	"errors": true,
}

var runCrossCompile = flag.Bool("cross-compile", true, "run cross compilation tests")
var minioServer = flag.String("minio", "", "path to the minio server binary")
var debug = flag.Bool("debug", false, "output debug messages")

var minioServerEnv = map[string]string{
	"MINIO_ACCESS_KEY": "KEBIYDZ87HCIH5D17YCN",
	"MINIO_SECRET_KEY": "bVX1KhipSBPopEfmhc7rGz8ooxx27xdJ7Gkh1mVe",
}

var minioEnv = map[string]string{
	"RESTIC_TEST_S3_SERVER": "http://127.0.0.1:9000",
	"AWS_ACCESS_KEY_ID":     "KEBIYDZ87HCIH5D17YCN",
	"AWS_SECRET_ACCESS_KEY": "bVX1KhipSBPopEfmhc7rGz8ooxx27xdJ7Gkh1mVe",
}

func init() {
	flag.Parse()
}

// CIEnvironment is implemented by environments where tests can be run.
type CIEnvironment interface {
	Prepare() error
	RunTests() error
	Teardown() error
}

// TravisEnvironment is the environment in which Travis tests run.
type TravisEnvironment struct {
	goxOSArch []string
	minio     string

	minioSrv     *Background
	minioTempdir string

	env map[string]string
}

func (env *TravisEnvironment) getMinio() error {
	if *minioServer != "" {
		msg("using minio server at %q\n", *minioServer)
		env.minio = *minioServer
		return nil
	}

	tempfile, err := ioutil.TempFile("", "minio-server-")
	if err != nil {
		return fmt.Errorf("create tempfile for minio download failed: %v\n", err)
	}

	url := fmt.Sprintf("https://dl.minio.io/server/minio/release/%s-%s/minio",
		runtime.GOOS, runtime.GOARCH)
	msg("downloading %v\n", url)
	res, err := http.Get(url)
	if err != nil {
		return fmt.Errorf("error downloading minio server: %v\n", err)
	}

	_, err = io.Copy(tempfile, res.Body)
	if err != nil {
		return fmt.Errorf("error saving minio server to file: %v\n", err)
	}

	err = res.Body.Close()
	if err != nil {
		return fmt.Errorf("error closing HTTP download: %v\n", err)
	}

	err = tempfile.Close()
	if err != nil {
		msg("closing tempfile failed: %v\n", err)
		return fmt.Errorf("error closing minio server file: %v\n", err)
	}

	err = os.Chmod(tempfile.Name(), 0755)
	if err != nil {
		return fmt.Errorf("chmod(minio-server) failed: %v", err)
	}

	msg("downloaded minio server to %v\n", tempfile.Name())
	env.minio = tempfile.Name()
	return nil
}

func (env *TravisEnvironment) runMinio() error {
	if env.minio == "" {
		return nil
	}

	// start minio server
	msg("starting minio server at %s", env.minio)

	dir, err := ioutil.TempDir("", "minio-root")
	if err != nil {
		return fmt.Errorf("running minio server failed: %v", err)
	}

	env.minioSrv, err = StartBackgroundCommand(minioServerEnv, env.minio,
		"server",
		"--address", "127.0.0.1:9000",
		dir)
	if err != nil {
		return fmt.Errorf("error running minio server: %v", err)
	}

	// go func() {
	// 	time.Sleep(300 * time.Millisecond)
	// 	env.minioSrv.Cmd.Process.Kill()
	// }()

	for k, v := range minioEnv {
		env.env[k] = v
	}

	env.minioTempdir = dir
	return nil
}

// Prepare installs dependencies and starts services in order to run the tests.
func (env *TravisEnvironment) Prepare() error {
	env.env = make(map[string]string)

	msg("preparing environment for Travis CI\n")

	for _, pkg := range []string{
		"golang.org/x/tools/cmd/cover",
		"github.com/pierrre/gotestcover",
	} {
		err := run("go", "get", pkg)
		if err != nil {
			return err
		}
	}

	if err := env.getMinio(); err != nil {
		return err
	}
	if err := env.runMinio(); err != nil {
		return err
	}

	if runtime.GOOS == "darwin" {
		// install the libraries necessary for fuse
		for _, cmd := range [][]string{
			{"brew", "update"},
			{"brew", "tap", "caskroom/cask"},
			{"brew", "cask", "install", "osxfuse"},
		} {
			if err := run(cmd[0], cmd[1:]...); err != nil {
				return err
			}
		}
	}

	if *runCrossCompile && !(runtime.Version() < "go1.7") {
		// only test cross compilation on linux with Travis
		if err := run("go", "get", "github.com/mitchellh/gox"); err != nil {
			return err
		}
		if runtime.GOOS == "linux" {
			env.goxOSArch = []string{
				"linux/386", "linux/amd64",
				"windows/386", "windows/amd64",
				"darwin/386", "darwin/amd64",
				"freebsd/386", "freebsd/amd64",
				"opendbsd/386", "opendbsd/amd64",
			}
			if !strings.HasPrefix(runtime.Version(), "go1.3") {
				env.goxOSArch = append(env.goxOSArch,
					"linux/arm", "freebsd/arm")
			}
		} else {
			env.goxOSArch = []string{runtime.GOOS + "/" + runtime.GOARCH}
		}

		msg("gox: OS/ARCH %v\n", env.goxOSArch)

		if runtime.Version() < "go1.5" {
			err := run("gox", "-build-toolchain",
				"-osarch", strings.Join(env.goxOSArch, " "))

			if err != nil {
				return err
			}
		}
	}

	return nil
}

// Teardown stops backend services and cleans the environment again.
func (env *TravisEnvironment) Teardown() error {
	msg("run travis teardown\n")
	if env.minioSrv != nil {
		msg("stopping minio server\n")

		if env.minioSrv.Cmd.ProcessState == nil {
			err := env.minioSrv.Cmd.Process.Kill()
			if err != nil {
				fmt.Fprintf(os.Stderr, "error killing minio server process: %v", err)
			}
		} else {
			result := <-env.minioSrv.Result
			if result.Error != nil {
				msg("minio server returned error: %v\n", result.Error)
				msg("stdout: %s\n", result.Stdout)
				msg("stderr: %s\n", result.Stderr)
			}
		}

		err := os.RemoveAll(env.minioTempdir)
		if err != nil {
			msg("error removing minio tempdir %v: %v\n", env.minioTempdir, err)
		}
	}

	return nil
}

func goVersionAtLeast151() bool {
	v := runtime.Version()

	if match, _ := regexp.MatchString(`^go1\.[0-4]`, v); match {
		return false
	}

	if v == "go1.5" {
		return false
	}

	return true
}

// Background is a program running in the background.
type Background struct {
	Cmd    *exec.Cmd
	Result chan Result
}

// Result is the result of a program that ran in the background.
type Result struct {
	Stdout, Stderr string
	Error          error
}

// StartBackgroundCommand runs a program in the background.
func StartBackgroundCommand(env map[string]string, cmd string, args ...string) (*Background, error) {
	msg("running background command %v %v\n", cmd, args)
	b := Background{
		Result: make(chan Result, 1),
	}

	stdout := bytes.NewBuffer(nil)
	stderr := bytes.NewBuffer(nil)

	c := exec.Command(cmd, args...)
	c.Stdout = stdout
	c.Stderr = stderr

	if *debug {
		c.Stdout = io.MultiWriter(c.Stdout, os.Stdout)
		c.Stderr = io.MultiWriter(c.Stderr, os.Stderr)
	}
	c.Env = updateEnv(os.Environ(), env)

	b.Cmd = c

	err := c.Start()
	if err != nil {
		msg("error starting background job %v: %v\n", cmd, err)
		return nil, err
	}

	go func() {
		err := b.Cmd.Wait()
		msg("background job %v returned: %v\n", cmd, err)
		msg("stdout: %s\n", stdout.Bytes())
		msg("stderr: %s\n", stderr.Bytes())
		b.Result <- Result{
			Stdout: string(stdout.Bytes()),
			Stderr: string(stderr.Bytes()),
			Error:  err,
		}
	}()

	return &b, nil
}

// RunTests starts the tests for Travis.
func (env *TravisEnvironment) RunTests() error {
	// run fuse tests on darwin
	if runtime.GOOS != "darwin" {
		msg("skip fuse integration tests on %v\n", runtime.GOOS)
		os.Setenv("RESTIC_TEST_FUSE", "0")
	}

	cwd, err := os.Getwd()
	if err != nil {
		return fmt.Errorf("Getwd() returned error: %v", err)
	}

	env.env["GOPATH"] = cwd + ":" + filepath.Join(cwd, "vendor")

	if *runCrossCompile && !(runtime.Version() < "go1.7") {
		// compile for all target architectures with tags
		for _, tags := range []string{"release", "debug"} {
			err := runWithEnv(env.env, "gox", "-verbose",
				"-osarch", strings.Join(env.goxOSArch, " "),
				"-tags", tags,
				"-output", "/tmp/{{.Dir}}_{{.OS}}_{{.Arch}}",
				"cmds/restic")
			if err != nil {
				return err
			}
		}
	}

	// run the build script
	if err := run("go", "run", "build.go"); err != nil {
		return err
	}

	// run the tests and gather coverage information
	err = runWithEnv(env.env, "gotestcover", "-coverprofile", "all.cov", "cmds/...", "restic/...")
	if err != nil {
		return err
	}

	if err = runGofmt(); err != nil {
		return err
	}

	deps, err := findImports()
	if err != nil {
		return err
	}

	foundForbiddenImports := false
	for name, imports := range deps {
		for _, pkg := range imports {
			if _, ok := ForbiddenImports[pkg]; ok {
				fmt.Fprintf(os.Stderr, "========== package %v imports forbidden package %v\n", name, pkg)
				foundForbiddenImports = true
			}
		}
	}

	if foundForbiddenImports {
		return errors.New("CI: forbidden imports found")
	}

	return nil
}

// AppveyorEnvironment is the environment on Windows.
type AppveyorEnvironment struct{}

// Prepare installs dependencies and starts services in order to run the tests.
func (env *AppveyorEnvironment) Prepare() error {
	msg("preparing environment for Appveyor CI\n")
	return nil
}

// RunTests start the tests.
func (env *AppveyorEnvironment) RunTests() error {
	return run("go", "run", "build.go", "-v", "-T")
}

// Teardown is a noop.
func (env *AppveyorEnvironment) Teardown() error {
	return nil
}

// findGoFiles returns a list of go source code file names below dir.
func findGoFiles(dir string) (list []string, err error) {
	err = filepath.Walk(dir, func(name string, fi os.FileInfo, err error) error {
		if filepath.Base(name) == "vendor" {
			return filepath.SkipDir
		}

		if filepath.Ext(name) == ".go" {
			relpath, err := filepath.Rel(dir, name)
			if err != nil {
				return err
			}

			list = append(list, relpath)
		}

		return err
	})

	return list, err
}

func msg(format string, args ...interface{}) {
	fmt.Printf("CI: "+format, args...)
}

func updateEnv(env []string, override map[string]string) []string {
	var newEnv []string
	for _, s := range env {
		d := strings.SplitN(s, "=", 2)
		key := d[0]

		if _, ok := override[key]; ok {
			continue
		}

		newEnv = append(newEnv, s)
	}

	for k, v := range override {
		newEnv = append(newEnv, k+"="+v)
	}

	return newEnv
}

func findImports() (map[string][]string, error) {
	res := make(map[string][]string)

	cwd, err := os.Getwd()
	if err != nil {
		return nil, fmt.Errorf("Getwd() returned error: %v", err)
	}

	gopath := cwd + ":" + filepath.Join(cwd, "vendor")

	cmd := exec.Command("go", "list", "-f", `{{.ImportPath}} {{join .Imports " "}}`, "./src/...")
	cmd.Env = updateEnv(os.Environ(), map[string]string{"GOPATH": gopath})
	cmd.Stderr = os.Stderr

	output, err := cmd.Output()
	if err != nil {
		return nil, err
	}

	sc := bufio.NewScanner(bytes.NewReader(output))
	for sc.Scan() {
		wordScanner := bufio.NewScanner(strings.NewReader(sc.Text()))
		wordScanner.Split(bufio.ScanWords)

		if !wordScanner.Scan() {
			return nil, fmt.Errorf("package name not found in line: %s", output)
		}
		name := wordScanner.Text()
		var deps []string

		for wordScanner.Scan() {
			deps = append(deps, wordScanner.Text())
		}

		res[name] = deps
	}

	return res, nil
}

func runGofmt() error {
	dir, err := os.Getwd()
	if err != nil {
		return fmt.Errorf("Getwd(): %v\n", err)
	}

	files, err := findGoFiles(dir)
	if err != nil {
		return fmt.Errorf("error finding Go files: %v\n", err)
	}

	msg("runGofmt() with %d files\n", len(files))
	args := append([]string{"-l"}, files...)
	cmd := exec.Command("gofmt", args...)
	cmd.Stderr = os.Stderr

	buf, err := cmd.Output()
	if err != nil {
		return fmt.Errorf("error running gofmt: %v\noutput: %s\n", err, buf)
	}

	if len(buf) > 0 {
		return fmt.Errorf("not formatted with `gofmt`:\n%s\n", buf)
	}

	return nil
}

func run(command string, args ...string) error {
	msg("run %v %v\n", command, strings.Join(args, " "))
	return runWithEnv(nil, command, args...)
}

// runWithEnv calls a command with the current environment, except the entries
// of the env map are set additionally.
func runWithEnv(env map[string]string, command string, args ...string) error {
	msg("runWithEnv %v %v\n", command, strings.Join(args, " "))
	cmd := exec.Command(command, args...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	if env != nil {
		cmd.Env = updateEnv(os.Environ(), env)
	}
	err := cmd.Run()

	if err != nil {
		return fmt.Errorf("error running %v %v: %v",
			command, strings.Join(args, " "), err)
	}
	return nil
}

func isTravis() bool {
	return os.Getenv("TRAVIS_BUILD_DIR") != ""
}

func isAppveyor() bool {
	return runtime.GOOS == "windows"
}

func main() {
	var env CIEnvironment

	switch {
	case isTravis():
		env = &TravisEnvironment{}
	case isAppveyor():
		env = &AppveyorEnvironment{}
	default:
		fmt.Fprintln(os.Stderr, "unknown CI environment")
		os.Exit(1)
	}

	foundError := false
	for _, f := range []func() error{env.Prepare, env.RunTests, env.Teardown} {
		err := f()
		if err != nil {
			foundError = true
			fmt.Fprintf(os.Stderr, "error: %v\n", err)
		}
	}

	if foundError {
		os.Exit(1)
	}
}