MongoDB Full-Text Search and Advanced Indexing: SQL-Style Text Queries and Search Optimization

-- SQL basic text search limitations

-- Simple pattern matching - case sensitive, no relevance
SELECT product_name, description, price
FROM products
WHERE product_name LIKE '%laptop%'
   OR description LIKE '%laptop%';
-- Problems: Case sensitivity, no stemming, no relevance scoring

-- Regular expressions - expensive and limited
SELECT title, content, author
FROM articles  
WHERE content ~* '(machine|artificial|deep).*(learning|intelligence)';
-- Problems: No ranking, poor performance on large datasets

-- Multiple keyword search - complex and inefficient
SELECT *
FROM products
WHERE (LOWER(product_name) LIKE '%gaming%' OR LOWER(description) LIKE '%gaming%')
  AND (LOWER(product_name) LIKE '%laptop%' OR LOWER(description) LIKE '%laptop%')
  AND (LOWER(product_name) LIKE '%performance%' OR LOWER(description) LIKE '%performance%');
-- Problems: Complex syntax, no semantic understanding, poor performance

// MongoDB advanced text search capabilities
db.products.find({
  $text: {
    $search: "gaming laptop performance",
    $language: "english",
    $caseSensitive: false,
    $diacriticSensitive: false
  }
}, {
  score: { $meta: "textScore" }
}).sort({
  score: { $meta: "textScore" }
});

// Results include:
// - Stemming: "games" matches "gaming"  
// - Language-specific tokenization
// - Relevance scoring based on term frequency and position
// - Multi-field search across indexed text fields
// - Performance optimized with specialized text indexes

// Basic text index creation
db.products.createIndex({
  product_name: "text",
  description: "text",
  category: "text"
});

// Weighted text index for relevance tuning
db.products.createIndex({
  product_name: "text",
  description: "text", 
  tags: "text",
  category: "text"
}, {
  weights: {
    product_name: 10,    // Product name is most important
    description: 5,      // Description has medium importance  
    tags: 8,            // Tags are highly relevant
    category: 3         // Category provides context
  },
  name: "product_text_search",
  default_language: "english",
  language_override: "language"
});

// Compound index combining text search with other criteria
db.products.createIndex({
  category: 1,           // Standard index for filtering
  price: 1,             // Range queries
  product_name: "text",  // Text search
  description: "text"
}, {
  weights: {
    product_name: 15,
    description: 8
  }
});

// Multi-language text index
db.articles.createIndex({
  title: "text",
  content: "text"
}, {
  default_language: "english",
  language_override: "lang",  // Document field that specifies language
  weights: {
    title: 20,
    content: 10
  }
});

-- SQL full-text search equivalent patterns

-- Create full-text index on multiple columns
CREATE FULLTEXT INDEX ft_products_search 
ON products (product_name, description, tags);

-- Weighted full-text search with relevance ranking
SELECT 
  product_id,
  product_name,
  description,
  MATCH(product_name, description, tags) 
    AGAINST('gaming laptop performance' IN NATURAL LANGUAGE MODE) AS relevance_score
FROM products
WHERE MATCH(product_name, description, tags) 
  AGAINST('gaming laptop performance' IN NATURAL LANGUAGE MODE)
ORDER BY relevance_score DESC;

-- Boolean full-text search with operators
SELECT *
FROM products
WHERE MATCH(product_name, description) 
  AGAINST('+gaming +laptop -refurbished' IN BOOLEAN MODE);

-- Full-text search with additional filtering
SELECT 
  product_name,
  price,
  category,
  MATCH(product_name, description) 
    AGAINST('high performance gaming' IN NATURAL LANGUAGE MODE) AS score
FROM products
WHERE price BETWEEN 1000 AND 3000
  AND category = 'computers'
  AND MATCH(product_name, description) 
    AGAINST('high performance gaming' IN NATURAL LANGUAGE MODE)
ORDER BY score DESC
LIMIT 20;

// Advanced text search implementation
class TextSearchService {
  constructor(db) {
    this.db = db;
    this.productsCollection = db.collection('products');
  }

