package internal

import (
	"os"

	logrusStack "github.com/Gurpartap/logrus-stack"
	"github.com/sirupsen/logrus"
	"github.com/urfave/cli"
)

// Secrets stores the variable from SecretsFlag
var Secrets bool

// SecretsFlag turns on/off automatically generating secrets
var SecretsFlag = &cli.BoolFlag{
	Name:        "secrets, ss",
	Usage:       "Automatically generate secrets",
	Destination: &Secrets,
}

// Pass stores the variable from PassFlag
var Pass bool

// PassFlag turns on/off storing generated secrets in pass
var PassFlag = &cli.BoolFlag{
	Name:        "pass, p",
	Usage:       "Store the generated secrets in a local pass store",
	Destination: &Pass,
}

// Context is temp
var Context string

// ContextFlag is temp
var ContextFlag = &cli.StringFlag{
	Name:        "context, c",
	Value:       "",
	Destination: &Context,
}

// Force force functionality without asking.
var Force bool

// ForceFlag turns on/off force functionality.
var ForceFlag = &cli.BoolFlag{
	Name:        "force, f",
	Usage:       "Perform action without further prompt. Use with care!",
	Destination: &Force,
}

// Chaos engages chaos mode.
var Chaos bool

// ChaosFlag turns on/off chaos functionality.
var ChaosFlag = &cli.BoolFlag{
	Name:        "chaos, ch",
	Usage:       "Deploy uncommitted recipes changes. Use with care!",
	Destination: &Chaos,
}

// DNSProvider specifies a DNS provider.
var DNSProvider string

// DNSProviderFlag selects a DNS provider.
var DNSProviderFlag = &cli.StringFlag{
	Name:        "provider, p",
	Value:       "",
	Usage:       "DNS provider",
	Destination: &DNSProvider,
}

var NoInput bool
var NoInputFlag = &cli.BoolFlag{
	Name:        "no-input, n",
	Usage:       "Toggle non-interactive mode",
	Destination: &NoInput,
}

var DNSType string

var DNSTypeFlag = &cli.StringFlag{
	Name:        "type, t",
	Value:       "",
	Usage:       "Domain name record type (e.g. A)",
	Destination: &DNSType,
}

var DNSName string

var DNSNameFlag = &cli.StringFlag{
	Name:        "name, n",
	Value:       "",
	Usage:       "Domain name record name (e.g. mysubdomain)",
	Destination: &DNSName,
}

var DNSValue string

var DNSValueFlag = &cli.StringFlag{
	Name:        "value, v",
	Value:       "",
	Usage:       "Domain name record value (e.g. 192.168.1.1)",
	Destination: &DNSValue,
}

var DNSTTL string
var DNSTTLFlag = &cli.StringFlag{
	Name:        "ttl, T",
	Value:       "600s",
	Usage:       "Domain name TTL value (seconds)",
	Destination: &DNSTTL,
}

var DNSPriority int

var DNSPriorityFlag = &cli.IntFlag{
	Name:        "priority, P",
	Value:       10,
	Usage:       "Domain name priority value",
	Destination: &DNSPriority,
}

var ServerProvider string

var ServerProviderFlag = &cli.StringFlag{
	Name:        "provider, p",
	Usage:       "3rd party server provider",
	Destination: &ServerProvider,
}

var CapsulInstanceURL string

var CapsulInstanceURLFlag = &cli.StringFlag{
	Name:        "capsul-url, cu",
	Value:       "yolo.servers.coop",
	Usage:       "capsul instance URL",
	Destination: &CapsulInstanceURL,
}

var CapsulName string

var CapsulNameFlag = &cli.StringFlag{
	Name:        "capsul-name, cn",
	Value:       "",
	Usage:       "capsul name",
	Destination: &CapsulName,
}

var CapsulType string

var CapsulTypeFlag = &cli.StringFlag{
	Name:        "capsul-type, ct",
	Value:       "f1-xs",
	Usage:       "capsul type",
	Destination: &CapsulType,
}

var CapsulImage string

var CapsulImageFlag = &cli.StringFlag{
	Name:        "capsul-image, ci",
	Value:       "debian10",
	Usage:       "capsul image",
	Destination: &CapsulImage,
}

