// Copyright © 2017-2023 Mikael Berthe <mikael@lilotux.net>

//

// Licensed under the MIT license.

// Please see the LICENSE file is this directory.

package cmd

import (

	"os"

	"strconv"

	"strings"

	"github.com/pkg/errors"

	"github.com/spf13/cobra"

	flag "github.com/spf13/pflag"

	"github.com/McKael/madon/v3"

)

var accountUpdateFlags, accountMuteFlags, accountFollowFlags *flag.FlagSet

var accountsOpts struct {

	accountID             madon.ActivityID

	accountUID            string

	limit, keep           uint             // Limit the results

	sinceID, maxID        madon.ActivityID // Query boundaries

	all                   bool             // Try to fetch all results

	onlyMedia, onlyPinned bool             // For acccount statuses

	excludeReplies        bool             // For acccount statuses

	remoteUID             string           // For account follow

	reblogs               bool             // For account follow

	acceptFR, rejectFR    bool             // For account follow_requests

	list                  bool             // For account follow_requests/reports

	accountIDs            string           // For account relationships

	statusIDs             string           // For account reports

	comment               string           // For account reports

	displayName, note     string           // For account update

	profileFields         []string         // For account update

	avatar, header        string           // For account update

	defaultLanguage       string           // For account update

	defaultPrivacy        string           // For account update

	defaultSensitive      bool             // For account update

	locked, bot           bool             // For account update

	muteNotifications     bool             // For account mute

	following             bool             // For account search

}

func init() {

	RootCmd.AddCommand(accountsCmd)

	// Subcommands

	accountsCmd.AddCommand(accountSubcommands...)

	// Global flags

	accountsCmd.PersistentFlags().StringVarP(&accountsOpts.accountID, "account-id", "a", "", "Account ID number")

	accountsCmd.PersistentFlags().StringVarP(&accountsOpts.accountUID, "user-id", "u", "", "Account user ID")

	accountsCmd.PersistentFlags().UintVarP(&accountsOpts.limit, "limit", "l", 0, "Limit number of API results")

	accountsCmd.PersistentFlags().UintVarP(&accountsOpts.keep, "keep", "k", 0, "Limit number of results")

	accountsCmd.PersistentFlags().StringVar(&accountsOpts.sinceID, "since-id", "", "Request IDs greater than a value")

	accountsCmd.PersistentFlags().StringVar(&accountsOpts.maxID, "max-id", "", "Request IDs less (or equal) than a value")

	accountsCmd.PersistentFlags().BoolVar(&accountsOpts.all, "all", false, "Fetch all results")

	// Subcommand flags

	accountStatusesSubcommand.Flags().BoolVar(&accountsOpts.onlyPinned, "pinned", false, "Only statuses that have been pinned")

	accountStatusesSubcommand.Flags().BoolVar(&accountsOpts.onlyMedia, "only-media", false, "Only statuses with media attachments")

	accountStatusesSubcommand.Flags().BoolVar(&accountsOpts.excludeReplies, "exclude-replies", false, "Exclude replies to other statuses")

	accountFollowRequestsSubcommand.Flags().BoolVar(&accountsOpts.list, "list", false, "List pending follow requests")

	accountFollowRequestsSubcommand.Flags().BoolVar(&accountsOpts.acceptFR, "accept", false, "Accept the follow request from the account ID")

	accountFollowRequestsSubcommand.Flags().BoolVar(&accountsOpts.rejectFR, "reject", false, "Reject the follow request from the account ID")

	accountMuteSubcommand.Flags().BoolVarP(&accountsOpts.muteNotifications, "notifications", "", true, "Mute the notifications")

	accountFollowSubcommand.Flags().BoolVarP(&accountsOpts.reblogs, "show-reblogs", "", true, "Follow account's boosts")

	accountFollowSubcommand.Flags().StringVarP(&accountsOpts.remoteUID, "remote", "r", "", "Follow remote account (user@domain)")

	accountRelationshipsSubcommand.Flags().StringVar(&accountsOpts.accountIDs, "account-ids", "", "Comma-separated list of account IDs")

	accountReportsSubcommand.Flags().StringVar(&accountsOpts.statusIDs, "status-ids", "", "Comma-separated list of status IDs")

	accountReportsSubcommand.Flags().StringVar(&accountsOpts.comment, "comment", "", "Report comment")

	accountReportsSubcommand.Flags().BoolVar(&accountsOpts.list, "list", false, "List current user reports")

	accountSearchSubcommand.Flags().BoolVar(&accountsOpts.following, "following", false, "Restrict search to accounts you are following")

	accountUpdateSubcommand.Flags().StringVar(&accountsOpts.displayName, "display-name", "", "User display name")

	accountUpdateSubcommand.Flags().StringVar(&accountsOpts.note, "note", "", "User note (a.k.a. bio)")

	accountUpdateSubcommand.Flags().StringVar(&accountsOpts.avatar, "avatar", "", "User avatar image")

	accountUpdateSubcommand.Flags().StringVar(&accountsOpts.header, "header", "", "User header image")

	accountUpdateSubcommand.Flags().StringArrayVar(&accountsOpts.profileFields, "profile-field", nil, "Profile metadata field (NAME=VALUE)")

	accountUpdateSubcommand.Flags().StringVar(&accountsOpts.defaultLanguage, "default-language", "", "Default toots language (iso 639 code)")

	accountUpdateSubcommand.Flags().StringVar(&accountsOpts.defaultPrivacy, "default-privacy", "", "Default toot privacy (public, unlisted, private)")

	accountUpdateSubcommand.Flags().BoolVar(&accountsOpts.defaultSensitive, "default-sensitive", false, "Mark medias as sensitive by default")

	accountUpdateSubcommand.Flags().BoolVar(&accountsOpts.locked, "locked", false, "Following account requires approval")

	accountUpdateSubcommand.Flags().BoolVar(&accountsOpts.bot, "bot", false, "Set as service (automated) account")

	// Those variables will be used to check if the options were

	// explicitly set or not

	accountUpdateFlags = accountUpdateSubcommand.Flags()

	accountMuteFlags = accountMuteSubcommand.Flags()

	accountFollowFlags = accountFollowSubcommand.Flags()

}

