Changed self-crawling as experimental, cleanup unused features

node-request-images.go

@@ -1,84 +1,198 @@
+//go:build experimental
+// +build experimental
+
 package main
 
 import (
-	"encoding/json"
+	"bytes"
+	"encoding/binary"
 	"fmt"
 	"time"
 )
 
+// const (
+// 	MessageTypeSearchImage         uint8 = 11
+// 	MessageTypeSearchImageThumb    uint8 = 111
+// 	MessageTypeSearchImageFull     uint8 = 112
+// 	MessageTypeSearchImageAllProxy uint8 = 113
+// 	MessageTypeImageResults        uint8 = 22
+// )
+
 var imageResultsChan = make(chan []ImageSearchResult)
 
-func handleImageResultsMessage(msg Message) {
-	var results []ImageSearchResult
-	err := json.Unmarshal([]byte(msg.Content), &results)
+func sendImageSearchRequestToNode(target, query, safe, lang string, page int, mode uint8) ([]ImageSearchResult, error) {
+	payload, err := encodeSearchTextParams(query, safe, lang, page)
 	if err != nil {
-		printWarn("Error unmarshalling image results: %v", err)
-		return
+		return nil, fmt.Errorf("encode error: %v", err)
 	}
 
+	msg := Message{
+		ID:      generateMessageID(),
+		Type:    mode, // one of the image search types
+		Content: payload,
+		Target:  target,
+	}
+
+	if err := sendMessage(msg); err != nil {
+		return nil, fmt.Errorf("send error: %v", err)
+	}
+
+	select {
+	case res := <-imageResultsChan:
+		return res, nil
+	case <-time.After(30 * time.Second):
+		return nil, fmt.Errorf("timeout from %s", target)
+	}
+}
+
+func handleImageResultsMessage(msg Message) {
+	results, err := decodeImageResults([]byte(msg.Content))
+	if err != nil {
+		printWarn("Error decoding image results: %v", err)
+		return
+	}
 	printDebug("Received image results: %+v", results)
-	// Send results to imageResultsChan
+
 	go func() {
 		imageResultsChan <- results
 	}()
 }
 
-func sendImageSearchRequestToNode(nodeAddr, query, safe, lang string, page int, visitedNodes []string) ([]ImageSearchResult, error) {
-	visitedNodes = append(visitedNodes, nodeAddr)
-	searchParams := struct {
-		Query        string   `json:"query"`
-		Safe         string   `json:"safe"`
-		Lang         string   `json:"lang"`
-		Page         int      `json:"page"`
-		ResponseAddr string   `json:"responseAddr"`
-		VisitedNodes []string `json:"visitedNodes"`
-	}{
-		Query:        query,
-		Safe:         safe,
-		Lang:         lang,
-		Page:         page,
-		ResponseAddr: fmt.Sprintf("http://localhost:%d/node", config.Port),
-		VisitedNodes: visitedNodes,
+func encodeImageResults(results []ImageSearchResult) ([]byte, error) {
+	buf := new(bytes.Buffer)
+
+	if err := binary.Write(buf, binary.BigEndian, uint16(len(results))); err != nil {
+		return nil, err
 	}
 
-	msgBytes, err := json.Marshal(searchParams)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal search parameters: %v", err)
+	for _, r := range results {
+		if err := writeString(buf, r.ID); err != nil {
+			return nil, err
+		}
+		if err := writeString(buf, r.Title); err != nil {
+			return nil, err
+		}
+		if err := writeString(buf, r.Full); err != nil {
+			return nil, err
+		}
+		if err := writeString(buf, r.Thumb); err != nil {
+			return nil, err
+		}
+		if err := writeString(buf, r.ProxyFull); err != nil {
+			return nil, err
+		}
+		if err := writeString(buf, r.ProxyThumb); err != nil {
+			return nil, err
+		}
+		if err := writeString(buf, r.Source); err != nil {
+			return nil, err
+		}
+		if err := binary.Write(buf, binary.BigEndian, int32(r.Width)); err != nil {
+			return nil, err
+		}
+		if err := binary.Write(buf, binary.BigEndian, int32(r.Height)); err != nil {
+			return nil, err
+		}
 	}
 
-	msg := Message{
-		ID:      hostID,
-		Type:    "search-image",
-		Content: string(msgBytes),
-	}
-
-	err = sendMessage(nodeAddr, msg)
-	if err != nil {
-		return nil, fmt.Errorf("failed to send search request to node %s: %v", nodeAddr, err)
-	}
-
-	// Wait for results
-	select {
-	case res := <-imageResultsChan:
-		return res, nil
-	case <-time.After(30 * time.Second):
-		return nil, fmt.Errorf("timeout waiting for results from node %s", nodeAddr)
-	}
+	return buf.Bytes(), nil
 }
 
-func tryOtherNodesForImageSearch(query, safe, lang string, page int, visitedNodes []string) []ImageSearchResult {
-	for _, nodeAddr := range peers {
-		if contains(visitedNodes, nodeAddr) {
-			continue // Skip nodes already visited
+func decodeImageResults(data []byte) ([]ImageSearchResult, error) {
+	buf := bytes.NewReader(data)
+
+	var count uint16
+	if err := binary.Read(buf, binary.BigEndian, &count); err != nil {
+		return nil, err
+	}
+
+	results := make([]ImageSearchResult, 0, count)
+	for i := 0; i < int(count); i++ {
+		id, _ := readString(buf)
+		title, _ := readString(buf)
+		full, _ := readString(buf)
+		thumb, _ := readString(buf)
+		proxyFull, _ := readString(buf)
+		proxyThumb, _ := readString(buf)
+		source, _ := readString(buf)
+
+		var width, height int32
+		if err := binary.Read(buf, binary.BigEndian, &width); err != nil {
+			return nil, err
 		}
-		results, err := sendImageSearchRequestToNode(nodeAddr, query, safe, lang, page, visitedNodes)
-		if err != nil {
-			printWarn("Error contacting node %s: %v", nodeAddr, err)
-			continue
+		if err := binary.Read(buf, binary.BigEndian, &height); err != nil {
+			return nil, err
 		}
-		if len(results) > 0 {
-			return results
+
+		results = append(results, ImageSearchResult{
+			ID:         id,
+			Title:      title,
+			Full:       full,
+			Thumb:      thumb,
+			ProxyFull:  proxyFull,
+			ProxyThumb: proxyThumb,
+			Source:     source,
+			Width:      int(width),
+			Height:     int(height),
+		})
+	}
+
+	return results, nil
+}
+
+func prepareProxiedImages(results []ImageSearchResult, mode uint8) []ImageSearchResult {
+	for i := range results {
+		switch mode {
+		case MsgTypeSearchImageThumbRequest:
+			results[i].ProxyThumb = "/image/" + results[i].ID + "_thumb.webp"
+		case MsgTypeSearchImageFullRequest:
+			results[i].ProxyFull = "/image/" + results[i].ID + "_full.webp"
+		case MsgTypeSearchImageAllRequest:
+			results[i].ProxyThumb = "/image/" + results[i].ID + "_thumb.webp"
+			results[i].ProxyFull = "/image/" + results[i].ID + "_full.webp"
 		}
 	}
-	return nil
+	return results
 }
+
+// func handleSearchImageMessage(msg Message) {
+// 	query, safe, lang, page, err := decodeSearchTextParams([]byte(msg.Content))
+// 	if err != nil {
+// 		printWarn("Error decoding image search parameters: %v", err)
+// 		return
+// 	}
+
+// 	results := fetchImageResults(query, safe, lang, page, true, true)
+
+// 	switch msg.Type {
+// 	case MsgTypeSearchImageRawRequest:
+// 		// No proxy URLs needed
+
+// 	case MsgTypeSearchImageThumbRequest:
+// 		results = prepareProxiedImages(results, MsgTypeSearchImageThumbRequest)
+// 	case MsgTypeSearchImageFullRequest:
+// 		results = prepareProxiedImages(results, MsgTypeSearchImageFullRequest)
+// 	case MsgTypeSearchImageAllRequest:
+// 		results = prepareProxiedImages(results, MsgTypeSearchImageAllRequest)
+// 	default:
+// 		printWarn("Unknown image request mode: %d", msg.Type)
+// 		return
+// 	}
+
+// 	payload, err := encodeImageResults(results)
+// 	if err != nil {
+// 		printWarn("Error encoding image search results: %v", err)
+// 		return
+// 	}
+
+// 	response := Message{
+// 		ID:      msg.ID,
+// 		Type:    MsgTypeSearchImageResponse,
+// 		Content: string(payload),
+// 		Target:  msg.Source, // Reply to sender
+// 	}
+
+// 	if err := sendMessage(response); err != nil {
+// 		printWarn("Error sending image search response: %v", err)
+// 	}
+// }