Blame for database/database.go

// (c) Jisin0

package database

import (
	"context"
	"fmt"
	"log"
	"regexp"
	"strings"
	"sync"
	"time"

	"github.com/Jisin0/Go-Filter-Bot/utils/config"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

var cachedSettings map[int64]*ChatSettings = make(map[int64]*ChatSettings)
var connectionCache map[int64]int64 = make(map[int64]int64) // cache users' connections.
var defaultChatSettings ChatSettings = ChatSettings{
	Stopped: []string{},
}

// ── In-memory filter result cache ─────────────────────────────────────────────

type filterCacheEntry struct {
	results []*Filter
	expiry  time.Time
}

var (
	filterCache    sync.Map
	FilterCacheTTL = 10 * time.Minute
)

func FilterCacheKey(chatID int64, fields []string) string {
	return fmt.Sprintf("%d:%s", chatID, strings.Join(fields, ","))
}

func GetCachedFilterResults(key string) ([]*Filter, bool) {
	v, ok := filterCache.Load(key)
	if !ok {
		return nil, false
	}
	e := v.(*filterCacheEntry)
	if time.Now().After(e.expiry) {
		filterCache.Delete(key)
		return nil, false
	}
	return e.results, true
}

func SetCachedFilterResults(key string, results []*Filter) {
	filterCache.Store(key, &filterCacheEntry{
		results: results,
		expiry:  time.Now().Add(FilterCacheTTL),
	})
}

// Start cache cleanup daemon
func init() {
	go func() {
		for {
			time.Sleep(15 * time.Minute)
			now := time.Now()
			filterCache.Range(func(key, value any) bool {
				if now.After(value.(*filterCacheEntry).expiry) {
					filterCache.Delete(key)
				}
				return true
			})
		}
	}()
}

// InvalidateFilterCache removes all cached entries for a given chatID.
func InvalidateFilterCache(chatID int64) {
	prefix := fmt.Sprintf("%d:", chatID)
	filterCache.Range(func(k, _ any) bool {
		if strings.HasPrefix(k.(string), prefix) {
			filterCache.Delete(k)
		}
		return true
	})
}

// ── Ban cache ──────────────────────────────────────────────────────────────────

var banCache sync.Map // map[int64]bool

// ── Data types ─────────────────────────────────────────────────────────────────

type ChatSettings struct {
	// Stopped Global Filters
	Stopped []string
}

// A filter object stored in the database — VJ-style structure for high hit ratio.
type Filter struct {
	// Unique file_id used as _id (for auto-indexed files) or random string (for manual filters)
	ID string `bson:"_id"`
	// Chat where the filter is in effect
	ChatID int64 `bson:"group_id"`
	// The key/text used for searching — for auto-index this is the cleaned file_name
	Text string `bson:"text"`
	// Full original file name (e.g. "@CinemasTrend Gullak S05E02.mkv")
	FileName string `bson:"file_name,omitempty"`
	// File size in bytes
	FileSize int64 `bson:"file_size,omitempty"`
	// file_ref for Pyrogram compat (optional, empty for Bot API bots)
	FileRef string `bson:"file_ref,omitempty"`
	// MIME type (e.g. "video/x-matroska")
	MimeType string `bson:"mime_type,omitempty"`
	// The text content/caption saved
	Content string `bson:"content,omitempty"`
	// The id of a media saved for the filter if any (Telegram file_id)
	FileID string `bson:"file,omitempty"`
	// Buttons/markup saved for a filter if any
	Markup [][]map[string]string `bson:"button,omitempty"`
	// Alerts saved for a filter if any
	Alerts []string `bson:"alert,omitempty"`
	// Length of the text according to which filters are sorted
	Length int `bson:"length"`
	// Type of media saved if any (video/document/audio/photo/animation/sticker)
	MediaType string `bson:"mediaType,omitempty"`
}

// A User Saved in the database.
type User struct {
	// Unique telegram id of the user.
	ID int64 `bson:"_id"`
	// ID of the chat to which the user is connected.
	ConnectedChat int64 `bson:"connected,omitempty"`
}

// BannedUser is stored in the Banned collection.
type BannedUser struct {
	ID     int64  `bson:"_id"`
	Reason string `bson:"reason,omitempty"`
}

// BotSettings stores ALL bot-wide settings in the database.
// These can be changed at runtime via /settings command.
type BotSettings struct {
	ID             string  `bson:"_id"`
	ForceSubChats  []int64 `bson:"force_sub_chats"`
	IndexChannels  []int64 `bson:"index_channels"`
	MultiFilter    bool    `bson:"multi_filter"`
	SearchAsButton bool    `bson:"search_as_button"`
	AutoDelete     int64   `bson:"auto_delete"`
	ShortenerURL   string  `bson:"shortener_url"`
	ShortenerAPI   string  `bson:"shortener_api"`
	DynamicAdmins  []int64 `bson:"dynamic_admins"`
}

const globalSettingsID = "global"

// In-memory cache of bot settings.
var (
	cachedBotSettings *BotSettings
	botSettingsMu     sync.RWMutex
)

func NewDatabase() *Database {
	if config.MongodbURI == "" {
		log.Fatal("You must set your 'MONGODB_URI' environmental variable :(")
	}

	client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI(config.MongodbURI))
	if err != nil {
		panic(err)
	}

	db := client.Database("Adv_Auto_Filter")

	d := &Database{
		Client:  client,
		DB:      db,
		Ucol:    db.Collection("Users"),
		Col:     db.Collection("Main"),
		Mcol:    db.Collection("Manual_Filters"),
		BanCol:  db.Collection("Banned"),
		GlobCol: db.Collection("GlobalSettings"),
	}

	// Seed defaults from env on first run
	d.SeedBotSettings()

	return d
}

