package app

import (
	"errors"
	"fmt"
	"os"
	"os/exec"
	"path"
	"sort"
	"strings"

	"coopcloud.tech/abra/cli/internal"
	"coopcloud.tech/abra/pkg/app"
	"coopcloud.tech/abra/pkg/autocomplete"
	"coopcloud.tech/abra/pkg/client"
	"coopcloud.tech/abra/pkg/config"
	"coopcloud.tech/abra/pkg/recipe"
	recipePkg "coopcloud.tech/abra/pkg/recipe"
	"github.com/sirupsen/logrus"
	"github.com/urfave/cli"
)

var appCmdCommand = cli.Command{
	Name:    "command",
	Aliases: []string{"cmd"},
	Usage:   "Run app commands",
	Description: `Run an app specific command.

These commands are bash functions, defined in the abra.sh of the recipe itself.
They can be run within the context of a service (e.g. app) or locally on your
work station by passing "--local". Arguments can be passed into these functions
using the "-- <args>" syntax.

Example:

  abra app cmd example.com app create_user -- me@example.com
`,
	ArgsUsage: "<domain> [<service>] <command> [-- <args>]",
	Flags: []cli.Flag{
		internal.DebugFlag,
		internal.LocalCmdFlag,
		internal.RemoteUserFlag,
		internal.TtyFlag,
		internal.OfflineFlag,
		internal.ChaosFlag,
	},
	Before:      internal.SubCommandBefore,
	Subcommands: []cli.Command{appCmdListCommand},
	BashComplete: func(ctx *cli.Context) {
		args := ctx.Args()
		switch len(args) {
		case 0:
			autocomplete.AppNameComplete(ctx)
		case 1:
			autocomplete.ServiceNameComplete(args.Get(0))
		case 2:
			cmdNameComplete(args.Get(0))
		}
	},
	Action: func(c *cli.Context) error {
		app := internal.ValidateApp(c)

		if err := recipe.EnsureExists(app.Recipe); err != nil {
			logrus.Fatal(err)
		}

		if !internal.Chaos {
			if err := recipePkg.EnsureIsClean(app.Recipe); err != nil {
				logrus.Fatal(err)
			}

			if !internal.Offline {
				if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil {
					logrus.Fatal(err)
				}
			}

			if err := recipePkg.EnsureLatest(app.Recipe); err != nil {
				logrus.Fatal(err)
			}
		}

		if internal.LocalCmd && internal.RemoteUser != "" {
			internal.ShowSubcommandHelpAndError(c, errors.New("cannot use --local & --user together"))
		}

		hasCmdArgs, parsedCmdArgs := parseCmdArgs(c.Args(), internal.LocalCmd)

		abraSh := path.Join(config.RECIPES_DIR, app.Recipe, "abra.sh")
		if _, err := os.Stat(abraSh); err != nil {
			if os.IsNotExist(err) {
				logrus.Fatalf("%s does not exist for %s?", abraSh, app.Name)
			}
			logrus.Fatal(err)
		}

		if internal.LocalCmd {
			if !(len(c.Args()) >= 2) {
				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
			}

			cmdName := c.Args().Get(1)
			if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
				logrus.Fatal(err)
			}

			logrus.Debugf("--local detected, running %s on local work station", cmdName)

			var exportEnv string
			for k, v := range app.Env {
				exportEnv = exportEnv + fmt.Sprintf("%s='%s'; ", k, v)
			}

			var sourceAndExec string
			if hasCmdArgs {
				logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s %s", app.Name, app.StackName(), exportEnv, abraSh, cmdName, parsedCmdArgs)
			} else {
				logrus.Debug("did not detect any command arguments")
				sourceAndExec = fmt.Sprintf("TARGET=local; APP_NAME=%s; STACK_NAME=%s; %s . %s; %s", app.Name, app.StackName(), exportEnv, abraSh, cmdName)
			}

			shell := "/bin/bash"
			if _, err := os.Stat(shell); errors.Is(err, os.ErrNotExist) {
				logrus.Debugf("%s does not exist locally, use /bin/sh as fallback", shell)
				shell = "/bin/sh"
			}
			cmd := exec.Command(shell, "-c", sourceAndExec)

			if err := internal.RunCmd(cmd); err != nil {
				logrus.Fatal(err)
			}
		} else {
			if !(len(c.Args()) >= 3) {
				internal.ShowSubcommandHelpAndError(c, errors.New("missing arguments"))
			}

			targetServiceName := c.Args().Get(1)

			cmdName := c.Args().Get(2)
			if err := internal.EnsureCommand(abraSh, app.Recipe, cmdName); err != nil {
				logrus.Fatal(err)
			}

			serviceNames, err := config.GetAppServiceNames(app.Name)
			if err != nil {
				logrus.Fatal(err)
			}

			matchingServiceName := false
			for _, serviceName := range serviceNames {
				if serviceName == targetServiceName {
					matchingServiceName = true
				}
			}

			if !matchingServiceName {
				logrus.Fatalf("no service %s for %s?", targetServiceName, app.Name)
			}

			logrus.Debugf("running command %s within the context of %s_%s", cmdName, app.StackName(), targetServiceName)

			if hasCmdArgs {
				logrus.Debugf("parsed following command arguments: %s", parsedCmdArgs)
			} else {
				logrus.Debug("did not detect any command arguments")
			}

			cl, err := client.New(app.Server)
			if err != nil {
				logrus.Fatal(err)
			}

			if err := internal.RunCmdRemote(cl, app, abraSh, targetServiceName, cmdName, parsedCmdArgs); err != nil {
				logrus.Fatal(err)
			}
		}

		return nil
	},
}

