profile

var CreateCmd = &cobra.Command{
	Use:   "create",
	Short: "Create a new Pennsieve profile.",
	Long:  `Creates a new Pennsieve profile which includes API-Key and API-Secret.`,
	Run: func(cmd *cobra.Command, args []string) {

		var profileName string
		fmt.Println("\nCreate new profile:")
		fmt.Printf("   Profile name [user]: ")
		fmt.Scanln(&profileName)

		if len(profileName) == 0 {
			profileName = "user"
		}

		var apiToken string
		fmt.Printf("   API token: ")
		fmt.Scanln(&apiToken)

		var apiSecret string
		fmt.Printf("   API secret: ")
		fmt.Scanln(&apiSecret)

		fmt.Printf("Creating new profile: '%s'\n", profileName)

		fmt.Printf("Continue and write changes? (y/n) ")
		response := ""
		fmt.Scanln(&response)

		if response == "y" {
			viper.Set(fmt.Sprintf("%s.api_token", profileName), apiToken)
			viper.Set(fmt.Sprintf("%s.api_secret", profileName), apiSecret)

			err := viper.WriteConfig()
			if err != nil {
				fmt.Println(err)
			}
		}

	},
}

var ProfileCmd = &cobra.Command{
	Use:   "profile",
	Short: "Manage Pennsieve profiles",
	Long: `Profiles are used to store user-settings. They are stored in the ~/.server/config.ini file.

`,
	Run: func(cmd *cobra.Command, args []string) {
		ShowCmd.Run(cmd, args)
	},
}

var ReauthCmd = &cobra.Command{
	Use:   "reauth",
	Short: "Displays information about the logged in user.",
	Long:  `Displays information about the logged in user.`,
	Run: func(cmd *cobra.Command, args []string) {

		req := api.ReAuthenticateRequest{}

		port := viper.GetString("agent.port")
		conn, err := grpc.Dial(":"+port, grpc.WithTransportCredentials(insecure.NewCredentials()))
		if err != nil {
			fmt.Println("Error connecting to GRPC Server. See log for details.")
			log.Error("Error connecting to GRPC Server: ", err)
			return
		}
		defer conn.Close()

		client := api.NewAgentClient(conn)
		userResponse, err := client.ReAuthenticate(context.Background(), &req)
		if err != nil {
			shared.HandleAgentError(err, fmt.Sprintf("Error: Unable to complete getUser command: %v", err))
			return
		}

		db, _ := config.InitializeDB()
		userSettingsStore := store.NewUserSettingsStore(db)
		userInfoStore := store.NewUserInfoStore(db)
		_, err = config.InitPennsieveClient(userSettingsStore, userInfoStore)
		if err != nil {
			log.Fatalln("Cannot connect to Pennsieve.")
		}

		showFull, _ := cmd.Flags().GetBool("full")
		whoami.PrettyPrint(userResponse, showFull)
	},
}

var SetDefaultCmd = &cobra.Command{
	Use:   "set-default",
	Short: "Update the default profile",
	Long:  `Stores a default profile in the Pennsieve config.ini file`,
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		profile := args[0]

		isSet := viper.IsSet(profile + ".api_token")

		if isSet {
			viper.Set("global.default_profile", profile)
			viper.WriteConfig()
			fmt.Println("Default profile set to:", profile)
		} else {
			fmt.Printf("No profile with name %s exists.\n", profile)
		}
	},
}

var ShowCmd = &cobra.Command{
	Use:   "show",
	Short: "Shows current profile",
	Long:  `Shows current profile`,
	Run: func(cmd *cobra.Command, args []string) {

		req := api.GetUserRequest{}

		port := viper.GetString("agent.port")
		conn, err := grpc.Dial(":"+port, grpc.WithTransportCredentials(insecure.NewCredentials()))
		if err != nil {
			fmt.Println("Error connecting to GRPC Server: ", err)
			return
		}
		defer conn.Close()

		client := api.NewAgentClient(conn)

		userResponse, err := client.GetUser(context.Background(), &req)
		if err != nil {
			shared.HandleAgentError(err, fmt.Sprintf("Error: Unable to complete getUser command: %v", err))
			return
		}

		fmt.Println("Current profile: ", userResponse.Profile)
	},
}

var SwitchCmd = &cobra.Command{
	Use:   "switch",
	Short: "Switch between user profiles.",
	Long:  `Switch between user profiles that are defined in the Pennsieve Config file.`,

	Args: cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		selectedProfile := args[0]

		req := api.SwitchProfileRequest{
			Profile: selectedProfile,
		}

		port := viper.GetString("agent.port")
		conn, err := grpc.Dial(":"+port, grpc.WithTransportCredentials(insecure.NewCredentials()))
		if err != nil {
			fmt.Println("Error connecting to GRPC Server: ", err)
			return
		}
		defer conn.Close()

		client := api.NewAgentClient(conn)
		switchResponse, err := client.SwitchProfile(context.Background(), &req)
		if err != nil {
			shared.HandleAgentError(err, fmt.Sprintf("Error: Unable to complete switchUser command: %v", err))
			return
		}

		prettyPrint(*switchResponse, false)

	},
}