commands

var (
	AWSCloud        = aws.NewAWSProvider()
	AvailableClouds = []providers.CloudProvider{
		AWSCloud,
	}
)

var AccountCommands = []*cli.Command{
	{
		Name:        "account",
		Usage:       "Linked service accounts",
		Description: "Kubernetes service accounts that are linked to accounts at the cloud provider (IAM). Use these accounts to allow apps to access cloud resources",
		Before:      func(c *cli.Context) error { return ensureClusterSelected() },
		Category:    "Cluster",
		Subcommands: []*cli.Command{
			{
				Name:  "create",
				Usage: "create a new linked service account",
				Action: func(c *cli.Context) error {
					return accountEdit(c.String("account"), false)
				},
				Flags: []cli.Flag{
					accountFlag,
				},
			},
			{
				Name:   "delete",
				Usage:  "deletes an account",
				Action: accountDelete,
				Flags: []cli.Flag{
					accountFlag,
				},
			},
			{
				Name:  "edit",
				Usage: "edit an existing linked service account",
				Action: func(c *cli.Context) error {
					return accountEdit(c.String("account"), true)
				},
				Flags: []cli.Flag{
					accountFlag,
				},
			},
			{
				Name:   "list",
				Usage:  "lists accounts on this cluster",
				Action: accountList,
			},
		},
	},
}

var AppCommands = []*cli.Command{
	{
		Name:    "app",
		Aliases: []string{"apps"},
		Usage:   "App commands",
		Before: func(c *cli.Context) error {
			return ensureClusterSelected()
		},
		Category: "App",
		Subcommands: []*cli.Command{
			{
				Name:      "delete",
				Usage:     "Deletes an app from the current cluster",
				Action:    appDelete,
				ArgsUsage: "<app>",
			},
			{
				Name:      "deploy",
				Usage:     "Deploy a new version of an app",
				Action:    appDeploy,
				ArgsUsage: "<app>",
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "tag",
						Usage:    "image tag to use",
						Required: true,
					},
				},
			},
			{
				Name:      "edit",
				Usage:     "Edit an app's configuration",
				Action:    appEdit,
				ArgsUsage: "<app>",
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:    "file",
						Aliases: []string{"f"},
						Usage:   "use contents of file to update, - to indicate stdin",
					},
				},
			},
			{
				Name:      "halt",
				Usage:     "Halt/unhalt an app. Halting an app scales it to down immediately",
				Action:    appHalt,
				ArgsUsage: "<app>",
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "target",
						Usage:    "target to halt/unhalt",
						Required: true,
					},
					&cli.BoolFlag{
						Name:  "unhalt",
						Usage: "unhalt an app",
					},
				},
			},
			{
				Name:   "list",
				Usage:  "List apps on this cluster",
				Action: appList,
				Flags: []cli.Flag{
					targetFlag,
				},
			},
			{
				Name:      "load",
				Usage:     "Load app into Kubernetes (same as kube apply -f)",
				ArgsUsage: "<app.yaml>",
				Action:    appLoad,
			},
			{
				Name:      "local",
				Usage:     "Run app locally with cluster environment. Either --app or --manifest is required",
				ArgsUsage: "<executable> [args...]",
				Action:    appLocal,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:    "app",
						Aliases: []string{"a"},
						Usage:   "name of app to load environment from. app must exist in the cluster",
					},
					&cli.StringFlag{
						Name:    "manifest",
						Aliases: []string{"m"},
						Usage:   "path to an app manifest. use to test an app before deployed to cluster",
					},
					targetFlag,
					&cli.StringSliceFlag{
						Name:    "env",
						Aliases: []string{"e"},
						Usage:   "additional environment variables to pass. --env KEY=VALUE",
					},
				},
			},
			{
				Name:      "logs",
				Usage:     "Print logs from a pod for the app",
				Aliases:   []string{"log"},
				ArgsUsage: "<app>",
				Action:    appLogs,
				Flags: []cli.Flag{
					&cli.BoolFlag{
						Name:    "follow",
						Aliases: []string{"f"},
						Usage:   "follow logs",
					},
					&cli.IntFlag{
						Name:  "tail",
						Usage: "number of lines to include from tail (default 100, -1 for all)",
						Value: 100,
					},
					podFlag,
					targetFlag,
					releaseFlag,
				},
			},
			{
				Name:   "new",
				Usage:  "Create a new app.yaml from template",
				Action: appNew,
			},
			{
				Name:      "pods",
				Usage:     "List pods for this app",
				ArgsUsage: "<app>",
				Action:    appPods,
				Flags: []cli.Flag{
					targetFlag,
					releaseFlag,
				},
			},
			{
				Name:      "restart",
				Usage:     "Restart the current app",
				ArgsUsage: "<app>",
				Action:    appRestart,
				Flags: []cli.Flag{
					targetFlag,
				},
			},
			{
				Name:      "rollback",
				Usage:     "Rolls back a bad release and deploys a previous one",
				ArgsUsage: "<app>",
				Action:    appRollback,
				Flags: []cli.Flag{
					targetFlag,
					releaseFlag,
				},
			},
			{
				Name:      "shell",
				Usage:     "Get shell access into a pod with the app",
				ArgsUsage: "<app>",
				Action:    appShell,
				Flags: []cli.Flag{
					podFlag,
					targetFlag,
					releaseFlag,
					&cli.StringFlag{
						Name:    "shell",
						Aliases: []string{"s"},
						Usage:   "command to run as the shell",
						Value:   "/bin/sh",
					},
				},
			},
			{
				Name:      "status",
				Usage:     "Information about the app and its targets",
				Action:    appStatus,
				ArgsUsage: "<app>",
				Flags: []cli.Flag{
					targetFlag,
				},
			},
		},
	},
}