  async basicTextSearch(searchTerm, options = {}) {
    const query = {
      $text: {
        $search: searchTerm,
        $language: options.language || "english",
        $caseSensitive: options.caseSensitive || false,
        $diacriticSensitive: options.diacriticSensitive || false
      }
    };

    // Add additional filters
    if (options.category) {
      query.category = options.category;
    }

    if (options.priceRange) {
      query.price = {
        $gte: options.priceRange.min,
        $lte: options.priceRange.max
      };
    }

    const results = await this.productsCollection.find(query, {
      projection: {
        product_name: 1,
        description: 1,
        price: 1,
        category: 1,
        score: { $meta: "textScore" }
      }
    })
    .sort({ score: { $meta: "textScore" } })
    .limit(options.limit || 20)
    .toArray();

    return results;
  }

  async phraseSearch(phrase, options = {}) {
    // Exact phrase search using quoted strings
    const query = {
      $text: {
        $search: `"${phrase}"`,
        $language: options.language || "english"
      }
    };

    return await this.productsCollection.find(query, {
      projection: {
        product_name: 1,
        description: 1,
        score: { $meta: "textScore" }
      }
    })
    .sort({ score: { $meta: "textScore" } })
    .limit(options.limit || 10)
    .toArray();
  }

  async booleanTextSearch(searchExpression, options = {}) {
    // Boolean search with inclusion/exclusion operators
    const query = {
      $text: {
        $search: searchExpression,  // e.g., "laptop gaming -refurbished"
        $language: options.language || "english"
      }
    };

    return await this.productsCollection.find(query, {
      projection: {
        product_name: 1,
        description: 1,
        price: 1,
        score: { $meta: "textScore" }
      }
    })
    .sort({ score: { $meta: "textScore" } })
    .limit(options.limit || 20)
    .toArray();
  }

  async fuzzySearch(searchTerm, options = {}) {
    // Combine text search with regex for fuzzy matching
    const textResults = await this.basicTextSearch(searchTerm, options);

    // Fuzzy fallback using regex for typos/variations
    if (textResults.length < 5) {
      const fuzzyPattern = this.buildFuzzyPattern(searchTerm);
      const regexQuery = {
        $or: [
          { product_name: { $regex: fuzzyPattern, $options: 'i' } },
          { description: { $regex: fuzzyPattern, $options: 'i' } }
        ]
      };

      const fuzzyResults = await this.productsCollection.find(regexQuery)
        .limit(10 - textResults.length)
        .toArray();

      return [...textResults, ...fuzzyResults];
    }

    return textResults;
  }

  buildFuzzyPattern(term) {
    // Create regex pattern allowing character variations
    const chars = term.split('');
    const pattern = chars.map(char => {
      return `${char}.*?`;
    }).join('');

    return pattern;
  }

  async searchWithFacets(searchTerm, facetFields = ['category', 'brand', 'price_range']) {
    const pipeline = [
      {
        $match: {
          $text: { $search: searchTerm }
        }
      },
      {
        $addFields: {
          score: { $meta: "textScore" },
          price_range: {
            $switch: {
              branches: [
                { case: { $lte: ["$price", 500] }, then: "Under $500" },
                { case: { $lte: ["$price", 1000] }, then: "$500 - $1000" },
                { case: { $lte: ["$price", 2000] }, then: "$1000 - $2000" },
                { case: { $gt: ["$price", 2000] }, then: "Over $2000" }
              ],
              default: "Unknown"
            }
          }
        }
      },
      {
        $facet: {
          results: [
            { $sort: { score: -1 } },
            { $limit: 20 },
            {
              $project: {
                product_name: 1,
                description: 1,
                price: 1,
                category: 1,
                brand: 1,
                score: 1
              }
            }
          ],
          category_facets: [
            { $group: { _id: "$category", count: { $sum: 1 } } },
            { $sort: { count: -1 } }
          ],
          brand_facets: [
            { $group: { _id: "$brand", count: { $sum: 1 } } },
            { $sort: { count: -1 } }
          ],
          price_facets: [
            { $group: { _id: "$price_range", count: { $sum: 1 } } },
            { $sort: { _id: 1 } }
          ]
        }
      }
    ];

    const facetResults = await this.productsCollection.aggregate(pipeline).toArray();
    return facetResults[0];
  }

  async autoComplete(prefix, field = 'product_name', limit = 10) {
    // Auto-completion using regex and text search
    const pipeline = [
      {
        $match: {
          [field]: { $regex: `^${prefix}`, $options: 'i' }
        }
      },
      {
        $group: {
          _id: `$${field}`,
          count: { $sum: 1 }
        }
      },
      {
        $sort: { count: -1 }
      },
      {
        $limit: limit
      },
      {
        $project: {
          suggestion: "$_id",
          frequency: "$count",
          _id: 0
        }
      }
    ];

    return await this.productsCollection.aggregate(pipeline).toArray();
  }
}

