util.go

package bot

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

	"emperror.dev/errors"

	"github.com/mrbentarikau/pagst/common"
	"github.com/mrbentarikau/pagst/common/pubsub"
	"github.com/bwmarrin/snowflake"
	"github.com/jonas747/discordgo/v2"
	"github.com/jonas747/dstate/v4"
	"github.com/mediocregopher/radix/v3"
	"github.com/patrickmn/go-cache"
)

var (
	Cache = cache.New(time.Minute, time.Minute)
)

func init() {
	// Discord epoch
	snowflake.Epoch = 1420070400000

	pubsub.FilterFunc = func(guildID int64) (handle bool) {
		if guildID == -1 || ReadyTracker.IsGuildShardReady(guildID) {
			return true
		}

		return false
	}
}

func ContextSession(ctx context.Context) *discordgo.Session {
	return ctx.Value(common.ContextKeyDiscordSession).(*discordgo.Session)
}

func SendDM(user int64, msg string) error {
	if strings.TrimSpace(msg) == "" {
		return nil
	}

	channel, err := common.BotSession.UserChannelCreate(user)
	if err != nil {
		return err
	}

	_, err = common.BotSession.ChannelMessageSend(channel.ID, msg)
	return err
}

func SendDMEmbed(user int64, embed *discordgo.MessageEmbed) error {
	channel, err := common.BotSession.UserChannelCreate(user)
	if err != nil {
		return err
	}

	_, err = common.BotSession.ChannelMessageSendEmbed(channel.ID, embed)
	return err
}

var (
	ErrStartingUp      = errors.New("Starting up, caches are being filled...")
	ErrGuildNotFound   = errors.New("Guild not found")
	ErrChannelNotFound = errors.New("Channel not found")
)

// AdminOrPerm is the same as AdminOrPermMS but only required a member ID
func AdminOrPerm(guildID int64, channelID int64, userID int64, needed int64) (bool, error) {
	// Ensure the member is in state
	ms, err := GetMember(guildID, userID)
	if err != nil {
		return false, err
	}

	return AdminOrPermMS(guildID, channelID, ms, needed)
}

// AdminOrPermMS checks if the provided member has all of the needed permissions or is a admin
func AdminOrPermMS(guildID int64, channelID int64, ms *dstate.MemberState, needed int64) (bool, error) {
	guild := State.GetGuild(guildID)
	if guild == nil {
		return false, ErrGuildNotFound
	}

	perms, err := guild.GetMemberPermissions(channelID, ms.User.ID, ms.Member.Roles)
	if err != nil {
		return false, err
	}

	if needed != 0 && perms&int64(needed) == int64(needed) {
		return true, nil
	}

	if perms&discordgo.PermissionManageServer != 0 || perms&discordgo.PermissionAdministrator != 0 {
		return true, nil
	}

	return false, nil
}

func SnowflakeToTime(i int64) time.Time {
	flake := snowflake.ID(i)
	t := time.Unix(flake.Time()/1000, 0)
	return t
}

func SetStatus(streaming, status, idle string, activity string) {
	if status == "" {
		r, _ := regexp.Compile(`\d+\.\d+\.\d+`)
		status = "v" + r.FindString(common.VERSION) + " :)"
	}

	err1 := common.RedisPool.Do(radix.Cmd(nil, "SET", "status_streaming", streaming))
	err2 := common.RedisPool.Do(radix.Cmd(nil, "SET", "status_name", status))
	err3 := common.RedisPool.Do(radix.Cmd(nil, "SET", "status_idle", idle))
	err4 := common.RedisPool.Do(radix.Cmd(nil, "SET", "status_activity", activity))
	if err1 != nil {
		logger.WithError(err1).Error("failed setting bot status in redis")
	}

	if err2 != nil {
		logger.WithError(err2).Error("failed setting bot status in redis")
	}
	if err3 != nil {
		logger.WithError(err2).Error("failed setting bot status in redis")
	}
	if err4 != nil {
		logger.WithError(err2).Error("failed setting bot status in redis")
	}

	pubsub.Publish("bot_status_changed", -1, nil)
}

func updateAllShardStatuses() {
	for _, v := range ShardManager.Sessions {
		RefreshStatus(v)
	}

}

// BotProbablyHasPermission returns true if its possible that the bot has the following permission,
// it also returns true if the bot member could not be found or if the guild is not in state (hence, probably)
func BotHasPermission(guildID int64, channelID int64, permission int64) (bool, error) {
	gs := State.GetGuild(guildID)
	if gs == nil {
		return false, ErrGuildNotFound
	}

	return BotHasPermissionGS(gs, channelID, permission)
}