var CapsulSSHKeys cli.StringSlice
var CapsulSSHKeysFlag = &cli.StringSliceFlag{
	Name:  "capsul-ssh-keys, cs",
	Usage: "capsul SSH key",
	Value: &CapsulSSHKeys,
}

var CapsulAPIToken string

var CapsulAPITokenFlag = &cli.StringFlag{
	Name:        "capsul-token, ca",
	Usage:       "capsul API token",
	EnvVar:      "CAPSUL_TOKEN",
	Destination: &CapsulAPIToken,
}

var HetznerCloudName string

var HetznerCloudNameFlag = &cli.StringFlag{
	Name:        "hetzner-name, hn",
	Value:       "",
	Usage:       "hetzner cloud name",
	Destination: &HetznerCloudName,
}

var HetznerCloudType string

var HetznerCloudTypeFlag = &cli.StringFlag{
	Name:        "hetzner-type, ht",
	Usage:       "hetzner cloud type",
	Destination: &HetznerCloudType,
	Value:       "cx11",
}

var HetznerCloudImage string

var HetznerCloudImageFlag = &cli.StringFlag{
	Name:        "hetzner-image, hi",
	Usage:       "hetzner cloud image",
	Value:       "debian-10",
	Destination: &HetznerCloudImage,
}

var HetznerCloudSSHKeys cli.StringSlice

var HetznerCloudSSHKeysFlag = &cli.StringSliceFlag{
	Name:  "hetzner-ssh-keys, hs",
	Usage: "hetzner cloud SSH keys (e.g. me@foo.com)",
	Value: &HetznerCloudSSHKeys,
}

var HetznerCloudLocation string

var HetznerCloudLocationFlag = &cli.StringFlag{
	Name:        "hetzner-location, hl",
	Usage:       "hetzner cloud server location",
	Value:       "hel1",
	Destination: &HetznerCloudLocation,
}

var HetznerCloudAPIToken string

var HetznerCloudAPITokenFlag = &cli.StringFlag{
	Name:        "hetzner-token, ha",
	Usage:       "hetzner cloud API token",
	EnvVar:      "HCLOUD_TOKEN",
	Destination: &HetznerCloudAPIToken,
}

// Debug stores the variable from DebugFlag.
var Debug bool

// DebugFlag turns on/off verbose logging down to the DEBUG level.
var DebugFlag = &cli.BoolFlag{
	Name:        "debug, d",
	Destination: &Debug,
	Usage:       "Show DEBUG messages",
}

// RC signifies the latest release candidate
var RC bool

// RCFlag chooses the latest release candidate for install
var RCFlag = &cli.BoolFlag{
	Name:        "rc",
	Destination: &RC,
	Usage:       "Insatll the latest release candidate",
}

var Major bool
var MajorFlag = &cli.BoolFlag{
	Name:        "major, ma, x",
	Usage:       "Increase the major part of the version",
	Destination: &Major,
}

var Minor bool
var MinorFlag = &cli.BoolFlag{
	Name:        "minor, mi, y",
	Usage:       "Increase the minor part of the version",
	Destination: &Minor,
}

var Patch bool
var PatchFlag = &cli.BoolFlag{
	Name:        "patch, pa, z",
	Usage:       "Increase the patch part of the version",
	Destination: &Patch,
}

var Dry bool
var DryFlag = &cli.BoolFlag{
	Name:        "dry-run, d",
	Usage:       "Only reports changes that would be made",
	Destination: &Dry,
}

var Publish bool
var PublishFlag = &cli.BoolFlag{
	Name:        "publish, p",
	Usage:       "Publish changes to git.coopcloud.tech",
	Destination: &Publish,
}

var Domain string
var DomainFlag = &cli.StringFlag{
	Name:        "domain, dn",
	Value:       "",
	Usage:       "Choose a domain name",
	Destination: &Domain,
}

var NewAppServer string
var NewAppServerFlag = &cli.StringFlag{
	Name:        "server, s",
	Value:       "",
	Usage:       "Show apps of a specific server",
	Destination: &NewAppServer,
}

