Search

// Basic search query
const response = await fetch(
  'https://fixfx.wiki/api/search?q=player management&limit=10&highlight=true'
);
const data = await response.json();
 
// Display search results
console.log(`Found ${data.metadata.total} results in ${data.metadata.took}ms`);
 
data.data.forEach((result, index) => {
  console.log(`${index + 1}. ${result.title}`);
  console.log(`   URL: ${result.url}`);
  console.log(`   Category: ${result.category}`);
  console.log(`   Score: ${result.score}`);
  
  // Show highlights
  if (result.highlights && result.highlights.length > 0) {
    console.log('   Highlights:');
    result.highlights.forEach(highlight => {
      console.log(`     ${highlight.field}: "${highlight.matched}"`);
    });
  }
  
  // Show content excerpt
  const excerpt = result.content.length > 150 
    ? result.content.substring(0, 150) + '...'
    : result.content;
  console.log(`   ${excerpt}`);
  console.log('');
});
 
// Show suggestions if available
if (data.metadata.suggestions && data.metadata.suggestions.length > 0) {
  console.log('Suggestions:');
  data.metadata.suggestions.forEach(suggestion => {
    console.log(`- ${suggestion}`);
  });
}

// Build an intelligent search interface
class SmartSearch {
  constructor(container) {
    this.container = container;
    this.debounceTimer = null;
    this.currentQuery = '';
    this.setupInterface();
  }
  
  setupInterface() {
    this.container.innerHTML = `
      <div class="search-box">
        <input type="text" placeholder="Search documentation..." id="search-input">
        <div class="search-suggestions" id="suggestions"></div>
        <div class="search-results" id="results"></div>
      </div>
    `;
    
    const input = this.container.querySelector('#search-input');
    input.addEventListener('input', (e) => this.handleInput(e.target.value));
  }
  
  handleInput(query) {
    clearTimeout(this.debounceTimer);
    this.currentQuery = query;
    
    if (query.length < 2) {
      this.clearResults();
      return;
    }
    
    this.debounceTimer = setTimeout(() => {
      this.performSearch(query);
    }, 300);
  }
  
  async performSearch(query) {
    try {
      // Get suggestions first
      const suggestResponse = await fetch(
        `https://fixfx.wiki/api/search?q=${encodeURIComponent(query)}&suggest=true&limit=5`
      );
      const suggestData = await suggestResponse.json();
      
      // Then get full results
      const response = await fetch(
        `https://fixfx.wiki/api/search?q=${encodeURIComponent(query)}&highlight=true&limit=20`
      );
      const data = await response.json();
      
      this.displaySuggestions(suggestData.metadata.suggestions || []);
      this.displayResults(data);
    } catch (error) {
      console.error('Search error:', error);
    }
  }
  
  displaySuggestions(suggestions) {
    const suggestionsEl = this.container.querySelector('#suggestions');
    
    if (suggestions.length === 0) {
      suggestionsEl.style.display = 'none';
      return;
    }
    
    suggestionsEl.innerHTML = suggestions
      .map(suggestion => `<div class="suggestion" onclick="this.parentNode.parentNode.querySelector('#search-input').value='${suggestion}'; this.parentNode.parentNode.dispatchEvent(new Event('search'))">${suggestion}</div>`)
      .join('');
    suggestionsEl.style.display = 'block';
  }
  
  displayResults(data) {
    const resultsEl = this.container.querySelector('#results');
    
    if (data.data.length === 0) {
      resultsEl.innerHTML = '<div class="no-results">No results found</div>';
      return;
    }
    
    const categoryFilter = this.buildCategoryFilter(data.metadata.categories);
    const resultsList = data.data.map(result => this.buildResultItem(result)).join('');
    
    resultsEl.innerHTML = `
      <div class="search-meta">
        Found ${data.metadata.total} results in ${data.metadata.took}ms
        ${categoryFilter}
      </div>
      <div class="results-list">${resultsList}</div>
    `;
  }
  
  buildCategoryFilter(categories) {
    const filters = Object.entries(categories)
      .filter(([, count]) => count > 0)
      .map(([category, count]) => `<span class="category-filter" data-category="${category}">${category} (${count})</span>`)
      .join('');
    
    return `<div class="category-filters">${filters}</div>`;
  }
  
  buildResultItem(result) {
    const highlights = result.highlights
      ? result.highlights.map(h => `<span class="highlight">${h.matched}</span>`).join(', ')
      : '';
    
    return `
      <div class="result-item" data-category="${result.category}">
        <h3><a href="${result.url}">${result.title}</a></h3>
        <div class="result-meta">
          <span class="category">${result.category}</span>
          <span class="score">Score: ${result.score.toFixed(2)}</span>
        </div>
        <p class="result-content">${result.content.substring(0, 200)}...</p>
        ${highlights ? `<div class="highlights">Matches: ${highlights}</div>` : ''}
      </div>
    `;
  }
  
  clearResults() {
    this.container.querySelector('#suggestions').style.display = 'none';
    this.container.querySelector('#results').innerHTML = '';
  }
}
 
// Initialize search
const searchContainer = document.getElementById('search-container');
const smartSearch = new SmartSearch(searchContainer);