var CertificateCommands = []*cli.Command{
	{
		Name:     "certificate",
		Category: "Cluster",
		Usage:    "Manage SSL certificates on this cluster",
		Aliases: []string{
			"cert",
		},
		Action: func(c *cli.Context) error {
			return cli.ShowAppHelp(c)
		},
		Subcommands: []*cli.Command{
			{
				Name:   "list",
				Usage:  "List certificates in Kube",
				Action: certList,
			},
			{
				Name:   "sync",
				Usage:  "Sync certificates from cloud provider",
				Action: certSync,
			},
			{
				Name:   "import",
				Usage:  "Imports an existing certificate to provider's certificate management",
				Action: certImport,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "domain",
						Usage:    "the domain to load this certificate",
						Required: true,
					},
					&cli.StringFlag{
						Name:     "certificate",
						Usage:    "certificate file",
						Required: true,
					},
					&cli.StringFlag{
						Name:     "private-key",
						Usage:    "private key file",
						Required: true,
					},
					&cli.StringFlag{
						Name:  "chain",
						Usage: "intermediate certificate chain file",
					},
				},
			},
		},
	},
}

var ClusterCommands = []*cli.Command{
	{
		Name:     "cluster",
		Usage:    "Cluster commands",
		Before:   ensureSetup,
		Category: "Cluster",
		Subcommands: []*cli.Command{
			{
				Name:   "configure",
				Usage:  "configure cluster settings",
				Action: clusterConfigure,
			},
			{
				Name:   "create",
				Usage:  "creates a cluster",
				Action: clusterCreate,
			},
			{
				Name:   "destroy",
				Usage:  "destroys a cluster",
				Action: clusterDestroy,
				Flags: []cli.Flag{
					clusterNameFlag,
				},
			},
			{
				Name:   "export",
				Usage:  "export apps, configs, and other cluster data",
				Action: clusterExport,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "dir",
						Usage:    "directory to export cluster data to",
						Required: true,
					},
				},
			},
			{
				Name:   "import",
				Usage:  "import apps, builds, and configs into the selected cluster",
				Action: clusterImport,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "dir",
						Usage:    "directory to import cluster data from",
						Required: true,
					},
				},
			},
			{
				Name:   "list",
				Usage:  "list clusters",
				Action: clusterList,
			},
			{
				Name:      "select",
				Usage:     "select an active cluster to work with",
				ArgsUsage: "<cluster>",
				Action: func(c *cli.Context) error {
					if c.Bool("reset") {
						return clusterReset()
					}
					if c.NArg() == 0 {
						cli.ShowSubcommandHelp(c)
						return nil
					}
					return clusterSelect(c.Args().Get(0))
				},
				Flags: []cli.Flag{
					&cli.BoolFlag{
						Name:  "reset",
						Usage: "unset current selected cluster",
					},
				},
			},
			{
				Name:   "shell",
				Usage:  "shell into a pod created for debugging. (deleted after terminating)",
				Action: clusterShell,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:  "image",
						Usage: "docker image to use for the pod",
						Value: "debian:latest",
					},
					&cli.BoolFlag{
						Name:  "force",
						Usage: "deletes an existing debugging image if exists",
					},
					&cli.StringSliceFlag{
						Name:  "cmd",
						Usage: "pass custom command and arguments",
					},
				},
			},
			{
				Name:   "status",
				Usage:  "Information about the cluster",
				Action: clusterStatus,
			},
			{
				Name:   "reinstall",
				Usage:  "reinstalls Konstellation components",
				Action: clusterReinstall,
			},
			{
				Name:   "get-token",
				Usage:  "returns a kubernetes compatible token",
				Action: clusterGetToken,
				Hidden: true,
				Flags: []cli.Flag{
					clusterNameFlag,
				},
			},
		},
	},
}

