added file que system

cmd/fsb/run.go

@@ -1,19 +1,25 @@
+// In file: cmd/fsb/run.go
+
 package main
 
 import (
 	"EverythingSuckz/fsb/config"
 	"EverythingSuckz/fsb/internal/bot"
 	"EverythingSuckz/fsb/internal/cache"
+	"EverythingSuckz/fsb/internal/commands"
 	"EverythingSuckz/fsb/internal/routes"
 	"EverythingSuckz/fsb/internal/types"
 	"EverythingSuckz/fsb/internal/utils"
 	"fmt"
 	"net/http"
+	"strings"
 	"time"
 
-	"github.com/spf13/cobra"
-
+	"github.com/celestix/gotgproto/ext"
 	"github.com/gin-gonic/gin"
+	"github.com/gotd/td/telegram/message/styling"
+	"github.com/gotd/td/tg"
+	"github.com/spf13/cobra"
 	"go.uber.org/zap"
 )
 
@@ -31,13 +37,25 @@ func runApp(cmd *cobra.Command, args []string) {
 	log := utils.Logger
 	mainLogger := log.Named("Main")
 	mainLogger.Info("Starting server")
+
+	bot.MessageQueue = make(chan bot.QueueItem, 200)
+
 	config.Load(log, cmd)
 	router := getRouter(log)
 
+	// Start the client FIRST.
 	mainBot, err := bot.StartClient(log)
 	if err != nil {
 		log.Panic("Failed to start main bot", zap.Error(err))
 	}
+
+	// **** THIS IS THE FIX ****
+	// Now that the client and its dispatcher exist, load the commands into it.
+	commands.Load(log, mainBot.Dispatcher)
+	// **************************
+
+	go processMessageQueue(log)
+
 	cache.InitCache(log)
 	workers, err := bot.StartWorkers(log)
 	if err != nil {
@@ -55,6 +73,66 @@ func runApp(cmd *cobra.Command, args []string) {
 	}
 }
 
+// This is the "methodical worker". It runs in the background.
+func processMessageQueue(log *zap.Logger) {
+	log = log.Named("QueueWorker")
+	log.Info("Message processing worker started.")
+
+	// This loop will run forever, waiting for items to appear in the queue.
+	for item := range bot.MessageQueue {
+		ctx := item.Ctx
+		u := item.Update
+		log.Info("Processing message from queue", zap.Int("MessageID", u.EffectiveMessage.ID))
+
+		// --- ALL THE HEAVY LIFTING IS DONE HERE, SLOWLY ---
+		chatId := u.EffectiveChat().GetID()
+		update, err := utils.ForwardMessages(ctx, chatId, config.ValueOf.LogChannelID, u.EffectiveMessage.ID)
+		if err != nil {
+			log.Error("Failed to forward message", zap.Error(err))
+			ctx.Reply(u, fmt.Sprintf("Error forwarding message: %s", err.Error()), nil)
+			continue // Skip to the next item in the queue
+		}
+
+		messageID := update.Updates[0].(*tg.UpdateMessageID).ID
+		doc := update.Updates[1].(*tg.UpdateNewChannelMessage).Message.(*tg.Message).Media
+		file, err := utils.FileFromMedia(doc)
+		if err != nil {
+			log.Error("Failed to get file from media", zap.Error(err))
+			ctx.Reply(u, fmt.Sprintf("Error getting file data: %s", err.Error()), nil)
+			continue
+		}
+
+		fullHash := utils.PackFile(file.FileName, file.FileSize, file.MimeType, file.ID)
+		hash := utils.GetShortHash(fullHash)
+		link := fmt.Sprintf("%s/stream/%d?hash=%s", config.ValueOf.Host, messageID, hash)
+		text := []styling.StyledTextOption{styling.Code(link)}
+		row := tg.KeyboardButtonRow{
+			Buttons: []tg.KeyboardButtonClass{
+				&tg.KeyboardButtonURL{Text: "Download", URL: link + "&d=true"},
+			},
+		}
+
+		// *** FIXING YOUR TYPO: Mime_Type -> MimeType ***
+		if strings.Contains(file.MimeType, "video") || strings.Contains(file.MimeType, "audio") || strings.Contains(file.MimeType, "pdf") {
+			row.Buttons = append(row.Buttons, &tg.KeyboardButtonURL{Text: "Stream", URL: link})
+		}
+
+		markup := &tg.ReplyInlineMarkup{Rows: []tg.KeyboardButtonRow{row}}
+		replyOpts := &ext.ReplyOpts{Markup: markup, NoWebpage: false, ReplyToMessageId: u.EffectiveMessage.ID}
+		if strings.Contains(link, "http://localhost") {
+			replyOpts.Markup = nil // Don't send buttons for localhost links
+		}
+		
+		if _, err = ctx.Reply(u, text, replyOpts); err != nil {
+			log.Error("Failed to send final link reply", zap.Error(err))
+		}
+		// --- END OF HEAVY LIFTING ---
+
+		// PAUSE between each message to avoid flood limits.
+		time.Sleep(500 * time.Millisecond)
+	}
+}
+
 func getRouter(log *zap.Logger) *gin.Engine {
 	if config.ValueOf.Dev {
 		gin.SetMode(gin.DebugMode)
@@ -71,10 +149,9 @@ func getRouter(log *zap.Logger) *gin.Engine {
 			Version: versionString,
 		})
 	})