// Multi-language text search implementation
class MultiLanguageSearchService {
  constructor(db) {
    this.db = db;
    this.documentsCollection = db.collection('documents');

    // Language-specific stemming and stop words
    this.languageConfig = {
      english: { 
        stopwords: ['the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'],
        stemming: true
      },
      spanish: {
        stopwords: ['el', 'la', 'y', 'o', 'pero', 'en', 'con', 'por', 'para', 'de'],
        stemming: true
      },
      french: {
        stopwords: ['le', 'la', 'et', 'ou', 'mais', 'dans', 'sur', 'avec', 'par', 'pour', 'de'],
        stemming: true
      }
    };
  }

  async setupMultiLanguageIndexes() {
    // Create language-specific text indexes
    for (const [language, config] of Object.entries(this.languageConfig)) {
      await this.documentsCollection.createIndex({
        title: "text",
        content: "text",
        tags: "text"
      }, {
        name: `text_search_${language}`,
        default_language: language,
        language_override: "lang",
        weights: {
          title: 15,
          content: 10,
          tags: 8
        }
      });
    }

    // Create compound index with language field
    await this.documentsCollection.createIndex({
      language: 1,
      title: "text",
      content: "text"
    }, {
      name: "multilang_text_search"
    });
  }

  async searchMultiLanguage(searchTerm, targetLanguage = null, options = {}) {
    const query = {
      $text: {
        $search: searchTerm,
        $language: targetLanguage || "english",
        $caseSensitive: false,
        $diacriticSensitive: false
      }
    };

    // Filter by specific language if provided
    if (targetLanguage) {
      query.language = targetLanguage;
    }

    const pipeline = [
      { $match: query },
      {
        $addFields: {
          score: { $meta: "textScore" },
          // Boost score for exact language match
          language_bonus: {
            $cond: {
              if: { $eq: ["$language", targetLanguage || "english"] },
              then: 1.5,
              else: 1.0
            }
          }
        }
      },
      {
        $addFields: {
          adjusted_score: { $multiply: ["$score", "$language_bonus"] }
        }
      },
      {
        $sort: { adjusted_score: -1 }
      },
      {
        $limit: options.limit || 20
      },
      {
        $project: {
          title: 1,
          content: { $substr: ["$content", 0, 200] }, // Excerpt
          language: 1,
          author: 1,
          created_at: 1,
          score: "$adjusted_score"
        }
      }
    ];

    return await this.documentsCollection.aggregate(pipeline).toArray();
  }

  async detectLanguage(text) {
    // Simple language detection based on common words
    const words = text.toLowerCase().split(/\s+/);
    const languageScores = {};

    for (const [language, config] of Object.entries(this.languageConfig)) {
      const stopwordMatches = words.filter(word => 
        config.stopwords.includes(word)
      ).length;

      languageScores[language] = stopwordMatches / words.length;
    }

    // Return language with highest score
    return Object.entries(languageScores)
      .sort(([,a], [,b]) => b - a)[0][0];
  }

  async searchWithLanguageDetection(searchTerm, options = {}) {
    // Auto-detect search term language
    const detectedLanguage = await this.detectLanguage(searchTerm);

    return await this.searchMultiLanguage(searchTerm, detectedLanguage, options);
  }

  async translateAndSearch(searchTerm, sourceLanguage, targetLanguages = ['english']) {
    // This would integrate with translation services
    const searchResults = new Map();

    for (const targetLanguage of targetLanguages) {
      // Placeholder for translation service integration
      const translatedTerm = await this.translateTerm(searchTerm, sourceLanguage, targetLanguage);

      const results = await this.searchMultiLanguage(translatedTerm, targetLanguage);
      searchResults.set(targetLanguage, results);
    }

    return searchResults;
  }

  async translateTerm(term, from, to) {
    // Placeholder for translation service
    // In practice, integrate with Google Translate, AWS Translate, etc.
    return term; // Return original term for now
  }
}

// Search analytics and performance optimization
class SearchAnalytics {
  constructor(db) {
    this.db = db;
    this.searchLogsCollection = db.collection('search_logs');
    this.productsCollection = db.collection('products');
  }