var ConfigCommands = []*cli.Command{
	{
		Name:  "config",
		Usage: "Config for apps",
		Before: func(c *cli.Context) error {
			return ensureClusterSelected()
		},
		Category: "App",
		Subcommands: []*cli.Command{
			{
				Name:   "delete",
				Usage:  "Delete a config",
				Action: configDelete,
				Flags: []cli.Flag{
					nameFlag,
					appFlag,
					&cli.StringFlag{
						Name:  "target",
						Usage: "delete config for a single target",
					},
				},
			},
			{
				Name:   "edit",
				Usage:  "Create or edit a config. Use --app to edit an app config, or --name to edit a shared config",
				Action: configEdit,
				Flags: []cli.Flag{
					nameFlag,
					appFlag,
					&cli.StringFlag{
						Name:  "target",
						Usage: "edit config only for a specific target (target values will override the base config)",
					},
				},
			},
			{
				Name:   "list",
				Usage:  "List config files on this cluster",
				Action: configList,
				Flags: []cli.Flag{
					appFilterFlag,
				},
			},
			{
				Name:      "show",
				Usage:     "Show config for a release of the app",
				Action:    configShow,
				ArgsUsage: "<release>",
			},
		},
	},
}

var LaunchCommands = []*cli.Command{
	{
		Name:     "launch",
		Usage:    "Launch management webapps",
		Category: "Cluster",
		Before: func(c *cli.Context) error {
			return ensureClusterSelected()
		},
		Action: func(c *cli.Context) error {
			return cli.ShowAppHelp(c)
		},
		Subcommands: []*cli.Command{
			{
				Name:   "alertmanager",
				Usage:  "Launch Alert Manager",
				Action: launchAlertManager,
			},
			{
				Name:   "grafana",
				Usage:  "Launch Grafana",
				Action: launchGrafana,
			},
			{
				Name:   "kubedash",
				Usage:  "Launch Kubernetes Dashboard",
				Action: launchKubeDash,
			},
			{
				Name:   "prometheus",
				Usage:  "Launch Prometheus UI",
				Action: launchPrometheus,
			},
			{
				Name:   "proxy",
				Usage:  "Start a proxy to any service",
				Action: launchProxy,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "app",
						Aliases:  []string{"service"},
						Usage:    "name of app or service to proxy",
						Required: true,
					},
					&cli.StringFlag{
						Name:    "target",
						Aliases: []string{"namespace"},
						Usage:   "target or namespace of the service (defaults to first target)",
					},
					&cli.StringFlag{
						Name:  "port",
						Usage: "port name or number for the service",
					},
				},
			},
		},
	},
}

var NodepoolCommands = []*cli.Command{
	{
		Name:     "nodepool",
		Usage:    "Nodepool management",
		Category: "Cluster",
		Before: func(c *cli.Context) error {
			return ensureClusterSelected()
		},
		Subcommands: []*cli.Command{
			{
				Name:   "list",
				Usage:  "list Nodepools in the current cluster",
				Action: nodepoolList,
			},
			{
				Name:   "create",
				Usage:  "create a new Nodepool",
				Action: nodepoolCreate,
			},
			{
				Name:   "destroy",
				Usage:  "destroys a Nodepool",
				Action: nodepoolDestroy,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "nodepool",
						Usage:    "Name of Nodepool to destroy",
						Required: true,
					},
				},
			},
		},
	},
}

var SetupCommands = []*cli.Command{
	{
		Name:     "setup",
		Usage:    "Setup Konstellation CLI",
		Category: "Other",
		Action:   setupStart,
	},
}

var VPCCommands = []*cli.Command{
	{
		Name:     "vpc",
		Usage:    "VPC management",
		Category: "Other",
		Before:   ensureSetup,
		Subcommands: []*cli.Command{
			{
				Name:   "list",
				Usage:  "list VPCs in configured regions",
				Action: vpcList,
			},
			{
				Name:   "destroy",
				Usage:  "destroys a Konstellation-created VPC",
				Action: vpcDestroy,
				Flags: []cli.Flag{
					&cli.StringFlag{
						Name:     "vpc",
						Usage:    "ID of VPC to destroy",
						Required: true,
					},
				},
			},
		},
	},
}