// SeedBotSettings ensures there is a settings doc in the DB.
// On first run it seeds from env vars; after that it loads from DB.
func (db *Database) SeedBotSettings() {
	res := db.GlobCol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: globalSettingsID}})
	if res.Err() == mongo.ErrNoDocuments {
		// First run – seed from env
		s := BotSettings{
			ID:             globalSettingsID,
			ForceSubChats:  config.ForceSubChannels,
			IndexChannels:  config.IndexChannels,
			MultiFilter:    config.MultiFilter,
			SearchAsButton: config.SearchAsButton,
			AutoDelete:     config.AutoDelete,
			ShortenerURL:   config.ShortenerURL,
			ShortenerAPI:   config.ShortenerAPI,
		}
		db.GlobCol.InsertOne(context.TODO(), s)
		botSettingsMu.Lock()
		cachedBotSettings = &s
		botSettingsMu.Unlock()
		fmt.Println("bot settings seeded from env")
	} else {
		// Already exists – load into cache
		var s BotSettings
		res.Decode(&s)
		botSettingsMu.Lock()
		cachedBotSettings = &s
		botSettingsMu.Unlock()
		fmt.Println("bot settings loaded from db")
	}
}

// GetBotSettings returns the cached bot settings.
func GetBotSettings() BotSettings {
	botSettingsMu.RLock()
	defer botSettingsMu.RUnlock()
	if cachedBotSettings == nil {
		return BotSettings{}
	}
	return *cachedBotSettings
}

// SetBotSetting updates a single setting key in the DB and refreshes cache.
func (db *Database) SetBotSetting(key string, value any) error {
	t := true
	_, err := db.GlobCol.UpdateOne(
		context.TODO(),
		bson.D{{Key: "_id", Value: globalSettingsID}},
		bson.D{{Key: "$set", Value: bson.D{{Key: key, Value: value}}}},
		&options.UpdateOptions{Upsert: &t},
	)
	if err != nil {
		fmt.Printf("db.setbotsetting: %v\n", err)
		return err
	}
	db.RefreshBotSettings()
	return nil
}

// RefreshBotSettings reloads settings from DB into cache.
func (db *Database) RefreshBotSettings() {
	res := db.GlobCol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: globalSettingsID}})
	if res.Err() == nil {
		var s BotSettings
		res.Decode(&s)
		botSettingsMu.Lock()
		cachedBotSettings = &s
		botSettingsMu.Unlock()
	}
}

type Database struct {
	// Mongo Client
	Client *mongo.Client
	// Database
	DB *mongo.Database
	// Users Collection
	Ucol *mongo.Collection
	// Main Collection
	Col *mongo.Collection
	// Manual Filters Collection
	Mcol *mongo.Collection
	// Banned Users Collection
	BanCol *mongo.Collection
	// Global Settings Collection
	GlobCol *mongo.Collection
}

