github.com/meowstercatel/discordgo@v0.0.0-20250615204139-29b43d676735/state.go (about)

     1  // Discordgo - Discord bindings for Go
     2  // Available at https://github.com/bwmarrin/discordgo
     3  
     4  // Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>.  All rights reserved.
     5  // Use of this source code is governed by a BSD-style
     6  // license that can be found in the LICENSE file.
     7  
     8  // This file contains code related to state tracking.  If enabled, state
     9  // tracking will capture the initial READY packet and many other websocket
    10  // events and maintain an in-memory state of guilds, channels, users, and
    11  // so forth.  This information can be accessed through the Session.State struct.
    12  
    13  package discordgo
    14  
    15  import (
    16  	"errors"
    17  	"sort"
    18  	"sync"
    19  )
    20  
    21  // ErrNilState is returned when the state is nil.
    22  var ErrNilState = errors.New("state not instantiated, please use discordgo.New() or assign Session.State")
    23  
    24  // ErrStateNotFound is returned when the state cache
    25  // requested is not found
    26  var ErrStateNotFound = errors.New("state cache not found")
    27  
    28  // ErrMessageIncompletePermissions is returned when the message
    29  // requested for permissions does not contain enough data to
    30  // generate the permissions.
    31  var ErrMessageIncompletePermissions = errors.New("message incomplete, unable to determine permissions")
    32  
    33  // A State contains the current known state.
    34  // As discord sends this in a READY blob, it seems reasonable to simply
    35  // use that struct as the data store.
    36  type State struct {
    37  	sync.RWMutex
    38  	Ready
    39  
    40  	// MaxMessageCount represents how many messages per channel the state will store.
    41  	MaxMessageCount    int
    42  	TrackChannels      bool
    43  	TrackThreads       bool
    44  	TrackEmojis        bool
    45  	TrackStickers      bool
    46  	TrackMembers       bool
    47  	TrackThreadMembers bool
    48  	TrackRoles         bool
    49  	TrackVoice         bool
    50  	TrackPresences     bool
    51  
    52  	guildMap   map[string]*Guild
    53  	channelMap map[string]*Channel
    54  	memberMap  map[string]map[string]*Member
    55  }
    56  
    57  // NewState creates an empty state.
    58  func NewState() *State {
    59  	return &State{
    60  		Ready: Ready{
    61  			PrivateChannels: []*Channel{},
    62  			Guilds:          []*Guild{},
    63  		},
    64  		TrackChannels:      true,
    65  		TrackThreads:       true,
    66  		TrackEmojis:        true,
    67  		TrackStickers:      true,
    68  		TrackMembers:       true,
    69  		TrackThreadMembers: true,
    70  		TrackRoles:         true,
    71  		TrackVoice:         true,
    72  		TrackPresences:     true,
    73  		guildMap:           make(map[string]*Guild),
    74  		channelMap:         make(map[string]*Channel),
    75  		memberMap:          make(map[string]map[string]*Member),
    76  	}
    77  }
    78  
    79  func (s *State) createMemberMap(guild *Guild) {
    80  	members := make(map[string]*Member)
    81  	for _, m := range guild.Members {
    82  		members[m.User.ID] = m
    83  	}
    84  	s.memberMap[guild.ID] = members
    85  }
    86  
    87  // GuildAdd adds a guild to the current world state, or
    88  // updates it if it already exists.
    89  func (s *State) GuildAdd(guild *Guild) error {
    90  	if s == nil {
    91  		return ErrNilState
    92  	}
    93  
    94  	s.Lock()
    95  	defer s.Unlock()
    96  
    97  	// Update the channels to point to the right guild, adding them to the channelMap as we go
    98  	for _, c := range guild.Channels {
    99  		s.channelMap[c.ID] = c
   100  	}
   101  
   102  	// Add all the threads to the state in case of thread sync list.
   103  	for _, t := range guild.Threads {
   104  		s.channelMap[t.ID] = t
   105  	}
   106  
   107  	// If this guild contains a new member slice, we must regenerate the member map so the pointers stay valid
   108  	if guild.Members != nil {
   109  		s.createMemberMap(guild)
   110  	} else if _, ok := s.memberMap[guild.ID]; !ok {
   111  		// Even if we have no new member slice, we still initialize the member map for this guild if it doesn't exist
   112  		s.memberMap[guild.ID] = make(map[string]*Member)
   113  	}
   114  
   115  	if g, ok := s.guildMap[guild.ID]; ok {
   116  		// We are about to replace `g` in the state with `guild`, but first we need to
   117  		// make sure we preserve any fields that the `guild` doesn't contain from `g`.
   118  		if guild.MemberCount == 0 {
   119  			guild.MemberCount = g.MemberCount
   120  		}
   121  		if guild.Roles == nil {
   122  			guild.Roles = g.Roles
   123  		}
   124  		if guild.Emojis == nil {
   125  			guild.Emojis = g.Emojis
   126  		}
   127  		if guild.Members == nil {
   128  			guild.Members = g.Members
   129  		}
   130  		if guild.Presences == nil {
   131  			guild.Presences = g.Presences
   132  		}
   133  		if guild.Channels == nil {
   134  			guild.Channels = g.Channels
   135  		}
   136  		if guild.Threads == nil {
   137  			guild.Threads = g.Threads
   138  		}
   139  		if guild.VoiceStates == nil {
   140  			guild.VoiceStates = g.VoiceStates
   141  		}
   142  		*g = *guild
   143  		return nil
   144  	}
   145  
   146  	s.Guilds = append(s.Guilds, guild)
   147  	s.guildMap[guild.ID] = guild
   148  
   149  	return nil
   150  }
   151  
   152  // GuildRemove removes a guild from current world state.
   153  func (s *State) GuildRemove(guild *Guild) error {
   154  	if s == nil {
   155  		return ErrNilState
   156  	}
   157  
   158  	_, err := s.Guild(guild.ID)
   159  	if err != nil {
   160  		return err
   161  	}
   162  
   163  	s.Lock()
   164  	defer s.Unlock()
   165  
   166  	delete(s.guildMap, guild.ID)
   167  
   168  	for i, g := range s.Guilds {
   169  		if g.ID == guild.ID {
   170  			s.Guilds = append(s.Guilds[:i], s.Guilds[i+1:]...)
   171  			return nil
   172  		}
   173  	}
   174  
   175  	return nil
   176  }
   177  
   178  // Guild gets a guild by ID.
   179  // Useful for querying if @me is in a guild:
   180  //    _, err := discordgo.Session.State.Guild(guildID)
   181  //	  isInGuild := err == nil
   182  func (s *State) Guild(guildID string) (*Guild, error) {
   183  	if s == nil {
   184  		return nil, ErrNilState
   185  	}
   186  
   187  	s.RLock()
   188  	defer s.RUnlock()
   189  
   190  	if g, ok := s.guildMap[guildID]; ok {
   191  		return g, nil
   192  	}
   193  
   194  	return nil, ErrStateNotFound
   195  }
   196  
   197  func (s *State) presenceAdd(guildID string, presence *Presence) error {
   198  	guild, ok := s.guildMap[guildID]
   199  	if !ok {
   200  		return ErrStateNotFound
   201  	}
   202  
   203  	for i, p := range guild.Presences {
   204  		if p.User.ID == presence.User.ID {
   205  			//guild.Presences[i] = presence
   206  
   207  			//Update status
   208  			guild.Presences[i].Activities = presence.Activities
   209  			if presence.Status != "" {
   210  				guild.Presences[i].Status = presence.Status
   211  			}
   212  			if presence.ClientStatus.Desktop != "" {
   213  				guild.Presences[i].ClientStatus.Desktop = presence.ClientStatus.Desktop
   214  			}
   215  			if presence.ClientStatus.Mobile != "" {
   216  				guild.Presences[i].ClientStatus.Mobile = presence.ClientStatus.Mobile
   217  			}
   218  			if presence.ClientStatus.Web != "" {
   219  				guild.Presences[i].ClientStatus.Web = presence.ClientStatus.Web
   220  			}
   221  
   222  			//Update the optionally sent user information
   223  			//ID Is a mandatory field so you should not need to check if it is empty
   224  			guild.Presences[i].User.ID = presence.User.ID
   225  
   226  			if presence.User.Avatar != "" {
   227  				guild.Presences[i].User.Avatar = presence.User.Avatar
   228  			}
   229  			if presence.User.Discriminator != "" {
   230  				guild.Presences[i].User.Discriminator = presence.User.Discriminator
   231  			}
   232  			if presence.User.Email != "" {
   233  				guild.Presences[i].User.Email = presence.User.Email
   234  			}
   235  			if presence.User.Token != "" {
   236  				guild.Presences[i].User.Token = presence.User.Token
   237  			}
   238  			if presence.User.Username != "" {
   239  				guild.Presences[i].User.Username = presence.User.Username
   240  			}
   241  
   242  			return nil
   243  		}
   244  	}
   245  
   246  	guild.Presences = append(guild.Presences, presence)
   247  	return nil
   248  }
   249  
   250  // PresenceAdd adds a presence to the current world state, or
   251  // updates it if it already exists.
   252  func (s *State) PresenceAdd(guildID string, presence *Presence) error {
   253  	if s == nil {
   254  		return ErrNilState
   255  	}
   256  
   257  	s.Lock()
   258  	defer s.Unlock()
   259  
   260  	return s.presenceAdd(guildID, presence)
   261  }
   262  
   263  // PresenceRemove removes a presence from the current world state.
   264  func (s *State) PresenceRemove(guildID string, presence *Presence) error {
   265  	if s == nil {
   266  		return ErrNilState
   267  	}
   268  
   269  	guild, err := s.Guild(guildID)
   270  	if err != nil {
   271  		return err
   272  	}
   273  
   274  	s.Lock()
   275  	defer s.Unlock()
   276  
   277  	for i, p := range guild.Presences {
   278  		if p.User.ID == presence.User.ID {
   279  			guild.Presences = append(guild.Presences[:i], guild.Presences[i+1:]...)
   280  			return nil
   281  		}
   282  	}
   283  
   284  	return ErrStateNotFound
   285  }
   286  
   287  // Presence gets a presence by ID from a guild.
   288  func (s *State) Presence(guildID, userID string) (*Presence, error) {
   289  	if s == nil {
   290  		return nil, ErrNilState
   291  	}
   292  
   293  	guild, err := s.Guild(guildID)
   294  	if err != nil {
   295  		return nil, err
   296  	}
   297  
   298  	for _, p := range guild.Presences {
   299  		if p.User.ID == userID {
   300  			return p, nil
   301  		}
   302  	}
   303  
   304  	return nil, ErrStateNotFound
   305  }
   306  
   307  // TODO: Consider moving Guild state update methods onto *Guild.
   308  
   309  func (s *State) memberAdd(member *Member) error {
   310  	guild, ok := s.guildMap[member.GuildID]
   311  	if !ok {
   312  		return ErrStateNotFound
   313  	}
   314  
   315  	members, ok := s.memberMap[member.GuildID]
   316  	if !ok {
   317  		return ErrStateNotFound
   318  	}
   319  
   320  	m, ok := members[member.User.ID]
   321  	if !ok {
   322  		members[member.User.ID] = member
   323  		guild.Members = append(guild.Members, member)
   324  	} else {
   325  		// We are about to replace `m` in the state with `member`, but first we need to
   326  		// make sure we preserve any fields that the `member` doesn't contain from `m`.
   327  		if member.JoinedAt.IsZero() {
   328  			member.JoinedAt = m.JoinedAt
   329  		}
   330  		*m = *member
   331  	}
   332  	return nil
   333  }
   334  
   335  // MemberAdd adds a member to the current world state, or
   336  // updates it if it already exists.
   337  func (s *State) MemberAdd(member *Member) error {
   338  	if s == nil {
   339  		return ErrNilState
   340  	}
   341  
   342  	s.Lock()
   343  	defer s.Unlock()
   344  
   345  	return s.memberAdd(member)
   346  }
   347  
   348  // MemberRemove removes a member from current world state.
   349  func (s *State) MemberRemove(member *Member) error {
   350  	if s == nil {
   351  		return ErrNilState
   352  	}
   353  
   354  	guild, err := s.Guild(member.GuildID)
   355  	if err != nil {
   356  		return err
   357  	}
   358  
   359  	s.Lock()
   360  	defer s.Unlock()
   361  
   362  	members, ok := s.memberMap[member.GuildID]
   363  	if !ok {
   364  		return ErrStateNotFound
   365  	}
   366  
   367  	_, ok = members[member.User.ID]
   368  	if !ok {
   369  		return ErrStateNotFound
   370  	}
   371  	delete(members, member.User.ID)
   372  
   373  	for i, m := range guild.Members {
   374  		if m.User.ID == member.User.ID {
   375  			guild.Members = append(guild.Members[:i], guild.Members[i+1:]...)
   376  			return nil
   377  		}
   378  	}
   379  
   380  	return ErrStateNotFound
   381  }
   382  
   383  // Member gets a member by ID from a guild.
   384  func (s *State) Member(guildID, userID string) (*Member, error) {
   385  	if s == nil {
   386  		return nil, ErrNilState
   387  	}
   388  
   389  	s.RLock()
   390  	defer s.RUnlock()
   391  
   392  	members, ok := s.memberMap[guildID]
   393  	if !ok {
   394  		return nil, ErrStateNotFound
   395  	}
   396  
   397  	m, ok := members[userID]
   398  	if ok {
   399  		return m, nil
   400  	}
   401  
   402  	return nil, ErrStateNotFound
   403  }
   404  
   405  // RoleAdd adds a role to the current world state, or
   406  // updates it if it already exists.
   407  func (s *State) RoleAdd(guildID string, role *Role) error {
   408  	if s == nil {
   409  		return ErrNilState
   410  	}
   411  
   412  	guild, err := s.Guild(guildID)
   413  	if err != nil {
   414  		return err
   415  	}
   416  
   417  	s.Lock()
   418  	defer s.Unlock()
   419  
   420  	for i, r := range guild.Roles {
   421  		if r.ID == role.ID {
   422  			guild.Roles[i] = role
   423  			return nil
   424  		}
   425  	}
   426  
   427  	guild.Roles = append(guild.Roles, role)
   428  	return nil
   429  }
   430  
   431  // RoleRemove removes a role from current world state by ID.
   432  func (s *State) RoleRemove(guildID, roleID string) error {
   433  	if s == nil {
   434  		return ErrNilState
   435  	}
   436  
   437  	guild, err := s.Guild(guildID)
   438  	if err != nil {
   439  		return err
   440  	}
   441  
   442  	s.Lock()
   443  	defer s.Unlock()
   444  
   445  	for i, r := range guild.Roles {
   446  		if r.ID == roleID {
   447  			guild.Roles = append(guild.Roles[:i], guild.Roles[i+1:]...)
   448  			return nil
   449  		}
   450  	}
   451  
   452  	return ErrStateNotFound
   453  }
   454  
   455  // Role gets a role by ID from a guild.
   456  func (s *State) Role(guildID, roleID string) (*Role, error) {
   457  	if s == nil {
   458  		return nil, ErrNilState
   459  	}
   460  
   461  	guild, err := s.Guild(guildID)
   462  	if err != nil {
   463  		return nil, err
   464  	}
   465  
   466  	s.RLock()
   467  	defer s.RUnlock()
   468  
   469  	for _, r := range guild.Roles {
   470  		if r.ID == roleID {
   471  			return r, nil
   472  		}
   473  	}
   474  
   475  	return nil, ErrStateNotFound
   476  }
   477  
   478  // ChannelAdd adds a channel to the current world state, or
   479  // updates it if it already exists.
   480  // Channels may exist either as PrivateChannels or inside
   481  // a guild.
   482  func (s *State) ChannelAdd(channel *Channel) error {
   483  	if s == nil {
   484  		return ErrNilState
   485  	}
   486  
   487  	s.Lock()
   488  	defer s.Unlock()
   489  
   490  	// If the channel exists, replace it
   491  	if c, ok := s.channelMap[channel.ID]; ok {
   492  		if channel.Messages == nil {
   493  			channel.Messages = c.Messages
   494  		}
   495  		if channel.PermissionOverwrites == nil {
   496  			channel.PermissionOverwrites = c.PermissionOverwrites
   497  		}
   498  		if channel.ThreadMetadata == nil {
   499  			channel.ThreadMetadata = c.ThreadMetadata
   500  		}
   501  
   502  		*c = *channel
   503  		return nil
   504  	}
   505  
   506  	if channel.Type == ChannelTypeDM || channel.Type == ChannelTypeGroupDM {
   507  		s.PrivateChannels = append(s.PrivateChannels, channel)
   508  		s.channelMap[channel.ID] = channel
   509  		return nil
   510  	}
   511  
   512  	guild, ok := s.guildMap[channel.GuildID]
   513  	if !ok {
   514  		return ErrStateNotFound
   515  	}
   516  
   517  	if channel.IsThread() {
   518  		guild.Threads = append(guild.Threads, channel)
   519  	} else {
   520  		guild.Channels = append(guild.Channels, channel)
   521  	}
   522  
   523  	s.channelMap[channel.ID] = channel
   524  
   525  	return nil
   526  }
   527  
   528  // ChannelRemove removes a channel from current world state.
   529  func (s *State) ChannelRemove(channel *Channel) error {
   530  	if s == nil {
   531  		return ErrNilState
   532  	}
   533  
   534  	_, err := s.Channel(channel.ID)
   535  	if err != nil {
   536  		return err
   537  	}
   538  
   539  	if channel.Type == ChannelTypeDM || channel.Type == ChannelTypeGroupDM {
   540  		s.Lock()
   541  		defer s.Unlock()
   542  
   543  		for i, c := range s.PrivateChannels {
   544  			if c.ID == channel.ID {
   545  				s.PrivateChannels = append(s.PrivateChannels[:i], s.PrivateChannels[i+1:]...)
   546  				break
   547  			}
   548  		}
   549  		delete(s.channelMap, channel.ID)
   550  		return nil
   551  	}
   552  
   553  	guild, err := s.Guild(channel.GuildID)
   554  	if err != nil {
   555  		return err
   556  	}
   557  
   558  	s.Lock()
   559  	defer s.Unlock()
   560  
   561  	if channel.IsThread() {
   562  		for i, t := range guild.Threads {
   563  			if t.ID == channel.ID {
   564  				guild.Threads = append(guild.Threads[:i], guild.Threads[i+1:]...)
   565  				break
   566  			}
   567  		}
   568  	} else {
   569  		for i, c := range guild.Channels {
   570  			if c.ID == channel.ID {
   571  				guild.Channels = append(guild.Channels[:i], guild.Channels[i+1:]...)
   572  				break
   573  			}
   574  		}
   575  	}
   576  
   577  	delete(s.channelMap, channel.ID)
   578  
   579  	return nil
   580  }
   581  
   582  // ThreadListSync syncs guild threads with provided ones.
   583  func (s *State) ThreadListSync(tls *ThreadListSync) error {
   584  	guild, err := s.Guild(tls.GuildID)
   585  	if err != nil {
   586  		return err
   587  	}
   588  
   589  	s.Lock()
   590  	defer s.Unlock()
   591  
   592  	// This algorithm filters out archived or
   593  	// threads which are children of channels in channelIDs
   594  	// and then it adds all synced threads to guild threads and cache
   595  	index := 0
   596  outer:
   597  	for _, t := range guild.Threads {
   598  		if !t.ThreadMetadata.Archived && tls.ChannelIDs != nil {
   599  			for _, v := range tls.ChannelIDs {
   600  				if t.ParentID == v {
   601  					delete(s.channelMap, t.ID)
   602  					continue outer
   603  				}
   604  			}
   605  			guild.Threads[index] = t
   606  			index++
   607  		} else {
   608  			delete(s.channelMap, t.ID)
   609  		}
   610  	}
   611  	guild.Threads = guild.Threads[:index]
   612  	for _, t := range tls.Threads {
   613  		s.channelMap[t.ID] = t
   614  		guild.Threads = append(guild.Threads, t)
   615  	}
   616  
   617  	for _, m := range tls.Members {
   618  		if c, ok := s.channelMap[m.ID]; ok {
   619  			c.Member = m
   620  		}
   621  	}
   622  
   623  	return nil
   624  }
   625  
   626  // ThreadMembersUpdate updates thread members list
   627  func (s *State) ThreadMembersUpdate(tmu *ThreadMembersUpdate) error {
   628  	thread, err := s.Channel(tmu.ID)
   629  	if err != nil {
   630  		return err
   631  	}
   632  	s.Lock()
   633  	defer s.Unlock()
   634  
   635  	for idx, member := range thread.Members {
   636  		for _, removedMember := range tmu.RemovedMembers {
   637  			if member.ID == removedMember {
   638  				thread.Members = append(thread.Members[:idx], thread.Members[idx+1:]...)
   639  				break
   640  			}
   641  		}
   642  	}
   643  
   644  	for _, addedMember := range tmu.AddedMembers {
   645  		thread.Members = append(thread.Members, addedMember.ThreadMember)
   646  		if addedMember.Member != nil {
   647  			err = s.memberAdd(addedMember.Member)
   648  			if err != nil {
   649  				return err
   650  			}
   651  		}
   652  		if addedMember.Presence != nil {
   653  			err = s.presenceAdd(tmu.GuildID, addedMember.Presence)
   654  			if err != nil {
   655  				return err
   656  			}
   657  		}
   658  	}
   659  	thread.MemberCount = tmu.MemberCount
   660  
   661  	return nil
   662  }
   663  
   664  // ThreadMemberUpdate sets or updates member data for the current user.
   665  func (s *State) ThreadMemberUpdate(mu *ThreadMemberUpdate) error {
   666  	thread, err := s.Channel(mu.ID)
   667  	if err != nil {
   668  		return err
   669  	}
   670  
   671  	thread.Member = mu.ThreadMember
   672  	return nil
   673  }
   674  
   675  // Channel gets a channel by ID, it will look in all guilds and private channels.
   676  func (s *State) Channel(channelID string) (*Channel, error) {
   677  	if s == nil {
   678  		return nil, ErrNilState
   679  	}
   680  
   681  	s.RLock()
   682  	defer s.RUnlock()
   683  
   684  	if c, ok := s.channelMap[channelID]; ok {
   685  		return c, nil
   686  	}
   687  
   688  	return nil, ErrStateNotFound
   689  }
   690  
   691  // Emoji returns an emoji for a guild and emoji id.
   692  func (s *State) Emoji(guildID, emojiID string) (*Emoji, error) {
   693  	if s == nil {
   694  		return nil, ErrNilState
   695  	}
   696  
   697  	guild, err := s.Guild(guildID)
   698  	if err != nil {
   699  		return nil, err
   700  	}
   701  
   702  	s.RLock()
   703  	defer s.RUnlock()
   704  
   705  	for _, e := range guild.Emojis {
   706  		if e.ID == emojiID {
   707  			return e, nil
   708  		}
   709  	}
   710  
   711  	return nil, ErrStateNotFound
   712  }
   713  
   714  // EmojiAdd adds an emoji to the current world state.
   715  func (s *State) EmojiAdd(guildID string, emoji *Emoji) error {
   716  	if s == nil {
   717  		return ErrNilState
   718  	}
   719  
   720  	guild, err := s.Guild(guildID)
   721  	if err != nil {
   722  		return err
   723  	}
   724  
   725  	s.Lock()
   726  	defer s.Unlock()
   727  
   728  	for i, e := range guild.Emojis {
   729  		if e.ID == emoji.ID {
   730  			guild.Emojis[i] = emoji
   731  			return nil
   732  		}
   733  	}
   734  
   735  	guild.Emojis = append(guild.Emojis, emoji)
   736  	return nil
   737  }
   738  
   739  // EmojisAdd adds multiple emojis to the world state.
   740  func (s *State) EmojisAdd(guildID string, emojis []*Emoji) error {
   741  	for _, e := range emojis {
   742  		if err := s.EmojiAdd(guildID, e); err != nil {
   743  			return err
   744  		}
   745  	}
   746  	return nil
   747  }
   748  
   749  // MessageAdd adds a message to the current world state, or updates it if it exists.
   750  // If the channel cannot be found, the message is discarded.
   751  // Messages are kept in state up to s.MaxMessageCount per channel.
   752  func (s *State) MessageAdd(message *Message) error {
   753  	if s == nil {
   754  		return ErrNilState
   755  	}
   756  
   757  	c, err := s.Channel(message.ChannelID)
   758  	if err != nil {
   759  		return err
   760  	}
   761  
   762  	s.Lock()
   763  	defer s.Unlock()
   764  
   765  	// If the message exists, merge in the new message contents.
   766  	for _, m := range c.Messages {
   767  		if m.ID == message.ID {
   768  			if message.Content != "" {
   769  				m.Content = message.Content
   770  			}
   771  			if message.EditedTimestamp != nil {
   772  				m.EditedTimestamp = message.EditedTimestamp
   773  			}
   774  			if message.Mentions != nil {
   775  				m.Mentions = message.Mentions
   776  			}
   777  			if message.Embeds != nil {
   778  				m.Embeds = message.Embeds
   779  			}
   780  			if message.Attachments != nil {
   781  				m.Attachments = message.Attachments
   782  			}
   783  			if !message.Timestamp.IsZero() {
   784  				m.Timestamp = message.Timestamp
   785  			}
   786  			if message.Author != nil {
   787  				m.Author = message.Author
   788  			}
   789  			if message.Components != nil {
   790  				m.Components = message.Components
   791  			}
   792  
   793  			return nil
   794  		}
   795  	}
   796  
   797  	c.Messages = append(c.Messages, message)
   798  
   799  	if len(c.Messages) > s.MaxMessageCount {
   800  		c.Messages = c.Messages[len(c.Messages)-s.MaxMessageCount:]
   801  	}
   802  
   803  	return nil
   804  }
   805  
   806  // MessageRemove removes a message from the world state.
   807  func (s *State) MessageRemove(message *Message) error {
   808  	if s == nil {
   809  		return ErrNilState
   810  	}
   811  
   812  	return s.messageRemoveByID(message.ChannelID, message.ID)
   813  }
   814  
   815  // messageRemoveByID removes a message by channelID and messageID from the world state.
   816  func (s *State) messageRemoveByID(channelID, messageID string) error {
   817  	c, err := s.Channel(channelID)
   818  	if err != nil {
   819  		return err
   820  	}
   821  
   822  	s.Lock()
   823  	defer s.Unlock()
   824  
   825  	for i, m := range c.Messages {
   826  		if m.ID == messageID {
   827  			c.Messages = append(c.Messages[:i], c.Messages[i+1:]...)
   828  
   829  			return nil
   830  		}
   831  	}
   832  
   833  	return ErrStateNotFound
   834  }
   835  
   836  func (s *State) voiceStateUpdate(update *VoiceStateUpdate) error {
   837  	guild, err := s.Guild(update.GuildID)
   838  	if err != nil {
   839  		return err
   840  	}
   841  
   842  	s.Lock()
   843  	defer s.Unlock()
   844  
   845  	// Handle Leaving Channel
   846  	if update.ChannelID == "" {
   847  		for i, state := range guild.VoiceStates {
   848  			if state.UserID == update.UserID {
   849  				guild.VoiceStates = append(guild.VoiceStates[:i], guild.VoiceStates[i+1:]...)
   850  				return nil
   851  			}
   852  		}
   853  	} else {
   854  		for i, state := range guild.VoiceStates {
   855  			if state.UserID == update.UserID {
   856  				guild.VoiceStates[i] = update.VoiceState
   857  				return nil
   858  			}
   859  		}
   860  
   861  		guild.VoiceStates = append(guild.VoiceStates, update.VoiceState)
   862  	}
   863  
   864  	return nil
   865  }
   866  
   867  // VoiceState gets a VoiceState by guild and user ID.
   868  func (s *State) VoiceState(guildID, userID string) (*VoiceState, error) {
   869  	if s == nil {
   870  		return nil, ErrNilState
   871  	}
   872  
   873  	guild, err := s.Guild(guildID)
   874  	if err != nil {
   875  		return nil, err
   876  	}
   877  
   878  	for _, state := range guild.VoiceStates {
   879  		if state.UserID == userID {
   880  			return state, nil
   881  		}
   882  	}
   883  
   884  	return nil, ErrStateNotFound
   885  }
   886  
   887  // Message gets a message by channel and message ID.
   888  func (s *State) Message(channelID, messageID string) (*Message, error) {
   889  	if s == nil {
   890  		return nil, ErrNilState
   891  	}
   892  
   893  	c, err := s.Channel(channelID)
   894  	if err != nil {
   895  		return nil, err
   896  	}
   897  
   898  	s.RLock()
   899  	defer s.RUnlock()
   900  
   901  	for _, m := range c.Messages {
   902  		if m.ID == messageID {
   903  			return m, nil
   904  		}
   905  	}
   906  
   907  	return nil, ErrStateNotFound
   908  }
   909  
   910  // OnReady takes a Ready event and updates all internal state.
   911  func (s *State) onReady(se *Session, r *Ready) (err error) {
   912  	if s == nil {
   913  		return ErrNilState
   914  	}
   915  
   916  	s.Lock()
   917  	defer s.Unlock()
   918  
   919  	// We must track at least the current user for Voice, even
   920  	// if state is disabled, store the bare essentials.
   921  	if !se.StateEnabled {
   922  		ready := Ready{
   923  			Version:     r.Version,
   924  			SessionID:   r.SessionID,
   925  			User:        r.User,
   926  			Shard:       r.Shard,
   927  			Application: r.Application,
   928  		}
   929  
   930  		s.Ready = ready
   931  
   932  		return nil
   933  	}
   934  
   935  	s.Ready = *r
   936  
   937  	for _, g := range s.Guilds {
   938  		s.guildMap[g.ID] = g
   939  		s.createMemberMap(g)
   940  
   941  		for _, c := range g.Channels {
   942  			s.channelMap[c.ID] = c
   943  		}
   944  	}
   945  
   946  	for _, c := range s.PrivateChannels {
   947  		s.channelMap[c.ID] = c
   948  	}
   949  
   950  	return nil
   951  }
   952  
   953  // OnInterface handles all events related to states.
   954  func (s *State) OnInterface(se *Session, i interface{}) (err error) {
   955  	if s == nil {
   956  		return ErrNilState
   957  	}
   958  
   959  	r, ok := i.(*Ready)
   960  	if ok {
   961  		return s.onReady(se, r)
   962  	}
   963  
   964  	if !se.StateEnabled {
   965  		return nil
   966  	}
   967  
   968  	switch t := i.(type) {
   969  	case *GuildCreate:
   970  		err = s.GuildAdd(t.Guild)
   971  	case *GuildUpdate:
   972  		err = s.GuildAdd(t.Guild)
   973  	case *GuildDelete:
   974  		var old *Guild
   975  		old, err = s.Guild(t.ID)
   976  		if err == nil {
   977  			oldCopy := *old
   978  			t.BeforeDelete = &oldCopy
   979  		}
   980  
   981  		err = s.GuildRemove(t.Guild)
   982  	case *GuildMemberAdd:
   983  		var guild *Guild
   984  		// Updates the MemberCount of the guild.
   985  		guild, err = s.Guild(t.Member.GuildID)
   986  		if err != nil {
   987  			return err
   988  		}
   989  		guild.MemberCount++
   990  
   991  		// Caches member if tracking is enabled.
   992  		if s.TrackMembers {
   993  			err = s.MemberAdd(t.Member)
   994  		}
   995  	case *GuildMemberUpdate:
   996  		if s.TrackMembers {
   997  			var old *Member
   998  			old, err = s.Member(t.GuildID, t.User.ID)
   999  			if err == nil {
  1000  				oldCopy := *old
  1001  				t.BeforeUpdate = &oldCopy
  1002  			}
  1003  
  1004  			err = s.MemberAdd(t.Member)
  1005  		}
  1006  	case *GuildMemberRemove:
  1007  		var guild *Guild
  1008  		// Updates the MemberCount of the guild.
  1009  		guild, err = s.Guild(t.Member.GuildID)
  1010  		if err != nil {
  1011  			return err
  1012  		}
  1013  		guild.MemberCount--
  1014  
  1015  		// Removes member from the cache if tracking is enabled.
  1016  		if s.TrackMembers {
  1017  			err = s.MemberRemove(t.Member)
  1018  		}
  1019  	case *GuildMembersChunk:
  1020  		if s.TrackMembers {
  1021  			for i := range t.Members {
  1022  				t.Members[i].GuildID = t.GuildID
  1023  				err = s.MemberAdd(t.Members[i])
  1024  			}
  1025  		}
  1026  
  1027  		if s.TrackPresences {
  1028  			for _, p := range t.Presences {
  1029  				err = s.PresenceAdd(t.GuildID, p)
  1030  			}
  1031  		}
  1032  	case *GuildRoleCreate:
  1033  		if s.TrackRoles {
  1034  			err = s.RoleAdd(t.GuildID, t.Role)
  1035  		}
  1036  	case *GuildRoleUpdate:
  1037  		if s.TrackRoles {
  1038  			err = s.RoleAdd(t.GuildID, t.Role)
  1039  		}
  1040  	case *GuildRoleDelete:
  1041  		if s.TrackRoles {
  1042  			err = s.RoleRemove(t.GuildID, t.RoleID)
  1043  		}
  1044  	case *GuildEmojisUpdate:
  1045  		if s.TrackEmojis {
  1046  			var guild *Guild
  1047  			guild, err = s.Guild(t.GuildID)
  1048  			if err != nil {
  1049  				return err
  1050  			}
  1051  			s.Lock()
  1052  			defer s.Unlock()
  1053  			guild.Emojis = t.Emojis
  1054  		}
  1055  	case *GuildStickersUpdate:
  1056  		if s.TrackStickers {
  1057  			var guild *Guild
  1058  			guild, err = s.Guild(t.GuildID)
  1059  			if err != nil {
  1060  				return err
  1061  			}
  1062  			s.Lock()
  1063  			defer s.Unlock()
  1064  			guild.Stickers = t.Stickers
  1065  		}
  1066  	case *ChannelCreate:
  1067  		if s.TrackChannels {
  1068  			err = s.ChannelAdd(t.Channel)
  1069  		}
  1070  	case *ChannelUpdate:
  1071  		if s.TrackChannels {
  1072  			old, err := s.Channel(t.ID)
  1073  			if err == nil {
  1074  				oldCopy := *old
  1075  				t.BeforeUpdate = &oldCopy
  1076  			}
  1077  			err = s.ChannelAdd(t.Channel)
  1078  		}
  1079  	case *ChannelDelete:
  1080  		if s.TrackChannels {
  1081  			err = s.ChannelRemove(t.Channel)
  1082  		}
  1083  	case *ThreadCreate:
  1084  		if s.TrackThreads {
  1085  			err = s.ChannelAdd(t.Channel)
  1086  		}
  1087  	case *ThreadUpdate:
  1088  		if s.TrackThreads {
  1089  			old, err := s.Channel(t.ID)
  1090  			if err == nil {
  1091  				oldCopy := *old
  1092  				t.BeforeUpdate = &oldCopy
  1093  			}
  1094  			err = s.ChannelAdd(t.Channel)
  1095  		}
  1096  	case *ThreadDelete:
  1097  		if s.TrackThreads {
  1098  			err = s.ChannelRemove(t.Channel)
  1099  		}
  1100  	case *ThreadMemberUpdate:
  1101  		if s.TrackThreads {
  1102  			err = s.ThreadMemberUpdate(t)
  1103  		}
  1104  	case *ThreadMembersUpdate:
  1105  		if s.TrackThreadMembers {
  1106  			err = s.ThreadMembersUpdate(t)
  1107  		}
  1108  	case *ThreadListSync:
  1109  		if s.TrackThreads {
  1110  			err = s.ThreadListSync(t)
  1111  		}
  1112  	case *MessageCreate:
  1113  		if s.MaxMessageCount != 0 {
  1114  			err = s.MessageAdd(t.Message)
  1115  		}
  1116  	case *MessageUpdate:
  1117  		if s.MaxMessageCount != 0 {
  1118  			var old *Message
  1119  			old, err = s.Message(t.ChannelID, t.ID)
  1120  			if err == nil {
  1121  				oldCopy := *old
  1122  				t.BeforeUpdate = &oldCopy
  1123  			}
  1124  
  1125  			err = s.MessageAdd(t.Message)
  1126  		}
  1127  	case *MessageDelete:
  1128  		if s.MaxMessageCount != 0 {
  1129  			var old *Message
  1130  			old, err = s.Message(t.ChannelID, t.ID)
  1131  			if err == nil {
  1132  				oldCopy := *old
  1133  				t.BeforeDelete = &oldCopy
  1134  			}
  1135  
  1136  			err = s.MessageRemove(t.Message)
  1137  		}
  1138  	case *MessageDeleteBulk:
  1139  		if s.MaxMessageCount != 0 {
  1140  			for _, mID := range t.Messages {
  1141  				s.messageRemoveByID(t.ChannelID, mID)
  1142  			}
  1143  		}
  1144  	case *VoiceStateUpdate:
  1145  		if s.TrackVoice {
  1146  			var old *VoiceState
  1147  			old, err = s.VoiceState(t.GuildID, t.UserID)
  1148  			if err == nil {
  1149  				oldCopy := *old
  1150  				t.BeforeUpdate = &oldCopy
  1151  			}
  1152  
  1153  			err = s.voiceStateUpdate(t)
  1154  		}
  1155  	case *PresenceUpdate:
  1156  		if s.TrackPresences {
  1157  			s.PresenceAdd(t.GuildID, &t.Presence)
  1158  		}
  1159  		if s.TrackMembers {
  1160  			if t.Status == StatusOffline {
  1161  				return
  1162  			}
  1163  
  1164  			var m *Member
  1165  			m, err = s.Member(t.GuildID, t.User.ID)
  1166  
  1167  			if err != nil {
  1168  				// Member not found; this is a user coming online
  1169  				m = &Member{
  1170  					GuildID: t.GuildID,
  1171  					User:    t.User,
  1172  				}
  1173  			} else {
  1174  				if t.User.Username != "" {
  1175  					m.User.Username = t.User.Username
  1176  				}
  1177  			}
  1178  
  1179  			err = s.MemberAdd(m)
  1180  		}
  1181  
  1182  	}
  1183  
  1184  	return
  1185  }
  1186  
  1187  // UserChannelPermissions returns the permission of a user in a channel.
  1188  // userID    : The ID of the user to calculate permissions for.
  1189  // channelID : The ID of the channel to calculate permission for.
  1190  func (s *State) UserChannelPermissions(userID, channelID string) (apermissions int64, err error) {
  1191  	if s == nil {
  1192  		return 0, ErrNilState
  1193  	}
  1194  
  1195  	channel, err := s.Channel(channelID)
  1196  	if err != nil {
  1197  		return
  1198  	}
  1199  
  1200  	guild, err := s.Guild(channel.GuildID)
  1201  	if err != nil {
  1202  		return
  1203  	}
  1204  
  1205  	member, err := s.Member(guild.ID, userID)
  1206  	if err != nil {
  1207  		return
  1208  	}
  1209  
  1210  	return memberPermissions(guild, channel, userID, member.Roles), nil
  1211  }
  1212  
  1213  // MessagePermissions returns the permissions of the author of the message
  1214  // in the channel in which it was sent.
  1215  func (s *State) MessagePermissions(message *Message) (apermissions int64, err error) {
  1216  	if s == nil {
  1217  		return 0, ErrNilState
  1218  	}
  1219  
  1220  	if message.Author == nil || message.Member == nil {
  1221  		return 0, ErrMessageIncompletePermissions
  1222  	}
  1223  
  1224  	channel, err := s.Channel(message.ChannelID)
  1225  	if err != nil {
  1226  		return
  1227  	}
  1228  
  1229  	guild, err := s.Guild(channel.GuildID)
  1230  	if err != nil {
  1231  		return
  1232  	}
  1233  
  1234  	return memberPermissions(guild, channel, message.Author.ID, message.Member.Roles), nil
  1235  }
  1236  
  1237  // UserColor returns the color of a user in a channel.
  1238  // While colors are defined at a Guild level, determining for a channel is more useful in message handlers.
  1239  // 0 is returned in cases of error, which is the color of @everyone.
  1240  // userID    : The ID of the user to calculate the color for.
  1241  // channelID   : The ID of the channel to calculate the color for.
  1242  func (s *State) UserColor(userID, channelID string) int {
  1243  	if s == nil {
  1244  		return 0
  1245  	}
  1246  
  1247  	channel, err := s.Channel(channelID)
  1248  	if err != nil {
  1249  		return 0
  1250  	}
  1251  
  1252  	guild, err := s.Guild(channel.GuildID)
  1253  	if err != nil {
  1254  		return 0
  1255  	}
  1256  
  1257  	member, err := s.Member(guild.ID, userID)
  1258  	if err != nil {
  1259  		return 0
  1260  	}
  1261  
  1262  	return firstRoleColorColor(guild, member.Roles)
  1263  }
  1264  
  1265  // MessageColor returns the color of the author's name as displayed
  1266  // in the client associated with this message.
  1267  func (s *State) MessageColor(message *Message) int {
  1268  	if s == nil {
  1269  		return 0
  1270  	}
  1271  
  1272  	if message.Member == nil || message.Member.Roles == nil {
  1273  		return 0
  1274  	}
  1275  
  1276  	channel, err := s.Channel(message.ChannelID)
  1277  	if err != nil {
  1278  		return 0
  1279  	}
  1280  
  1281  	guild, err := s.Guild(channel.GuildID)
  1282  	if err != nil {
  1283  		return 0
  1284  	}
  1285  
  1286  	return firstRoleColorColor(guild, message.Member.Roles)
  1287  }
  1288  
  1289  func firstRoleColorColor(guild *Guild, memberRoles []string) int {
  1290  	roles := Roles(guild.Roles)
  1291  	sort.Sort(roles)
  1292  
  1293  	for _, role := range roles {
  1294  		for _, roleID := range memberRoles {
  1295  			if role.ID == roleID {
  1296  				if role.Color != 0 {
  1297  					return role.Color
  1298  				}
  1299  			}
  1300  		}
  1301  	}
  1302  
  1303  	for _, role := range roles {
  1304  		if role.ID == guild.ID {
  1305  			return role.Color
  1306  		}
  1307  	}
  1308  
  1309  	return 0
  1310  }