-
 	router.HEAD("/", func(ctx *gin.Context) {
-	ctx.Status(http.StatusOK)
-    })
+		ctx.Status(http.StatusOK)
+	})
 	routes.Load(log, router)
 	return router
-}
+}

internal/bot/client.go

@@ -2,7 +2,6 @@ package bot
 
 import (
 	"EverythingSuckz/fsb/config"
-	"EverythingSuckz/fsb/internal/commands"
 	"context"
 	"time"
 
@@ -47,9 +46,8 @@ func StartClient(log *zap.Logger) (*gotgproto.Client, error) {
 		if result.err != nil {
 			return nil, result.err
 		}
-		commands.Load(log, result.client.Dispatcher)
 		log.Info("Client started", zap.String("username", result.client.Self.Username))
 		Bot = result.client
 		return result.client, nil
 	}
-}
+}

internal/bot/queue.go

@@ -0,0 +1,16 @@
+// In file: internal/bot/queue.go
+
+package bot
+
+import "github.com/celestix/gotgproto/ext"
+
+// QueueItem holds the necessary context and update for a message to be processed.
+// It is EXPORTED (starts with a capital letter) so other packages can use it.
+type QueueItem struct {
+	Ctx    *ext.Context
+	Update *ext.Update
+}
+
+// MessageQueue is the channel that will act as our queue.
+// It is also EXPORTED so it can be accessed from other packages.
+var MessageQueue chan QueueItem

internal/commands/stream.go

