From 6fd80199bf2ecdb4cac9a6c34f0947f39757331d Mon Sep 17 00:00:00 2001
From: jonas747 <jonasr747@gmail.com>
Date: Wed, 28 Dec 2016 21:29:36 +0100
Subject: [PATCH] Handle MessageDeleteBulk event (#304)

* Handle MessageDeleteBulk event

* Changed State.MessageRemove to use id's

* Revert State.MessageRemove change and add State.messageRemoveById

* Fix linting
---
 eventhandlers.go | 26 ++++++++++++++++++++++++++
 events.go        |  6 ++++++
 state.go         | 15 +++++++++++++--
 3 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/eventhandlers.go b/eventhandlers.go
index b39806b..5decb50 100644
--- a/eventhandlers.go
+++ b/eventhandlers.go
@@ -31,6 +31,7 @@ const (
 	messageAckEventType              = "MESSAGE_ACK"
 	messageCreateEventType           = "MESSAGE_CREATE"
 	messageDeleteEventType           = "MESSAGE_DELETE"
+	messageDeleteBulkEventType       = "MESSAGE_DELETE_BULK"
 	messageReactionAddEventType      = "MESSAGE_REACTION_ADD"
 	messageReactionRemoveEventType   = "MESSAGE_REACTION_REMOVE"
 	messageUpdateEventType           = "MESSAGE_UPDATE"
@@ -562,6 +563,28 @@ func (eh messageDeleteEventHandler) Handle(s *Session, i interface{}) {
 
 var _ EventHandler = messageDeleteEventHandler(nil)
 
+// messageDeleteBulkEventHandler is an event handler for MessageDeleteBulk events.
+type messageDeleteBulkEventHandler func(*Session, *MessageDeleteBulk)
+
+// Type returns the event type for MessageDeleteBulk events.
+func (eh messageDeleteBulkEventHandler) Type() string {
+	return messageDeleteBulkEventType
+}
+
+// New returns a new instance of MessageDeleteBulk.
+func (eh messageDeleteBulkEventHandler) New() interface{} {
+	return &MessageDeleteBulk{}
+}
+
+// Handle is the handler for MessageDeleteBulk events.
+func (eh messageDeleteBulkEventHandler) Handle(s *Session, i interface{}) {
+	if t, ok := i.(*MessageDeleteBulk); ok {
+		eh(s, t)
+	}
+}
+
+var _ EventHandler = messageDeleteBulkEventHandler(nil)
+
 // messageReactionAddEventHandler is an event handler for MessageReactionAdd events.
 type messageReactionAddEventHandler func(*Session, *MessageReactionAdd)
 
@@ -961,6 +984,8 @@ func handlerForInterface(handler interface{}) EventHandler {
 		return messageCreateEventHandler(v)
 	case func(*Session, *MessageDelete):
 		return messageDeleteEventHandler(v)
+	case func(*Session, *MessageDeleteBulk):
+		return messageDeleteBulkEventHandler(v)
 	case func(*Session, *MessageReactionAdd):
 		return messageReactionAddEventHandler(v)
 	case func(*Session, *MessageReactionRemove):
@@ -1020,6 +1045,7 @@ func init() {
 	registerInterfaceProvider(messageAckEventHandler(nil))
 	registerInterfaceProvider(messageCreateEventHandler(nil))
 	registerInterfaceProvider(messageDeleteEventHandler(nil))
+	registerInterfaceProvider(messageDeleteBulkEventHandler(nil))
 	registerInterfaceProvider(messageReactionAddEventHandler(nil))
 	registerInterfaceProvider(messageReactionRemoveEventHandler(nil))
 	registerInterfaceProvider(messageUpdateEventHandler(nil))
diff --git a/events.go b/events.go
index dfb8735..4e4e299 100644
--- a/events.go
+++ b/events.go
@@ -233,3 +233,9 @@ type VoiceServerUpdate struct {
 type VoiceStateUpdate struct {
 	*VoiceState
 }
+
+// MessageDeleteBulk is the data for a MessageDeleteBulk event
+type MessageDeleteBulk struct {
+	Messages  []string `json:"ids"`
+	ChannelID string   `json:"channel_id"`
+}
diff --git a/state.go b/state.go
index 1602603..9d73038 100644
--- a/state.go
+++ b/state.go
@@ -524,7 +524,12 @@ func (s *State) MessageRemove(message *Message) error {
 		return ErrNilState
 	}
 
-	c, err := s.Channel(message.ChannelID)
+	return s.messageRemoveByID(message.ChannelID, message.ID)
+}
+
+// messageRemoveByID removes a message by channelID and messageID from the world state.
+func (s *State) messageRemoveByID(channelID, messageID string) error {
+	c, err := s.Channel(channelID)
 	if err != nil {
 		return err
 	}
@@ -533,7 +538,7 @@ func (s *State) MessageRemove(message *Message) error {
 	defer s.Unlock()
 
 	for i, m := range c.Messages {
-		if m.ID == message.ID {
+		if m.ID == messageID {
 			c.Messages = append(c.Messages[:i], c.Messages[i+1:]...)
 			return nil
 		}
@@ -710,6 +715,12 @@ func (s *State) onInterface(se *Session, i interface{}) (err error) {
 		if s.MaxMessageCount != 0 {
 			err = s.MessageRemove(t.Message)
 		}
+	case *MessageDeleteBulk:
+		if s.MaxMessageCount != 0 {
+			for _, mID := range t.Messages {
+				s.messageRemoveByID(t.ChannelID, mID)
+			}
+		}
 	case *VoiceStateUpdate:
 		if s.TrackVoice {
 			err = s.voiceStateUpdate(t)