  async logSearchQuery(searchData) {
    const logEntry = {
      search_term: searchData.query,
      user_id: searchData.userId,
      session_id: searchData.sessionId,
      timestamp: new Date(),
      results_count: searchData.resultsCount,
      clicked_results: [],
      execution_time_ms: searchData.executionTime,
      search_type: searchData.searchType, // basic, fuzzy, phrase, etc.
      filters_applied: searchData.filters || {},
      user_agent: searchData.userAgent,
      ip_address: searchData.ipAddress
    };

    await this.searchLogsCollection.insertOne(logEntry);
    return logEntry._id;
  }

  async trackSearchClick(searchLogId, clickedResult) {
    await this.searchLogsCollection.updateOne(
      { _id: searchLogId },
      {
        $push: {
          clicked_results: {
            result_id: clickedResult.id,
            result_position: clickedResult.position,
            clicked_at: new Date()
          }
        }
      }
    );
  }

  async getSearchAnalytics(timeframe = 7) {
    const since = new Date(Date.now() - timeframe * 24 * 60 * 60 * 1000);

    const pipeline = [
      {
        $match: {
          timestamp: { $gte: since }
        }
      },
      {
        $group: {
          _id: {
            search_term: { $toLower: "$search_term" },
            date: { $dateToString: { format: "%Y-%m-%d", date: "$timestamp" } }
          },
          search_count: { $sum: 1 },
          avg_results: { $avg: "$results_count" },
          avg_execution_time: { $avg: "$execution_time_ms" },
          unique_users: { $addToSet: "$user_id" },
          click_through_rate: {
            $avg: {
              $cond: {
                if: { $gt: [{ $size: "$clicked_results" }, 0] },
                then: 1,
                else: 0
              }
            }
          }
        }
      },
      {
        $addFields: {
          unique_user_count: { $size: "$unique_users" }
        }
      },
      {
        $sort: { search_count: -1 }
      },
      {
        $limit: 100
      }
    ];

    return await this.searchLogsCollection.aggregate(pipeline).toArray();
  }

  async getPopularSearchTerms(limit = 20) {
    const pipeline = [
      {
        $match: {
          timestamp: { $gte: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000) }
        }
      },
      {
        $group: {
          _id: { $toLower: "$search_term" },
          frequency: { $sum: 1 },
          avg_results: { $avg: "$results_count" },
          click_rate: {
            $avg: {
              $cond: {
                if: { $gt: [{ $size: "$clicked_results" }, 0] },
                then: 1,
                else: 0
              }
            }
          }
        }
      },
      {
        $match: {
          frequency: { $gte: 2 }  // Only terms searched more than once
        }
      },
      {
        $sort: { frequency: -1 }
      },
      {
        $limit: limit
      },
      {
        $project: {
          search_term: "$_id",
          frequency: 1,
          avg_results: { $round: ["$avg_results", 1] },
          click_rate: { $round: ["$click_rate", 3] },
          _id: 0
        }
      }
    ];