@@ -1,10 +1,10 @@
+// In file: internal/commands/stream.go
+
 package commands
 
 import (
-	"fmt"
-	"strings"
-
 	"EverythingSuckz/fsb/config"
+	"EverythingSuckz/fsb/internal/bot" // <--- Import the bot package
 	"EverythingSuckz/fsb/internal/utils"
 
 	"github.com/celestix/gotgproto/dispatcher"
@@ -12,8 +12,8 @@ import (
 	"github.com/celestix/gotgproto/ext"
 	"github.com/celestix/gotgproto/storage"
 	"github.com/celestix/gotgproto/types"
-	"github.com/gotd/td/telegram/message/styling"
 	"github.com/gotd/td/tg"
+	"go.uber.org/zap"
 )
 
 func (m *command) LoadStream(dispatcher dispatcher.Dispatcher) {
@@ -33,13 +33,12 @@ func supportedMediaFilter(m *types.Message) (bool, error) {
 		return true, nil
 	case *tg.MessageMediaPhoto:
 		return true, nil
-	case tg.MessageMediaClass:
-		return false, dispatcher.EndGroups
 	default:
-		return false, nil
+		return false, dispatcher.EndGroups
 	}
 }
 
+// This function is now the "fast receptionist". It does minimal work.
 func sendLink(ctx *ext.Context, u *ext.Update) error {
 	chatId := u.EffectiveChat().GetID()
 	peerChatId := ctx.PeerStorage.GetPeerById(chatId)
@@ -51,67 +50,16 @@ func sendLink(ctx *ext.Context, u *ext.Update) error {
 		return dispatcher.EndGroups
 	}
 	supported, err := supportedMediaFilter(u.EffectiveMessage)
-	if err != nil {
-		return err
-	}
-	if !supported {
+	if err != nil || !supported {
 		ctx.Reply(u, "Sorry, this message type is unsupported.", nil)
 		return dispatcher.EndGroups
 	}
-	update, err := utils.ForwardMessages(ctx, chatId, config.ValueOf.LogChannelID, u.EffectiveMessage.ID)
-	if err != nil {
-		utils.Logger.Sugar().Error(err)
-		ctx.Reply(u, fmt.Sprintf("Error - %s", err.Error()), nil)
-		return dispatcher.EndGroups
-	}
-	messageID := update.Updates[0].(*tg.UpdateMessageID).ID
-	doc := update.Updates[1].(*tg.UpdateNewChannelMessage).Message.(*tg.Message).Media
-	file, err := utils.FileFromMedia(doc)
-	if err != nil {
-		ctx.Reply(u, fmt.Sprintf("Error - %s", err.Error()), nil)
-		return dispatcher.EndGroups
-	}
-	fullHash := utils.PackFile(
-		file.FileName,
-		file.FileSize,
-		file.MimeType,
-		file.ID,
-	)
-	hash := utils.GetShortHash(fullHash)
-	link := fmt.Sprintf("%s/stream/%d?hash=%s", config.ValueOf.Host, messageID, hash)
-	text := []styling.StyledTextOption{styling.Code(link)}
-	row := tg.KeyboardButtonRow{
-		Buttons: []tg.KeyboardButtonClass{
-			&tg.KeyboardButtonURL{
-				Text: "Download",
-				URL:  link + "&d=true",
-			},
-		},
-	}
-	if strings.Contains(file.MimeType, "video") || strings.Contains(file.MimeType, "audio") || strings.Contains(file.MimeType, "pdf") {
-		row.Buttons = append(row.Buttons, &tg.KeyboardButtonURL{
-			Text: "Stream",
-			URL:  link,
-		})
-	}
-	markup := &tg.ReplyInlineMarkup{
-		Rows: []tg.KeyboardButtonRow{row},
-	}
-	if strings.Contains(link, "http://localhost") {
-		_, err = ctx.Reply(u, text, &ext.ReplyOpts{
-			NoWebpage:        false,
-			ReplyToMessageId: u.EffectiveMessage.ID,
-		})
-	} else {
-		_, err = ctx.Reply(u, text, &ext.ReplyOpts{
-			Markup:           markup,
-			NoWebpage:        false,
-			ReplyToMessageId: u.EffectiveMessage.ID,
-		})
-	}
-	if err != nil {
-		utils.Logger.Sugar().Error(err)
-		ctx.Reply(u, fmt.Sprintf("Error - %s", err.Error()), nil)
-	}
+
+	// Create an item with our data and send it to the queue.
+	// This is very fast and will not cause a flood error.
+	item := bot.QueueItem{Ctx: ctx, Update: u}
+	bot.MessageQueue <- item
+	utils.Logger.Info("Added message to processing queue", zap.Int("MessageID", u.EffectiveMessage.ID))
+
 	return dispatcher.EndGroups
-}
+}