package client import ( "fmt" "math/rand" "strings" "sync" "time" "git.kirsle.net/apps/barertc/pkg/log" "git.kirsle.net/apps/barertc/pkg/messages" "github.com/aichaos/rivescript-go" "github.com/aichaos/rivescript-go/lang/javascript" ) const ( // Number of recent chat messages to hold onto. ScrollbackBuffer = 500 // How long for the lobby room to be quiet before you'll greet the // next person who joins the room. LobbyDeadThreshold = 20 * time.Minute // Minimum time between greeting users who enter chat, IF we will // do so. When the rush hour picks up, don't spam too much and // greet everybody who enters. AutoGreetGlobalCooldown = 8 * time.Minute // Minimum time between re-greeting the same user. AutoGreetUserCooldown = 45 * time.Minute // Default (lobby) channel. LobbyChannel = "lobby" ) // BotHandlers holds onto a set of handler functions for the BareBot. type BotHandlers struct { rs *rivescript.RiveScript client *Client // Cache for the Who's Online list. whoList []messages.WhoList whoMu sync.RWMutex // Auto-greeter cooldowns autoGreet map[string]time.Time autoGreetCooldown time.Time // global cooldown between auto-greets autoGreetMu sync.RWMutex // MessageID history. Keep a buffer of recent messages sent in // case the robot needs to report one (which should generally // happen immediately, if it does). messageBuf []messages.Message messageBufMu sync.RWMutex // Main (lobby) channel quiet detector. Record the time of the last // message seen: if the lobby has been quiet for a long time, and // someone new joins the room, greet them - overriding the global // autoGreet cooldown or ignoring the number of chatters in the room. lobbyChannelLastUpdated time.Time // Store the reactions we have previously sent by messageID, // so we don't accidentally take back our own reactions. reactions map[int64]map[string]interface{} reactionsMu sync.Mutex // Deadlock detection (deadlock_watch.go): record time of last successful // ping to self, to detect when the server is deadlocked. deadlockLastOK time.Time } // SetupChatbot configures a sensible set of default handlers for the BareBot application. // // This function is very opinionated and is designed for the BareBot program. It will // initialize a RiveScript bot using the brain found at the "./brain" folder, and register // handlers for the various WebSocket messages on chat. func (c *Client) SetupChatbot() error { var handler = &BotHandlers{ client: c, rs: rivescript.New(&rivescript.Config{ UTF8: true, }), autoGreet: map[string]time.Time{}, messageBuf: []messages.Message{}, reactions: map[int64]map[string]interface{}{}, } // Add JavaScript support. handler.rs.SetHandler("javascript", javascript.New(handler.rs)) // Attach RiveScript object macros. handler.setObjectMacros() log.Info("Initializing RiveScript brain") if err := handler.rs.LoadDirectory("./brain"); err != nil { return fmt.Errorf("RiveScript LoadDirectory: %s", err) } if err := handler.rs.SortReplies(); err != nil { return fmt.Errorf("RiveScript SortReplies: %s", err) } // Set all the handler funcs. c.OnWho = handler.OnWho c.OnMe = handler.OnMe c.OnMessage = handler.OnMessage c.OnReact = handler.OnReact c.OnPresence = handler.OnPresence c.OnRing = handler.OnRing c.OnOpen = handler.OnOpen c.OnWatch = handler.OnWatch c.OnUnwatch = handler.OnUnwatch c.OnError = handler.OnError c.OnDisconnect = handler.OnDisconnect c.OnPing = handler.OnPing // Watch for deadlocks. go handler.watchForDeadlock() return nil } // OnWho handles Who List updates in chat. func (h *BotHandlers) OnWho(msg messages.Message) { log.Info("OnWho: %d people online", len(msg.WhoList)) h.whoMu.Lock() defer h.whoMu.Unlock() h.whoList = msg.WhoList } // OnMe handles user status updates pushed by the server (renamed username, nsfw flag added) func (h *BotHandlers) OnMe(msg messages.Message) { // Has the server changed our name? if h.client.Username() != msg.Username { log.Error("OnMe: the server has renamed us to '%s'", msg.Username) h.client.claims.Subject = msg.Username } } // Buffer a message seen on chat for a while. func (h *BotHandlers) cacheMessage(msg messages.Message) { h.messageBufMu.Lock() defer h.messageBufMu.Unlock() h.messageBuf = append(h.messageBuf, msg) if len(h.messageBuf) > ScrollbackBuffer { h.messageBuf = h.messageBuf[len(h.messageBuf)-ScrollbackBuffer:] } } // Get a message by ID from the recent message buffer. func (h *BotHandlers) getMessageByID(msgID int64) (messages.Message, bool) { h.messageBufMu.RLock() defer h.messageBufMu.RUnlock() for _, msg := range h.messageBuf { if msg.MessageID == msgID { return msg, true } } return messages.Message{}, false } // OnMessage handles chat messages. func (h *BotHandlers) OnMessage(msg messages.Message) { // Strip HTML. msg.Message = StripHTML(msg.Message) // Ignore echoed message from ourself. if msg.Username == h.client.Username() { h.onMessageFromSelf(msg) return } // Cache it in our message buffer. h.cacheMessage(msg) // Record the last seen if this is the lobby channel. if msg.Channel == LobbyChannel { h.lobbyChannelLastUpdated = time.Now() } // Do we send a reply to this? var ( sendReply bool replyPrefix string // original topic the user was in, in case of PublicChannel match // so we can put the user back in their original topic after. userTopic string ) if strings.HasPrefix(msg.Channel, "@") { // Direct message: always reply. sendReply = true // Log message to console. log.Info("DM [%s] %s", msg.Username, msg.Message) } else { // Log message to console. log.Info("[%s to #%s] %s", msg.Username, msg.Channel, msg.Message) // Public channel message. See if they at-mention the robot. if ok, message := AtMentioned(h.client, msg.Message); ok { msg.Message = message sendReply = true replyPrefix = fmt.Sprintf("**@%s:** ", msg.Username) } else { // We were not at mentioned: can reply anyway but put us // into the PublicChannel topic. log.Error("trying for PublicChannel") if topic, err := h.rs.GetUservar(msg.Username, "topic"); err == nil { userTopic = topic } else { log.Error("Couldn't get topic for %s: %s", msg.Username, err) userTopic = "random" } h.rs.SetUservar(msg.Username, "topic", "PublicChannel") sendReply = true // Restore the user's original topic? defer func() { if userTopic != "" { log.Error("Set user topic back to: %s", userTopic) h.rs.SetUservar(msg.Username, "topic", userTopic) } }() } } // Do we reply? if sendReply { // Set their user variables. h.SetUserVariables(msg) reply, err := h.rs.Reply(msg.Username, msg.Message) log.Error("REPLY: %s", reply) if NoReply(reply) { return } // Delay a moment before responding. time.Sleep(500 * time.Millisecond) if err != nil { h.client.Send(messages.Message{ Action: messages.ActionMessage, Channel: msg.Channel, Username: msg.Username, Message: fmt.Sprintf("[RiveScript Error] %s", err), }) } else { h.client.Send(messages.Message{ Action: messages.ActionMessage, Channel: msg.Channel, Username: msg.Username, Message: replyPrefix + reply, }) } } } // OnTakeback handles users requesting to take back messages they had sent. func (h *BotHandlers) OnTakeback(msg messages.Message) { log.Info("Takeback: user %s takes back msgID %d", msg.Username, msg.MessageID) } // OnReact handles emoji reactions to messages. func (h *BotHandlers) OnReact(msg messages.Message) { log.Info("React: user %s reacts with %s on msgID %d", msg.Username, msg.Message, msg.MessageID) // Ignore echoed message from ourself. if msg.Username == h.client.Username() { return } // Sanity check that we can actually see the message being reacted to: so we don't // upvote reactions posted to messageIDs in other peoples' DM threads. if _, ok := h.getMessageByID(msg.MessageID); !ok { return } // If we have already reacted to it, don't react again. h.reactionsMu.Lock() defer h.reactionsMu.Unlock() if _, ok := h.reactions[msg.MessageID]; !ok { h.reactions[msg.MessageID] = map[string]interface{}{} } if _, ok := h.reactions[msg.MessageID][msg.Message]; ok { log.Info("I already reacted %s on message %d", msg.Message, msg.MessageID) return // already upvoted it } else { h.reactions[msg.MessageID][msg.Message] = nil } // Half the time, agree with the reaction. if rand.Intn(100) > 50 { go func() { time.Sleep(2500 * time.Millisecond) h.client.Send(messages.Message{ Action: messages.ActionReact, MessageID: msg.MessageID, Message: msg.Message, }) }() } } // OnPresence handles join/exit room events as well as kicked/banned messages. func (h *BotHandlers) OnPresence(msg messages.Message) { log.Info("Presence: [%s] %s", msg.Username, msg.Message) // Ignore echoed message from ourself. if msg.Username == h.client.Username() { return } // A join message? if strings.Contains(msg.Message, "has joined the room") { // Do we force a greeting? (if lobby channel has been quiet) var forceGreeting = time.Since(h.lobbyChannelLastUpdated) > LobbyDeadThreshold // Global auto-greet cooldown. if time.Now().Before(h.autoGreetCooldown) { return } h.autoGreetCooldown = time.Now().Add(AutoGreetGlobalCooldown) // Don't greet the same user too often in case of bouncing. h.autoGreetMu.Lock() if timeout, ok := h.autoGreet[msg.Username]; ok { if time.Now().Before(timeout) && !forceGreeting { // Do not greet again. log.Info("Do not auto-greet again: too soon") h.autoGreetMu.Unlock() return } } h.autoGreet[msg.Username] = time.Now().Add(AutoGreetUserCooldown) h.autoGreetMu.Unlock() // Send a message to the lobby. TODO: configurable channel name. time.Sleep(5 * time.Second) // Ensure they are still online. if _, ok := h.GetUser(msg.Username); !ok { log.Error("Wanted to auto-greet [%s] but they left the room!", msg.Username) return } // Set their user variables. h.SetUserVariables(msg) if forceGreeting { h.rs.SetGlobal("numUsersOnline", "0") } reply, err := h.rs.Reply(msg.Username, "/greet") if err == nil && !NoReply(reply) { h.client.Send(messages.Message{ Action: messages.ActionMessage, Channel: LobbyChannel, Username: msg.Username, Message: reply, }) } } } // OnRing handles somebody requesting to open our webcam. func (h *BotHandlers) OnRing(msg messages.Message) { } // OnOpen handles the server echo to us wanting to open another user's webcam. func (h *BotHandlers) OnOpen(msg messages.Message) { } // OnWatch handles somebody adding themselves to our Watching list. func (h *BotHandlers) OnWatch(msg messages.Message) { } // OnUnwatch handles somebody removing themselves from our Watching list. func (h *BotHandlers) OnUnwatch(msg messages.Message) { } // OnError handles ChatServer messages from the backend. func (h *BotHandlers) OnError(msg messages.Message) { log.Error("[%s] %s", msg.Username, msg.Message) } // OnDisconnect handles kick messages from the backend (told: do not reconnect). func (h *BotHandlers) OnDisconnect(msg messages.Message) { } // OnPing handles server keepalive pings. func (h *BotHandlers) OnPing(msg messages.Message) { }