// ── User functions ─────────────────────────────────────────────────────────────

func (db *Database) AddUser(userid int64) error {
	var (
		filter = User{ID: userid}
	)

	res := db.Ucol.FindOne(context.TODO(), filter)
	if res.Err() == mongo.ErrNoDocuments {
		_, err := db.Ucol.InsertOne(context.TODO(), filter)
		if err != nil {
			fmt.Printf("db.adduser: %v", err)
		}
	}

	return nil
}

var statText string = `
╭ ▸ <b>Users</b> : <code>%v</code> 
├ ▸ <b>Filters</b> : <code>%v</code>
├ ▸ <b>Groups</b> : <code>%v</code>
╰ ▸ <b>Banned</b> : <code>%v</code>
`

//nolint:errcheck // meh
func (db *Database) Stats() string {
	users, _ := db.Ucol.CountDocuments(context.TODO(), bson.M{})
	chats, _ := db.Col.CountDocuments(context.TODO(), bson.M{})
	mfilters, _ := db.Mcol.CountDocuments(context.TODO(), bson.M{})
	banned, _ := db.BanCol.CountDocuments(context.TODO(), bson.M{})

	return fmt.Sprintf(statText, users, mfilters, chats, banned)
}

func (db *Database) GetConnection(userID int64) (int64, bool) {
	if c, ok := connectionCache[userID]; ok {
		if c == 0 {
			ok = false
		}

		return c, ok
	}

	res := db.Ucol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: userID}})
	if res.Err() != nil { // this shouldn't happen. the user should be saved in the db.
		connectionCache[userID] = 0
		return 0, false
	}

	var doc User

	res.Decode(&doc)

	connectionCache[userID] = doc.ConnectedChat

	if doc.ConnectedChat != 0 {
		return doc.ConnectedChat, true
	}

	return doc.ConnectedChat, false
}

func (db *Database) ConnectUser(userID, chatID int64) {
	var tf = true

	_, err := db.Ucol.UpdateOne(context.TODO(), bson.D{{Key: "_id", Value: userID}}, bson.D{{Key: "$set", Value: bson.D{{Key: "connected", Value: chatID}}}}, &options.UpdateOptions{Upsert: &tf})
	if err != nil {
		fmt.Printf("db.connectuser: %v\n", err)
	}

	// clear any cache.
	delete(connectionCache, userID)
}

func (db *Database) DeleteConnection(userID int64) {
	_, err := db.Ucol.UpdateOne(context.TODO(), bson.D{{Key: "_id", Value: userID}}, bson.D{{Key: "$unset", Value: "connected"}})
	if err != nil {
		fmt.Printf("db.connectuser: %v\n", err)
	}

	// clear any cache.
	delete(connectionCache, userID)
}

// ── Ban functions ──────────────────────────────────────────────────────────────

// BanUser bans a user, preventing the bot from responding to them.
func (db *Database) BanUser(userID int64, reason string) error {
	banCache.Store(userID, true)
	t := true
	_, err := db.BanCol.UpdateOne(
		context.TODO(),
		bson.D{{Key: "_id", Value: userID}},
		bson.D{{Key: "$set", Value: bson.D{
			{Key: "_id", Value: userID},
			{Key: "reason", Value: reason},
		}}},
		&options.UpdateOptions{Upsert: &t},
	)
	if err != nil {
		fmt.Printf("db.banuser: %v\n", err)
	}
	return err
}

// UnbanUser removes a ban from a user.
func (db *Database) UnbanUser(userID int64) error {
	banCache.Delete(userID)
	_, err := db.BanCol.DeleteOne(context.TODO(), bson.D{{Key: "_id", Value: userID}})
	if err != nil {
		fmt.Printf("db.unbanuser: %v\n", err)
	}
	return err
}

// IsBanned checks if a user is banned. Uses in-memory cache first.
func (db *Database) IsBanned(userID int64) bool {
	if v, ok := banCache.Load(userID); ok {
		return v.(bool)
	}
	res := db.BanCol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: userID}})
	banned := res.Err() == nil
	banCache.Store(userID, banned)
	return banned
}