    return await this.searchLogsCollection.aggregate(pipeline).toArray();
  }

  async identifyZeroResultQueries(limit = 50) {
    const pipeline = [
      {
        $match: {
          results_count: 0,
          timestamp: { $gte: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000) }
        }
      },
      {
        $group: {
          _id: { $toLower: "$search_term" },
          occurrence_count: { $sum: 1 },
          last_searched: { $max: "$timestamp" }
        }
      },
      {
        $sort: { occurrence_count: -1 }
      },
      {
        $limit: limit
      },
      {
        $project: {
          search_term: "$_id",
          occurrence_count: 1,
          last_searched: 1,
          _id: 0
        }
      }
    ];

    return await this.searchLogsCollection.aggregate(pipeline).toArray();
  }

  async optimizeSearchIndexes() {
    // Analyze query patterns to optimize indexes
    const searchPatterns = await this.getSearchAnalytics(30);

    const optimizationRecommendations = [];

    for (const pattern of searchPatterns) {
      const searchTerm = pattern._id.search_term;

      // Check if current indexes are efficient for common queries
      const indexStats = await this.productsCollection.aggregate([
        { $indexStats: {} }
      ]).toArray();

      // Analyze index usage for text searches
      const textIndexUsage = indexStats.filter(stat => 
        stat.name.includes('text') || stat.key.hasOwnProperty('_fts')
      );

      if (pattern.avg_execution_time > 100) { // Slow queries > 100ms
        optimizationRecommendations.push({
          issue: 'slow_search',
          search_term: searchTerm,
          avg_time: pattern.avg_execution_time,
          recommendation: 'Consider adding compound index for frequent filters'
        });
      }

      if (pattern.avg_results < 1) { // Very few results
        optimizationRecommendations.push({
          issue: 'low_recall',
          search_term: searchTerm,
          avg_results: pattern.avg_results,
          recommendation: 'Consider fuzzy matching or synonym expansion'
        });
      }
    }

    return optimizationRecommendations;
  }

  async generateSearchSuggestions() {
    // Generate search suggestions based on popular terms
    const popularTerms = await this.getPopularSearchTerms(100);

    const suggestions = [];

    for (const term of popularTerms) {
      // Extract keywords from successful searches
      const keywords = term.search_term.split(' ').filter(word => word.length > 2);

      for (const keyword of keywords) {
        // Find related products to suggest similar searches
        const relatedProducts = await this.productsCollection.find({
          $text: { $search: keyword }
        }, {
          projection: { product_name: 1, category: 1, tags: 1 }
        }).limit(5).toArray();

        const relatedTerms = new Set();

        relatedProducts.forEach(product => {
          // Extract terms from product names and categories
          const productWords = product.product_name.toLowerCase().split(/\s+/);
          const categoryWords = product.category ? product.category.toLowerCase().split(/\s+/) : [];
          const tagWords = product.tags ? product.tags.flatMap(tag => tag.toLowerCase().split(/\s+/)) : [];

          [...productWords, ...categoryWords, ...tagWords].forEach(word => {
            if (word.length > 2 && word !== keyword) {
              relatedTerms.add(word);
            }
          });
        });

        if (relatedTerms.size > 0) {
          suggestions.push({
            base_term: keyword,
            suggested_terms: Array.from(relatedTerms).slice(0, 5),
            popularity: term.frequency
          });
        }
      }
    }

    return suggestions.slice(0, 50); // Top 50 suggestions
  }
}

// Real-time search suggestions system
class SearchSuggestionEngine {
  constructor(db) {
    this.db = db;
    this.suggestionsCollection = db.collection('search_suggestions');
    this.productsCollection = db.collection('products');
  }

  async buildSuggestionIndex() {
    // Create suggestions from product data
    const products = await this.productsCollection.find({}, {
      projection: {
        product_name: 1,
        category: 1,
        brand: 1,
        tags: 1,
        description: 1
      }
    }).toArray();

    const suggestionSet = new Set();

    for (const product of products) {
      // Extract searchable terms
      const terms = this.extractTerms(product);
      terms.forEach(term => suggestionSet.add(term));
    }

    // Convert to suggestion documents
    const suggestionDocs = Array.from(suggestionSet).map(term => ({
      text: term,
      length: term.length,
      frequency: 1, // Initial frequency
      created_at: new Date()
    }));

    // Clear existing suggestions and insert new ones
    await this.suggestionsCollection.deleteMany({});

    if (suggestionDocs.length > 0) {
      await this.suggestionsCollection.insertMany(suggestionDocs);
    }

    // Create indexes for fast prefix matching
    await this.suggestionsCollection.createIndex({ text: 1 });
    await this.suggestionsCollection.createIndex({ length: 1, frequency: -1 });
  }

  extractTerms(product) {
    const terms = new Set();

    // Product name - split and add individual words and phrases
    if (product.product_name) {
      const words = product.product_name.toLowerCase()
        .replace(/[^\w\s]/g, ' ')
        .split(/\s+/)
        .filter(word => word.length >= 2);

      words.forEach(word => terms.add(word));

      // Add 2-word and 3-word phrases
      for (let i = 0; i < words.length - 1; i++) {
        terms.add(`${words[i]} ${words[i + 1]}`);
        if (i < words.length - 2) {
          terms.add(`${words[i]} ${words[i + 1]} ${words[i + 2]}`);
        }
      }
    }

    // Category and brand
    if (product.category) {
      terms.add(product.category.toLowerCase());
    }

    if (product.brand) {
      terms.add(product.brand.toLowerCase());
    }

    // Tags
    if (product.tags && Array.isArray(product.tags)) {
      product.tags.forEach(tag => {
        if (typeof tag === 'string') {
          terms.add(tag.toLowerCase());
        }
      });
    }

    return Array.from(terms);
  }

