added imgur + some cleanup

images.go

@@ -1,120 +1,35 @@
 package main
 
 import (
-	"encoding/json"
 	"fmt"
 	"html/template"
 	"log"
+	"math/rand"
 	"net/http"
-	"net/url"
+	"sync"
 	"time"
 )
 
-// QwantAPIResponse represents the JSON response structure from Qwant API
-type QwantAPIResponse struct {
-	Data struct {
-		Result struct {
-			Items []struct {
-				Media     string `json:"media"`
-				Thumbnail string `json:"thumbnail"`
-				Title     string `json:"title"`
-				Url       string `json:"url"`
-				Width     int    `json:"width"`
-				Height    int    `json:"height"`
-			} `json:"items"`
-		} `json:"result"`
-	} `json:"data"`
+var (
+	imageEngines    []imageEngine
+	imageEngineLock sync.Mutex
+)
+
+type imageEngine struct {
+	Name   string
+	Func   func(string, string, string, int) ([]ImageSearchResult, error)
+	Weight int
 }
 
-var funcs = template.FuncMap{
-	"sub": func(a, b int) int {
-		return a - b
-	},
-	"add": func(a, b int) int {
-		return a + b
-	},
+func init() {
+	imageEngines = []imageEngine{
+		{Name: "Qwant", Func: PerformQwantImageSearch, Weight: 1},
+		{Name: "Imgur", Func: PerformImgurImageSearch, Weight: 2},
+	}
+
+	rand.Seed(time.Now().UnixNano())
 }
 
-// FetchImageResults contacts the image search API and returns a slice of ImageSearchResult
-func fetchImageResults(query string, safe, lang string, page int) ([]ImageSearchResult, error) {
-	const resultsPerPage = 50
-	var offset int
-	if page <= 1 {
-		offset = 0
-	} else {
-		offset = (page - 1) * resultsPerPage
-	}
-
-	// Ensuring safe search is disabled by default if not specified
-	if safe == "" {
-		safe = "0"
-	}
-
-	// Defaulting to English Canada locale if not specified
-	if lang == "" {
-		lang = "en_CA"
-	}
-
-	// Format &lang=lang_de is incorrect, implement fix !
-	apiURL := fmt.Sprintf("https://api.qwant.com/v3/search/images?t=images&q=%s&count=%d&locale=%s&offset=%d&device=desktop&tgp=2&safesearch=%s",
-		url.QueryEscape(query),
-		resultsPerPage,
-		lang,
-		offset,
-		safe)
-
-	client := &http.Client{Timeout: 10 * time.Second}
-
-	req, err := http.NewRequest("GET", apiURL, nil)
-	if err != nil {
-		return nil, fmt.Errorf("creating request: %v", err)
-	}
-
-	// User Agent generation
-	ImageUserAgent, err := GetUserAgent("Image-Search")
-	if err != nil {
-		fmt.Println("Error:", err)
-		return nil, err
-	}
-
-	if debugMode {
-		fmt.Println("Generated User Agent (images):", ImageUserAgent)
-	}
-
-	req.Header.Set("User-Agent", ImageUserAgent)
-
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("making request: %v", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
-	}
-
-	var apiResp QwantAPIResponse
-	if err := json.NewDecoder(resp.Body).Decode(&apiResp); err != nil {
-		return nil, fmt.Errorf("decoding response: %v", err)
-	}
-
-	var results []ImageSearchResult
-	for _, item := range apiResp.Data.Result.Items {
-		results = append(results, ImageSearchResult{
-			Thumbnail:  item.Thumbnail, // Thumbnail URL
-			Title:      item.Title,     // Image title
-			Media:      item.Media,     // Direct link to the image
-			Source:     item.Url,
-			ThumbProxy: "/img_proxy?url=" + url.QueryEscape(item.Media),
-			Width:      item.Width,
-			Height:     item.Height,
-		})
-	}
-
-	return results, nil
-}
-
-// HandleImageSearch is the HTTP handler for image search requests
 func handleImageSearch(w http.ResponseWriter, query, safe, lang string, page int) {
 	startTime := time.Now()
 
@@ -174,31 +89,58 @@ func getImageResultsFromCacheOrFetch(cacheKey CacheKey, query, safe, lang string
 	select {
 	case results := <-cacheChan:
 		if results == nil {
-			combinedResults = fetchAndCacheImageResults(query, safe, lang, page)
+			combinedResults = fetchImageResults(query, safe, lang, page)
+			resultsCache.Set(cacheKey, convertToSearchResults(combinedResults))
 		} else {
 			_, _, imageResults := convertToSpecificResults(results)
 			combinedResults = imageResults
 		}
 	case <-time.After(2 * time.Second):
 		log.Println("Cache check timeout")
-		combinedResults = fetchAndCacheImageResults(query, safe, lang, page)
+		combinedResults = fetchImageResults(query, safe, lang, page)
+		resultsCache.Set(cacheKey, convertToSearchResults(combinedResults))
 	}
 
 	return combinedResults
 }
 
-func fetchAndCacheImageResults(query, safe, lang string, page int) []ImageSearchResult {
-	results, err := fetchImageResults(query, safe, lang, page)
-	if err != nil || len(results) == 0 {
-		log.Printf("Error fetching image results: %v", err)
-		return []ImageSearchResult{
-			{Title: "Results are currently unavailable, sorry. Please try again later."},
-		}
-	}
+func fetchImageResults(query, safe, lang string, page int) []ImageSearchResult {
+	engine := selectImageEngine()
+	log.Printf("Using image search engine: %s", engine.Name)
 
-	// Cache the valid results
-	cacheKey := CacheKey{Query: query, Page: page, Safe: safe == "true", Lang: lang, Type: "image"}
-	resultsCache.Set(cacheKey, convertToSearchResults(results))
+	results, err := engine.Func(query, safe, lang, page)
+	if err != nil {
+		log.Printf("Error performing image search with %s: %v", engine.Name, err)
+		return nil
+	}
 
 	return results
 }
+
+func selectImageEngine() imageEngine {
+	imageEngineLock.Lock()
+	defer imageEngineLock.Unlock()
+
+	totalWeight := 0
+	for _, engine := range imageEngines {
+		totalWeight += engine.Weight
+	}
+
+	randValue := rand.Intn(totalWeight)
+	for _, engine := range imageEngines {
+		if randValue < engine.Weight {
+			// Adjust weights for load balancing
+			for i := range imageEngines {
+				if imageEngines[i].Name == engine.Name {
+					imageEngines[i].Weight = max(1, imageEngines[i].Weight-1)
+				} else {
+					imageEngines[i].Weight++
+				}
+			}
+			return engine
+		}
+		randValue -= engine.Weight
+	}
+
+	return imageEngines[0] // fallback to the first engine
+}