auth

var AuthCmd = &cobra.Command{
	Use:   "auth",
	Short: "Authenticate yba cli",
	Long: "Authenticate the yba cli through this command by providing the host and API Token." +
		" If non-interactive mode is set, provide the host and API Token using flags. " +
		"Default for host is \"http://localhost:9000\"",
	Example: "yba auth -f -H <host> -a <api-token>",
	Run: func(cmd *cobra.Command, args []string) {
		force, err := cmd.Flags().GetBool("force")
		if err != nil {
			logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
		}
		var apiToken string
		var host string
		var data []byte
		hostConfig := viper.GetString("host")
		if !force {
			fmt.Printf("Enter Host [%s]: ", hostConfig)

			reader := bufio.NewReader(os.Stdin)
			input, err := reader.ReadString('\n')
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read host: "+err.Error()+"\n",
						formatter.RedColor))
			}

			if input == "\n" {
				input = hostConfig + "\n"
			}
			host = strings.TrimSpace(input)
			if len(host) == 0 {
				if len(strings.TrimSpace(hostConfig)) == 0 {
					logrus.Fatalln(formatter.Colorize("Host cannot be empty.\n",
						formatter.RedColor))
				} else {
					host = hostConfig
				}
			}

			fmt.Print("Enter API Token: ")
			data, err = term.ReadPassword(int(os.Stdin.Fd()))
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read apiToken: "+err.Error()+"\n",
						formatter.RedColor))
			}
			apiToken = string(data)

		} else {
			hostFlag, err := cmd.Flags().GetString("host")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}

			if strings.Compare(hostFlag, "http://localhost:9000") == 0 {
				if len(strings.TrimSpace(hostConfig)) == 0 {
					host = hostFlag
				} else {
					host = hostConfig
				}
			} else {
				host = hostFlag
			}
			apiToken, err = cmd.Flags().GetString("apiToken")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}
		}

		if strings.TrimSpace(apiToken) == "" {
			logrus.Fatalln(formatter.Colorize("apiToken cannot be empty.\n",
				formatter.RedColor))
		}
		viper.GetViper().Set("host", &host)

		logrus.Infoln("\n")

		url, err := ybaAuthClient.ParseURL(host)
		if err != nil {
			logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
		}

		authUtil(url, apiToken)
	},
}

var HostCmd = &cobra.Command{
	Use:     "host",
	Short:   "Refer to YugabyteDB Anywhere host details",
	Long:    "Refer to YugabyteDB Anywhere host details",
	Example: "yba host",
	Run: func(cmd *cobra.Command, args []string) {
		hostString := viper.GetString("host")
		if len(strings.TrimSpace(hostString)) == 0 {
			logrus.Fatalln(
				formatter.Colorize(
					"No valid YugabyteDB Anywhere Host detected. "+
						"Run \"yba auth\" or \"yba login\" to authenticate with YugabyteDB Anywhere.\n",
					formatter.RedColor))
		}

		ybaAuthClient.NewAuthAPIClientAndCustomer()
		logrus.Infof("YugabyteDB Anywhere is available on %s at version %s\n",
			hostString,
			ybaAuthClient.GetHostVersion())
	},
}