// GetBannedUsers returns all banned users.
func (db *Database) GetBannedUsers() ([]BannedUser, error) {
	cur, err := db.BanCol.Find(context.TODO(), bson.D{})
	if err != nil {
		return nil, err
	}
	var users []BannedUser
	if err := cur.All(context.TODO(), &users); err != nil {
		return nil, err
	}
	return users, nil
}

// ── Force-sub functions ────────────────────────────────────────────────────────

// GetForceSubChannels reads from the cached bot settings.
func (db *Database) GetForceSubChannels() []int64 {
	return GetBotSettings().ForceSubChats
}

// AddForceSubChannel adds a channel to the force-sub list and refreshes cache.
func (db *Database) AddForceSubChannel(chanID int64) error {
	t := true
	_, err := db.GlobCol.UpdateOne(
		context.TODO(),
		bson.D{{Key: "_id", Value: globalSettingsID}},
		bson.D{{Key: "$addToSet", Value: bson.D{{Key: "force_sub_chats", Value: chanID}}}},
		&options.UpdateOptions{Upsert: &t},
	)
	if err != nil && strings.Contains(err.Error(), "non-array type null") {
		_, err = db.GlobCol.UpdateOne(
			context.TODO(),
			bson.D{{Key: "_id", Value: globalSettingsID}},
			bson.D{{Key: "$set", Value: bson.D{{Key: "force_sub_chats", Value: []int64{chanID}}}}},
		)
	}
	if err == nil {
		db.RefreshBotSettings()
	}
	return err
}

// RemoveForceSubChannel removes a channel from the force-sub list and refreshes cache.
func (db *Database) RemoveForceSubChannel(chanID int64) error {
	_, err := db.GlobCol.UpdateOne(
		context.TODO(),
		bson.D{{Key: "_id", Value: globalSettingsID}},
		bson.D{{Key: "$pull", Value: bson.D{{Key: "force_sub_chats", Value: chanID}}}},
	)
	if err != nil && strings.Contains(err.Error(), "non-array type null") {
		_, err = db.GlobCol.UpdateOne(
			context.TODO(),
			bson.D{{Key: "_id", Value: globalSettingsID}},
			bson.D{{Key: "$set", Value: bson.D{{Key: "force_sub_chats", Value: []int64{}}}}},
		)
	}
	if err == nil {
		db.RefreshBotSettings()
	}
	return err
}

// ── Auto-Index functions ───────────────────────────────────────────────────────

// AddIndexChannel adds a channel to the auto-index list.
func (db *Database) AddIndexChannel(chanID int64) error {
	t := true
	_, err := db.GlobCol.UpdateOne(
		context.TODO(),
		bson.D{{Key: "_id", Value: globalSettingsID}},
		bson.D{{Key: "$addToSet", Value: bson.D{{Key: "index_channels", Value: chanID}}}},
		&options.UpdateOptions{Upsert: &t},
	)
	if err != nil && strings.Contains(err.Error(), "non-array type null") {
		_, err = db.GlobCol.UpdateOne(
			context.TODO(),
			bson.D{{Key: "_id", Value: globalSettingsID}},
			bson.D{{Key: "$set", Value: bson.D{{Key: "index_channels", Value: []int64{chanID}}}}},
		)
	}
	if err == nil {
		db.RefreshBotSettings()
	}
	return err
}

// RemoveIndexChannel removes a channel from the auto-index list.
func (db *Database) RemoveIndexChannel(chanID int64) error {
	_, err := db.GlobCol.UpdateOne(
		context.TODO(),
		bson.D{{Key: "_id", Value: globalSettingsID}},
		bson.D{{Key: "$pull", Value: bson.D{{Key: "index_channels", Value: chanID}}}},
	)
	if err != nil && strings.Contains(err.Error(), "non-array type null") {
		_, err = db.GlobCol.UpdateOne(
			context.TODO(),
			bson.D{{Key: "_id", Value: globalSettingsID}},
			bson.D{{Key: "$set", Value: bson.D{{Key: "index_channels", Value: []int64{}}}}},
		)
	}
	if err == nil {
		db.RefreshBotSettings()
	}
	return err
}