var NewAppName string
var NewAppNameFlag = &cli.StringFlag{
	Name:        "app-name, a",
	Value:       "",
	Usage:       "Choose an app name",
	Destination: &NewAppName,
}

var NoDomainChecks bool
var NoDomainChecksFlag = &cli.BoolFlag{
	Name:        "no-domain-checks, nd",
	Usage:       "Disable app domain sanity checks",
	Destination: &NoDomainChecks,
}

var StdErrOnly bool
var StdErrOnlyFlag = &cli.BoolFlag{
	Name:        "stderr, s",
	Usage:       "Only tail stderr",
	Destination: &StdErrOnly,
}

var AutoDNSRecord bool
var AutoDNSRecordFlag = &cli.BoolFlag{
	Name:        "auto, a",
	Usage:       "Automatically configure DNS records",
	Destination: &AutoDNSRecord,
}

var DontWaitConverge bool
var DontWaitConvergeFlag = &cli.BoolFlag{
	Name:        "no-converge-checks, nc",
	Usage:       "Don't wait for converge logic checks",
	Destination: &DontWaitConverge,
}

var Watch bool
var WatchFlag = &cli.BoolFlag{
	Name:        "watch, w",
	Usage:       "Watch status by polling repeatedly",
	Destination: &Watch,
}

var OnlyErrors bool
var OnlyErrorFlag = &cli.BoolFlag{
	Name:        "errors, e",
	Usage:       "Only show errors",
	Destination: &OnlyErrors,
}

var SkipUpdates bool
var SkipUpdatesFlag = &cli.BoolFlag{
	Name:        "skip-updates, s",
	Usage:       "Skip updating recipe repositories",
	Destination: &SkipUpdates,
}

var RegistryUsername string
var RegistryUsernameFlag = &cli.StringFlag{
	Name:        "username, user",
	Value:       "",
	Usage:       "Registry username",
	EnvVar:      "REGISTRY_USERNAME",
	Destination: &RegistryUsername,
}

var RegistryPassword string
var RegistryPasswordFlag = &cli.StringFlag{
	Name:        "password, pass",
	Value:       "",
	Usage:       "Registry password",
	EnvVar:      "REGISTRY_PASSWORD",
	Destination: &RegistryUsername,
}

var AllTags bool
var AllTagsFlag = &cli.BoolFlag{
	Name:        "all-tags, a",
	Usage:       "List all tags, not just upgrades",
	Destination: &AllTags,
}

// SSHFailMsg is a hopefully helpful SSH failure message
var SSHFailMsg = `
Woops, Abra is unable to connect to connect to %s.

Here are a few tips for debugging your local SSH config. Abra uses plain 'ol
SSH to make connections to servers, so if your SSH config is working, Abra is
working.

In the first place, Abra will always try to read your Docker context connection
string for SSH connection details. You can view your server context configs
with the following command. Are they correct?

    abra server ls

Is your ssh-agent running? You can start it by running the following command:

    eval "$(ssh-agent)"

If your SSH private key loaded? You can check by running the following command:

    ssh-add -L

If, you can add it with:

    ssh-add ~/.ssh/<private-key-part>

If you are using a non-default public/private key, you can configure this in
your ~/.ssh/config file which Abra will read in order to figure out connection
details:

Host foo.coopcloud.tech
  Hostname foo.coopcloud.tech
  User bar
  Port 12345
  IdentityFile ~/.ssh/bar@foo.coopcloud.tech

If you're only using password authentication, you can use the following config:

Host foo.coopcloud.tech
  Hostname foo.coopcloud.tech
  User bar
  Port 12345
  PreferredAuthentications=password
  PubkeyAuthentication=no

Good luck!

`

// SubCommandBefore wires up pre-action machinery (e.g. --debug handling).
func SubCommandBefore(c *cli.Context) error {
	if Debug {
		logrus.SetLevel(logrus.DebugLevel)
		logrus.SetFormatter(&logrus.TextFormatter{})
		logrus.SetOutput(os.Stderr)
		logrus.AddHook(logrusStack.StandardHook())
	}

	return nil
}