package cmd

import (
	"context"
	"fmt"
	"net"
	"os"
	"os/exec"
	"os/signal"
	"regexp"
	"syscall"

	"github.com/railwayapp/cli/entity"
	"github.com/railwayapp/cli/errors"
	"github.com/railwayapp/cli/ui"
)

var RAIL_PORT = 4411

func (h *Handler) Run(ctx context.Context, req *entity.CommandRequest) error {
	envs, err := h.ctrl.GetEnvs(ctx)

	if err != nil {
		return err
	}

	pwd, err := os.Getwd()
	if err != nil {
		return err
	}

	hasDockerfile := true

	if _, err := os.Stat(fmt.Sprintf("%s/Dockerfile", pwd)); os.IsNotExist(err) {
		hasDockerfile = false
	}

	if len(req.Args) == 0 && hasDockerfile {
		return h.runInDocker(ctx, pwd, envs)
	} else if len(req.Args) == 0 {
		return errors.CommandNotSpecified
	}

	cmd := exec.CommandContext(ctx, req.Args[0], req.Args[1:]...)
	cmd.Env = os.Environ()

	// Inject railway envs
	for k, v := range *envs {
		cmd.Env = append(cmd.Env, fmt.Sprintf("%s=%+v", k, v))
	}

	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stdout
	cmd.Stdin = os.Stdin
	catchSignals(cmd)

	err = cmd.Run()
	if err != nil {
		return err
	}

	printLooksGood()

	return nil
}

func (h *Handler) runInDocker(ctx context.Context, pwd string, envs *entity.Envs) error {
	// Start building the image
	projectCfg, err := h.cfg.GetProjectConfigs()
	if err != nil {
		return err
	}

	project, err := h.ctrl.GetProject(ctx, projectCfg.Project)
	if err != nil {
		return err
	}

	// Strip characters not allowed in Docker image names
	environment, err := h.ctrl.GetEnvironment(ctx)
	if err != nil {
		return err
	}

	sanitiser := regexp.MustCompile(`[^A-Za-z0-9_-]`)
	imageNameWithoutNsOrTag := sanitiser.ReplaceAllString(project.Name, "") + "-" + sanitiser.ReplaceAllString(environment.Name, "")
	image := fmt.Sprintf("railway-local/%s:latest", imageNameWithoutNsOrTag)

	buildArgs := []string{"build", "-q", "-t", image, pwd}

	// Build up env
	for k, v := range *envs {
		buildArgs = append(buildArgs, "--build-arg", fmt.Sprintf("%s=\"%+v\"", k, v))
	}

	buildCmd := exec.CommandContext(ctx, "docker", buildArgs...)
	ui.StartSpinner(&ui.SpinnerCfg{
		Message: fmt.Sprintf("Building %s from Dockerfile... (this may take a bit)", ui.GreenText(image)),
		Tokens:  ui.TrainEmojis,
	})

	out, err := buildCmd.CombinedOutput()
	if err != nil {
		ui.StopSpinner("")
		return showCmdError(buildCmd.Args, out, err)
	}

	ui.StopSpinner(fmt.Sprintf("🎉 Built %s", ui.GreenText(image)))

	port, err := getAvailablePort()
	if err != nil {
		return err
	}
	// Start running the image
	fmt.Printf("🚂 Running at %s\n\n", ui.GreenText(fmt.Sprintf("127.0.0.1:%d", port)))

	runArgs := []string{"run", "--init", "--rm", "-p", fmt.Sprintf("127.0.0.1:%d:%d", port, port), "-e", fmt.Sprintf("PORT=%d", port)}
	// Build up env
	for k, v := range *envs {
		runArgs = append(runArgs, "-e", fmt.Sprintf("%s=%+v", k, v))
	}
	runArgs = append(runArgs, image)

	// Run the container
	runCmd := exec.CommandContext(ctx, "docker", runArgs...)
	runCmd.Stdout = os.Stdout
	runCmd.Stderr = os.Stdout
	runCmd.Stdin = os.Stdin
	catchSignals(runCmd)

	err = runCmd.Run()
	if err != nil {
		return err
	}

	printLooksGood()

	return nil
}

func getAvailablePort() (int, error) {
	searchRange := 64
	for i := RAIL_PORT; i < RAIL_PORT+searchRange; i++ {
		if isAvailable(i) {
			return i, nil
		}
	}
	return -1, fmt.Errorf("Couldn't find available port between %d and %d", RAIL_PORT, RAIL_PORT+searchRange)
}

func isAvailable(port int) bool {
	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", port))
	if err != nil {
		return false
	}
	_ = ln.Close()
	return true
}

func showCmdError(args []string, output []byte, err error) error {
	if _, ok := err.(*exec.ExitError); ok {
		// Full cmd for error logging
		argstr := ""
		for _, arg := range args {
			argstr += arg + " "
		}

		fmt.Println(ui.RedText("exec error:"))
		fmt.Println(ui.RedText("-- START OUTPUT --"))
		fmt.Printf("%s\n", string(output))
		fmt.Println(ui.RedText("-- END OUTPUT --"))
		fmt.Println()
		fmt.Println(ui.RedText("while running:"))
		fmt.Printf("%+v\n", argstr)
	}
	return err
}

func catchSignals(cmd *exec.Cmd) {
	sigs := make(chan os.Signal, 1)

	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		sig := <-sigs
		err := cmd.Process.Signal(sig)
		if err != nil {
			fmt.Println("Child process error: \n", err)
		}
	}()
}

func printLooksGood() {
	// Get space between last output and this message
	fmt.Println()
	fmt.Printf(
		"🚄 Looks good? Then put it on the train and deploy with `%s`!\n",
		ui.GreenText("railway up"),
	)
}