  async getSuggestions(prefix, limit = 10) {
    // Get suggestions starting with prefix
    const suggestions = await this.suggestionsCollection.find({
      text: { $regex: `^${prefix.toLowerCase()}`, $options: 'i' },
      length: { $lte: 50 } // Reasonable length limit
    })
    .sort({ frequency: -1, length: 1 })
    .limit(limit)
    .project({ text: 1, frequency: 1, _id: 0 })
    .toArray();

    return suggestions.map(s => s.text);
  }

  async updateSuggestionFrequency(searchTerm) {
    // Update frequency when user searches
    await this.suggestionsCollection.updateOne(
      { text: searchTerm.toLowerCase() },
      { 
        $inc: { frequency: 1 },
        $set: { last_used: new Date() }
      },
      { upsert: true }
    );
  }

  async getFuzzySuggestions(term, maxDistance = 2, limit = 5) {
    // Get fuzzy suggestions for typos
    const pipeline = [
      {
        $project: {
          text: 1,
          frequency: 1,
          distance: {
            $function: {
              body: function(text1, text2) {
                // Levenshtein distance calculation
                const a = text1.toLowerCase();
                const b = text2.toLowerCase();
                const matrix = [];

                for (let i = 0; i <= b.length; i++) {
                  matrix[i] = [i];
                }

                for (let j = 0; j <= a.length; j++) {
                  matrix[0][j] = j;
                }

                for (let i = 1; i <= b.length; i++) {
                  for (let j = 1; j <= a.length; j++) {
                    if (b.charAt(i - 1) === a.charAt(j - 1)) {
                      matrix[i][j] = matrix[i - 1][j - 1];
                    } else {
                      matrix[i][j] = Math.min(
                        matrix[i - 1][j - 1] + 1,
                        matrix[i][j - 1] + 1,
                        matrix[i - 1][j] + 1
                      );
                    }
                  }
                }

                return matrix[b.length][a.length];
              },
              args: ["$text", term],
              lang: "js"
            }
          }
        }
      },
      {
        $match: {
          distance: { $lte: maxDistance }
        }
      },
      {
        $sort: {
          distance: 1,
          frequency: -1
        }
      },
      {
        $limit: limit
      },
      {
        $project: {
          text: 1,
          distance: 1,
          _id: 0
        }
      }
    ];

    return await this.suggestionsCollection.aggregate(pipeline).toArray();
  }

  async contextualSuggestions(partialQuery, userContext = {}) {
    // Provide contextual suggestions based on user behavior
    const contextFilters = {};

    if (userContext.previousSearches) {
      // Weight suggestions based on user's search history
      const historicalTerms = userContext.previousSearches.flatMap(search => 
        search.split(' ')
      );

      contextFilters.historical_boost = {
        $in: historicalTerms
      };
    }

    if (userContext.category) {
      // Boost suggestions from user's preferred category
      contextFilters.category_match = userContext.category;
    }

    const pipeline = [
      {
        $match: {
          text: { $regex: `^${partialQuery.toLowerCase()}`, $options: 'i' }
        }
      },
      {
        $addFields: {
          context_score: {
            $add: [
              "$frequency",
              // Boost for historical relevance
              {
                $cond: {
                  if: { $in: ["$text", userContext.previousSearches || []] },
                  then: 10,
                  else: 0
                }
              }
            ]
          }
        }
      },
      {
        $sort: { context_score: -1, length: 1 }
      },
      {
        $limit: 8
      },
      {
        $project: { text: 1, _id: 0 }
      }
    ];

    const suggestions = await this.suggestionsCollection.aggregate(pipeline).toArray();
    return suggestions.map(s => s.text);
  }
}

// Geospatial text search implementation
class GeoTextSearchService {
  constructor(db) {
    this.db = db;
    this.businessesCollection = db.collection('businesses');
  }

  async setupGeoTextIndexes() {
    // Create compound geospatial and text index
    await this.businessesCollection.createIndex({
      location: "2dsphere",     // Geospatial index
      name: "text",            // Text search
      description: "text",
      tags: "text"
    }, {
      weights: {
        name: 15,
        description: 8,
        tags: 10
      }
    });

    // Alternative: separate indexes
    await this.businessesCollection.createIndex({ location: "2dsphere" });
    await this.businessesCollection.createIndex({
      name: "text",
      description: "text",
      tags: "text"
    });
  }