// Discover related content
async function discoverRelatedContent(currentPage) {
  // Extract key terms from current page
  const keyTerms = extractKeyTerms(currentPage);
  
  const relatedContent = [];
  
  for (const term of keyTerms.slice(0, 3)) {
    const response = await fetch(
      `https://fixfx.wiki/api/search?q=${encodeURIComponent(term)}&limit=5`
    );
    const data = await response.json();
    
    // Filter out current page and add to related content
    const related = data.data
      .filter(item => item.url !== currentPage.url)
      .slice(0, 2);
    
    relatedContent.push(...related);
  }
  
  // Remove duplicates and sort by relevance
  const uniqueContent = relatedContent
    .filter((item, index, self) => 
      index === self.findIndex(t => t.url === item.url)
    )
    .sort((a, b) => b.score - a.score)
    .slice(0, 6);
  
  return uniqueContent;
}
 
function extractKeyTerms(page) {
  // Simple keyword extraction from title and content
  const text = `${page.title} ${page.content}`.toLowerCase();
  const words = text.match(/\b\w{4,}\b/g) || [];
  
  // Count word frequency
  const frequency = {};
  words.forEach(word => {
    frequency[word] = (frequency[word] || 0) + 1;
  });
  
  // Return top terms
  return Object.entries(frequency)
    .sort(([,a], [,b]) => b - a)
    .slice(0, 10)
    .map(([word]) => word);
}
 
// Example usage
const currentPage = {
  title: "ESX Player Management",
  content: "Learn how to manage players in ESX framework...",
  url: "/docs/frameworks/esx/player-management"
};
 
discoverRelatedContent(currentPage).then(related => {
  console.log('Related Content:', related);
});

// Track search analytics
class SearchAnalytics {
  constructor() {
    this.searchHistory = [];
    this.popularQueries = new Map();
    this.categoryPreferences = new Map();
  }
  
  trackSearch(query, results, category = null) {
    const searchEvent = {
      query,
      timestamp: new Date().toISOString(),
      resultCount: results.metadata.total,
      searchTime: results.metadata.took,
      category,
      topResult: results.data[0]?.url || null
    };
    
    this.searchHistory.push(searchEvent);
    
    // Update popular queries
    const count = this.popularQueries.get(query) || 0;
    this.popularQueries.set(query, count + 1);
    
    // Update category preferences
    if (category) {
      const catCount = this.categoryPreferences.get(category) || 0;
      this.categoryPreferences.set(category, catCount + 1);
    }
    
    // Limit history size
    if (this.searchHistory.length > 1000) {
      this.searchHistory = this.searchHistory.slice(-500);
    }
  }
  
  getPopularQueries(limit = 10) {
    return Array.from(this.popularQueries.entries())
      .sort(([,a], [,b]) => b - a)
      .slice(0, limit)
      .map(([query, count]) => ({ query, count }));
  }
  
  getCategoryPreferences() {
    const total = Array.from(this.categoryPreferences.values())
      .reduce((sum, count) => sum + count, 0);
    
    return Array.from(this.categoryPreferences.entries())
      .map(([category, count]) => ({
        category,
        count,
        percentage: (count / total * 100).toFixed(1)
      }))
      .sort((a, b) => b.count - a.count);
  }
  
  getSearchTrends(days = 7) {
    const cutoff = new Date();
    cutoff.setDate(cutoff.getDate() - days);
    
    const recentSearches = this.searchHistory.filter(
      search => new Date(search.timestamp) > cutoff
    );
    
    // Group by day
    const trends = {};
    recentSearches.forEach(search => {
      const day = search.timestamp.split('T')[0];
      trends[day] = (trends[day] || 0) + 1;
    });
    
    return Object.entries(trends)
      .sort(([a], [b]) => a.localeCompare(b))
      .map(([date, count]) => ({ date, count }));
  }
  
  generateReport() {
    const popularQueries = this.getPopularQueries();
    const categoryPrefs = this.getCategoryPreferences();
    const trends = this.getSearchTrends();
    
    console.log('Search Analytics Report');
    console.log('======================');
    console.log(`Total Searches: ${this.searchHistory.length}`);
    console.log('');
    
    console.log('Popular Queries:');
    popularQueries.forEach((item, index) => {
      console.log(`${index + 1}. "${item.query}" (${item.count} searches)`);
    });
    console.log('');
    
    console.log('Category Preferences:');
    categoryPrefs.forEach(item => {
      console.log(`- ${item.category}: ${item.count} searches (${item.percentage}%)`);
    });
    console.log('');
    
    console.log('Search Trends (Last 7 Days):');
    trends.forEach(item => {
      console.log(`${item.date}: ${item.count} searches`);
    });
    
    return {
      totalSearches: this.searchHistory.length,
      popularQueries,
      categoryPreferences: categoryPrefs,
      trends
    };
  }
}
 
// Usage example
const analytics = new SearchAnalytics();
 
// Track searches (would be called during actual searches)
async function performTrackedSearch(query, category = null) {
  const response = await fetch(
    `https://fixfx.wiki/api/search?q=${encodeURIComponent(query)}&category=${category || ''}`
  );
  const results = await response.json();
  
  analytics.trackSearch(query, results, category);
  return results;
}
 
// Example tracked searches
await performTrackedSearch('ESX player management', 'frameworks');
await performTrackedSearch('vehicle spawning', 'guides');
await performTrackedSearch('database setup');
 
// Generate report
analytics.generateReport();