// ── Filter functions ───────────────────────────────────────────────────────────

func (db *Database) SaveMfilter(data *Filter) {
	_, err := db.Mcol.InsertOne(context.TODO(), data)
	if err != nil {
		fmt.Printf("db.savemfilter: %v\n", err)
	}
	InvalidateFilterCache(data.ChatID)
}

// Returns all manual filters for a chat.
func (db *Database) GetMfilters(chatID int64) (*mongo.Cursor, error) {
	return db.Mcol.Aggregate(
		context.TODO(),
		[]bson.D{
			{{Key: "$match", Value: bson.D{{Key: "group_id", Value: chatID}}}},
			{{Key: "$sort", Value: bson.D{{Key: "length", Value: -1}}}},
		},
	)
}

// SearchMfilterClassic uses the traditional way of fetching mfilters by fetching all mfilters of a chat and doing regex queries individually.
// This method is more resource intensive but could be faster for large scale bots with several hundred/thousand groups.
func (db *Database) SearchMfilterClassic(chatID int64, input string) (results []*Filter) {
	res, e := db.GetMfilters(chatID)
	if e != nil {
		fmt.Printf("db.searchmfiltersclassic: %v\n", e)
		return results
	}

	for res.Next(context.TODO()) {
		var f Filter

		err := res.Decode(&f)
		if err != nil {
			fmt.Printf("db.searchmfilterclassic: %v\n", err)
			continue
		}

		text := `(?i)( |^|[^\w])` + f.Text + `( |$|[^\w])`

		pattern := regexp.MustCompile(text)

		m := pattern.FindStringSubmatch(input)
		if len(m) > 0 {
			results = append(results, &f)
		}
	}

	return results
}

// SearchMfilterNew does a regex query on the database — searches both text and file_name
// fields for a much higher hit ratio (VJ-style approach).
func (db *Database) SearchMfilterNew(chatID int64, fields []string, multiFilter bool) (results []*Filter) {
	// Build a pattern that matches any word from the query
	pattern := "(?i)(" + strings.Join(fields, "|") + ")"

	// Search in BOTH text and file_name fields for maximum coverage
	filter := bson.D{
		{Key: "group_id", Value: chatID},
		{Key: "$or", Value: bson.A{
			bson.D{{Key: "text", Value: bson.M{"$regex": pattern}}},
			bson.D{{Key: "file_name", Value: bson.M{"$regex": pattern}}},
		}},
	}

	if !multiFilter {
		res := db.Mcol.FindOne(context.Background(), filter)
		switch res.Err() {
		case mongo.ErrNoDocuments:
			return results
		case nil:
			var f Filter
			if err := res.Decode(&f); err != nil {
				fmt.Printf("db.searchmfilternew: %v\n", err)
				return results
			}
			return append(results, &f)
		}
	}

	res, err := db.Mcol.Find(context.Background(), filter, options.Find().SetSort(bson.D{{Key: "length", Value: -1}}).SetLimit(50))
	if err != nil {
		fmt.Printf("db.searchmfilternew: %v\n", err)
		return results
	}

	for res.Next(context.Background()) {
		var r Filter
		if err := res.Decode(&r); err != nil {
			fmt.Printf("db.searchmfilternew: %v\n", err)
			continue
		}
		results = append(results, &r)
	}

	return results
}

func (db *Database) GetMfilter(chatID int64, key string) (bson.M, bool) {
	res := db.Mcol.FindOne(context.TODO(), bson.D{{Key: "group_id", Value: chatID}, {Key: "text", Value: key}})

	var b bson.M

	if res.Err() != nil {
		return b, false
	} else {
		err := res.Decode(&b)
		if err != nil {
			fmt.Printf("db.getmfilter: %v\n", err)
			return b, false
		}

		return b, true
	}
}

func (db *Database) StringMfilter(chatID int64) string {
	r, err := db.GetMfilters(chatID)
	if err != nil {
		return fmt.Sprintf("failed to get filters: %v", err)
	}

	var text string

	for r.Next(context.TODO()) {
		var d bson.M

		r.Decode(&d)
		text += fmt.Sprintf("\n• <code>%v</code>", d["text"])
	}

	return text
}

