/*
 * Copyright 2026 Oleg Borodin <onborodin@gmail.com>
 *
 * This work is published and licensed under a Creative Commons
 * Attribution-NonCommercial-NoDerivatives 4.0 International License.
 *
 * Distribution of this work is permitted, but commercial use and
 * modifications are strictly prohibited.
 */
package main

import (
	"context"
	"regexp"
	"strings"
	"time"

	"github.com/spf13/cobra"

	"mstore/app/descr"
	"mstore/pkg/client"
)

func (util *GrantUtil) CreateGrantCmds() *cobra.Command {
	var subCmd = &cobra.Command{
		Use:   "account",
		Short: "Grant operation",
	}
	const defaultTimeout uint64 = 10

	// CreateGrant
	var createGrantCmd = &cobra.Command{
		Use:   "create",
		Short: "Create grant",
		Run:   util.CreateGrant,
	}
	createGrantCmd.Flags().StringVarP(&util.createGrantParams.Username, "username", "u", "", "Username")
	createGrantCmd.Flags().StringVarP(&util.createGrantParams.Password, "password", "p", "", "Password")
	createGrantCmd.Flags().StringVarP(&util.createGrantParams.Hostname, "host", "x", defaultHostname, "Hostname")
	createGrantCmd.Flags().Uint64VarP(&util.createGrantParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")

	createGrantCmd.Flags().StringVarP(&util.createGrantParams.Right, "newuser", "U", "", "New account username")
	createGrantCmd.Flags().StringVarP(&util.createGrantParams.Pattern, "newpass", "P", "", "New account password")
	createGrantCmd.MarkFlagRequired("host")
	createGrantCmd.MarkFlagsRequiredTogether("newuser", "newpass")
	createGrantCmd.MarkFlagsRequiredTogether("username", "password")

	subCmd.AddCommand(createGrantCmd)

	// GetGrant
	var getGrantCmd = &cobra.Command{
		Use:   "get",
		Short: "Get detail grant info",
		Run:   util.GetGrant,
	}
	getGrantCmd.Flags().StringVarP(&util.getGrantParams.Hostname, "host", "x", defaultHostname, "Hostname")
	getGrantCmd.Flags().StringVarP(&util.getGrantParams.Username, "username", "u", "", "Username")
	getGrantCmd.Flags().StringVarP(&util.getGrantParams.Password, "password", "p", "", "Password")
	getGrantCmd.Flags().Uint64VarP(&util.getGrantParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")
	getGrantCmd.Flags().StringVarP(&util.getGrantParams.GrantID, "id", "I", "", "Grant ID or name")
	getGrantCmd.Flags().StringVarP(&util.getGrantParams.GrantID, "name", "n", "", "Grant ID or name")

	getGrantCmd.MarkFlagRequired("host")
	getGrantCmd.MarkFlagsOneRequired("id", "name")
	getGrantCmd.MarkFlagsRequiredTogether("username", "password")

	subCmd.AddCommand(getGrantCmd)

	// UpdateGrant
	var updateGrantCmd = &cobra.Command{
		Use:   "update",
		Short: "Update grant parameters",
		Run:   util.UpdateGrant,
	}
	updateGrantCmd.Flags().StringVarP(&util.updateGrantParams.Username, "username", "u", "", "Username")
	updateGrantCmd.Flags().StringVarP(&util.updateGrantParams.Password, "password", "p", "", "Password")
	updateGrantCmd.Flags().StringVarP(&util.updateGrantParams.Hostname, "host", "x", "", "File path")
	updateGrantCmd.Flags().Uint64VarP(&util.updateGrantParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")

	updateGrantCmd.Flags().StringVarP(&util.updateGrantParams.GrantID, "id", "I", "", "Grant ID or username")
	updateGrantCmd.Flags().StringVarP(&util.updateGrantParams.GrantID, "name", "n", "", "Grant ID or username")
	updateGrantCmd.Flags().StringVarP(&util.updateGrantParams.Right, "newuser", "U", "", "New username")
	updateGrantCmd.Flags().StringVarP(&util.updateGrantParams.Pattern, "pass", "P", "", "New password")
	updateGrantCmd.MarkFlagRequired("host")
	updateGrantCmd.MarkFlagsOneRequired("id", "name")

	subCmd.AddCommand(updateGrantCmd)

	// DeleteGrant
	var deleteGrantCmd = &cobra.Command{
		Use:   "delete",
		Short: "Delete grant",
		Run:   util.DeleteGrant,
	}
	deleteGrantCmd.Flags().StringVarP(&util.deleteGrantParams.Username, "username", "u", "", "Username")
	deleteGrantCmd.Flags().StringVarP(&util.deleteGrantParams.Password, "password", "p", "", "Password")
	deleteGrantCmd.Flags().StringVarP(&util.deleteGrantParams.Hostname, "host", "x", defaultHostname, "Hostname")
	deleteGrantCmd.Flags().Uint64VarP(&util.deleteGrantParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")

	deleteGrantCmd.Flags().StringVarP(&util.deleteGrantParams.GrantID, "id", "I", "", "Grant ID")
	deleteGrantCmd.MarkFlagRequired("host")
	deleteGrantCmd.MarkFlagsRequiredTogether("username", "password")

	subCmd.AddCommand(deleteGrantCmd)

	return subCmd
}

func (util *GrantUtil) CreateGrantsCmds() *cobra.Command {
	var subCmd = &cobra.Command{
		Use:   "grans",
		Short: "Grants operation",
	}
	const defaultTimeout uint64 = 10
	// ListGrants
	var listGrantsCmd = &cobra.Command{
		Use:   "list",
		Short: "list user grants",
		Run:   util.ListGrants,
	}
	listGrantsCmd.Flags().StringVarP(&util.listGrantsParams.Username, "username", "u", "", "Username")
	listGrantsCmd.Flags().StringVarP(&util.listGrantsParams.Password, "password", "p", "", "Password")
	listGrantsCmd.Flags().StringVarP(&util.listGrantsParams.Hostname, "host", "x", defaultHostname, "Hostname")
	listGrantsCmd.Flags().Uint64VarP(&util.listGrantsParams.Timeout, "timeout", "t", defaultTimeout, "Operation timeout")
	listGrantsCmd.Flags().BoolVarP(&util.listGrantsParams.Detail, "detail", "d", false, "Show detail information")
	listGrantsCmd.Flags().StringVarP(&util.listGrantsParams.AccountID, "id", "I", "", "User account ID")
	listGrantsCmd.Flags().StringVarP(&util.listGrantsParams.AccountID, "name", "n", "", "User account ID")

	listGrantsCmd.MarkFlagRequired("host")
	listGrantsCmd.MarkFlagsOneRequired("id", "name")

	subCmd.AddCommand(listGrantsCmd)
	return subCmd
}

type GrantUtil struct {
	createGrantParams CreateGrantParams
	updateGrantParams UpdateGrantParams
	getGrantParams    GetGrantParams
	deleteGrantParams DeleteGrantParams
	listGrantsParams  ListGrantsParams
}

// CreateGrant
type CreateGrantParams struct {
	Username  string
	Password  string
	Hostname  string
	AccountID string
	Right     string
	Pattern   string
	Timeout   uint64
}
type CreateGrantResult struct {
	GrantID string `json:"grantId"`
}

func (util *GrantUtil) CreateGrant(cmd *cobra.Command, args []string) {
	res, err := util.createGrant(&util.createGrantParams)
	printResponse(res, err)
}

func (util *GrantUtil) createGrant(params *CreateGrantParams) (*CreateGrantResult, error) {
	var err error
	res := &CreateGrantResult{}
	params.Hostname, err = packUserinfo(params.Hostname, params.Right, params.Pattern)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(params.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	accountID, err := client.NewClient().CreateGrant(ctx, params.Hostname, params.AccountID, params.Right, params.Pattern)
	if err != nil {
		return res, err
	}
	res.GrantID = accountID
	return res, err
}

// UpdateGrant
type UpdateGrantParams struct {
	Hostname string
	Username string
	Password string
	Timeout  uint64
	GrantID  string
	Right    string
	Pattern  string
}
type UpdateGrantResult struct{}

func (util *GrantUtil) UpdateGrant(cmd *cobra.Command, args []string) {
	res, err := util.updateGrant(&util.updateGrantParams)
	printResponse(res, err)
}

func (util *GrantUtil) updateGrant(params *UpdateGrantParams) (*UpdateGrantResult, error) {
	var err error
	res := &UpdateGrantResult{}
	params.Hostname, err = packUserinfo(params.Hostname, params.Username, params.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(params.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	id := strings.ToLower(params.GrantID)
	err = client.NewClient().UpdateGrant(ctx, params.Hostname, id, params.Pattern)
	if err != nil {
		return res, err
	}
	return res, err
}

// GetGrant
type GetGrantParams struct {
	Hostname string
	Username string
	Password string
	Timeout  uint64
	GrantID  string
}

type GetGrantResult struct {
	Grant *descr.Grant `json:"grant,omitempty"`
}

func (util *GrantUtil) GetGrant(cmd *cobra.Command, args []string) {
	res, err := util.getGrant(&util.getGrantParams)
	printResponse(res, err)
}

func (util *GrantUtil) getGrant(params *GetGrantParams) (*GetGrantResult, error) {
	var err error
	res := &GetGrantResult{}
	params.Hostname, err = packUserinfo(params.Hostname, params.Username, params.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(params.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	opRes := &descr.Grant{}

	id := strings.ToLower(params.GrantID)
	opRes, err = client.NewClient().GetGrant(ctx, params.Hostname, id)
	if err != nil {
		return res, err
	}
	res.Grant = opRes
	return res, err
}

// DeleteGrant
type DeleteGrantParams struct {
	Hostname string
	Username string
	Password string
	GrantID  string
	Timeout  uint64
}

type DeleteGrantResult struct{}

func (util *GrantUtil) DeleteGrant(cmd *cobra.Command, args []string) {
	res, err := util.deleteGrant(&util.deleteGrantParams)
	printResponse(res, err)
}
func (util *GrantUtil) deleteGrant(params *DeleteGrantParams) (*DeleteGrantResult, error) {
	var err error
	res := &DeleteGrantResult{}
	params.Hostname, err = packUserinfo(params.Hostname, params.Username, params.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(params.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	id := strings.ToLower(params.GrantID)
	err = client.NewClient().DeleteGrant(ctx, params.Hostname, id)
	if err != nil {
		return res, err
	}
	return res, err
}

// ListGrants
type ListGrantsParams struct {
	Hostname  string
	Username  string
	Password  string
	Timeout   uint64
	Detail    bool
	AccountID string
}

type ListGrantsResult struct {
	Grants []descr.Grant `json:"grants,omitempty"`
	Rights []string      `json:"rights,omitempty"`
}

func (util *GrantUtil) ListGrants(cmd *cobra.Command, args []string) {
	res, err := util.listGrants(&util.listGrantsParams)
	printResponse(res, err)
}
func (util *GrantUtil) listGrants(params *ListGrantsParams) (*ListGrantsResult, error) {
	var err error
	res := &ListGrantsResult{}
	params.Hostname, err = packUserinfo(params.Hostname, params.Username, params.Password)
	if err != nil {
		return res, err
	}
	timeout := time.Duration(params.Timeout) * time.Second
	ctx, _ := context.WithTimeout(context.Background(), timeout)
	grants := make([]descr.Grant, 0)
	re := regexp.MustCompile(uuidRegex)
	id := strings.ToLower(params.AccountID)
	if re.MatchString(id) {
		grants, err = client.NewClient().ListGrantsByAccountID(ctx, params.Hostname, params.AccountID)
	} else {
		grants, err = client.NewClient().ListGrantsByUsername(ctx, params.Hostname, params.AccountID)
	}
	if err != nil {
		return res, err
	}
	if params.Detail {
		res.Grants = grants
	} else {
		res.Rights = make([]string, 0)
		for _, item := range grants {
			res.Rights = append(res.Rights, item.Right)
		}
	}
	return res, err
}