func parseCmdArgs(args []string, isLocal bool) (bool, string) {
	var (
		parsedCmdArgs string
		hasCmdArgs    bool
	)

	if isLocal {
		if len(args) > 2 {
			return true, fmt.Sprintf("%s ", strings.Join(args[2:], " "))
		}
	} else {
		if len(args) > 3 {
			return true, fmt.Sprintf("%s ", strings.Join(args[3:], " "))
		}
	}

	return hasCmdArgs, parsedCmdArgs
}

func cmdNameComplete(appName string) {
	app, err := app.Get(appName)
	if err != nil {
		return
	}
	cmdNames, _ := getShCmdNames(app)
	if err != nil {
		return
	}
	for _, n := range cmdNames {
		fmt.Println(n)
	}
}

var appCmdListCommand = cli.Command{
	Name:      "list",
	Aliases:   []string{"ls"},
	Usage:     "List all available commands",
	ArgsUsage: "<domain>",
	Flags: []cli.Flag{
		internal.DebugFlag,
		internal.OfflineFlag,
		internal.ChaosFlag,
	},
	BashComplete: autocomplete.AppNameComplete,
	Before:       internal.SubCommandBefore,
	Action: func(c *cli.Context) error {
		app := internal.ValidateApp(c)

		if err := recipe.EnsureExists(app.Recipe); err != nil {
			logrus.Fatal(err)
		}

		if !internal.Chaos {
			if err := recipePkg.EnsureIsClean(app.Recipe); err != nil {
				logrus.Fatal(err)
			}

			if !internal.Offline {
				if err := recipePkg.EnsureUpToDate(app.Recipe); err != nil {
					logrus.Fatal(err)
				}
			}

			if err := recipePkg.EnsureLatest(app.Recipe); err != nil {
				logrus.Fatal(err)
			}
		}

		cmdNames, err := getShCmdNames(app)
		if err != nil {
			logrus.Fatal(err)
		}

		for _, cmdName := range cmdNames {
			fmt.Println(cmdName)
		}

		return nil
	},
}

func getShCmdNames(app config.App) ([]string, error) {
	abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
	cmdNames, err := config.ReadAbraShCmdNames(abraShPath)
	if err != nil {
		return nil, err
	}

	sort.Strings(cmdNames)
	return cmdNames, nil
}