func (db *Database) StopGfilter(chatID int64, key string) {
	var t = true

	_, err := db.Col.UpdateOne(context.TODO(), bson.D{{Key: "_id", Value: chatID}}, bson.D{{Key: "$append", Value: bson.D{{Key: "stopped", Value: key}}}}, &options.UpdateOptions{Upsert: &t})
	if err != nil {
		fmt.Println(err)
	}

	go db.RecacheSettings(chatID)
}

func (db *Database) DeleteMfilter(chatID int64, key string) {
	_, err := db.Mcol.DeleteOne(context.TODO(), bson.D{{Key: "group_id", Value: chatID}, {Key: "text", Value: key}})
	if err != nil {
		fmt.Printf("db.deletemfilter: %v\n", err)
	}
	InvalidateFilterCache(chatID)
}

func (db *Database) SetChatSetting(chatID int64, key string, value any) {
	go db.SetDefaultSettings(chatID)

	_, err := db.Col.UpdateOne(context.TODO(), bson.D{{Key: "_id", Value: chatID}}, bson.D{{Key: "$set", Value: bson.D{{Key: key, Value: value}}}})
	if err != nil {
		fmt.Printf("db.connectuser: %v\n", err)
		return
	}

	go db.RecacheSettings(chatID)
}

func (db *Database) SetDefaultSettings(chatID int64) {
	r := db.Col.FindOne(context.TODO(), bson.D{{Key: "_id", Value: chatID}})
	if r.Err() == mongo.ErrNoDocuments {
		db.Col.InsertOne(context.TODO(), defaultSettings(chatID))
	}
}

func defaultSettings(chatID int64) bson.D {
	return bson.D{
		{Key: "_id", Value: chatID},
	}
}

// A Function To Update Cached Settings With Latest From DB
func (db *Database) RecacheSettings(chatID int64) {
	res := db.Col.FindOne(context.TODO(), bson.D{{Key: "_id", Value: chatID}})
	if res.Err() == mongo.ErrNoDocuments {
		cachedSettings[chatID] = &defaultChatSettings
	} else {
		var r ChatSettings

		err := res.Decode(&r)
		if err != nil {
			fmt.Printf("db.recachesettings: %v\n", err)
			return
		}

		cachedSettings[chatID] = &r
	}
}

func (db *Database) GetCachedSetting(chatID int64) *ChatSettings {
	s, e := cachedSettings[chatID]
	if !e {
		go db.RecacheSettings(chatID)
		return &defaultChatSettings
	} else {
		return s
	}
}

func (db *Database) StartGfilter(chatID int64, key string) {
	keys := db.GetCachedSetting(chatID).Stopped
	for i, k := range keys {
		if k == key {
			keys[i] = keys[len(keys)-1]
			keys = keys[:len(keys)-1]
		}
	}

	_, err := db.Col.UpdateOne(context.TODO(), bson.D{{Key: "_id", Value: chatID}}, bson.D{{Key: "$set", Value: bson.D{{Key: "stopped", Value: keys}}}})
	if err != nil {
		fmt.Printf("db.startgfilter: %v\n", err)
	}

	go db.RecacheSettings(chatID)
}

func (db *Database) GetAlert(uniqueID string, index int) string {
	defaultString := "404: Content Not Found !"
	res := db.Mcol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: uniqueID}})

	var f Filter

	res.Decode(&f)

	if len(f.Alerts) < index+1 {
		return defaultString
	} else {
		return f.Alerts[index]
	}
}

// ── Dynamic Admin functions ────────────────────────────────────────────────────

// GetDynamicAdmins returns the list of dynamically added admins from DB.
func (db *Database) GetDynamicAdmins() []int64 {
	s := GetBotSettings()
	return s.DynamicAdmins
}

// AddDynamicAdmin adds a user to the dynamic admins list.
func (db *Database) AddDynamicAdmin(userID int64) error {
	t := true
	_, err := db.GlobCol.UpdateOne(
		context.TODO(),
		bson.D{{Key: "_id", Value: globalSettingsID}},
		bson.D{{Key: "$addToSet", Value: bson.D{{Key: "dynamic_admins", Value: userID}}}},
		&options.UpdateOptions{Upsert: &t},
	)
	if err == nil {
		db.RefreshBotSettings()
	}
	return err
}

