// +build mage

package main

import (
	"context"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"

	"github.com/jtolds/qod"
	"github.com/magefile/mage/mg"
	"github.com/pkg/errors"
)

var wd string
var arches []string

func init() {
	lwd, err := os.Getwd()
	qod.ANE(err)

	wd = lwd

	arches = []string{"amd64", "ppc64", "386", "arm", "arm64"}
}

const pkgBase = "git.xeserv.us/xena/route/"

func output(cmd string, args ...string) (string, error) {
	c := exec.Command(cmd, args...)
	c.Env = os.Environ()
	c.Stderr = os.Stderr
	b, err := c.Output()
	if err != nil {
		return "", errors.Wrapf(err, `failed to run %v %q`, cmd, args)
	}
	return string(b), nil
}

func gitTag() (string, error) {
	s, err := output("git", "describe", "--tags")
	if err != nil {
		ee, ok := errors.Cause(err).(*exec.ExitError)
		if ok && ee.Exited() {
			// probably no git tag
			return "dev", nil
		}
		return "", err
	}

	return strings.TrimSuffix(s, "\n"), nil
}

func shouldWork(ctx context.Context, env []string, dir string, cmdName string, args ...string) {
	loc, err := exec.LookPath(cmdName)
	qod.ANE(err)

	cmd := exec.CommandContext(ctx, loc, args...)
	cmd.Dir = dir
	cmd.Env = append(env, os.Environ()...)

	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	log.Printf("starting process, env: %v, pwd: %s, cmd: %s, args: %v", env, dir, loc, args)
	err = cmd.Run()
	qod.ANE(err)
}

func goBuild(ctx context.Context, env []string, dir string, pkgname string) {
	shouldWork(ctx, env, dir, "go", "build", "-v", pkgBase+pkgname)
}

func goInstall(ctx context.Context, env []string, pkgname string) {
	shouldWork(ctx, nil, wd, "go", "install", pkgBase+pkgname)
}

func goBuildPlugin(ctx context.Context, dir, pkgname, fname string) {
	if runtime.GOOS != "linux" {
		qod.Printlnf("plugins don't work on non-linux machines yet :(")
		return
	}

	shouldWork(ctx, nil, dir, "go", "build", "-v", "-buildmode=plugin", "-o="+fname, pkgBase+pkgname)
	qod.Printlnf("built %s for %s", fname, runtime.GOOS)
}

func buildBins(goos, goarch string) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	d := filepath.Join(wd, "./bin")

	os.MkdirAll(filepath.Join(d, goos, goarch), 0777)

	for _, pkg := range []string{"route-httpagent", "route-cli", "routed", "terraform-provider-route"} {
		env := []string{"GOOS=" + goos, "GOARCH=" + goarch}
		goBuild(ctx, env, filepath.Join(d, goos, goarch), "cmd/"+pkg)
		goInstall(ctx, env, "cmd/"+pkg)

		qod.Printlnf("built binary for %s for %s/%s", pkg, goos, goarch)
	}
}

// Docker builds docker images
func Docker() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	ver, err := gitTag()
	qod.ANE(err)

	shouldWork(ctx, nil, wd, "box", "box.rb")
	shouldWork(ctx, nil, wd, "docker", "tag", "xena/route:latest", "xena/route:"+ver)
	shouldWork(ctx, nil, wd, "docker", "tag", "xena/route:thick", "xena/route:thick-"+ver)
}

// Linux builds binaries for linux
func Linux() {
	for _, arch := range arches {
		buildBins("linux", arch)
	}
	Plugin()
}

// Windows builds binaries for windows
func Windows() {
	buildBins("windows", "amd64")
}

// Darwin builds binaries for darwin
func Darwin() {
	buildBins("darwin", "amd64")
}

// Build builds the binaries for route and routed.
func Build() {
	buildBins(runtime.GOOS, runtime.GOARCH)

	if runtime.GOOS == "linux" {
		Plugin()
	}
}

// Plugin builds all of the plugins for programs wanting to augment themselves with route.
func Plugin() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	goBuildPlugin(ctx, filepath.Join(wd, "./bin/linux"), "plugins/autohttpagent", "autohttpagent.so")
}

// Package builds all binaries for all platforms and assembles a package of
// documentation, useful tools and all route components.
func Package() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	os.RemoveAll("./bin/darwin")
	os.RemoveAll("./bin/linux")
	os.RemoveAll("./bin/windows")

	mg.Deps(Linux, Windows, Darwin)

	ver, err := gitTag()
	qod.ANE(err)

	for _, arch := range arches {
		for _, osname := range []string{"linux", "windows", "darwin"} {
			if arch != "amd64" && osname != "linux" {
				continue
			}

			dir, err := ioutil.TempDir("", "route-package-"+osname+"-"+arch)
			qod.ANE(err)
			qod.Printlnf("%s", dir)

			for _, file := range []string{"route-cli", "route-httpagent", "routed"} {
				if osname == "windows" {
					file = file + ".exe"
				}
				shouldWork(ctx, nil, filepath.Join(wd, "bin", osname, arch), "cp", "-rf", file, dir)
			}

			shouldWork(ctx, nil, wd, "cp", "-rf", "doc", dir)
			shouldWork(ctx, nil, wd, "cp", "-rf", "README.md", dir)
			shouldWork(ctx, nil, wd, "cp", "-rf", "LICENSE", dir)
			shouldWork(ctx, nil, wd, "cp", "-rf", "Gopkg.lock", dir)

			shouldWork(ctx, nil, dir, "tar", "czf", filepath.Join(wd, "bin", fmt.Sprintf("route-%s-%s-%s.tar.gz", ver, osname, arch)), ".")
		}
	}
}

// Version is the version as git reports.
func Version() {
	ver, err := gitTag()
	qod.ANE(err)
	qod.Printlnf("route-%s", ver)
}

// Test runs all of the functional and unit tests for the project.
func Test() {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	shouldWork(ctx, nil, wd, "go", "test", "-v", "./...")
}