package app

import (
	"context"
	"fmt"

	appPkg "coopcloud.tech/abra/pkg/app"
	"coopcloud.tech/abra/pkg/autocomplete"
	"coopcloud.tech/abra/pkg/envfile"
	"coopcloud.tech/abra/pkg/lint"
	"coopcloud.tech/abra/pkg/recipe"
	stack "coopcloud.tech/abra/pkg/upstream/stack"
	"coopcloud.tech/tagcmp"

	"coopcloud.tech/abra/cli/internal"
	"coopcloud.tech/abra/pkg/client"
	"coopcloud.tech/abra/pkg/log"
	"github.com/AlecAivazis/survey/v2"
	"github.com/urfave/cli"
)

var appRollbackCommand = cli.Command{
	Name:      "rollback",
	Aliases:   []string{"rl"},
	Usage:     "Roll an app back to a previous version",
	ArgsUsage: "<domain> [<version>]",
	Flags: []cli.Flag{
		internal.DebugFlag,
		internal.NoInputFlag,
		internal.ForceFlag,
		internal.ChaosFlag,
		internal.NoDomainChecksFlag,
		internal.DontWaitConvergeFlag,
		internal.OfflineFlag,
	},
	Before: internal.SubCommandBefore,
	Description: `
This command rolls an app back to a previous version if one exists.

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

This action could be destructive, please ensure you have a copy of your app
data beforehand.

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")
		}

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

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

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

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

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

		if !isDeployed {
			log.Fatalf("%s is not deployed?", app.Name)
		}

		catl, err := recipe.ReadRecipeCatalogue(internal.Offline)
		if err != nil {
			log.Fatal(err)
		}

		versions, err := recipe.GetRecipeCatalogueVersions(app.Recipe.Name, 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 := app.Recipe.GetRecipeVersions(internal.Offline)
			if err != nil {
				log.Warn(err)
			}
			for _, recipeVersion := range recipeVersions {
				for version := range recipeVersion {
					versions = append(versions, version)
				}
			}
		}

		var availableDowngrades []string
		if deployedVersion == "unknown" {
			availableDowngrades = versions
			log.Warnf("failed to determine deployed version of %s", app.Name)
		}

		if specificVersion != "" {
			parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
			if err != nil {
				log.Fatal(err)
			}
			parsedSpecificVersion, err := tagcmp.Parse(specificVersion)
			if err != nil {
				log.Fatal(err)
			}
			if parsedSpecificVersion.IsGreaterThan(parsedDeployedVersion) || parsedSpecificVersion.Equals(parsedDeployedVersion) {
				log.Fatalf("%s is not a downgrade for %s?", deployedVersion, specificVersion)
			}
			availableDowngrades = append(availableDowngrades, specificVersion)
		}

		if deployedVersion != "unknown" && !internal.Chaos && specificVersion == "" {
			for _, version := range versions {
				parsedDeployedVersion, err := tagcmp.Parse(deployedVersion)
				if err != nil {
					log.Fatal(err)
				}
				parsedVersion, err := tagcmp.Parse(version)
				if err != nil {
					log.Fatal(err)
				}
				if parsedVersion.IsLessThan(parsedDeployedVersion) && !(parsedVersion.Equals(parsedDeployedVersion)) {
					availableDowngrades = append(availableDowngrades, version)
				}
			}

			if len(availableDowngrades) == 0 && !internal.Force {
				log.Info("no available downgrades, you're on oldest ✌️")
				return nil
			}
		}

		var chosenDowngrade string
		if len(availableDowngrades) > 0 && !internal.Chaos {
			if internal.Force || internal.NoInput || specificVersion != "" {
				chosenDowngrade = availableDowngrades[len(availableDowngrades)-1]
				log.Debugf("choosing %s as version to downgrade to (--force/--no-input)", chosenDowngrade)
			} else {
				prompt := &survey.Select{
					Message: fmt.Sprintf("Please select a downgrade (current version: %s):", deployedVersion),
					Options: internal.ReverseStringList(availableDowngrades),
				}
				if err := survey.AskOne(prompt, &chosenDowngrade); err != nil {
					return err
				}
			}
		}

		if !internal.Chaos {
			if err := app.Recipe.EnsureVersion(chosenDowngrade); err != nil {
				log.Fatal(err)
			}
		}

		if internal.Chaos {
			log.Warn("chaos mode engaged")
			var err error
			chosenDowngrade, err = app.Recipe.ChaosVersion()
			if err != nil {
				log.Fatal(err)
			}
		}

		abraShEnv, err := envfile.ReadAbraShEnvVars(app.Recipe.AbraShPath)
		if err != nil {
			log.Fatal(err)
		}
		for k, v := range abraShEnv {
			app.Env[k] = v
		}

		composeFiles, err := app.Recipe.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.Name)
		appPkg.SetChaosLabel(compose, stackName, internal.Chaos)
		appPkg.SetChaosVersionLabel(compose, stackName, chosenDowngrade)
		appPkg.SetUpdateLabel(compose, stackName, app.Env)

		// NOTE(d1): no release notes implemeneted for rolling back
		if err := internal.NewVersionOverview(app, deployedVersion, chosenDowngrade, ""); err != nil {
			log.Fatal(err)
		}

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

		return nil
	},
}