var LoginCmd = &cobra.Command{
	Use:   "login",
	Short: "Authenticate yba cli using email and password",
	Long: "Connect to YugabyteDB Anywhere host machine using email and password." +
		" If non-interactive mode is set, provide the host, email and password using flags. " +
		"Default for host is \"http://localhost:9000\".",
	Example: "yba login -f -e <email> -p <password> -H <host>",
	Run: func(cmd *cobra.Command, args []string) {
		force, err := cmd.Flags().GetBool("force")
		if err != nil {
			logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
		}
		var email, password string
		var host string
		var data []byte
		hostConfig := viper.GetString("host")
		if !force {
			fmt.Printf("Enter Host [%s]: ", hostConfig)

			reader := bufio.NewReader(os.Stdin)
			input, err := reader.ReadString('\n')
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read host: "+err.Error()+"\n",
						formatter.RedColor))
			}

			if input == "\n" {
				input = hostConfig + "\n"
			}
			host = strings.TrimSpace(input)
			if len(host) == 0 {
				if len(strings.TrimSpace(hostConfig)) == 0 {
					logrus.Fatalln(
						formatter.Colorize("Host cannot be empty.\n",
							formatter.RedColor))
				} else {
					host = hostConfig
				}
			}

			fmt.Print("Enter email or username: ")
			_, err = fmt.Scanln(&email)
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read email: "+err.Error()+"\n",
						formatter.RedColor))
			}

			fmt.Print("Enter password: ")
			data, err = term.ReadPassword(int(os.Stdin.Fd()))
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read password: "+err.Error()+"\n",
						formatter.RedColor))
			}
			password = string(data)

		} else {
			hostFlag, err := cmd.Flags().GetString("host")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}

			if strings.Compare(hostFlag, "http://localhost:9000") == 0 {
				if len(strings.TrimSpace(hostConfig)) == 0 {
					host = hostFlag
				} else {
					host = hostConfig
				}
			} else {
				host = hostFlag
			}
			email, err = cmd.Flags().GetString("email")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}
			password, err = cmd.Flags().GetString("password")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}
		}

		viper.GetViper().Set("host", &host)
		if strings.TrimSpace(email) == "" {
			logrus.Fatalln(
				formatter.Colorize(
					"Email cannot be empty.\n",
					formatter.RedColor))
		}

		if strings.TrimSpace(password) == "" {
			logrus.Fatalln(
				formatter.Colorize(
					"Password cannot be empty.\n",
					formatter.RedColor))
		}

		logrus.Infoln("\n")

		url, err := ybaAuthClient.ParseURL(host)
		if err != nil {
			logrus.Fatal(
				formatter.Colorize(
					err.Error()+"\n",
					formatter.RedColor))
		}

		authAPI, err := ybaAuthClient.NewAuthAPIClientInitialize(url, "")
		if err != nil {
			logrus.Fatal(
				formatter.Colorize(
					err.Error()+"\n",
					formatter.RedColor))
		}

		req := ybaclient.CustomerLoginFormData{
			Email:    email,
			Password: password,
		}

		r, response, err := authAPI.ApiLogin().CustomerLoginFormData(req).Execute()
		if err != nil {
			errMessage := util.ErrorFromHTTPResponse(
				response, err, "Login", "Authentication")
			logrus.Fatalf(formatter.Colorize(errMessage.Error()+"\n", formatter.RedColor))
		}
		logrus.Debugf("API Login response without errors\n")

		authUtil(url, r.GetApiToken())
	},
}