// accountsCmd represents the accounts command

// This command does nothing without a subcommand

var accountsCmd = &cobra.Command{

	Use:     "account [--account-id ID] subcommand",

	Aliases: []string{"accounts"},

	Short:   "Account-related functions",

	//Long:    `TBW...`, // TODO

}

// Note: Some account subcommands are not defined in this file.

var accountSubcommands = []*cobra.Command{

	&cobra.Command{

		Use: "show",

		Long: `Displays the details about the requested account.

If no account ID is specified, the current user account is used.`,

		Aliases: []string{"display"},

		Short:   "Display the account",

		Example: `  madonctl account show   # Display your own account

  madonctl account show --account-id 1234

  madonctl account show --user-id Gargron@mastodon.social

  madonctl account show --user-id https://mastodon.social/@Gargron

  madonctl account show 1234

  madonctl account show Gargron@mastodon.social

  madonctl account show https://mastodon.social/@Gargron

`,

		RunE: func(cmd *cobra.Command, args []string) error {

			return accountSubcommandsRunE(cmd.Name(), args)

		},

	},

	&cobra.Command{

		Use:   "followers",

		Short: "Display the accounts following the specified account",

		RunE: func(cmd *cobra.Command, args []string) error {

			return accountSubcommandsRunE(cmd.Name(), args)

		},

	},

	&cobra.Command{

		Use:   "following",

		Short: "Display the accounts followed by the specified account",

		RunE: func(cmd *cobra.Command, args []string) error {

			return accountSubcommandsRunE(cmd.Name(), args)

		},

	},

	&cobra.Command{

		Use:     "favourites",

		Aliases: []string{"favorites", "favourited", "favorited"},

		Short:   "Display the user's favourites",

		RunE: func(cmd *cobra.Command, args []string) error {

			return accountSubcommandsRunE(cmd.Name(), args)

		},

	},

	&cobra.Command{

		Use:     "blocks",

		Aliases: []string{"blocked"},

		Short:   "Display the user's blocked accounts",

		RunE: func(cmd *cobra.Command, args []string) error {

			return accountSubcommandsRunE(cmd.Name(), args)

		},

	},

	&cobra.Command{

		Use:     "mutes",

		Aliases: []string{"muted"},

		Short:   "Display the user's muted accounts",

		RunE: func(cmd *cobra.Command, args []string) error {

			return accountSubcommandsRunE(cmd.Name(), args)

		},

	},

	accountSearchSubcommand,

	accountStatusesSubcommand,

	accountFollowRequestsSubcommand,

	accountFollowSubcommand,

	accountUnfollowSubcommand,

	accountBlockSubcommand,

	accountUnblockSubcommand,

	accountMuteSubcommand,

	accountUnmuteSubcommand,

	accountPinSubcommand,

	accountUnpinSubcommand,

	accountRelationshipsSubcommand,

	accountReportsSubcommand,

	accountUpdateSubcommand,

	accountListEndorsementsSubcommand,

}

