Fixing what broke during making it modular

sneed/client.go

@@ -1,14 +1,27 @@
 package sneed
 
 import (
+	"encoding/json"
 	"fmt"
+	"html"
 	"log"
 	"net/http"
+	"regexp"
 	"sync"
 	"time"
 
 	"github.com/gorilla/websocket"
 	"local/sneedchatbridge/cookie"
+	"local/sneedchatbridge/utils"
+)
+
+const (
+	ProcessedCacheSize     = 250
+	ReconnectInterval      = 7 * time.Second
+	MappingCacheSize       = 1000
+	MappingCleanupInterval = 5 * time.Minute
+	MappingMaxAge          = 1 * time.Hour
+	OutboundMatchWindow    = 60 * time.Second
 )
 
 type Client struct {
@@ -23,17 +36,45 @@ type Client struct {
 	lastMessage time.Time
 	stopCh      chan struct{}
 	wg          sync.WaitGroup
+
+	// processed
+	processedMu         sync.Mutex
+	processedMessageIDs []int
+
+	messageEditDates *utils.BoundedMap
+
+	// event callbacks
+	OnMessage    func(map[string]interface{})
+	OnEdit       func(int, string)
+	OnDelete     func(int)
+	OnConnect    func()
+	OnDisconnect func()
+
+	// outbound correlation for echo suppression / mapping
+	recentOutboundIter func() []map[string]interface{}
+	mapDiscordSneed    func(int, int, string)
+
+	bridgeUserID   int
+	bridgeUsername string
 }
 
 func NewClient(roomID int, cookieSvc *cookie.RefreshService) *Client {
 	return &Client{
-		wsURL:   "wss://kiwifarms.st:9443/chat.ws",
-		roomID:  roomID,
-		cookies: cookieSvc,
-		stopCh:  make(chan struct{}),
+		wsURL:               "wss://kiwifarms.st:9443/chat.ws",
+		roomID:              roomID,
+		cookies:             cookieSvc,
+		stopCh:              make(chan struct{}),
+		processedMessageIDs: make([]int, 0, ProcessedCacheSize),
+		messageEditDates:    utils.NewBoundedMap(MappingCacheSize, MappingMaxAge),
+		lastMessage:         time.Now(),
 	}
 }
 
+func (c *Client) SetBridgeIdentity(userID int, username string) {
+	c.bridgeUserID = userID
+	c.bridgeUsername = username
+}
+
 func (c *Client) Connect() error {
 	c.mu.Lock()
 	if c.connected {
@@ -43,7 +84,9 @@ func (c *Client) Connect() error {
 	c.mu.Unlock()
 
 	headers := http.Header{}
-	headers.Add("Cookie", c.cookies.GetCurrentCookie())
+	if ck := c.cookies.GetCurrentCookie(); ck != "" {
+		headers.Add("Cookie", ck)
+	}
 
 	log.Printf("Connecting to Sneedchat room %d", c.roomID)
 	conn, _, err := websocket.DefaultDialer.Dial(c.wsURL, headers)
@@ -63,6 +106,9 @@ func (c *Client) Connect() error {
 	go c.joinRoom()
 
 	log.Printf("✅ Successfully connected to Sneedchat room %d", c.roomID)
+	if c.OnConnect != nil {
+		c.OnConnect()
+	}
 	return nil
 }
 
@@ -95,7 +141,7 @@ func (c *Client) readLoop() {
 			return
 		}
 		c.lastMessage = time.Now()
-		_ = message // plug in your existing JSON handling if needed
+		c.handleIncoming(string(message))
 	}
 }
 
@@ -147,8 +193,11 @@ func (c *Client) handleDisconnect() {
 	}
 	c.mu.Unlock()
 	log.Println("🔴 Sneedchat disconnected")
-	time.Sleep(7 * time.Second)
-	_ = c.Connect() // try once; your original had a loop — add if desired
+	if c.OnDisconnect != nil {
+		c.OnDisconnect()
+	}
+	time.Sleep(ReconnectInterval)
+	_ = c.Connect()
 }
 
 func (c *Client) Disconnect() {
@@ -161,3 +210,173 @@ func (c *Client) Disconnect() {
 	c.mu.Unlock()
 	c.wg.Wait()
 }
+
+func (c *Client) handleIncoming(raw string) {
+	var payload SneedPayload
+	if err := json.Unmarshal([]byte(raw), &payload); err != nil {
+		return
+	}
+
+	// top-level deletes
+	if payload.Delete != nil {
+		var ids []int
+		switch v := payload.Delete.(type) {
+		case float64:
+			ids = []int{int(v)}
+		case []interface{}:
+			for _, x := range v {
+				if fid, ok := x.(float64); ok {
+					ids = append(ids, int(fid))
+				}
+			}
+		}
+		for _, id := range ids {
+			c.messageEditDates.Delete(id)
+			c.removeFromProcessed(id)
+			if c.OnDelete != nil {
+				c.OnDelete(id)
+			}
+		}
+	}
+
+	// messages list or single
+	var messages []SneedMessage
+	if len(payload.Messages) > 0 {
+		messages = payload.Messages
+	} else if payload.Message != nil {
+		messages = []SneedMessage{*payload.Message}
+	}
+	for _, m := range messages {
+		c.processMessage(m)
+	}
+}
+
+func (c *Client) processMessage(m SneedMessage) {
+	username := "Unknown"
+	var userID int
+	if a, ok := m.Author["username"].(string); ok {
+		username = a
+	}
+	if id, ok := m.Author["id"].(float64); ok {
+		userID = int(id)
+	}
+
+	messageText := m.MessageRaw
+	if messageText == "" {
+		messageText = m.Message
+	}
+	messageText = html.UnescapeString(messageText)
+
+	editDate := m.MessageEditDate
+	deleted := m.Deleted || m.IsDeleted
+	if deleted {
+		c.messageEditDates.Delete(m.MessageID)
+		c.removeFromProcessed(m.MessageID)
+		if c.OnDelete != nil {
+			c.OnDelete(m.MessageID)
+		}
+		return
+	}
+
+	// suppress bridge echoes
+	if (c.bridgeUserID > 0 && userID == c.bridgeUserID) ||
+		(c.bridgeUsername != "" && username == c.bridgeUsername) {
+		// correlate outbound -> map IDs
+		if m.MessageID > 0 && c.recentOutboundIter != nil && c.mapDiscordSneed != nil {
+			now := time.Now()
+			for _, entry := range c.recentOutboundIter() {
+				if mapped, ok := entry["mapped"].(bool); ok && mapped {
+					continue
+				}
+				content, _ := entry["content"].(string)
+				if ts, ok := entry["ts"].(time.Time); ok {
+					if content == messageText && now.Sub(ts) <= OutboundMatchWindow {
+						if discordID, ok := entry["discord_id"].(int); ok {
+							c.mapDiscordSneed(discordID, m.MessageID, username)
+							entry["mapped"] = true
+							break
+						}
+					}
+				}
+			}
+		}
+		c.addToProcessed(m.MessageID)
+		c.messageEditDates.Set(m.MessageID, editDate)
+		return
+	}
+
+	// de-dup / edits
+	if c.isProcessed(m.MessageID) {
+		if prev, exists := c.messageEditDates.Get(m.MessageID); exists {
+			if editDate > prev.(int) {
+				c.messageEditDates.Set(m.MessageID, editDate)
+				if c.OnEdit != nil {
+					c.OnEdit(m.MessageID, messageText)
+				}
+			}
+		}
+		return
+	}
+
+	// new message
+	c.addToProcessed(m.MessageID)
+	c.messageEditDates.Set(m.MessageID, editDate)
+
+	if c.OnMessage != nil {
+		c.OnMessage(map[string]interface{}{
+			"username":   username,
+			"content":    messageText,
+			"message_id": m.MessageID,
+			"author_id":  userID,
+			"raw":        m,
+		})
+	}
+}
+
+func (c *Client) isProcessed(id int) bool {
+	c.processedMu.Lock()
+	defer c.processedMu.Unlock()
+	for _, x := range c.processedMessageIDs {
+		if x == id {
+			return true
+		}
+	}
+	return false
+}
+
+func (c *Client) addToProcessed(id int) {
+	c.processedMu.Lock()
+	defer c.processedMu.Unlock()
+	c.processedMessageIDs = append(c.processedMessageIDs, id)
+	if len(c.processedMessageIDs) > ProcessedCacheSize {
+		c.processedMessageIDs = c.processedMessageIDs[1:]
+	}
+}
+
+func (c *Client) removeFromProcessed(id int) {
+	c.processedMu.Lock()
+	defer c.processedMu.Unlock()
+	for i, x := range c.processedMessageIDs {
+		if x == id {
+			c.processedMessageIDs = append(c.processedMessageIDs[:i], c.processedMessageIDs[i+1:]...)
+			return
+		}
+	}
+}
+
+// helpers for mapping in bridge
+func (c *Client) SetOutboundIter(f func() []map[string]interface{}) {
+	c.recentOutboundIter = f
+}
+func (c *Client) SetMapDiscordSneed(f func(int, int, string)) {
+	c.mapDiscordSneed = f
+}
+
+// expose helper for mention replacement
+func ReplaceBridgeMention(content, bridgeUsername, pingID string) string {
+	if bridgeUsername == "" || pingID == "" {
+		return content
+	}
+	pat := regexp.MustCompile(fmt.Sprintf(`(?i)@%s(?:\W|$)`, regexp.QuoteMeta(bridgeUsername)))
+	return pat.ReplaceAllString(content, fmt.Sprintf("<@%s>", pingID))
+}