Search/node-handle-search.go

//go:build experimental
// +build experimental

package main

import (
	"encoding/json"
)

type searchParams struct {
	Query        string `json:"query"`
	Safe         string `json:"safe"`
	Lang         string `json:"lang"`
	Page         int    `json:"page"`
	ResponseAddr string `json:"responseAddr"`
}

func extractTargetFromAddress(addr string) string {
	if len(addr) > 5 && addr[len(addr)-5:] == ".sock" {
		return addr[:len(addr)-5]
	}
	return addr
}

// Utility to respond to any search
func respondToSearch(req searchParams, msgType uint8, results any) {
	if req.ResponseAddr == "" {
		printErr("ResponseAddr is empty")
		return
	}

	respBytes, err := json.Marshal(results)
	if err != nil {
		printWarn("Failed to marshal results for msg type %d: %v", msgType, err)
		return
	}

	resp := Message{
		ID:      generateMessageID(),
		Type:    msgType,
		Content: respBytes,
		Target:  req.ResponseAddr,
	}

	err = sendMessage(resp)
	if err != nil {
		printWarn("Failed to send search results to %s: %v", req.ResponseAddr, err)
	}
}

func sendBinaryResponse(req searchParams, msgType uint8, payload []byte, msgID uint32) {
	if req.ResponseAddr == "" {
		printErr("ResponseAddr is empty")
		return
	}

	resp := Message{
		ID:      msgID,
		Type:    msgType,
		Content: payload,
		Target:  req.ResponseAddr,
	}

	if err := sendMessage(resp); err != nil {
		printWarn("Failed to send binary search results: %v", err)
	}
}

func handleSearchTextMessage(msg Message) {
	var req searchParams
	if err := json.Unmarshal([]byte(msg.Content), &req); err != nil {
		printWarn("Invalid JSON: %v", err)
		return
	}
	printDebug("Received search-text from %s", req.ResponseAddr)

	results := fetchTextResults(req.Query, req.Safe, req.Lang, req.Page)
	data, err := encodeTextResults(results)
	if err != nil {
		printWarn("Failed to encode text results: %v", err)
		return
	}

	sendBinaryResponse(req, MsgTypeSearchTextResponse, data, msg.ID)
}

func handleSearchVideoMessage(msg Message) {
	var req searchParams
	if err := json.Unmarshal([]byte(msg.Content), &req); err != nil {
		printWarn("Invalid JSON: %v", err)
		return
	}
	printDebug("Received search-video from %s", req.ResponseAddr)

	results := fetchVideoResults(req.Query, req.Safe, req.Lang, req.Page)
	data, err := encodeVideoResults(results)
	if err != nil {
		printWarn("Failed to encode video results: %v", err)
		return
	}

	sendBinaryResponse(req, MsgTypeSearchVideoResponse, data, msg.ID)
}

func handleSearchMusicMessage(msg Message) {
	var req searchParams
	if err := json.Unmarshal([]byte(msg.Content), &req); err != nil {
		printWarn("Invalid JSON: %v", err)
		return
	}
	printDebug("Received search-music from %s", req.ResponseAddr)

	results := fetchMusicResults(req.Query, req.Page)
	data, err := encodeMusicResults(results)
	if err != nil {
		printWarn("Failed to encode music results: %v", err)
		return
	}

	sendBinaryResponse(req, MsgTypeSearchMusicResponse, data, msg.ID)
}

func handleSearchFileMessage(msg Message) {
	var req searchParams
	if err := json.Unmarshal([]byte(msg.Content), &req); err != nil {
		printWarn("Invalid JSON: %v", err)
		return
	}
	printDebug("Received search-file from %s", req.ResponseAddr)

	results := fetchFileResults(req.Query, req.Safe, req.Lang, req.Page)
	data, err := encodeFileResults(results)
	if err != nil {
		printWarn("Failed to encode file results: %v", err)
		return
	}

	sendBinaryResponse(req, MsgTypeSearchFileResponse, data, msg.ID)
}

func handleSearchForumMessage(msg Message) {
	var req searchParams
	if err := json.Unmarshal([]byte(msg.Content), &req); err != nil {
		printWarn("Invalid JSON: %v", err)
		return
	}
	printDebug("Received search-forum from %s", req.ResponseAddr)

	results := fetchForumResults(req.Query, req.Safe, req.Lang, req.Page)
	data, err := encodeForumResults(results)
	if err != nil {
		printWarn("Failed to encode forum results: %v", err)
		return
	}

	sendBinaryResponse(req, MsgTypeSearchForumResponse, data, msg.ID)
}

func handleSearchImageMessage(msg Message) {
	var req searchParams
	if err := json.Unmarshal([]byte(msg.Content), &req); err != nil {
		printWarn("Invalid JSON: %v", err)
		return
	}
	printDebug("Received image search type %d from %s", msg.Type, req.ResponseAddr)

	var (
		thumbsNeeded bool
		fullNeeded   bool
	)

	switch msg.Type {
	case MsgTypeSearchImageRawRequest:
		thumbsNeeded = false
		fullNeeded = false
	case MsgTypeSearchImageThumbRequest:
		thumbsNeeded = true
		fullNeeded = false
	case MsgTypeSearchImageFullRequest:
		thumbsNeeded = false
		fullNeeded = true
	case MsgTypeSearchImageAllRequest:
		thumbsNeeded = true
		fullNeeded = true
	default:
		printWarn("Unknown image search type: %d", msg.Type)
		return
	}

	results := fetchImageResults(req.Query, req.Safe, req.Lang, req.Page, true, thumbsNeeded)

	if fullNeeded || thumbsNeeded {
		results = prepareProxiedImages(results, msg.Type)
	}

	data, err := encodeImageResults(results)
	if err != nil {
		printWarn("Failed to encode image results: %v", err)
		return
	}

	sendBinaryResponse(req, MsgTypeSearchImageResponse, data, msg.ID)
}