Upload filter.go

filter.go

@@ -0,0 +1,896 @@
+// (c) Jisin0
+
+package plugins
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/Jisin0/Go-Filter-Bot/database"
+	"github.com/Jisin0/Go-Filter-Bot/utils"
+	"github.com/Jisin0/Go-Filter-Bot/utils/autodelete"
+	"github.com/Jisin0/Go-Filter-Bot/utils/customfilters"
+	"github.com/Jisin0/Go-Filter-Bot/utils/shortener"
+	"github.com/PaulSonOfLars/gotgbot/v2"
+	"github.com/PaulSonOfLars/gotgbot/v2/ext"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo/options"
+)
+
+// Regex expressions for callbacks and filtering
+var (
+	buttonRegex   *regexp.Regexp = regexp.MustCompile(`\[([^\[]+?)\]\((buttonurl|url|alert):(?:/{0,2})(.+?)\)`)
+	parseRegex    *regexp.Regexp = regexp.MustCompile(`^"([^"]+)"`)
+	cbstopRegex   *regexp.Regexp = regexp.MustCompile(`stopf\((.+)\)`)
+	cbalertRegex  *regexp.Regexp = regexp.MustCompile(`alert\((.+)\)`)
+	cbfileRegex   *regexp.Regexp = regexp.MustCompile(`file\((.+)\)`)
+	usernameRegex *regexp.Regexp = regexp.MustCompile(`(?i)@[a-z0-9_]+(?:\s|-)*`)
+)
+
+var DB *database.Database = database.NewDatabase()
+
+const (
+	lenUniqueID        = 15  // length of unique id string for filters
+	globalNumber int64 = 101 // Number used as chat id for global filters.
+	maxKeyLength       = 20  // maximum length for a keyword of a filter
+
+	filterSplitCount     = 3 // number of subtrings into which input of /filter command should be split
+	minButtonParseParams = 4 // Parse of a button should yield atleast this many values
+
+	alertCacheDuration = 3000 // number of seconds an alert should be cache by the client
+)
+
+const (
+	cbStopParamCount = 3 // number of parameters required for cbstop
+	maxButttons      = 5 // maximum number of buttons to scan for
+)
+
+// ── Filter result cache ───────────────────────────────────────────────────────
+
+// filterCacheEntry holds cached search results with a TTL expiry.
+type filterCacheEntry struct {
+	results []*database.Filter
+	expiry  time.Time
+}
+
+const filterCacheTTL = 10 * time.Minute
+
+// searchWithCache wraps DB search calls with in-memory caching.
+func searchWithCache(chatID int64, fields []string, message string, multiFilter bool) []*database.Filter {
+	var cacheKey string
+	useNew := len(fields) <= 15
+
+	if useNew {
+		cacheKey = database.FilterCacheKey(chatID, fields)
+	} else {
+		cacheKey = database.FilterCacheKey(chatID, []string{message})
+	}
+
+	if cached, ok := database.GetCachedFilterResults(cacheKey); ok {
+		return cached
+	}
+
+	var results []*database.Filter
+	if useNew {
+		results = DB.SearchMfilterNew(chatID, fields, multiFilter)
+	} else {
+		results = DB.SearchMfilterClassic(chatID, message)
+	}
+
+	database.SetCachedFilterResults(cacheKey, results)
+	return results
+}
+
+// ── Manual filter handler ─────────────────────────────────────────────────────
+
+func sendSearchResults(results []*database.Filter, bot *gotgbot.Bot, update *gotgbot.Message, chatID int64, messageID int64) {
+	if len(results) == 0 {
+		return
+	}
+
+	s := database.GetBotSettings()
+
+	// Just limit to 10 for now
+	if len(results) > 10 {
+		results = results[:10]
+	}
+
+	if s.SearchAsButton {
+		var rows [][]gotgbot.InlineKeyboardButton
+		for _, f := range results {
+			btnText := strings.SplitN(f.Content, "\n", 2)[0]
+			btnText = usernameRegex.ReplaceAllString(btnText, "")
+			btnText = strings.TrimSpace(btnText)
+			if btnText == "" {
+				btnText = f.Text
+			}
+			if len(btnText) > 60 {
+				btnText = btnText[:57] + "..."
+			}
+			rows = append(rows, []gotgbot.InlineKeyboardButton{{
+				Text:         "📁 " + btnText,
+				CallbackData: fmt.Sprintf("file(%s)", f.ID),
+			}})
+		}
+
+		text := fmt.Sprintf("<b>Here are the results found (%d):</b>\n<i>Click the buttons below to get the file.</i>", len(results))
+		m, err := update.Reply(bot, text, &gotgbot.SendMessageOpts{
+			ParseMode:   gotgbot.ParseModeHTML,
+			ReplyMarkup: gotgbot.InlineKeyboardMarkup{InlineKeyboard: rows},
+			ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID},
+		})
+		if err == nil && m != nil && s.AutoDelete > 0 {
+			autodelete.InsertAutodel(autodelete.AutodelData{ChatID: chatID, MessageID: m.MessageId}, s.AutoDelete*60)
+		}
+	} else {
+		botUser := bot.User.Username
+		text := fmt.Sprintf("<b>Here are the results found (%d):</b>\n\n", len(results))
+		for i, f := range results {
+			btnText := strings.SplitN(f.Content, "\n", 2)[0]
+			btnText = usernameRegex.ReplaceAllString(btnText, "")
+			btnText = strings.TrimSpace(btnText)
+			if btnText == "" {
+				btnText = f.Text
+			}
+			link := fmt.Sprintf("https://t.me/%s?start=file_%s", botUser, f.ID)
+			text += fmt.Sprintf("%d. <a href='%s'>%s</a>\n", i+1, link, btnText)
+		}
+		text += "\n<i>Click the link above to get the file in PM.</i>"
+
+		m, err := update.Reply(bot, text, &gotgbot.SendMessageOpts{
+			ParseMode:   gotgbot.ParseModeHTML,
+			ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID},
+			LinkPreviewOptions: &gotgbot.LinkPreviewOptions{IsDisabled: true},
+		})
+		if err == nil && m != nil && s.AutoDelete > 0 {
+			autodelete.InsertAutodel(autodelete.AutodelData{ChatID: chatID, MessageID: m.MessageId}, s.AutoDelete*60)
+		}
+	}
+}
+
+// MFilter handles automatic replies for manual filters.
+func MFilter(bot *gotgbot.Bot, ctx *ext.Context) error {
+	update := ctx.Message
+	chatType := update.Chat.Type
+
+	// Group/supergroup search is now handled by Filter() (VJ-style with "Searching..." indicator)
+	// MFilter only handles PM search via connected group
+	if chatType != gotgbot.ChatTypePrivate {
+		return nil
+	}
+
+	chatID, ok := DB.GetConnection(update.Chat.Id)
+	if !ok {
+		return nil
+	}
+
+	message := update.Text
+	if update.Caption != "" {
+		message = update.Caption
+	}
+
+	fields := strings.Fields(message)
+	s := database.GetBotSettings()
+	results := searchWithCache(chatID, fields, message, s.MultiFilter)
+
+	if len(results) > 0 {
+		sendSearchResults(results, bot, update, chatID, update.MessageId)
+	}
+
+	return nil
+}
+
+// Function to handle filter and gfilter commands
+//
+//nolint:errcheck // too many
+func NewFilter(bot *gotgbot.Bot, ctx *ext.Context) error {
+	var (
+		c      int64
+		update = ctx.Message
+	)
+
+	// I didnt wanna create a whole new function for gfilter so ...
+	if strings.HasPrefix(update.Text, "/gfilter") {
+		if !utils.IsAdmin(ctx.EffectiveUser.Id) {
+			update.Reply(bot, "Thats an Admin-only Command :(", &gotgbot.SendMessageOpts{})
+			return nil
+		}
+
+		c = globalNumber
+	} else {
+		// Verifying and getting connections for private chats
+		var v bool
+
+		c, v = customfilters.Verify(bot, ctx)
+		if !v {
+			return nil
+		} else if c == 0 {
+			c = ctx.Message.Chat.Id
+		}
+	}
+
+	args := strings.SplitN(update.Text, " ", filterSplitCount)
+	if len(args) < 2 && (update.ReplyToMessage == nil && len(args) < filterSplitCount) {
+		update.Reply(
+			bot,
+			"Not Enough Parameters :(\n\nExample:- <code>/filter hi hello</code>",
+			&gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML},
+		)
+
+		return nil
+	}
+
+	parse := ParseQuotes(strings.SplitN(update.Text, " ", 2)[1])
+
+	key := strings.ToLower(parse[0])
+
+	if len(key) > maxKeyLength {
+		update.Reply(bot, fmt.Sprintf("Sorry The Length of the Key Can't be More than %d Characters !\nInput Key: <code>%s</code>", maxKeyLength, key), &gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML})
+	}
+
+	e := DB.Mcol.FindOne(context.TODO(), bson.D{{Key: "group_id", Value: c}, {Key: "text", Value: key}})
+	if e.Err() == nil {
+		update.Reply(
+			bot,
+			fmt.Sprintf("It Looks Like Another Filter For <code>%v</code> Has Already Been Saved In This Chat, If You Want To Stop It First Use The Button Below", key),
+			&gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML, ReplyMarkup: gotgbot.InlineKeyboardMarkup{InlineKeyboard: [][]gotgbot.InlineKeyboardButton{
+				{{Text: "Stop Filter", CallbackData: fmt.Sprintf("stopf(%v|%v|y)", key, "local")}},
+			}}},
+		)
+
+		return nil
+	}
+
+	var (
+		text   = parse[1]
+		button [][]map[string]string
+	)
+
+	if update.ReplyToMessage != nil {
+		text += update.ReplyToMessage.OriginalHTML()
+		text += update.ReplyToMessage.OriginalCaptionHTML()
+
+		if update.ReplyToMessage.ReplyMarkup != nil {
+			// Buttons are converted to maps to save to the database
+			button = buttonToMap(ctx.Message.ReplyToMessage.ReplyMarkup.InlineKeyboard)
+		}
+	}
+
+	uniqueID := utils.RandString(lenUniqueID)
+
+	text, button, alert := parseButtons(text, uniqueID, button)
+
+	// Finding media if any
+	var (
+		fileID    string
+		mediaType string
+	)
+
+	if msg := update.ReplyToMessage; msg != nil {
+		switch {
+		case msg.Document != nil:
+			fileID = msg.Document.FileId
+			mediaType = "document"
+		case msg.Video != nil:
+			fileID = msg.Video.FileId
+			mediaType = "video"
+		case msg.Audio != nil:
+			fileID = msg.Audio.FileId
+			mediaType = "audio"
+		case msg.Sticker != nil:
+			fileID = msg.Sticker.FileId
+			mediaType = "sticker"
+		case msg.Animation != nil:
+			fileID = msg.Animation.FileId
+			mediaType = "animation"
+		case msg.Photo != nil:
+			fileID = msg.Photo[len(msg.Photo)-1].FileId
+			mediaType = "photo"
+		}
+	}
+
+	f := &database.Filter{
+		ID:        uniqueID,
+		ChatID:    c,
+		Text:      key,
+		Content:   text,
+		FileID:    fileID,
+		Markup:    button,
+		Alerts:    alert,
+		Length:    len(key),
+		MediaType: mediaType,
+	}
+
+	DB.SaveMfilter(f)
+
+	_, err := update.Reply(
+		bot,
+		fmt.Sprintf("<i>Successfully Saved A Manual Filter For <code>%v</code> !</i>", key),
+		&gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML},
+	)
+	if err != nil {
+		fmt.Println(err)
+	}
+
+	return nil
+}
+
+func CbStop(bot *gotgbot.Bot, ctx *ext.Context) error {
+	// Function to handle callbacks from confirm buttons when stopping a filter
+	update := ctx.CallbackQuery
+
+	c, v := customfilters.Verify(bot, ctx)
+	if !v {
+		return nil
+	} else if c == 0 {
+		c = update.Message.GetChat().Id
+	}
+
+	// Making sure the callback data is valid
+	args := strings.Split(cbstopRegex.FindStringSubmatch(update.Data)[1], "|")
+	if len(args) < cbStopParamCount {
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "Bad Button :(", ShowAlert: true})
+		return nil
+	}
+
+	var (
+		key   = args[0]
+		ftype = args[1]
+		erase = args[2]
+	)
+
+	if ftype == "local" {
+		if erase == "y" {
+			DB.DeleteMfilter(c, key)
+			update.Message.EditText(bot, fmt.Sprintf("Manual Filter For <code>%v</code> Was Deleted Successfully !", key), &gotgbot.EditMessageTextOpts{ParseMode: gotgbot.ParseModeHTML})
+		} else if erase == "n" {
+			update.Message.EditText(bot, fmt.Sprintf(`Are You Sure You Want To Permanently Delete The Manual Filter For %v ?\nClick The "Yes I'm Sure" Button To Confirm `, key), &gotgbot.EditMessageTextOpts{ReplyMarkup: gotgbot.InlineKeyboardMarkup{InlineKeyboard: [][]gotgbot.InlineKeyboardButton{{{Text: "Ignore", CallbackData: "close"}, {Text: "Yes I'm Sure", CallbackData: fmt.Sprintf("stopf(%v|local|y)", key)}}}}, ParseMode: gotgbot.ParseModeHTML})
+		}
+	} else if ftype == "global" {
+		DB.StopGfilter(c, key)
+		update.Message.EditText(bot, fmt.Sprintf("Global Filter For <code>%v</code> Has Been Stopped Successfully !", key), &gotgbot.EditMessageTextOpts{ParseMode: gotgbot.ParseModeHTML})
+	}
+
+	return nil
+}
+
+// Function to handle the stop command
+//
+//nolint:errcheck // too many
+func StopMfilter(bot *gotgbot.Bot, ctx *ext.Context) error {
+	c, v := customfilters.Verify(bot, ctx)
+	if !v {
+		return nil
+	} else if c == 0 {
+		c = ctx.Message.Chat.Id
+	}
+
+	var (
+		update = ctx.Message
+		split  = strings.SplitN(update.Text, " ", 2)
+		key    string
+	)
+
+	switch {
+	case len(split) < 2 && update.Chat.Type == gotgbot.ChatTypePrivate:
+		m := utils.Ask(bot, "Ok Now Send Me The Name OF The Filter You Would Like To Stop ...", ctx.EffectiveChat, ctx.EffectiveUser)
+		if m == nil {
+			return nil
+		}
+
+		key = m.Text
+	case len(split) < 2:
+		update.Reply(bot, "Whoops looks like you forgot to mention a filter to stop !", &gotgbot.SendMessageOpts{})
+	default:
+		key = split[1]
+	}
+
+	// Checking if theres a local/global filter for the key
+	_, k := DB.GetMfilter(c, key)
+	_, ok := DB.GetMfilter(globalNumber, key)
+
+	// If there isnt local or global
+	if !k && !ok {
+		update.Reply(bot, fmt.Sprintf("I Couldnt Find Any Filter For <code>%v</code> To Stop !", key), &gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML})
+		return nil
+	}
+
+	// Both local and global
+	switch {
+	case k && ok:
+		markup := gotgbot.InlineKeyboardMarkup{InlineKeyboard: [][]gotgbot.InlineKeyboardButton{{{Text: "Local", CallbackData: fmt.Sprintf("stopf(%v|local|y)", key)}, {Text: "Global", CallbackData: fmt.Sprintf("stopf(%v|global|y)", key)}}}}
+
+		_, err := update.Reply(bot, "Please Select If You Would Like To Stop The Manual Filter (which you saved) Or Global Filter (saved by owners) For <code>"+key+"</code>", &gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML, ReplyMarkup: markup})
+		if err != nil {
+			fmt.Println(err)
+		}
+	case k:
+		// Only local
+		markup := gotgbot.InlineKeyboardMarkup{InlineKeyboard: [][]gotgbot.InlineKeyboardButton{{{Text: "CONFIRM", CallbackData: fmt.Sprintf("stopf(%v|local|y)", key)}}}}
+
+		_, err := update.Reply(bot, "Please Press The Button Below To Confirm Deletion Of Manual Filter For <code>"+key+"</code>", &gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML, ReplyMarkup: markup})
+		if err != nil {
+			fmt.Println(err)
+		}
+	case ok:
+		// Only global
+		markup := gotgbot.InlineKeyboardMarkup{InlineKeyboard: [][]gotgbot.InlineKeyboardButton{{{Text: "CONFIRM", CallbackData: fmt.Sprintf("stopf(%v|global|y)", key)}}}}
+
+		_, err := update.Reply(bot, "Please Press The Button Below To Stop Global Filter For <code>"+key+"</code>", &gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML, ReplyMarkup: markup})
+		if err != nil {
+			fmt.Println(err)
+		}
+	}
+
+	return nil
+}
+
+func AllMfilters(bot *gotgbot.Bot, ctx *ext.Context) error {
+	// Function to handle the /filters command
+	update := ctx.Message
+	c := update.Chat.Id
+
+	if update.Chat.Type == gotgbot.ChatTypePrivate {
+		if i, k := DB.GetConnection(update.From.Id); k {
+			c = i
+		}
+	}
+
+	text := DB.StringMfilter(c)
+
+	_, err := update.Reply(bot, "Lɪsᴛ ᴏғ ғɪʟᴛᴇʀs ғᴏʀ ᴛʜɪs ᴄʜᴀᴛ :\n"+text, &gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML})
+	if err != nil {
+		fmt.Printf("allmfilters: %v\n", err)
+	}
+
+	return nil
+}
+
+// Function to handle callbacks from alert button in saved filters
+//
+//nolint:errcheck // unnecessary
+func CbAlert(bot *gotgbot.Bot, ctx *ext.Context) error {
+	update := ctx.CallbackQuery
+
+	args := strings.Split(cbalertRegex.FindStringSubmatch(update.Data)[1], "|")
+	if len(args) < 2 {
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "Bad Request !", ShowAlert: true})
+	} else {
+		uniqueID := args[0]
+
+		index, err := strconv.Atoi(args[1])
+		if err != nil {
+			update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "Bad Request !", ShowAlert: true})
+		} else {
+			text := DB.GetAlert(uniqueID, index)
+			update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: text, ShowAlert: true, CacheTime: alertCacheDuration})
+		}
+	}
+
+	return nil
+}
+
+// SendFileByID finds a filter by ID and sends it.
+func SendFileByID(fileID string, bot *gotgbot.Bot, update *gotgbot.Message) {
+	res := DB.Mcol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: fileID}})
+	if res.Err() != nil {
+		fmt.Printf("SendFileByID: file %q not found in DB: %v\n", fileID, res.Err())
+		update.Reply(bot, "❌ File not found. It may have been deleted or the link is invalid.", &gotgbot.SendMessageOpts{ //nolint:errcheck
+			ReplyParameters: &gotgbot.ReplyParameters{MessageId: update.MessageId, AllowSendingWithoutReply: true},
+		})
+		return
+	}
+	var f database.Filter
+	if err := res.Decode(&f); err != nil {
+		fmt.Printf("SendFileByID: decode error for %q: %v\n", fileID, err)
+		return
+	}
+	if err := sendFilter(&f, bot, update.Chat.Id, update.MessageId, update.Chat.Type); err != nil {
+		update.Reply(bot, "❌ Failed to send file. Please try again or contact admin.", &gotgbot.SendMessageOpts{ //nolint:errcheck
+			ReplyParameters: &gotgbot.ReplyParameters{MessageId: update.MessageId, AllowSendingWithoutReply: true},
+		})
+	}
+}
+
+// CbSendFile handles inline button clicks to send a specific file.
+//nolint:errcheck
+func CbSendFile(bot *gotgbot.Bot, ctx *ext.Context) error {
+	update := ctx.CallbackQuery
+	if !CheckForceSub(bot, ctx) {
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "⚠️ Please join the required channel(s) first!", ShowAlert: true})
+		return nil
+	}
+
+	match := cbfileRegex.FindStringSubmatch(update.Data)
+	if len(match) < 2 {
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "Invalid file button!", ShowAlert: true})
+		return nil
+	}
+
+	fileDocID := match[1]
+	fmt.Printf("CbSendFile: lookup _id=%q\n", fileDocID)
+
+	res := DB.Mcol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: fileDocID}})
+	if res.Err() != nil {
+		fmt.Printf("CbSendFile: file %q not found: %v\n", fileDocID, res.Err())
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "❌ File not found. It may have been removed.", ShowAlert: true})
+		return nil
+	}
+
+	var f database.Filter
+	if err := res.Decode(&f); err != nil {
+		fmt.Printf("CbSendFile: decode error: %v\n", err)
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "❌ Error loading file.", ShowAlert: true})
+		return nil
+	}
+
+	chatID := update.Message.GetChat().Id
+	msgID := update.Message.GetMessageId()
+	chatType := update.Message.GetChat().Type
+
+	if err := sendFilter(&f, bot, chatID, msgID, chatType); err != nil {
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "❌ Failed to send file: " + err.Error(), ShowAlert: true})
+		return nil
+	}
+
+	update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "✅ Sent! Check below or your PM."})
+	return nil
+}
+
+func buttonToMap(btn [][]gotgbot.InlineKeyboardButton) [][]map[string]string {
+	// Convert a button into a map
+	var (
+		totalButtons [][]map[string]string
+		rowButtons   []map[string]string
+	)
+
+	for _, i := range btn {
+		rowButtons = []map[string]string{}
+
+		for _, j := range i {
+			b := map[string]string{"Text": j.Text}
+
+			switch {
+			case j.CallbackData != "":
+				b["CallbackData"] = j.CallbackData
+			case j.Url != "":
+				b["Url"] = j.Url
+			default:
+				continue
+			}
+
+			rowButtons = append(rowButtons, b)
+		}
+
+		totalButtons = append(totalButtons, rowButtons)
+	}
+
+	return totalButtons
+}
+
+func mapToButton(data [][]map[string]string) [][]gotgbot.InlineKeyboardButton {
+	// Convert a map back into button
+	var totalButtons [][]gotgbot.InlineKeyboardButton
+
+	for _, i := range data {
+		var rowButtons []gotgbot.InlineKeyboardButton
+
+		for _, b := range i {
+			text := b["Text"]
+
+			if u, k := b["Url"]; k {
+				rowButtons = append(rowButtons, gotgbot.InlineKeyboardButton{Text: text, Url: u})
+			} else if c, k := b["CallbackData"]; k {
+				rowButtons = append(rowButtons, gotgbot.InlineKeyboardButton{Text: text, CallbackData: c})
+			}
+		}
+
+		totalButtons = append(totalButtons, rowButtons)
+	}
+
+	return totalButtons
+}
+
+func ParseQuotes(text string) []string {
+	res := parseRegex.FindStringSubmatch(text)
+	if len(res) > 0 {
+		return []string{res[1], strings.Replace(text, "\""+res[1]+"\"", "", 1)} // very hacky workaround by adding quotes //TODO: update regex to include quotes
+	} else {
+		split := strings.SplitN(text, " ", 2)
+		return []string{split[0], strings.Replace(text, split[0], "", 1)}
+	}
+}
+
+func parseButtons(text, uniqueID string, totalButtons [][]map[string]string) (messageText string, buttons [][]map[string]string, alertText []string) {
+	var (
+		returnText = text
+		rowButtons []map[string]string
+		alert      []string
+	)
+
+	for _, rows := range strings.Split(text, "\n") {
+		for _, m := range buttonRegex.FindAllStringSubmatch(rows, maxButttons) {
+			if len(m) < minButtonParseParams {
+				continue
+			}
+
+			if m[2] == "url" || m[2] == "buttonurl" {
+				rowButtons = append(rowButtons, map[string]string{"Text": m[1], "Url": m[3]})
+			} else if m[2] == "alert" || m[2] == "buttonalert" {
+				alert = append(alert, m[3])
+				rowButtons = append(rowButtons, map[string]string{"Text": m[1], "CallbackData": fmt.Sprintf("alert(%v|%v)", uniqueID, len(alert)-1)})
+			}
+
+			returnText = strings.Replace(returnText, m[0], "", 1)
+		}
+
+		if len(rowButtons) > 0 {
+			totalButtons = append(totalButtons, rowButtons)
+		}
+
+		rowButtons = []map[string]string{}
+	}
+
+	return strings.Trim(returnText, " "), totalButtons, alert
+}
+
+// sendFilter sends the data from filter f to the chatID.
+// URL buttons are shortened via the configured shortener service (if any).
+// Returns an error if sending failed (so callers can show user feedback).
+func sendFilter(f *database.Filter, bot *gotgbot.Bot, chatID, messageID int64, chatType string) error {
+	// Shorten URL buttons if a shortener is configured (read from dynamic settings)
+	markup := f.Markup
+	s := database.GetBotSettings()
+	if s.ShortenerAPI != "" && s.ShortenerURL != "" {
+		markup = shortener.ShortenAll(markup)
+	}
+
+	content := f.Content
+	// If it's a media filter (indexed file), use the clean filename as caption
+	if f.MediaType != "" {
+		if f.FileName != "" {
+			content = f.FileName
+		} else if content != "" {
+			// Extract first non-username line or fallback
+			content = usernameRegex.ReplaceAllString(content, "")
+			content = strings.TrimSpace(content)
+		}
+	} else {
+		// Strip usernames from text filter caption
+		content = usernameRegex.ReplaceAllString(content, "")
+	}
+
+	var (
+		buttons = mapToButton(markup)
+		ikm     = gotgbot.InlineKeyboardMarkup{InlineKeyboard: buttons}
+		err     error
+		m       *gotgbot.Message
+	)
+
+	mediaType := f.MediaType
+	if mediaType != "" {
+		fileID := gotgbot.InputFileByID(f.FileID)
+
+		switch mediaType {
+		case "document":
+			m, err = bot.SendDocument(chatID, fileID, &gotgbot.SendDocumentOpts{Caption: content, ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		case "sticker":
+			m, err = bot.SendSticker(chatID, fileID, &gotgbot.SendStickerOpts{ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true}, ReplyMarkup: ikm})
+		case "video":
+			m, err = bot.SendVideo(chatID, fileID, &gotgbot.SendVideoOpts{Caption: content, ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		case "photo":
+			m, err = bot.SendPhoto(chatID, fileID, &gotgbot.SendPhotoOpts{Caption: content, ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		case "audio":
+			m, err = bot.SendAudio(chatID, fileID, &gotgbot.SendAudioOpts{Caption: content, ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		case "animation":
+			m, err = bot.SendAnimation(chatID, fileID, &gotgbot.SendAnimationOpts{Caption: content, ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		default:
+			fmt.Println("Unknown media type " + mediaType)
+		}
+	} else {
+		m, err = bot.SendMessage(chatID, content, &gotgbot.SendMessageOpts{ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+	}
+
+	if err != nil {
+		fmt.Printf("sendFilter: failed to send %q (type=%s, fileID=%s...): %v\n",
+			f.FileName, f.MediaType, safePrefix(f.FileID, 20), err)
+		return err
+	}
+
+	if m != nil && s.AutoDelete > 0 {
+		// Only auto-delete in groups — PM file sends should not auto-delete
+		if chatType != gotgbot.ChatTypePrivate {
+			autodelete.InsertAutodel(autodelete.AutodelData{ChatID: chatID, MessageID: m.MessageId}, s.AutoDelete*60) //nolint:errcheck
+		}
+	}
+	return nil
+}
+
+// safePrefix returns the first n chars of s, or s itself if shorter.
+func safePrefix(s string, n int) string {
+	if len(s) <= n {
+		return s
+	}
+	return s[:n]
+}
+
+// ══════════════════════════════════════════════════════════════════════════════
+// VJ-FILTER-BOT style search — ported from Python to Go
+// Credit: Bot code made by Claude
+// ══════════════════════════════════════════════════════════════════════════════
+
+
+// vjCleanQuery replicates VJ bot's query cleaning before search.
+// Removes noise words that hurt search accuracy.
+func vjCleanQuery(raw string) string {
+	q := regexp.MustCompile(`(?i)\b(please|pls|plz|send|movie|new|latest|bro|bruh|broh|find|link|file|dubbed|full|helo|that|undo|kitti|thar|kittum|anyone)\b`).ReplaceAllString(strings.ToLower(raw), " ")
+	q = regexp.MustCompile(`[-:.]`).ReplaceAllString(q, " ")
+	q = regexp.MustCompile(`\s{2,}`).ReplaceAllString(q, " ")
+	return strings.TrimSpace(q)
+}
+
+// buildVJRegex builds MongoDB regex exactly matching VJ-FILTER-BOT's get_search_results.
+// Single word: boundary match. Multi-word: words joined by wildcard separator.
+func buildVJRegex(query string) string {
+	query = strings.TrimSpace(query)
+	if query == "" {
+		return "."
+	}
+	if !strings.Contains(query, " ") {
+		return `(\b|[.\+\-_])` + regexp.QuoteMeta(query) + `(\b|[.\+\-_])`
+	}
+	parts := strings.Fields(query)
+	escaped := make([]string, len(parts))
+	for i, p := range parts {
+		escaped[i] = regexp.QuoteMeta(p)
+	}
+	return strings.Join(escaped, `.*[\s\.\+\-_]`)
+}
+
+// searchVJ searches file_name AND text fields using VJ-style regex.
+// This is the core of VJ's high hit ratio.
+func searchVJ(chatID int64, rawQuery string, limit int64) []*database.Filter {
+	query := vjCleanQuery(rawQuery)
+	if query == "" {
+		return nil
+	}
+	pattern := buildVJRegex(query)
+	filter := bson.D{
+		{Key: "group_id", Value: chatID},
+		{Key: "$or", Value: bson.A{
+			bson.D{{Key: "file_name", Value: bson.M{"$regex": pattern, "$options": "i"}}},
+			bson.D{{Key: "text", Value: bson.M{"$regex": pattern, "$options": "i"}}},
+		}},
+		{Key: "file", Value: bson.M{"$exists": true, "$ne": ""}},
+	}
+
+	cur, err := DB.Mcol.Find(
+		context.Background(),
+		filter,
+		options.Find().
+			SetSort(bson.D{{Key: "$natural", Value: -1}}).
+			SetLimit(limit),
+	)
+	if err != nil {
+		return nil
+	}
+	defer cur.Close(context.Background())
+
+	var results []*database.Filter
+	for cur.Next(context.Background()) {
+		var f database.Filter
+		if err := cur.Decode(&f); err == nil {
+			results = append(results, &f)
+		}
+	}
+	return results
+}
+
+// Filter is the main group message handler using VJ-style search.
+// Replaces the old MFilter+searchWithCache approach for group messages.
+//
+//nolint:errcheck
+func Filter(bot *gotgbot.Bot, ctx *ext.Context) error {
+	msg := ctx.Message
+	if msg == nil {
+		return nil
+	}
+
+	query := strings.TrimSpace(msg.Text + msg.Caption)
+	if strings.HasPrefix(query, "/") || strings.HasPrefix(query, "#") || len(query) < 2 || len(query) > 100 {
+		return nil
+	}
+
+	chatID := msg.Chat.Id
+	messageID := msg.MessageId
+
+	s := database.GetBotSettings()
+
+	// Force sub check
+	if len(s.ForceSubChats) > 0 && !CheckForceSub(bot, ctx) {
+		return nil
+	}
+
+	// "Searching For..." indicator — VJ style
+	searching, _ := msg.Reply(bot,
+		fmt.Sprintf("<b><i>Searching For %s 🔍</i></b>", query),
+		&gotgbot.SendMessageOpts{
+			ParseMode:       gotgbot.ParseModeHTML,
+			ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true},
+		},
+	)
+
+	t0 := time.Now()
+	results := searchVJ(globalNumber, query, 100) // fetch all, paginate 10/page like VJ
+	searchTime := time.Since(t0).Seconds()
+
+	if len(results) == 0 {
+		if searching != nil {
+			googleQuery := strings.ReplaceAll(vjCleanQuery(query), " ", "+") + "+movie"
+			searching.EditText(bot,
+				fmt.Sprintf("❌ <b>No results found for:</b> <code>%s</code>\n\n💡 <i>Check spelling and try again.</i>", query),
+				&gotgbot.EditMessageTextOpts{
+					ParseMode: gotgbot.ParseModeHTML,
+					ReplyMarkup: gotgbot.InlineKeyboardMarkup{InlineKeyboard: [][]gotgbot.InlineKeyboardButton{
+						{{Text: "🔍 Search on Google", Url: "https://www.google.com/search?q=" + googleQuery}},
+					}},
+				},
+			)
+		}
+		return nil
+	}
+
+	// Delete searching indicator and show paginated results
+	if searching != nil {
+		searching.Delete(bot, nil)
+	}
+	sendVJResults(results, bot, msg, query, chatID, messageID, searchTime)
+	return nil
+}
+
+// CbPages handles the no-op page-counter button.
+// CbPages is defined in vjsearch.go
+
+// fileDisplayName returns VJ-style "[size] name" display string.
+func fileDisplayName(f *database.Filter) string {
+	name := f.FileName
+	if name == "" {
+		name = strings.SplitN(f.Content, "\n", 2)[0]
+		name = usernameRegex.ReplaceAllString(name, "")
+		name = regexp.MustCompile(`<[^>]+>`).ReplaceAllString(name, "")
+	}
+	if name == "" {
+		name = f.Text
+	}
+	name = usernameRegex.ReplaceAllString(name, "")
+	name = regexp.MustCompile(`(?i)https?://\S+|t\.me/\S+|www\.\S+`).ReplaceAllString(name, "")
+	name = strings.TrimSpace(name)
+
+	prefix := ""
+	if f.FileSize > 0 {
+		prefix = "[" + getFileSize(f.FileSize) + "] "
+	}
+	full := prefix + name
+	if len(full) > 58 {
+		full = full[:55] + "..."
+	}
+	return full
+}
+
+// getFileSize returns human-readable file size.
+func getFileSize(size int64) string {
+	switch {
+	case size >= 1024*1024*1024:
+		return fmt.Sprintf("%.1f GB", float64(size)/(1024*1024*1024))
+	case size >= 1024*1024:
+		return fmt.Sprintf("%.1f MB", float64(size)/(1024*1024))
+	case size >= 1024:
+		return fmt.Sprintf("%.1f KB", float64(size)/1024)
+	default:
+		return fmt.Sprintf("%d B", size)
+	}
+}