  async searchNearby(searchTerm, location, radius = 5000, options = {}) {
    // Search for businesses near a location matching text criteria
    const pipeline = [
      {
        $geoNear: {
          near: {
            type: "Point",
            coordinates: [location.longitude, location.latitude]
          },
          distanceField: "distance_meters",
          maxDistance: radius,
          spherical: true,
          query: {
            $text: { $search: searchTerm }
          }
        }
      },
      {
        $addFields: {
          text_score: { $meta: "textScore" },
          // Combine distance and text relevance scoring
          combined_score: {
            $add: [
              { $meta: "textScore" },
              // Distance penalty (closer is better)
              { $multiply: [
                { $divide: [{ $subtract: [radius, "$distance_meters"] }, radius] },
                5  // Distance weight factor
              ]}
            ]
          }
        }
      },
      {
        $sort: { combined_score: -1 }
      },
      {
        $limit: options.limit || 20
      },
      {
        $project: {
          name: 1,
          description: 1,
          address: 1,
          location: 1,
          distance_meters: { $round: ["$distance_meters", 0] },
          text_score: { $round: ["$text_score", 2] },
          combined_score: { $round: ["$combined_score", 2] }
        }
      }
    ];

    return await this.businessesCollection.aggregate(pipeline).toArray();
  }

  async searchInArea(searchTerm, polygon, options = {}) {
    // Search within a defined geographic area
    const query = {
      $and: [
        {
          location: {
            $geoWithin: {
              $geometry: polygon
            }
          }
        },
        {
          $text: { $search: searchTerm }
        }
      ]
    };

    return await this.businessesCollection.find(query, {
      projection: {
        name: 1,
        description: 1,
        address: 1,
        location: 1,
        score: { $meta: "textScore" }
      }
    })
    .sort({ score: { $meta: "textScore" } })
    .limit(options.limit || 20)
    .toArray();
  }

  async clusterSearchResults(searchTerm, center, radius = 10000) {
    // Group search results by geographic clusters
    const pipeline = [
      {
        $match: {
          $and: [
            {
              location: {
                $geoWithin: {
                  $centerSphere: [
                    [center.longitude, center.latitude],
                    radius / 6378100 // Convert to radians (Earth radius in meters)
                  ]
                }
              }
            },
            {
              $text: { $search: searchTerm }
            }
          ]
        }
      },
      {
        $addFields: {
          text_score: { $meta: "textScore" },
          // Create grid coordinates for clustering
          grid_x: {
            $floor: {
              $multiply: [
                { $arrayElemAt: ["$location.coordinates", 0] },
                1000  // Grid resolution
              ]
            }
          },
          grid_y: {
            $floor: {
              $multiply: [
                { $arrayElemAt: ["$location.coordinates", 1] },
                1000
              ]
            }
          }
        }
      },
      {
        $group: {
          _id: {
            grid_x: "$grid_x",
            grid_y: "$grid_y"
          },
          businesses: {
            $push: {
              name: "$name",
              location: "$location",
              text_score: "$text_score",
              address: "$address"
            }
          },
          count: { $sum: 1 },
          avg_score: { $avg: "$text_score" },
          center_point: {
            $avg: {
              coordinates: "$location.coordinates"
            }
          }
        }
      },
      {
        $match: {
          count: { $gte: 2 }  // Only clusters with multiple businesses
        }
      },
      {
        $sort: { avg_score: -1 }
      }
    ];

    return await this.businessesCollection.aggregate(pipeline).toArray();
  }

  async spatialAutoComplete(prefix, location, radius = 10000, limit = 10) {
    // Autocomplete suggestions based on nearby businesses
    const pipeline = [
      {
        $match: {
          location: {
            $geoWithin: {
              $centerSphere: [
                [location.longitude, location.latitude],
                radius / 6378100
              ]
            }
          }
        }
      },
      {
        $project: {
          name: 1,
          name_words: {
            $split: [{ $toLower: "$name" }, " "]
          }
        }
      },
      {
        $unwind: "$name_words"
      },
      {
        $match: {
          name_words: { $regex: `^${prefix.toLowerCase()}` }
        }
      },
      {
        $group: {
          _id: "$name_words",
          frequency: { $sum: 1 }
        }
      },
      {
        $sort: { frequency: -1 }
      },
      {
        $limit: limit
      },
      {
        $project: {
          suggestion: "$_id",
          frequency: 1,
          _id: 0
        }
      }
    ];

    return await this.businessesCollection.aggregate(pipeline).toArray();
  }
}