// RemoveDynamicAdmin removes a user from the dynamic admins list.
func (db *Database) RemoveDynamicAdmin(userID int64) error {
	_, err := db.GlobCol.UpdateOne(
		context.TODO(),
		bson.D{{Key: "_id", Value: globalSettingsID}},
		bson.D{{Key: "$pull", Value: bson.D{{Key: "dynamic_admins", Value: userID}}}},
	)
	if err != nil && strings.Contains(err.Error(), "non-array type null") {
		_, err = db.GlobCol.UpdateOne(
			context.TODO(),
			bson.D{{Key: "_id", Value: globalSettingsID}},
			bson.D{{Key: "$set", Value: bson.D{{Key: "dynamic_admins", Value: []int64{}}}}},
		)
	}
	if err == nil {
		db.RefreshBotSettings()
	}
	return err
}

// GetAllUserIDs returns all user IDs stored in the DB.
func (db *Database) GetAllUserIDs() ([]int64, error) {
	cur, err := db.Ucol.Find(context.TODO(), bson.M{})
	if err != nil {
		return nil, err
	}
	defer cur.Close(context.TODO())

	var ids []int64
	for cur.Next(context.TODO()) {
		var u User
		if err := cur.Decode(&u); err == nil {
			ids = append(ids, u.ID)
		}
	}
	return ids, nil
}

// GetBotSettingsAdminsEnv returns the env-seeded admins (stored in config).
// This is just a passthrough so plugins don't need to import config directly.
func (db *Database) GetBotSettingsAdminsEnv() []int64 {
	return config.Admins
}

// AddUserAndCheck adds a user and returns true if they were new (not in DB before).
func (db *Database) AddUserAndCheck(userid int64) bool {
	filter := User{ID: userid}
	res := db.Ucol.FindOne(context.TODO(), bson.D{{Key: "_id", Value: userid}})
	if res.Err() == mongo.ErrNoDocuments {
		db.Ucol.InsertOne(context.TODO(), filter)
		return true // new user
	}
	return false
}

// CleanGhostFilters removes bad "reference" type docs and channel-msg-style text docs.
// Returns the number of documents deleted.
func (db *Database) CleanGhostFilters() int64 {
	res1, _ := db.Mcol.DeleteMany(context.TODO(), bson.D{{Key: "mediaType", Value: "reference"}})
	// Also clean docs where text looks like "channel_-100xxx_msg_xx"
	res2, _ := db.Mcol.DeleteMany(context.TODO(), bson.D{
		{Key: "text", Value: bson.D{{Key: "$regex", Value: `^channel_-\d+_msg_\d+$`}}},
	})
	count := int64(0)
	if res1 != nil {
		count += res1.DeletedCount
	}
	if res2 != nil {
		count += res2.DeletedCount
	}
	return count
}

// 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 true, nil
}

// MigrateLongIDs finds documents whose _id is a long Telegram file_id (>20 chars)
// and re-inserts them with a short random _id (safe for Telegram callback_data,
// which has a 64-byte total limit including the "file()" wrapper).
// Returns the number of documents migrated.
func (db *Database) MigrateLongIDs() (int, error) {
	// Find all docs in the global filter namespace with a long _id
	cur, err := db.Mcol.Find(context.TODO(), bson.D{
		{Key: "group_id", Value: 101},
	})
	if err != nil {
		return 0, err
	}
	defer cur.Close(context.TODO())

	migrated := 0
	for cur.Next(context.TODO()) {
		var f Filter
		if err := cur.Decode(&f); err != nil {
			continue
		}
		if len(f.ID) <= 20 {
			continue // already short, skip
		}

		oldID := f.ID
		newID := randShortID(15)

		// Insert with new short _id
		f.ID = newID
		if _, err := db.Mcol.InsertOne(context.TODO(), f); err != nil {
			continue
		}
		// Delete the old long-_id document
		if _, err := db.Mcol.DeleteOne(context.TODO(), bson.D{{Key: "_id", Value: oldID}}); err != nil {
			fmt.Printf("MigrateLongIDs: failed to delete old doc %s: %v\n", oldID, err)
			continue
		}
		migrated++
	}
	return migrated, nil
}