// BotProbablyHasPermissionGS is the same as BotProbablyHasPermission but with a guildstate instead of guildid
func BotHasPermissionGS(gs *dstate.GuildSet, channelID int64, permission int64) (bool, error) {
	ms, err := GetMember(gs.ID, common.BotUser.ID)
	if err != nil {
		logger.WithError(err).WithField("guild", gs.ID).Error("bot isnt a member of a guild?")
		return false, err
	}

	perms, err := gs.GetMemberPermissions(channelID, ms.User.ID, ms.Member.Roles)
	if err != nil {
		if is, _ := dstate.IsChannelNotFound(err); is {
			// we silently ignore unknown channels
			err = nil
		} else {
			logger.WithError(err).WithField("guild", gs.ID).Error("Failed checking perms")
			return false, err
		}
	}

	if perms&int64(permission) == int64(permission) {
		return true, err
	}

	if perms&discordgo.PermissionAdministrator == discordgo.PermissionAdministrator {
		return true, err
	}

	return false, err
}

func BotPermissions(gs *dstate.GuildSet, channelID int64) (int64, error) {
	ms, err := GetMember(gs.ID, common.BotUser.ID)
	if err != nil {
		return 0, err
	}

	perms, err := gs.GetMemberPermissions(channelID, ms.User.ID, ms.Member.Roles)
	if err != nil {
		return 0, err
	}

	return int64(perms), nil
}

func SendMessage(guildID int64, channelID int64, msg string) (permsOK bool, resp *discordgo.Message, err error) {
	hasPerms, err := BotHasPermission(guildID, channelID, discordgo.PermissionSendMessages|discordgo.PermissionReadMessages)
	if !hasPerms {
		return false, nil, err
	}

	resp, err = common.BotSession.ChannelMessageSend(channelID, msg)
	permsOK = true
	return
}

func SendMessageGS(gs *dstate.GuildSet, channelID int64, msg string) (permsOK bool, resp *discordgo.Message, err error) {
	hasPerms, err := BotHasPermissionGS(gs, channelID, discordgo.PermissionSendMessages|discordgo.PermissionReadMessages)
	if !hasPerms {
		return false, nil, err
	}

	resp, err = common.BotSession.ChannelMessageSend(channelID, msg)
	return true, resp, err
}

func SendMessageEmbed(guildID int64, channelID int64, msg *discordgo.MessageEmbed) (permsOK bool, resp *discordgo.Message, err error) {
	hasPerms, err := BotHasPermission(guildID, channelID, discordgo.PermissionSendMessages|discordgo.PermissionReadMessages|discordgo.PermissionEmbedLinks)
	if !hasPerms {
		return false, nil, err
	}

	resp, err = common.BotSession.ChannelMessageSendEmbed(channelID, msg)
	permsOK = true
	return
}

func SendMessageEmbedGS(gs *dstate.GuildSet, channelID int64, msg *discordgo.MessageEmbed) (permsOK bool, resp *discordgo.Message, err error) {
	hasPerms, err := BotHasPermissionGS(gs, channelID, discordgo.PermissionSendMessages|discordgo.PermissionReadMessages|discordgo.PermissionEmbedLinks)
	if !hasPerms {
		return false, nil, err
	}

	resp, err = common.BotSession.ChannelMessageSendEmbed(channelID, msg)
	permsOK = true
	return
}

// GuildShardID returns the shard id for the provided guild id
func guildShardID(guildID int64) int {
	return GuildShardID(getTotalShards(), guildID)
}

// GuildShardID returns the shard id for the provided guild id
func GuildShardID(totalShards, guildID int64) int {
	shardID := int((guildID >> 22) % totalShards)
	return shardID
}

func getTotalShards() int64 {
	return int64(totalShardCount)
}

// NodeID returns this node's ID if using the orchestrator system
func NodeID() string {
	if !UsingOrchestrator || NodeConn == nil {
		return "none"
	}

	return NodeConn.GetIDLock()
}

// RefreshStatus updates the provided sessions status according to the current status set
func RefreshStatus(session *discordgo.Session) {

	var streamingURL string
	var status string
	var idle string
	var activity string
	var idleState *discordgo.UpdateStatusData
	var now = 0
	var gameType discordgo.GameType

	err1 := common.RedisPool.Do(radix.Cmd(&streamingURL, "GET", "status_streaming"))
	err2 := common.RedisPool.Do(radix.Cmd(&status, "GET", "status_name"))
	err3 := common.RedisPool.Do(radix.Cmd(&idle, "GET", "status_idle"))
	err4 := common.RedisPool.Do(radix.Cmd(&activity, "GET", "status_activity"))
	if err1 != nil {
		logger.WithError(err1).Error("failed retrieving bot streaming status")
	}
	if err2 != nil {
		logger.WithError(err2).Error("failed retrieving bot status")
	}
	if err3 != nil {
		logger.WithError(err3).Error("failed retrieving bot status")
	}
	if err4 != nil {
		logger.WithError(err4).Error("failed retrieving bot status")
	}

	if streamingURL != "" {
		gameType = discordgo.GameTypeStreaming
		//session.UpdateStreamingStatus(0, status, streamingURL)
	} else {
		activity = strings.ToLower(activity)
		if activity == "listening" {
			gameType = discordgo.GameTypeListening
		} else if activity == "watching" {
			gameType = discordgo.GameTypeWatching
		} else {
			gameType = discordgo.GameTypeGame
		}
		/*timeMod := math.Mod(float64(time.Now().Hour()), 3)
		if timeMod == 0 {
			//session.UpdateStatus(0, status)
			gameType = discordgo.GameTypeGame
		} else if timeMod == 1 {
			//session.UpdateListeningStatus(status)
			gameType = discordgo.GameTypeListening
		} else {
			gameType = discordgo.GameTypeWatching
		}*/
	}

	if idle != "" {
		idleState = &discordgo.UpdateStatusData{Status: "idle"}
		now = int(time.Now().Unix() * 1000)
		idleState.IdleSince = &now
	} else {
		idleState = &discordgo.UpdateStatusData{Status: "online"}
		idleState.IdleSince = &now
	}
	idleState.Game = &discordgo.Game{Name: status, Type: gameType, URL: streamingURL}
	session.UpdateStatusComplex(*idleState)
}

