// Copyright © 2017-2018 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"

)

var accountUpdateFlags, accountMuteFlags, accountFollowFlags *flag.FlagSet

var accountsOpts struct {

	accountID             int64

	accountUID            string

	unset                 bool     // TODO remove eventually?

	limit, keep           uint     // Limit the results

	sinceID, maxID        int64    // 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().Int64VarP(&accountsOpts.accountID, "account-id", "a", 0, "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().Int64Var(&accountsOpts.sinceID, "since-id", 0, "Request IDs greater than a value")

	accountsCmd.PersistentFlags().Int64Var(&accountsOpts.maxID, "max-id", 0, "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")

	accountBlockSubcommand.Flags().BoolVarP(&accountsOpts.unset, "unset", "", false, "Unblock the account")

	accountMuteSubcommand.Flags().BoolVarP(&accountsOpts.unset, "unset", "", false, "Unmute the account")

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

	accountFollowSubcommand.Flags().BoolVarP(&accountsOpts.unset, "unset", "", false, "Unfollow the account")

	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,

	accountBlockSubcommand,

	accountMuteSubcommand,

	accountRelationshipsSubcommand,

	accountReportsSubcommand,

	accountUpdateSubcommand,

}

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 or unfollow the 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 accountBlockSubcommand = &cobra.Command{

	Use:   "block",

	Short: "Block or unblock the account",

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

		return accountSubcommandsRunE(cmd.Name(), args)

	},

}

var accountMuteSubcommand = &cobra.Command{

	Use:   "mute",

	Short: "Mute or unmute the account",

	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 > 0 {

		aCounter++

	}

	if opt.accountUID != "" {

		aCounter++

	}

	if opt.remoteUID != "" {

		aCounter++

	}

	if userInArg {

		aCounter++

	}

	if aCounter > 1 {

		return errors.New("too many account identifiers provided")

	}

	if userInArg {

		// Is the argument an account ID?

		if n, err := strconv.ParseInt(args[0], 10, 64); err == nil {

			opt.accountID = n

		} else if strings.HasPrefix(args[0], "https://") || strings.HasPrefix(args[0], "http://") {

			// That is not a remote UID scheme

			opt.accountUID = args[0]

		} else if subcmd == "follow" {

			// For the follow API, got to be a remote UID...

			opt.remoteUID = args[0]

			// ... unless it's local (i.e. no '@' in the identifier)...

			fid := strings.TrimLeft(args[0], "@")

			if !strings.ContainsRune(fid, '@') {

				opt.accountUID = args[0]

				opt.remoteUID = ""

			}

		} else {

			// Fall back to account UID