package cli

import (
	"errors"
	"fmt"
	"os"

	"coopcloud.tech/abra/cli/app"
	"coopcloud.tech/abra/cli/catalogue"
	"coopcloud.tech/abra/cli/internal"
	"coopcloud.tech/abra/cli/recipe"
	"coopcloud.tech/abra/cli/server"
	"coopcloud.tech/abra/pkg/config"
	"coopcloud.tech/abra/pkg/formatter"
	"coopcloud.tech/abra/pkg/i18n"
	"coopcloud.tech/abra/pkg/log"
	charmLog "github.com/charmbracelet/log"
	"github.com/spf13/cobra"
	"github.com/spf13/cobra/doc"
)

func Run(version, commit string) {
	rootCmd := &cobra.Command{
		// translators: `abra` binary name
		Use:     i18n.G("abra [cmd] [args] [flags]"),
		Short:   i18n.G("The Co-op Cloud command-line utility belt 🎩🐇"),
		Version: fmt.Sprintf("%s-%s", version, commit[:7]),
		ValidArgs: []string{
			i18n.G("app"),
			i18n.G("autocomplete"),
			i18n.G("catalogue"),
			i18n.G("man"),
			i18n.G("recipe"),
			i18n.G("server"),
			i18n.G("upgrade"),
		},

		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
			dirs := []map[string]os.FileMode{
				{config.ABRA_DIR: 0764},
				{config.SERVERS_DIR: 0700},
				{config.RECIPES_DIR: 0764},
				{config.LOGS_DIR: 0764},
			}

			for _, dir := range dirs {
				for path, perm := range dir {
					if err := os.Mkdir(path, perm); err != nil {
						if !os.IsExist(err) {
							return errors.New(i18n.G("unable to create %s: %s", path, err))
						}
						continue
					}
				}
			}

			log.Logger.SetStyles(charmLog.DefaultStyles())
			charmLog.SetDefault(log.Logger)

			if internal.MachineReadable {
				log.SetOutput(os.Stderr)
			}

			if internal.Debug {
				log.SetLevel(log.DebugLevel)
				log.SetOutput(os.Stderr)
				log.SetReportCaller(true)
			}

			log.Debug(i18n.G(
				"abra version: %s, commit: %s, lang: %s",
				version, formatter.SmallSHA(commit), i18n.Locale,
			))

			return nil
		},
	}

	rootCmd.CompletionOptions.DisableDefaultCmd = true

	manCommand := &cobra.Command{
		// translators: `man` command
		Use:     i18n.G("man [flags]"),
		Aliases: []string{"m"},
		Short:   i18n.G("Generate manpage"),
		Example: i18n.G(`  # generate the man pages into /usr/local/share/man/man1
  abra_path=$(which abra)  # pass abra absolute path to sudo below
  sudo $abra_path man
  sudo mandb

  # read the man pages
  man abra
  man abra-app-deploy`),
		Run: func(cmd *cobra.Command, args []string) {
			header := &doc.GenManHeader{
				Title:   "ABRA",
				Section: "1",
			}

			manDir := "/usr/local/share/man/man1"
			if _, err := os.Stat(manDir); os.IsNotExist(err) {
				log.Fatal(i18n.G("unable to proceed, %s does not exist?", manDir))
			}

			err := doc.GenManTree(rootCmd, header, manDir)
			if err != nil {
				log.Fatal(err)
			}

			log.Info(i18n.G("don't forget to run 'sudo mandb'"))
		},
	}

	rootCmd.PersistentFlags().BoolVarP(
		&internal.Debug,
		"debug",
		"d",
		false,
		i18n.G("show debug messages"),
	)

	rootCmd.PersistentFlags().BoolVarP(
		&internal.NoInput,
		"no-input",
		"n",
		false,
		i18n.G("toggle non-interactive mode"),
	)

	rootCmd.PersistentFlags().BoolVarP(
		&internal.Offline,
		"offline",
		"o",
		false,
		i18n.G("prefer offline & filesystem access"),
	)

	rootCmd.PersistentFlags().BoolVarP(
		&internal.IgnoreEnvVersion,
		"ignore-env-version",
		"i",
		false,
		i18n.G("ignore .env version checkout"),
	)

	catalogue.CatalogueCommand.AddCommand(
		catalogue.CatalogueGenerateCommand,
		catalogue.CatalogueSyncCommand,
	)

	server.ServerCommand.AddCommand(
		server.ServerAddCommand,
		server.ServerListCommand,
		server.ServerPruneCommand,
		server.ServerRemoveCommand,
	)

	recipe.RecipeCommand.AddCommand(
		recipe.RecipeDiffCommand,
		recipe.RecipeFetchCommand,
		recipe.RecipeLintCommand,
		recipe.RecipeListCommand,
		recipe.RecipeNewCommand,
		recipe.RecipeReleaseCommand,
		recipe.RecipeResetCommand,
		recipe.RecipeSyncCommand,
		recipe.RecipeUpgradeCommand,
		recipe.RecipeVersionCommand,
	)

	rootCmd.AddCommand(
		UpgradeCommand,
		AutocompleteCommand,
		manCommand,
		app.AppCommand,
		catalogue.CatalogueCommand,
		server.ServerCommand,
		recipe.RecipeCommand,
	)

	app.AppCmdCommand.AddCommand(
		app.AppCmdListCommand,
	)

	app.AppSecretCommand.AddCommand(
		app.AppSecretGenerateCommand,
		app.AppSecretInsertCommand,
		app.AppSecretRmCommand,
		app.AppSecretLsCommand,
	)

	app.AppVolumeCommand.AddCommand(
		app.AppVolumeListCommand,
		app.AppVolumeRemoveCommand,
	)

	app.AppBackupCommand.AddCommand(
		app.AppBackupListCommand,
		app.AppBackupDownloadCommand,
		app.AppBackupCreateCommand,
		app.AppBackupSnapshotsCommand,
	)

	app.AppCommand.AddCommand(
		app.AppBackupCommand,
		app.AppCheckCommand,
		app.AppCmdCommand,
		app.AppConfigCommand,
		app.AppCpCommand,
		app.AppDeployCommand,
		app.AppListCommand,
		app.AppLogsCommand,
		app.AppNewCommand,
		app.AppPsCommand,
		app.AppRemoveCommand,
		app.AppRestartCommand,
		app.AppRestoreCommand,
		app.AppRollbackCommand,
		app.AppRunCommand,
		app.AppSecretCommand,
		app.AppServicesCommand,
		app.AppUndeployCommand,
		app.AppUpgradeCommand,
		app.AppVolumeCommand,
		app.AppLabelsCommand,
		app.AppEnvCommand,
	)

	if err := rootCmd.Execute(); err != nil {
		os.Exit(1)
	}
}