package app

import (
	"context"
	"fmt"

	"coopcloud.tech/abra/cli/internal"
	"coopcloud.tech/abra/pkg/autocomplete"
	"coopcloud.tech/abra/pkg/envfile"
	"coopcloud.tech/abra/pkg/secret"

	appPkg "coopcloud.tech/abra/pkg/app"
	"coopcloud.tech/abra/pkg/client"
	"coopcloud.tech/abra/pkg/config"
	"coopcloud.tech/abra/pkg/dns"
	"coopcloud.tech/abra/pkg/formatter"
	"coopcloud.tech/abra/pkg/git"
	"coopcloud.tech/abra/pkg/lint"
	"coopcloud.tech/abra/pkg/log"
	"coopcloud.tech/abra/pkg/recipe"
	"coopcloud.tech/abra/pkg/upstream/stack"
	"github.com/urfave/cli"
)

var appDeployCommand = cli.Command{
	Name:      "deploy",
	Aliases:   []string{"d"},
	Usage:     "Deploy an app",
	ArgsUsage: "<domain> [<version>]",
	Flags: []cli.Flag{
		internal.DebugFlag,
		internal.NoInputFlag,
		internal.ForceFlag,
		internal.ChaosFlag,
		internal.NoDomainChecksFlag,
		internal.DontWaitConvergeFlag,
		internal.OfflineFlag,
	},
	Before: internal.SubCommandBefore,
	Description: `
Deploy an app. It does not support incrementing the version of a deployed app,
for this you need to look at the "abra app upgrade <domain>" command.

You may pass "--force" to re-deploy the same version again. This can be useful
if the container runtime has gotten into a weird state.

Chaos mode ("--chaos") will deploy your local checkout of a recipe as-is,
including unstaged changes and can be useful for live hacking and testing new
recipes.
`,
	BashComplete: autocomplete.AppNameComplete,
	Action: func(c *cli.Context) error {
		app := internal.ValidateApp(c)
		stackName := app.StackName()

		specificVersion := c.Args().Get(1)
		if specificVersion != "" && internal.Chaos {
			log.Fatal("cannot use <version> and --chaos together")
		}

		r2 := recipe.Get2(app.Recipe)
		if err := r2.Ensure(internal.Chaos, internal.Offline); err != nil {
			log.Fatal(err)
		}

		r, err := recipe.Get(app.Recipe, internal.Offline)
		if err != nil {
			log.Fatal(err)
		}

		if err := lint.LintForErrors(r); err != nil {
			log.Fatal(err)
		}

		log.Debugf("checking whether %s is already deployed", stackName)

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

		isDeployed, deployedVersion, err := stack.IsDeployed(context.Background(), cl, stackName)
		if err != nil {
			log.Fatal(err)
		}

		// NOTE(d1): check out specific version before dealing with secrets. This
		// is because we need to deal with GetComposeFiles under the hood and these
		// files change from version to version which therefore affects which
		// secrets might be generated
		version := deployedVersion
		if specificVersion != "" {
			version = specificVersion
			log.Debugf("choosing %s as version to deploy", version)
			if err := r2.EnsureVersion(version); err != nil {
				log.Fatal(err)
			}
		}

		secStats, err := secret.PollSecretsStatus(cl, app)
		if err != nil {
			log.Fatal(err)
		}

		for _, secStat := range secStats {
			if !secStat.CreatedOnRemote {
				log.Fatalf("unable to deploy, secrets not generated (%s)?", secStat.LocalName)
			}
		}

		if isDeployed {
			if internal.Force || internal.Chaos {
				log.Warnf("%s is already deployed but continuing (--force/--chaos)", app.Name)
			} else {
				log.Fatalf("%s is already deployed", app.Name)
			}
		}

		if !internal.Chaos && specificVersion == "" {
			catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
			if err != nil {
				log.Fatal(err)
			}
			versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe, catl)
			if err != nil {
				log.Fatal(err)
			}

			if len(versions) == 0 && !internal.Chaos {
				log.Warn("no published versions in catalogue, trying local recipe repository")
				recipeVersions, err := recipe.GetRecipeVersions(app.Recipe, internal.Offline)
				if err != nil {
					log.Warn(err)
				}
				for _, recipeVersion := range recipeVersions {
					for version := range recipeVersion {
						versions = append(versions, version)
					}
				}
			}

			if len(versions) > 0 && !internal.Chaos {
				version = versions[len(versions)-1]
				log.Debugf("choosing %s as version to deploy", version)
				if err := r2.EnsureVersion(version); err != nil {
					log.Fatal(err)
				}
			} else {
				head, err := git.GetRecipeHead(app.Recipe)
				if err != nil {
					log.Fatal(err)
				}
				version = formatter.SmallSHA(head.String())
				log.Warn("no versions detected, using latest commit")
			}
		}

		if internal.Chaos {
			log.Warnf("chaos mode engaged")
			var err error
			version, err = r2.ChaosVersion()
			if err != nil {
				log.Fatal(err)
			}
		}

		abraShPath := fmt.Sprintf("%s/%s/%s", config.RECIPES_DIR, app.Recipe, "abra.sh")
		abraShEnv, err := envfile.ReadAbraShEnvVars(abraShPath)
		if err != nil {
			log.Fatal(err)
		}
		for k, v := range abraShEnv {
			app.Env[k] = v
		}

		composeFiles, err := r2.GetComposeFiles(app.Env)
		if err != nil {
			log.Fatal(err)
		}

		deployOpts := stack.Deploy{
			Composefiles: composeFiles,
			Namespace:    stackName,
			Prune:        false,
			ResolveImage: stack.ResolveImageAlways,
			Detach:       false,
		}
		compose, err := appPkg.GetAppComposeConfig(app.Name, deployOpts, app.Env)
		if err != nil {
			log.Fatal(err)
		}

		appPkg.ExposeAllEnv(stackName, compose, app.Env)
		appPkg.SetRecipeLabel(compose, stackName, app.Recipe)
		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
		appPkg.SetChaosVersionLabel(compose, stackName, version)
		appPkg.SetUpdateLabel(compose, stackName, app.Env)

		envVars, err := appPkg.CheckEnv(app)
		if err != nil {
			log.Fatal(err)
		}

		for _, envVar := range envVars {
			if !envVar.Present {
				log.Warnf("env var %s missing from %s.env, present in recipe .env.sample", envVar.Name, app.Domain)
			}
		}

		if err := internal.DeployOverview(app, version, "continue with deployment?"); err != nil {
			log.Fatal(err)
		}

		if !internal.NoDomainChecks {
			domainName, ok := app.Env["DOMAIN"]
			if ok {
				if _, err = dns.EnsureDomainsResolveSameIPv4(domainName, app.Server); err != nil {
					log.Fatal(err)
				}
			} else {
				log.Warn("skipping domain checks as no DOMAIN=... configured for app")
			}
		} else {
			log.Warn("skipping domain checks as requested")
		}

		stack.WaitTimeout, err = appPkg.GetTimeoutFromLabel(compose, stackName)
		if err != nil {
			log.Fatal(err)
		}
		log.Debugf("set waiting timeout to %d s", stack.WaitTimeout)

		if err := stack.RunDeploy(cl, deployOpts, compose, app.Name, internal.DontWaitConverge); err != nil {
			log.Fatal(err)
		}

		postDeployCmds, ok := app.Env["POST_DEPLOY_CMDS"]
		if ok && !internal.DontWaitConverge {
			log.Debugf("run the following post-deploy commands: %s", postDeployCmds)
			if err := internal.PostCmds(cl, app, postDeployCmds); err != nil {
				log.Fatalf("attempting to run post deploy commands, saw: %s", err)
			}
		}
		return nil
	},
}