var accountSearchSubcommand = &cobra.Command{

	Use:   "search TEXT",

	Short: "Search for user accounts",

	Long: `Search for user accounts.

This command will lookup an account remotely if the search term is in the

@domain format and not yet known to the server.`,

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountStatusesSubcommand = &cobra.Command{

	Use:     "statuses",

	Aliases: []string{"st"},

	Short:   "Display the account statuses",

	Example: `  madonctl account statuses

  madonctl account statuses 404                         # local account numeric ID

  madonctl account statuses @McKael                     # local account

  madonctl account statuses Gargron@mastodon.social     # remote (known account)

  madonctl account statuses https://mastodon.social/@Gargron  # any account URL

`,

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountFollowRequestsSubcommand = &cobra.Command{

	Use:     "follow-requests",

	Aliases: []string{"follow-request", "fr"},

	Short:   "List, accept or deny a follow request",

	Example: `  madonctl account follow-requests --list

  madonctl account follow-requests --account-id X --accept

  madonctl account follow-requests --account-id Y --reject`,

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountFollowSubcommand = &cobra.Command{

	Use:   "follow",

	Short: "Follow an account",

	Example: `# Argument type can be set explicitly:

  madonctl account follow --account-id 1234

  madonctl account follow --remote Gargron@mastodon.social

# Or argument type can be guessed:

  madonctl account follow 4800

  madonctl account follow Gargron@mastodon.social --show-reblogs=false

  madonctl account follow https://mastodon.social/@Gargron

`,

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountUnfollowSubcommand = &cobra.Command{

	Use:   "unfollow",

	Short: "Stop following an account",

	Example: `  madonctl account unfollow --account-id 1234

Same usage as madonctl follow.

`,

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountBlockSubcommand = &cobra.Command{

	Use:   "block",

	Short: "Block the account",

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountUnblockSubcommand = &cobra.Command{

	Use:   "unblock",

	Short: "Unblock the account",

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountMuteSubcommand = &cobra.Command{

	Use:   "mute",

	Short: "Mute the account",

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountUnmuteSubcommand = &cobra.Command{

	Use:   "unmute",

	Short: "Unmute the account",

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountPinSubcommand = &cobra.Command{

	Use:     "pin",

	Short:   "Endorse (pin) the account",

	Aliases: []string{"endorse"},

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountUnpinSubcommand = &cobra.Command{

	Use:     "unpin",

	Short:   "Cancel endorsement of an account",

	Aliases: []string{"disavow"},

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountListEndorsementsSubcommand = &cobra.Command{

	Use:     "pinned",

	Short:   `Display the list of pinned (endorsed) accounts`,

	Aliases: []string{"list-endorsements", "get-endorsements"},

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountRelationshipsSubcommand = &cobra.Command{

	Use:   "relationships --account-ids ACC1,ACC2...",

	Short: "List relationships with the accounts",

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountReportsSubcommand = &cobra.Command{

	Use:   "reports",

	Short: "List reports or report a user account",

	Example: `  madonctl account reports --list

  madonctl account reports --account-id ACCOUNT --status-ids ID... --comment TEXT`,

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountUpdateSubcommand = &cobra.Command{

	Use:   "update",

	Short: "Update connected user account",

	Long: `Update connected user account

All flags are optional (set to an empty string if you want to delete a field).

The options --avatar and --header should be paths to image files.

Please note the avatar and header images cannot be removed, they can only be

replaced.`,

	Example: `  madonctl account update --display-name "Mr President"

  madonctl account update --note "I like madonctl"

  madonctl account update --avatar happyface.png`,

	RunE: func(cmd *cobra.Command, args []string) error {

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

// accountSubcommandsRunE is a generic function for status subcommands

func accountSubcommandsRunE(subcmd string, args []string) error {

	opt := accountsOpts

	if len(args) > 1 {

		return errors.New("too many arguments")

	}

	userInArg := false

	if len(args) == 1 {

		if len(args[0]) > 0 {

			userInArg = true

		} else {

			return errors.New("invalid argument (empty)")

		}

	}

	// Check account is provided in only one way

	aCounter := 0

	if opt.accountID != "" {

		aCounter++

	}

	if opt.accountUID != "" {

		aCounter++

	}

	if opt.remoteUID != "" {

		aCounter++

	}

	if userInArg {

		aCounter++