// IsMemberAbove returns weather ms1 is above ms2 in terms of roles (e.g the highest role of ms1 is higher than the highest role of ms2)
// assumes gs is locked, otherwise race conditions will occur
func IsMemberAbove(gs *dstate.GuildSet, ms1 *dstate.MemberState, ms2 *dstate.MemberState) bool {
	if ms1.User.ID == gs.OwnerID {
		return true
	} else if ms2.User.ID == gs.OwnerID {
		return false
	}

	highestMS1 := MemberHighestRole(gs, ms1)
	highestMS2 := MemberHighestRole(gs, ms2)

	if highestMS1 == nil && highestMS2 == nil {
		// none of them has any roles
		return false
	} else if highestMS1 == nil && highestMS2 != nil {
		// ms1 has no role but ms2 does
		return false
	} else if highestMS1 != nil && highestMS2 == nil {
		// ms1 has a role but not ms2
		return true
	}

	return common.IsRoleAbove(highestMS1, highestMS2)
}

// IsMemberAboveRole returns wether ms is above role
// assumes gs is locked, otherwise race conditions will occur
func IsMemberAboveRole(gs *dstate.GuildSet, ms1 *dstate.MemberState, role *discordgo.Role) bool {
	if ms1.User.ID == gs.OwnerID {
		return true
	}

	highestMSRole := MemberHighestRole(gs, ms1)
	if highestMSRole == nil {
		// can't be above the target role when we have no roles
		return false
	}

	return common.IsRoleAbove(highestMSRole, role)
}

// MemberHighestRole returns the highest role for ms, assumes gs is rlocked, otherwise race conditions will occur
func MemberHighestRole(gs *dstate.GuildSet, ms *dstate.MemberState) *discordgo.Role {
	var highest *discordgo.Role
	for _, rID := range ms.Member.Roles {
		for _, r := range gs.Roles {
			if r.ID != rID {
				continue
			}

			if highest == nil || common.IsRoleAbove(&r, highest) {
				highest = &r
			}

			break
		}
	}

	return highest
}

func GetUsers(guildID int64, ids ...int64) []*discordgo.User {
	resp := make([]*discordgo.User, 0, len(ids))
	for _, id := range ids {
		m := State.GetMember(guildID, id)
		if m != nil {
			resp = append(resp, &m.User)
			continue
		}

		user, err := common.BotSession.User(id)

		if err != nil {
			logger.WithError(err).WithField("guild", guildID).Error("failed retrieving user from api")
			resp = append(resp, &discordgo.User{
				ID:       id,
				Username: "Unknown (" + strconv.FormatInt(id, 10) + ")",
			})
			continue
		}

		resp = append(resp, user)
	}

	return resp
}

type GSCacheKey string

func CheckDiscordErrRetry(err error) bool {
	if err == nil {
		return false
	}

	err = errors.Cause(err)

	if cast, ok := err.(*discordgo.RESTError); ok {
		if cast.Message != nil && cast.Message.Code != 0 {
			// proper discord response, don't retry
			return false
		}
	}

	if err == ErrGuildNotFound {
		return false
	}

	// an unknown error unrelated to the discord api occured (503's for example) attempt a retry
	return true
}

func IsNormalUserMessage(msg *discordgo.Message) bool {
	if msg.Author == nil || msg.Author.ID == common.BotUser.ID || msg.WebhookID != 0 || msg.Author.Discriminator == "0000" || (msg.Member == nil && msg.GuildID != 0) {
		// message edits can have a nil author, those are embed edits
		// check against a discrim of 0000 to avoid some cases on webhook messages where webhook_id is 0, even tough its a webhook
		// discrim is in those 0000 which is a invalid user discrim. (atleast when i was testing)
		return false
	}

	return true
}