Search/cache.go

// common_cache.go
package main

import (
	"fmt"
	"sync"
	"time"
)

var resultsCache = NewResultsCache(6 * time.Hour) // Cache with 6-hour expiration

// SearchResult is a generic interface for all types of search results.
type SearchResult interface{}

// Define various search result types implementing SearchResult interface
type TextSearchResult struct {
	URL         string
	Header      string
	Description string
	Source      string
}

type ImageSearchResult struct {
	Thumbnail  string
	Title      string
	Media      string
	Width      int
	Height     int
	Source     string
	ThumbProxy string
}

type VideoResult struct {
	Href      string
	Title     string
	Date      string
	Views     string
	Creator   string
	Publisher string
	Image     string
	Duration  string
}

type TorrentResult struct {
	URL      string
	Seeders  int
	Leechers int
	Magnet   string
	Views    int
	Size     string
	Title    string
	Error    string
}

type ForumSearchResult struct {
	URL           string    `json:"url"`
	Header        string    `json:"header"`
	Description   string    `json:"description"`
	PublishedDate time.Time `json:"publishedDate"`
	ImgSrc        string    `json:"imgSrc,omitempty"`
	ThumbnailSrc  string    `json:"thumbnailSrc,omitempty"`
}

// CacheKey represents the key used to store search results in the cache.
type CacheKey struct {
	Query string
	Page  int
	Safe  bool
	Lang  string
	Type  string
}

// CachedItem represents an item stored in the cache with an expiration time.
type CachedItem struct {
	Results    []SearchResult
	StoredTime time.Time
}

// ResultsCache is a thread-safe map for caching search results by composite keys.
type ResultsCache struct {
	mu         sync.Mutex
	results    map[string]CachedItem
	expiration time.Duration
}

// NewResultsCache creates a new ResultsCache with a specified expiration duration.
func NewResultsCache(expiration time.Duration) *ResultsCache {
	return &ResultsCache{
		results:    make(map[string]CachedItem),
		expiration: expiration,
	}
}

// Get retrieves the results for a given key from the cache.
func (rc *ResultsCache) Get(key CacheKey) ([]SearchResult, bool) {
	rc.mu.Lock()
	defer rc.mu.Unlock()

	item, exists := rc.results[rc.keyToString(key)]
	if !exists {
		return nil, false
	}

	// Check if the item has expired
	if time.Since(item.StoredTime) > rc.expiration {
		delete(rc.results, rc.keyToString(key))
		return nil, false
	}

	return item.Results, true
}

// Set stores the results for a given key in the cache.
func (rc *ResultsCache) Set(key CacheKey, results []SearchResult) {
	rc.mu.Lock()
	defer rc.mu.Unlock()
	rc.results[rc.keyToString(key)] = CachedItem{
		Results:    results,
		StoredTime: time.Now(),
	}
}

// keyToString converts a CacheKey to a string representation.
func (rc *ResultsCache) keyToString(key CacheKey) string {
	return fmt.Sprintf("%s|%d|%t|%s|%s", key.Query, key.Page, key.Safe, key.Lang, key.Type)
}

// Helper functions to convert between generic SearchResult and specific ImageSearchResult
func convertToSearchResults(results interface{}) []SearchResult {
	switch res := results.(type) {
	case []TextSearchResult:
		genericResults := make([]SearchResult, len(res))
		for i, r := range res {
			genericResults[i] = r
		}
		return genericResults
	case []TorrentResult:
		genericResults := make([]SearchResult, len(res))
		for i, r := range res {
			genericResults[i] = r
		}
		return genericResults
	case []ImageSearchResult:
		genericResults := make([]SearchResult, len(res))
		for i, r := range res {
			genericResults[i] = r
		}
		return genericResults
	}
	return nil
}

func convertToSpecificResults(results []SearchResult) ([]TextSearchResult, []TorrentResult, []ImageSearchResult) {
	var textResults []TextSearchResult
	var torrentResults []TorrentResult
	var imageResults []ImageSearchResult
	for _, r := range results {
		switch res := r.(type) {
		case TextSearchResult:
			textResults = append(textResults, res)
		case TorrentResult:
			torrentResults = append(torrentResults, res)
		case ImageSearchResult:
			imageResults = append(imageResults, res)
		}
	}
	return textResults, torrentResults, imageResults
}