Auto index concept update

database/database.go

@@ -848,18 +848,36 @@ func (db *Database) CleanGhostFilters() int64 {
 	return count
 }
 
-// SaveMfilterByFileID saves a filter using Telegram file_id as the document _id.
-// This prevents duplicate indexing of the same file across multiple runs.
-func (db *Database) SaveMfilterByFileID(data *Filter) error {
-	t := true
-	_, err := db.Mcol.UpdateOne(
-		context.TODO(),
-		bson.D{{Key: "_id", Value: data.ID}},
-		bson.D{{Key: "$setOnInsert", Value: data}},
-		&options.UpdateOptions{Upsert: &t},
-	)
+// randShortID generates a random alphanumeric string of given length.
+// Safe for Telegram deep link start parameters (max 64 chars).
+func randShortID(n int) string {
+	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
+	b := make([]byte, n)
+	seed := time.Now().UnixNano()
+	for i := range b {
+		seed = seed*6364136223846793005 + 1442695040888963407
+		b[i] = chars[((seed>>33)&0x7fffffffffffffff)%int64(len(chars))]
+	}
+	return string(b)
+}
+
+// SaveMfilterByFileID saves a filter with a short random _id (safe for Telegram start params).
+// Deduplication is done by checking the 'file' (telegram file_id) field to avoid double-indexing.
+// Returns true if a new document was inserted, false if it already existed.
+func (db *Database) SaveMfilterByFileID(data *Filter) (bool, error) {
+	// Check if this telegram file_id already exists
+	existing := db.Mcol.FindOne(context.TODO(), bson.D{{Key: "file", Value: data.FileID}})
+	if existing.Err() == nil {
+		return false, nil // already indexed
+	}
+
+	// Generate a short random _id safe for Telegram deep links (max 64 chars with "file_" prefix = 59 chars)
+	data.ID = randShortID(15)
+
+	_, err := db.Mcol.InsertOne(context.TODO(), data)
 	if err != nil {
 		fmt.Printf("db.SaveMfilterByFileID: %v\n", err)
+		return false, err
 	}
-	return err
+	return true, nil
 }

main.go

@@ -80,6 +80,15 @@ func main() {
 	// Send restart alert to log channel
 	go logger.SendRestart(b)
 
+	// Auto-cleanup ghost/reference docs on every startup
+	go func() {
+		removed := plugins.DB.CleanGhostFilters()
+		if removed > 0 {
+			fmt.Printf("startup: cleaned %d ghost docs from DB\n", removed)
+			logger.Send(b, fmt.Sprintf("🧹 <b>Startup cleanup:</b> removed <code>%d</code> ghost documents from DB.", removed))
+		}
+	}()
+
 	// Always run the auto-delete daemon in the background to support dynamic settings
 	go autodelete.RunAutodel(b)
 

plugins/basics.go

@@ -172,14 +172,12 @@ func CbEdit(bot *gotgbot.Bot, update *ext.Context) error {
 	}
 
 	editMarkup := gotgbot.InlineKeyboardMarkup{InlineKeyboard: markup}
-	chatID := update.CallbackQuery.Message.GetChat().Id
-	msgID := update.CallbackQuery.Message.GetMessageId()
 
-	// Check if the original message has a photo (i.e. sent with START_IMAGE)
-	// In that case we must edit caption, not text.
-	origMsg, ok2 := update.CallbackQuery.Message.(*gotgbot.Message)
-	if ok2 && origMsg.Photo != nil {
-		// Edit caption on the photo message using the message helper
+	// Try to get the full message object
+	origMsg, isMsg := update.CallbackQuery.Message.(*gotgbot.Message)
+
+	// If it's a photo message (sent with START_IMAGE), edit caption
+	if isMsg && len(origMsg.Photo) > 0 {
 		_, _, err := origMsg.EditCaption(bot, &gotgbot.EditMessageCaptionOpts{
 			Caption:     text,
 			ParseMode:   gotgbot.ParseModeHTML,
@@ -191,20 +189,32 @@ func CbEdit(bot *gotgbot.Bot, update *ext.Context) error {
 		return nil
 	}
 
-	// Regular text message — edit text
-	_, _, err := update.CallbackQuery.Message.EditText(bot, text, &gotgbot.EditMessageTextOpts{
-		ChatId:    chatID,
-		MessageId: msgID,
-		ParseMode: gotgbot.ParseModeHTML,
-		LinkPreviewOptions: &gotgbot.LinkPreviewOptions{
-			IsDisabled: true,
-		},
-		ReplyMarkup: editMarkup,
+	// Standard text message edit
+	if isMsg {
+		_, _, err := origMsg.EditText(bot, text, &gotgbot.EditMessageTextOpts{
+			ParseMode:          gotgbot.ParseModeHTML,
+			LinkPreviewOptions: &gotgbot.LinkPreviewOptions{IsDisabled: true},
+			ReplyMarkup:        editMarkup,
+		})
+		if err != nil {
+			fmt.Printf("cbedit: %v\n", err)
+		}
+		return nil
+	}
+
+	// Fallback: use raw bot API with chat/message IDs
+	chatID := update.CallbackQuery.Message.GetChat().Id
+	msgID := update.CallbackQuery.Message.GetMessageId()
+	_, _, err := bot.EditMessageText(text, &gotgbot.EditMessageTextOpts{
+		ChatId:             chatID,
+		MessageId:          msgID,
+		ParseMode:          gotgbot.ParseModeHTML,
+		LinkPreviewOptions: &gotgbot.LinkPreviewOptions{IsDisabled: true},
+		ReplyMarkup:        editMarkup,
 	})
 	if err != nil {
-		fmt.Printf("cbedit: %v\n", err)
+		fmt.Printf("cbedit(fallback): %v\n", err)
 	}
-
 	return nil
 }
 

plugins/bulkindex.go

@@ -206,7 +206,8 @@ func runBulkIndex(bot *gotgbot.Bot, chanID, fromID, toID int64, statusMsg *gotgb
 			Length:    len(keyword),
 		}
 
-		if err := DB.SaveMfilterByFileID(f); err != nil {
+		inserted, err := DB.SaveMfilterByFileID(f)
+		if err != nil || !inserted {
 			skipped++
 		} else {
 			indexed++

plugins/filter.go

@@ -1,4 +1,6 @@
-// (c) Jisin0
+// Core auto-filter and search result logic.
+// Search algorithm ported from VJ-FILTER-BOT (Python/Pyrogram) to Go.
+// Credit: Bot code made by Claude
 
 package plugins
 
@@ -6,726 +8,399 @@ 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|-)*`)
+	"github.com/PaulSonOfLars/gotgbot/v2"
+	"github.com/PaulSonOfLars/gotgbot/v2/ext"
 )
 
-var DB *database.Database = database.NewDatabase()
+// DB is the shared database instance from customfilters package.
+var DB = customfilters.DB
 
 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
+	globalNumber = 101
+	lenUniqueID  = 15
 )
 
-const (
-	cbStopParamCount = 3 // number of parameters required for cbstop
-	maxButttons      = 5 // maximum number of buttons to scan for
+// VJ-style search: removes noise words from query before searching
+// Ported from auto_filter() in VJ-FILTER-BOT/plugins/pm_filter.py
+var (
+	usernameRegex = regexp.MustCompile(`(?i)@\w+`)
+	noiseWords    = regexp.MustCompile(`(?i)\b(please|pls|plz|send|movie|new|latest|bro|bruh|find|link|file|dubbed|full|helo|that|undo|kitti|thar|kittum|anyone|with subtitle[s]?)\b`)
 )
 
-// ── Filter result cache ───────────────────────────────────────────────────────
-
-// filterCacheEntry holds cached search results with a TTL expiry.
-type filterCacheEntry struct {
-	results []*database.Filter
-	expiry  time.Time
+// vjCleanQuery replicates VJ bot's search query cleaning logic.
+// Removes noise words, normalises spacing — improves search hit ratio.
+func vjCleanQuery(raw string) string {
+	q := strings.ToLower(raw)
+	q = noiseWords.ReplaceAllString(q, " ")
+	q = regexp.MustCompile(`[-:.]`).ReplaceAllString(q, " ")
+	q = regexp.MustCompile(`\s{2,}`).ReplaceAllString(q, " ")
+	return strings.TrimSpace(q)
 }
 
-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})
+// buildVJRegex builds a MongoDB regex pattern matching VJ-FILTER-BOT logic:
+//   - single word → word-boundary match
+//   - multi word  → words connected by wildcard separators (space/dot/dash/+)
+//
+// Source: get_search_results() in VJ-FILTER-BOT/database/ia_filterdb.py
+func buildVJRegex(query string) string {
+	query = strings.TrimSpace(query)
+	if query == "" {
+		return "."
 	}
-
-	if cached, ok := database.GetCachedFilterResults(cacheKey); ok {
-		return cached
+	if !strings.Contains(query, " ") {
+		// Single word: match at word boundary or file-name separator
+		return `(\b|[.\+\-_])` + regexp.QuoteMeta(query) + `(\b|[.\+\-_])`
 	}
-
-	var results []*database.Filter
-	if useNew {
-		results = DB.SearchMfilterNew(chatID, fields, multiFilter)
-	} else {
-		results = DB.SearchMfilterClassic(chatID, message)
+	// Multi-word: words connected by any separator (VJ exact logic)
+	parts := strings.Fields(query)
+	escaped := make([]string, len(parts))
+	for i, p := range parts {
+		escaped[i] = regexp.QuoteMeta(p)
 	}
-
-	database.SetCachedFilterResults(cacheKey, results)
-	return results
+	return strings.Join(escaped, `.*[\s\.\+\-_]`)
 }
 
-// ── Manual filter handler ─────────────────────────────────────────────────────
-
-// fileDisplayName returns the best display name for a filter result.
-// Prefers FileName (full file name), falls back to Content first line, then Text.
-func fileDisplayName(f *database.Filter) string {
-	name := f.FileName
-	if name == "" {
-		name = strings.SplitN(f.Content, "\n", 2)[0]
-		name = usernameRegex.ReplaceAllString(name, "")
-		name = strings.TrimSpace(name)
-	}
-	if name == "" {
-		name = f.Text
-	}
-	// Strip HTML tags for button display
-	name = regexp.MustCompile(`<[^>]+>`).ReplaceAllString(name, "")
-	name = strings.TrimSpace(name)
-	if len(name) > 58 {
-		name = name[:55] + "..."
+// SearchVJ searches the file_name field using VJ-style regex — the primary hit driver.
+// Falls back to text field for older manually-indexed docs.
+func SearchVJ(chatID int64, query string, limit int64) []*database.Filter {
+	query = vjCleanQuery(query)
+	if query == "" {
+		return nil
 	}
-	return name
-}
 
-func sendSearchResults(results []*database.Filter, bot *gotgbot.Bot, update *gotgbot.Message, chatID int64, messageID int64) {
-	if len(results) == 0 {
-		return
+	pattern := buildVJRegex(query)
+	mongoFilter := 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"}}},
+		}},
+		// Exclude ghost reference docs
+		{Key: "file", Value: bson.M{"$exists": true, "$ne": ""}},
 	}
 
-	s := database.GetBotSettings()
+	opts := options.Find().
+		SetSort(bson.D{{Key: "$natural", Value: -1}}). // newest first — matches VJ sort
+		SetLimit(limit)
 
-	// Use VJ-style paginated results when there are more than 5 files
-	if len(results) > 5 {
-		query := strings.TrimSpace(update.Text + " " + update.Caption)
-		if query == "" && len(results) > 0 {
-			query = results[0].Text
-		}
-		sendVJResults(results, bot, update, query, chatID, messageID)
-		return
+	cur, err := DB.Mcol.Find(context.Background(), mongoFilter, opts)
+	if err != nil {
+		fmt.Printf("SearchVJ: %v\n", err)
+		return nil
 	}
+	defer cur.Close(context.Background())
 
-	if s.SearchAsButton {
-		var rows [][]gotgbot.InlineKeyboardButton
-		for _, f := range results {
-			btnText := fileDisplayName(f)
-			rows = append(rows, []gotgbot.InlineKeyboardButton{{
-				Text:         "📁 " + btnText,
-				CallbackData: fmt.Sprintf("file(%s)", f.ID),
-			}})
-		}
-
-		text := fmt.Sprintf("🔍 <b>Results found: %d</b>\n<i>Click a button to get the file sent to you.</i>", len(results))
-		m, err := update.Reply(bot, text, &gotgbot.SendMessageOpts{
-			ParseMode:       gotgbot.ParseModeHTML,
-			ReplyMarkup:     gotgbot.InlineKeyboardMarkup{InlineKeyboard: rows},
-			ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true},
-		})
-		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>Results found: %d</b>\n\n", len(results))
-		for i, f := range results {
-			btnText := fileDisplayName(f)
-			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>Links open in PM — make sure you've started the bot!</i>"
-
-		m, err := update.Reply(bot, text, &gotgbot.SendMessageOpts{
-			ParseMode:       gotgbot.ParseModeHTML,
-			ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true},
-			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)
+	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
 }
-func MFilter(bot *gotgbot.Bot, ctx *ext.Context) error {
-	var (
-		chatID    int64
-		update    = ctx.Message
-		messageID = update.MessageId
-		chatType  = update.Chat.Type
-		message   = update.Text
-	)
-
-	if update.Caption != "" {
-		message = update.Caption
-	}
-
-	switch chatType {
-	case gotgbot.ChatTypePrivate:
-		var ok bool
-
-		chatID, ok = DB.GetConnection(update.Chat.Id)
-		if !ok {
-			return nil
-		}
-	case gotgbot.ChatTypeSupergroup, gotgbot.ChatTypeGroup:
-		chatID = update.Chat.Id
-	default:
-		return nil
-	}
-
-	fields := strings.Fields(message)
-	s := database.GetBotSettings()
-	results := searchWithCache(chatID, fields, message, s.MultiFilter)
 
-	if len(results) > 0 {
-		sendSearchResults(results, bot, update, chatID, messageID)
-	} else if update.Chat.Type != gotgbot.ChatTypePrivate {
-		// No results – suggest spelling check and Google search
-		sendNoResultsSuggestion(bot, update, message, messageID)
+// CountVJ returns total matching documents for pagination.
+func CountVJ(chatID int64, query string) int64 {
+	query = vjCleanQuery(query)
+	if query == "" {
+		return 0
+	}
+	pattern := buildVJRegex(query)
+	mongoFilter := 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": ""}},
 	}
-
-	return nil
+	count, _ := DB.Mcol.CountDocuments(context.Background(), mongoFilter)
+	return count
 }
 
-// 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},
-		)
+// ── Auto filter (group message handler) ──────────────────────────────────────
 
+// Filter is the main group message handler — the "give_filter" equivalent.
+//
+//nolint:errcheck
+func Filter(bot *gotgbot.Bot, ctx *ext.Context) error {
+	msg := ctx.Message
+	if msg == nil {
 		return nil
 	}
 
-	parse := ParseQuotes(strings.SplitN(update.Text, " ", 2)[1])
-
-	key := strings.ToLower(parse[0])
+	chatID := msg.Chat.Id
+	messageID := msg.MessageId
+	query := strings.TrimSpace(msg.Text + msg.Caption)
 
-	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})
+	// Ignore commands and very short queries
+	if strings.HasPrefix(query, "/") || strings.HasPrefix(query, "#") || len(query) < 2 {
+		return nil
 	}
-
-	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")}},
-			}}},
-		)
-
+	// Ignore very long messages (not a movie search)
+	if len(query) > 100 {
 		return nil
 	}
 
-	var (
-		text   = parse[1]
-		button [][]map[string]string
-	)
-
-	if update.ReplyToMessage != nil {
-		text += update.ReplyToMessage.OriginalHTML()
-		text += update.ReplyToMessage.OriginalCaptionHTML()
+	s := database.GetBotSettings()
 
-		if update.ReplyToMessage.ReplyMarkup != nil {
-			// Buttons are converted to maps to save to the database
-			button = buttonToMap(ctx.Message.ReplyToMessage.ReplyMarkup.InlineKeyboard)
+	// Check force sub
+	if len(s.ForceSubChats) > 0 {
+		if !CheckForceSub(bot, ctx) {
+			return nil
 		}
 	}
 
-	uniqueID := utils.RandString(lenUniqueID)
-
-	text, button, alert := parseButtons(text, uniqueID, button)
+	// Send "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},
+		})
 
-	// Finding media if any
-	var (
-		fileID    string
-		mediaType string
-	)
+	maxResults := int64(10)
+	results := SearchVJ(globalNumber, query, maxResults)
 
-	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"
+	if len(results) == 0 {
+		// No results — show Google search suggestion
+		if searching != nil {
+			googleQuery := strings.ReplaceAll(query, " ", "+") + "+telegram+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}},
+					}},
+				})
 		}
-	}
-
-	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
-	}
+	total := CountVJ(globalNumber, query)
 
-	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})
+	// Dispatch to VJ-style paginated results
+	if searching != nil {
+		searching.Delete(bot, nil) //nolint:errcheck
 	}
-
+	sendVJResults(results, bot, msg, query, chatID, messageID)
 	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
-	)
+// ── File sender ───────────────────────────────────────────────────────────────
 
-	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]
+// sendFilter sends a single filter result to the chat.
+//
+//nolint:errcheck
+func sendFilter(f *database.Filter, bot *gotgbot.Bot, update *gotgbot.Message, chatID, messageID int64) {
+	if f == nil {
+		return
 	}
 
-	// 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
+	// Skip ghost reference docs
+	mediaType := f.MediaType
+	if mediaType == "reference" || (mediaType != "" && f.FileID == "") {
+		fmt.Printf("sendFilter: skipping ghost doc id=%s type=%s\n", f.ID, mediaType)
+		return
 	}
 
-	// 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)}}}}
+	markup := f.Markup
+	s := database.GetBotSettings()
 
-		_, 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)}}}}
+	content := f.Content
+	content = usernameRegex.ReplaceAllString(content, "")
 
-		_, 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)
+	// Build caption: use FileName if Content is empty
+	if content == "" && f.FileName != "" {
+		content = "<b>" + f.FileName + "</b>"
+		if f.FileSize > 0 {
+			content += fmt.Sprintf("\n📦 Size: %s", getFileSize(f.FileSize))
 		}
 	}
 
-	return nil
-}
+	var (
+		buttons = mapToButton(markup)
+		ikm     = gotgbot.InlineKeyboardMarkup{InlineKeyboard: buttons}
+		err     error
+		m       *gotgbot.Message
+	)
 
-func AllMfilters(bot *gotgbot.Bot, ctx *ext.Context) error {
-	// Function to handle the /filters command
-	update := ctx.Message
-	c := update.Chat.Id
+	replyParams := &gotgbot.ReplyParameters{MessageId: messageID, AllowSendingWithoutReply: true}
 
-	if update.Chat.Type == gotgbot.ChatTypePrivate {
-		if i, k := DB.GetConnection(update.From.Id); k {
-			c = i
+	if mediaType != "" {
+		fileID := gotgbot.InputFileByID(f.FileID)
+		switch mediaType {
+		case "document":
+			m, err = bot.SendDocument(chatID, fileID, &gotgbot.SendDocumentOpts{Caption: content, ReplyParameters: replyParams, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		case "video":
+			m, err = bot.SendVideo(chatID, fileID, &gotgbot.SendVideoOpts{Caption: content, ReplyParameters: replyParams, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		case "audio":
+			m, err = bot.SendAudio(chatID, fileID, &gotgbot.SendAudioOpts{Caption: content, ReplyParameters: replyParams, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		case "photo":
+			m, err = bot.SendPhoto(chatID, fileID, &gotgbot.SendPhotoOpts{Caption: content, ReplyParameters: replyParams, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		case "animation":
+			m, err = bot.SendAnimation(chatID, fileID, &gotgbot.SendAnimationOpts{Caption: content, ReplyParameters: replyParams, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
+		case "sticker":
+			m, err = bot.SendSticker(chatID, fileID, &gotgbot.SendStickerOpts{ReplyParameters: replyParams, ReplyMarkup: ikm})
+		default:
+			// Try as document for unknown media types
+			m, err = bot.SendDocument(chatID, fileID, &gotgbot.SendDocumentOpts{Caption: content, ReplyParameters: replyParams, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
 		}
+	} else {
+		m, err = update.Reply(bot, content, &gotgbot.SendMessageOpts{
+			ReplyParameters: replyParams,
+			ReplyMarkup:     ikm,
+			ParseMode:       gotgbot.ParseModeHTML,
+		})
 	}
 
-	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)
+		fmt.Printf("sendFilter err: %v\n", err)
+		return
 	}
 
-	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})
-		}
+	if m != nil && s.AutoDelete > 0 {
+		autodelete.InsertAutodel(autodelete.AutodelData{ChatID: chatID, MessageID: m.MessageId}, s.AutoDelete*60)
 	}
-
-	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 {
-		var f database.Filter
-		res.Decode(&f)
-		sendFilter(&f, bot, update, update.Chat.Id, update.MessageId)
+// 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)
 	}
 }
 
+// ── CbSendFile — inline button file delivery ─────────────────────────────────
+
 // 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) {
+	data := update.Data
+
+	var fileDocID string
+	if strings.HasPrefix(data, "file(") && strings.HasSuffix(data, ")") {
+		fileDocID = data[5 : len(data)-1]
+	} else {
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "Invalid file data", ShowAlert: true})
 		return nil
 	}
-	
-	match := cbfileRegex.FindStringSubmatch(update.Data)
-	if len(match) < 2 {
-		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "Invalid file button!", ShowAlert: true})
+
+	// Lookup by _id
+	res := DB.Mcol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: fileDocID}})
+	if res.Err() != nil {
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "❌ File not found. It may have been deleted.", ShowAlert: true})
 		return nil
 	}
-	
-	fileID := match[1]
-	
-	update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{})
-	
-	msg, ok := update.Message.(*gotgbot.Message)
-	if !ok {
+
+	var f database.Filter
+	if err := res.Decode(&f); err != nil {
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{Text: "❌ Error loading file.", ShowAlert: true})
 		return nil
 	}
-	
-	SendFileByID(fileID, bot, msg)
-	
-	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)
+	msg, ok := update.Message.(*gotgbot.Message)
+	if !ok {
+		update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{})
+		return nil
 	}
 
-	return totalButtons
+	update.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{})
+	sendFilter(&f, bot, msg, msg.Chat.Id, msg.MessageId)
+	return nil
 }
 
-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
+// ── SendFileByID — start=file_xxx deep link handler ──────────────────────────
 
-		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)
+// SendFileByID finds a filter by its _id and sends it.
+func SendFileByID(fileDocID string, bot *gotgbot.Bot, update *gotgbot.Message) {
+	res := DB.Mcol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: fileDocID}})
+	if res.Err() != nil {
+		update.Reply(bot, "❌ File not found. It may have been deleted or the link is invalid.", &gotgbot.SendMessageOpts{})
+		return
 	}
-
-	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)}
+	var f database.Filter
+	if err := res.Decode(&f); err != nil {
+		return
 	}
+	sendFilter(&f, bot, update, update.Chat.Id, update.MessageId)
 }
 
-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
-	)
+// ── No-op callbacks ────────────────────────────────────────────────────────────
 
-	for _, rows := range strings.Split(text, "\n") {
-		for _, m := range buttonRegex.FindAllStringSubmatch(rows, maxButttons) {
-			if len(m) < minButtonParseParams {
-				continue
-			}
+// CbPages handles the no-op "pages" callback (page number display button).
+func CbPages(bot *gotgbot.Bot, ctx *ext.Context) error {
+	ctx.CallbackQuery.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{}) //nolint:errcheck
+	return nil
+}
 
-			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)})
+// ── Helpers used by vjsearch.go ───────────────────────────────────────────────
+
+// mapToButton converts [][]map[string]string markup to gotgbot keyboard rows.
+func mapToButton(markup [][]map[string]string) [][]gotgbot.InlineKeyboardButton {
+	var rows [][]gotgbot.InlineKeyboardButton
+	for _, row := range markup {
+		var buttons []gotgbot.InlineKeyboardButton
+		for _, btn := range row {
+			text := btn["name"]
+			if url, ok := btn["url"]; ok && url != "" {
+				buttons = append(buttons, gotgbot.InlineKeyboardButton{Text: text, Url: url})
+			} else if cb, ok := btn["data"]; ok && cb != "" {
+				buttons = append(buttons, gotgbot.InlineKeyboardButton{Text: text, CallbackData: cb})
 			}
-
-			returnText = strings.Replace(returnText, m[0], "", 1)
 		}
-
-		if len(rowButtons) > 0 {
-			totalButtons = append(totalButtons, rowButtons)
+		if len(buttons) > 0 {
+			rows = append(rows, buttons)
 		}
-
-		rowButtons = []map[string]string{}
 	}
-
-	return strings.Trim(returnText, " "), totalButtons, alert
+	return rows
 }
 
-// sendFilter sends the data from filter f to the chatID.
-// URL buttons are shortened via the configured shortener service (if any).
-func sendFilter(f *database.Filter, bot *gotgbot.Bot, update *gotgbot.Message, chatID, messageID int64) {
-	// 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
-	// Strip usernames from the 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}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
-		case "sticker":
-			m, err = bot.SendSticker(chatID, fileID, &gotgbot.SendStickerOpts{ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID}, ReplyMarkup: ikm})
-		case "video":
-			m, err = bot.SendVideo(chatID, fileID, &gotgbot.SendVideoOpts{Caption: content, ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
-		case "photo":
-			m, err = bot.SendPhoto(chatID, fileID, &gotgbot.SendPhotoOpts{Caption: content, ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
-		case "audio":
-			m, err = bot.SendAudio(chatID, fileID, &gotgbot.SendAudioOpts{Caption: content, ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
-		case "animation":
-			m, err = bot.SendAnimation(chatID, fileID, &gotgbot.SendAnimationOpts{Caption: content, ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
-		default:
-			fmt.Println("Unknown media type " + mediaType)
-		}
-	} else {
-		m, err = update.Reply(bot, content, &gotgbot.SendMessageOpts{ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID}, ReplyMarkup: ikm, ParseMode: gotgbot.ParseModeHTML})
-	}
-
-	if err != nil {
-		fmt.Println(err)
-		fmt.Println(f)
-		return
+// fileDisplayName returns the best display name for a filter, VJ-style:
+// strips @username, URLs, shows [size] prefix like VJ does.
+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 m != nil && s.AutoDelete > 0 {
-		err := autodelete.InsertAutodel(autodelete.AutodelData{ChatID: chatID, MessageID: m.MessageId}, s.AutoDelete*60)
-		if err != nil {
-			fmt.Printf("sendfilter: %v\n", err)
-		}
+	if name == "" {
+		name = f.Text
 	}
-}
+	// Strip @usernames and URLs from display name — VJ filter
+	name = usernameRegex.ReplaceAllString(name, "")
+	name = regexp.MustCompile(`(?i)https?://\S+|t\.me/\S+|www\.\S+`).ReplaceAllString(name, "")
+	name = strings.TrimSpace(name)
 
-// sendNoResultsSuggestion sends a "not found" message with a Google Search button.
-// Only triggered when a message is long enough to be a search query.
-//
-//nolint:errcheck
-func sendNoResultsSuggestion(bot *gotgbot.Bot, update *gotgbot.Message, query string, messageID int64) {
-	// Only trigger for messages that look like search queries (3+ chars, not commands)
-	query = strings.TrimSpace(query)
-	if len(query) < 3 || strings.HasPrefix(query, "/") {
-		return
+	// Add size prefix like VJ: "[800MB] Movie Name"
+	prefix := ""
+	if f.FileSize > 0 {
+		prefix = "[" + getFileSize(f.FileSize) + "] "
 	}
-	// Limit to reasonable length
-	if len(strings.Fields(query)) > 8 {
-		return
-	}
-
-	googleQuery := "https://www.google.com/search?q=" + strings.ReplaceAll(query, " ", "+") + "+telegram+movie+bot"
-
-	text := fmt.Sprintf(
-		"❌ <b>No results found for:</b> <code>%s</code>\n\n"+
-			"💡 <i>Check your spelling and try again, or search on Google.</i>",
-		query,
-	)
 
-	s := database.GetBotSettings()
-	m, err := update.Reply(bot, text, &gotgbot.SendMessageOpts{
-		ParseMode: gotgbot.ParseModeHTML,
-		ReplyMarkup: gotgbot.InlineKeyboardMarkup{InlineKeyboard: [][]gotgbot.InlineKeyboardButton{
-			{{Text: "🔍 Search on Google", Url: googleQuery}},
-		}},
-		ReplyParameters: &gotgbot.ReplyParameters{MessageId: messageID},
-	})
-	if err == nil && m != nil && s.AutoDelete > 0 {
-		autodelete.InsertAutodel(autodelete.AutodelData{ChatID: update.Chat.Id, MessageID: m.MessageId}, s.AutoDelete*60)
+	full := prefix + name
+	if len(full) > 58 {
+		full = full[:55] + "..."
 	}
-}
-
-// CbPages handles the no-op "pages" callback (page number display button).
-func CbPages(bot *gotgbot.Bot, ctx *ext.Context) error {
-	ctx.CallbackQuery.Answer(bot, &gotgbot.AnswerCallbackQueryOpts{}) //nolint:errcheck
-	return nil
+	return full
 }

plugins/index.go

@@ -106,17 +106,11 @@ func AutoIndex(bot *gotgbot.Bot, ctx *ext.Context) error {
 		return nil
 	}
 
-	// Skip if an identical global filter already exists
-	if _, exists := DB.GetMfilter(globalNumber, keyword); exists {
-		return nil
-	}
-
 	caption := ""
 	if msg.Caption != "" {
 		caption = msg.OriginalCaptionHTML()
 	}
 
-	// Extract file size and mime type
 	var fileSize int64
 	var mimeType string
 	switch {
@@ -132,10 +126,10 @@ func AutoIndex(bot *gotgbot.Bot, ctx *ext.Context) error {
 	}
 
 	f := &database.Filter{
-		ID:        fileID, // Use Telegram file_id as document _id for deduplication
+		// ID is generated by SaveMfilterByFileID (short, safe for Telegram deep links)
 		ChatID:    globalNumber,
 		Text:      keyword,
-		FileName:  rawName,  // full original name
+		FileName:  rawName,
 		Content:   caption,
 		FileID:    fileID,
 		MediaType: mediaType,
@@ -144,9 +138,14 @@ func AutoIndex(bot *gotgbot.Bot, ctx *ext.Context) error {
 		Length:    len(keyword),
 	}
 
-	DB.SaveMfilterByFileID(f)
-
-	fmt.Printf("auto-index: saved %q from channel %d\n", rawName, msg.Chat.Id)
+	inserted, err := DB.SaveMfilterByFileID(f)
+	if err != nil {
+		fmt.Printf("auto-index: save error: %v\n", err)
+	} else if inserted {
+		fmt.Printf("auto-index: ✅ indexed %q from channel %d\n", rawName, msg.Chat.Id)
+	} else {
+		fmt.Printf("auto-index: ⏭ skipped duplicate %q\n", rawName)
+	}
 	return nil
 }
 
@@ -207,11 +206,6 @@ func IndexNow(bot *gotgbot.Bot, ctx *ext.Context) error {
 		return nil
 	}
 
-	if _, exists := DB.GetMfilter(globalNumber, keyword); exists {
-		msg.Reply(bot, fmt.Sprintf("⚠️ A global filter for <code>%s</code> already exists.", keyword), &gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML})
-		return nil
-	}
-
 	caption := ""
 	if target.Caption != "" {
 		caption = target.OriginalCaptionHTML()
@@ -239,7 +233,6 @@ func IndexNow(bot *gotgbot.Bot, ctx *ext.Context) error {
 	}
 
 	f := &database.Filter{
-		ID:        fileID, // Use file_id as _id for deduplication
 		ChatID:    globalNumber,
 		Text:      keyword,
 		FileName:  origName,
@@ -251,10 +244,17 @@ func IndexNow(bot *gotgbot.Bot, ctx *ext.Context) error {
 		Length:    len(keyword),
 	}
 
-	DB.SaveMfilterByFileID(f)
-
+	inserted, err := DB.SaveMfilterByFileID(f)
+	if err != nil {
+		msg.Reply(bot, fmt.Sprintf("❌ Save error: %v", err), &gotgbot.SendMessageOpts{})
+		return nil
+	}
+	if !inserted {
+		msg.Reply(bot, fmt.Sprintf("⚠️ <code>%s</code> already indexed (duplicate file).", origName), &gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML})
+		return nil
+	}
 	msg.Reply(bot,
-		fmt.Sprintf("✅ Indexed as global filter: <code>%s</code>", keyword),
+		fmt.Sprintf("✅ Indexed: <code>%s</code>\nKeyword: <code>%s</code>", origName, keyword),
 		&gotgbot.SendMessageOpts{ParseMode: gotgbot.ParseModeHTML},
 	)
 	return nil