package users

import (
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
	"xcecli/common/request"
	"xcecli/config"
	logger "xcecli/config"
	"xcecli/models"

	"github.com/spf13/cobra"
	"go.uber.org/zap"
)

func NewUserSubmitter(configManager *config.ConfigManager) *UserSubmitter {
	return &UserSubmitter{
		configManager: configManager,
	}
}

type UserSubmitter struct {
	configManager *config.ConfigManager
	userName      string
	roleName      []string
}

func NewAssignUserRolesCmd(configManager *config.ConfigManager) *cobra.Command {
	userSubmitter := NewUserSubmitter(configManager)

	cmd := &cobra.Command{
		Use:   "assignrole",
		Short: "Assign role to API Server",
		Long: `Assign role to API Server.
Example:
        xce user assignrole -u user_name -r role_name1,role_name2      # assign role to a user"`,

		SilenceUsage: true,
		Run: func(cmd *cobra.Command, args []string) {
			if err := userSubmitter.ParseCmdArgs(cmd, args); err != nil {
				fmt.Println(strings.ToLower(err.Error()))
				return
			}
			if err := userSubmitter.RunUserAssignRole(); err != nil {
				fmt.Println(strings.ToLower(err.Error()))
				return
			}
		},
	}

	// add the flags
	flags := cmd.Flags()

	//modify the flags
	flags.StringVarP(&userSubmitter.userName, "user_name", "u", "", "specify the user name")
	flags.StringSliceVarP(&userSubmitter.roleName, "role_name", "r", []string{}, "specify the role name")
	return cmd
	//
}

func (rs *UserSubmitter) ParseCmdArgs(cmd *cobra.Command, args []string) error {
	if rs.userName == "" {
		return fmt.Errorf("please provide the user name")
	}
	if len(rs.userName) > 40 {
		return fmt.Errorf("error: user name cannot be longer than 40 characters")
	}
	if len(rs.roleName) == 0 {
		return fmt.Errorf("please provide the role name")
	}
	if len(args) > 0 {
		return fmt.Errorf("too many arguments")
	}
	return nil
}

func (us *UserSubmitter) RunUserAssignRole() error {
	// Get server info and validate authentication
	serverInfo, _ := us.configManager.GetServerInfo()
	// create the API client and submit the user
	apiClient := request.NewAPIClient(serverInfo.URL)
	apiClient.SetRootCAs(serverInfo.CACert)

	// build the user request
	userReq, err := us.BuildUserRequest()
	if err != nil {
		return err
	}

	// encode request to JSON bytes
	reqData, err := json.Marshal(userReq)
	if err != nil {
		errMsg := request.ExtractErrorMessage(err)
		return fmt.Errorf("failed to encode request data: [%s]", errMsg)
	}
	url := fmt.Sprintf("/xce/v1/users/%s/roles", us.userName)
	var resp models.UserAssignRoleResponse
	err = apiClient.PostRequestToAPIServer(
		serverInfo.Token,
		serverInfo.CACert,
		url,
		reqData,
		&resp,
	)

	if err != nil {
		return err
	}

	if resp.Code != http.StatusCreated {
		logger.Info("user assign role failed", zap.Any("resp", resp), zap.Error(err))
		return fmt.Errorf("%s", resp.Data.Message)
	}
	logger.Debug("user assign role successfully", zap.String("message", resp.Data.Message))
	logger.Info("user assign role successfully", zap.String("message", resp.Data.Message))
	fmt.Printf("%s\n", resp.Data.Message)
	return nil
}

func (us *UserSubmitter) BuildUserRequest() (*models.AddRoleForUserRequest, error) {
	roleReq := &models.AddRoleForUserRequest{
		UserName: us.userName,
		RoleName: us.roleName,
	}
	return roleReq, nil
}