var RegisterCmd = &cobra.Command{
	Use:   "register",
	Short: "Register a YugabyteDB Anywhere customer using yba cli",
	Long: "Register a YugabyteDB Anywhere customer using yba cli. " +
		"If non-interactive mode is set, provide the host, name, email, password" +
		" and environment using flags.",
	Example: "yba register -f -n <name> -e <email> -p <password> -H <host>",
	Run: func(cmd *cobra.Command, args []string) {
		force, err := cmd.Flags().GetBool("force")
		if err != nil {
			logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
		}
		var email, password, confirmPassword string
		var name, code string
		var host string
		var data []byte
		hostConfig := viper.GetString("host")
		if !force {
			fmt.Printf("Enter Host [%s]: ", hostConfig)

			reader := bufio.NewReader(os.Stdin)
			input, err := reader.ReadString('\n')
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read host: "+err.Error()+"\n",
						formatter.RedColor))
			}

			if input == "\n" {
				input = hostConfig + "\n"
			}
			host = strings.TrimSpace(input)
			if len(host) == 0 {
				if len(strings.TrimSpace(hostConfig)) == 0 {
					logrus.Fatalln(
						formatter.Colorize("Host cannot be empty.\n",
							formatter.RedColor))
				} else {
					host = hostConfig
				}
			}

			fmt.Printf("Enter name: ")
			readerName := bufio.NewReader(os.Stdin)
			inputName, err := readerName.ReadString('\n')
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read name: "+err.Error()+"\n",
						formatter.RedColor))
			}
			name = strings.TrimSpace(inputName)

			fmt.Printf("Enter environment [dev]: ")

			readerCode := bufio.NewReader(os.Stdin)
			inputCode, err := readerCode.ReadString('\n')
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read environment: "+err.Error()+"\n",
						formatter.RedColor))
			}
			code = strings.TrimSpace(inputCode)
			if len(code) == 0 {
				code = "dev"
			}

			fmt.Print("Enter email: ")
			_, err = fmt.Scanln(&email)
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read email: "+err.Error()+"\n",
						formatter.RedColor))
			}

			fmt.Print(
				"Enter password (must contain at least 8 characters " +
					"and at least 1 digit , 1 capital , 1 lowercase and 1 " +
					"of the !@#$^&* (special) characters): ")
			data, err = term.ReadPassword(int(os.Stdin.Fd()))
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read password: "+err.Error()+"\n",
						formatter.RedColor))
			}
			password = string(data)

			fmt.Print("Confirm entered password: ")
			data, err = term.ReadPassword(int(os.Stdin.Fd()))
			if err != nil {
				logrus.Fatalln(
					formatter.Colorize("Could not read password: "+err.Error()+"\n",
						formatter.RedColor))
			}
			confirmPassword = string(data)

			if !strings.EqualFold(password, confirmPassword) {
				logrus.Fatalln(
					formatter.Colorize("Passwords do not match.\n",
						formatter.RedColor))
			}

		} else {
			hostFlag, err := cmd.Flags().GetString("host")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}

			if strings.Compare(hostFlag, "http://localhost:9000") == 0 {
				if len(strings.TrimSpace(hostConfig)) == 0 {
					host = hostFlag
				} else {
					host = hostConfig
				}
			} else {
				host = hostFlag
			}
			name, err = cmd.Flags().GetString("name")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}
			email, err = cmd.Flags().GetString("email")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}
			password, err = cmd.Flags().GetString("password")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}
			code, err = cmd.Flags().GetString("environment")
			if err != nil {
				logrus.Fatal(formatter.Colorize(err.Error()+"\n", formatter.RedColor))
			}
		}

		viper.GetViper().Set("host", &host)

		if strings.TrimSpace(name) == "" {
			logrus.Fatalln(
				formatter.Colorize(
					"Name cannot be empty.\n",
					formatter.RedColor))
		}

		if strings.TrimSpace(email) == "" {
			logrus.Fatalln(
				formatter.Colorize(
					"Email cannot be empty.\n",
					formatter.RedColor))
		}

		if strings.TrimSpace(password) == "" {
			logrus.Fatalln(
				formatter.Colorize(
					"Password cannot be empty.\n",
					formatter.RedColor))
		}

		logrus.Infoln("\n")

		url, err := ybaAuthClient.ParseURL(host)
		if err != nil {
			logrus.Fatal(
				formatter.Colorize(
					err.Error()+"\n",
					formatter.RedColor))
		}

		authAPI, err := ybaAuthClient.NewAuthAPIClientInitialize(url, "")
		if err != nil {
			logrus.Fatal(
				formatter.Colorize(
					err.Error()+"\n",
					formatter.RedColor))
		}

		req := ybaclient.CustomerRegisterFormData{
			Email:    email,
			Password: password,
			Name:     name,
			Code:     code,
		}

		r, response, err := authAPI.RegisterCustomer().CustomerRegisterFormData(req).Execute()
		if err != nil {
			errMessage := util.ErrorFromHTTPResponse(
				response, err, "Register", "Authentication")
			logrus.Fatalf(formatter.Colorize(errMessage.Error()+"\n", formatter.RedColor))
		}
		logrus.Debugf("API Register response without errors\n")

		reqLogin := ybaclient.CustomerLoginFormData{
			Email:    email,
			Password: password,
		}

		r, response, err = authAPI.ApiLogin().CustomerLoginFormData(reqLogin).Execute()
		if err != nil {
			errMessage := util.ErrorFromHTTPResponse(
				response, err, "Register", "Login")
			logrus.Fatalf(formatter.Colorize(errMessage.Error()+"\n", formatter.RedColor))
		}
		logrus.Debugf("API Login response without errors\n")

		authUtil(url, r.GetApiToken())
	},
}