helpers.go

package main

import (
	"bytes"
	"context"
	"crypto/aes"
	"crypto/cipher"
	"crypto/hmac"
	"crypto/rand"
	"crypto/sha256"
	"encoding/binary"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"image"
	_ "image/gif"
	"image/jpeg"
	_ "image/png"
	"io"
	"net/http"
	"net/url"
	"os"
	"regexp"
	"runtime/debug"
	"strings"
	"sync"
	"unicode"
	"unicode/utf8"

	"time"

	"github.com/go-resty/resty/v2"
	"golang.org/x/sync/singleflight"

	"github.com/patrickmn/go-cache"

	_ "golang.org/x/image/webp"

	"github.com/PuerkitoBio/goquery"
	"github.com/jmoiron/sqlx"
	"github.com/nfnt/resize"
	"github.com/rs/zerolog/log"
)

const (
	openGraphFetchTimeout    = 5 * time.Second
	fetchImageMaxBytes       = 16 * 1024 * 1024  // 16MB
	fetchVideoMaxBytes       = 100 * 1024 * 1024 // 100MB
	fetchAudioMaxBytes       = 16 * 1024 * 1024  // 16MB
	fetchDocumentMaxBytes    = 100 * 1024 * 1024 // 100MB
	openGraphPageMaxBytes    = 2 * 1024 * 1024   // 2MB
	openGraphImageMaxBytes   = 10 * 1024 * 1024  // 10MB
	openGraphThumbnailWidth  = 192
	openGraphThumbnailHeight = 192
	openGraphHQThumbnailDim  = 600 // Max dimension of the uploaded thumbnail used for the large preview card
	openGraphJpegQuality     = 80
	openGraphMaxImageDim     = 4000 // Max width or height for Open Graph images
	openGraphUserFetchLimit  = 20   // Limit concurrent Open Graph fetches per user

	// WebP RIFF container constants
	riffHeaderSize  = 12 // "RIFF" + size (4) + "WEBP"
	chunkHeaderSize = 8  // tag (4) + size (4)
	riffSizeOffset  = 4  // Offset to RIFF size field

	// VP8X extended header chunk layout (10-byte payload)
	vp8xChunkSize    = chunkHeaderSize + 10
	vp8xPayloadSize  = 10
	vp8xFlagsOffset  = chunkHeaderSize     // Byte 0 of payload: feature flags
	vp8xWidthOffset  = chunkHeaderSize + 4 // Bytes 4-6: canvas width - 1 (24-bit LE)
	vp8xHeightOffset = chunkHeaderSize + 7 // Bytes 7-9: canvas height - 1 (24-bit LE)

	// VP8X feature flags
	vp8xFlagEXIF byte = 0x08
)

type WebhookFileErrorPayload struct {
	URL              string                 `json:"url"`
	Payload          map[string]interface{} `json:"payload"`
	UserID           string                 `json:"userID"`
	EncryptedHmacKey string                 `json:"encryptedHmacKey"`
	FilePath         string                 `json:"filePath"`
	AttemptTime      time.Time              `json:"attemptTime"`
	ErrorMessage     string                 `json:"errorMessage"`
}

type WebhookErrorPayload struct {
	URL              string                 `json:"url"`
	Payload          map[string]interface{} `json:"payload"`
	UserID           string                 `json:"userID"`
	EncryptedHmacKey string                 `json:"encryptedHmacKey"`
	AttemptTime      time.Time              `json:"attemptTime"`
	ErrorMessage     string                 `json:"errorMessage"`
}

// ProxyConfig holds per-user proxy settings for WhatsApp and webhook delivery.
type ProxyConfig struct {
	Enabled         bool   `json:"enabled"`
	ProxyURL        string `json:"proxyURL"`
	WebhookUseProxy *bool  `json:"webhookUseProxy,omitempty"`
}

func resolveWebhookUseProxy(perUser *bool) bool {
	if perUser != nil {
		return *perUser
	}
	return *globalWebhookUseProxy
}

func proxyConfigResponse(proxyURL string, webhookUseProxy bool) map[string]interface{} {
	return map[string]interface{}{
		"enabled":           proxyURL != "",
		"proxy_url":         proxyURL,
		"webhook_use_proxy": webhookUseProxy,
	}
}

type openGraphResult struct {
	Title       string
	Description string
	ImageData   []byte // small inline thumbnail (JPEGThumbnail field)
	HQImageData []byte // larger thumbnail uploaded to WA media servers for the big preview card
	HQWidth     uint32
	HQHeight    uint32
}

type UserSemaphoreManager struct {
	pools sync.Map
}

func NewUserSemaphoreManager() *UserSemaphoreManager {
	return &UserSemaphoreManager{}
}

func (usm *UserSemaphoreManager) ForUser(userID string) chan struct{} {
	// LoadOrStore provides an atomic way to get or create a semaphore.
	pool, _ := usm.pools.LoadOrStore(userID, make(chan struct{}, openGraphUserFetchLimit))
	return pool.(chan struct{})
}

var (
	urlRegex = regexp.MustCompile(`https?://[^\s"']*[^\"'\s\.,!?()[\]{}]`)

	userSemaphoreManager = NewUserSemaphoreManager()

	openGraphGroup singleflight.Group

	openGraphCache = cache.New(5*time.Minute, 10*time.Minute) // Cache Open Graph data for 5 minutes, cleanup every 10 minutes

)

// mentionRegex locates candidates; boundaries below exclude email addresses,
// URL paths, and numeric prefixes of longer tokens.
var mentionRegex = regexp.MustCompile(`@(\d+)`)

// extractMentionJIDs finds standalone @phone tokens in visible message text.
func extractMentionJIDs(text string) []string {
	matches := mentionRegex.FindAllStringSubmatchIndex(text, -1)
	seen := make(map[string]bool)
	var jids []string
	for _, m := range matches {
		// Ignore candidates anywhere inside a URL token, including paths that
		// put an opening parenthesis immediately before the @ sign.
		tokenStart := 0
		if space := strings.LastIndexFunc(text[:m[0]], unicode.IsSpace); space >= 0 {
			_, size := utf8.DecodeRuneInString(text[space:])
			tokenStart = space + size
		}
		tokenEnd := len(text)
		if end := strings.IndexFunc(text[m[1]:], unicode.IsSpace); end >= 0 {
			tokenEnd = m[1] + end
		}
		token := strings.ToLower(text[tokenStart:tokenEnd])
		if strings.Contains(token, "://") || strings.Contains(token, "www.") || strings.Contains(token, "mailto:") {
			continue
		}
		if m[0] > 0 {
			previous, _ := utf8.DecodeLastRuneInString(text[:m[0]])
			if !unicode.IsSpace(previous) && !strings.ContainsRune("([{,;!?\"'“‘", previous) {
				continue
			}
		}
		if m[1] < len(text) {
			next, size := utf8.DecodeRuneInString(text[m[1]:])
			if next == '.' {
				// A sentence-ending period is allowed, but a domain suffix is not.
				rest := text[m[1]+size:]
				if rest != "" {
					after, _ := utf8.DecodeRuneInString(rest)
					if !unicode.IsSpace(after) && !strings.ContainsRune(")]}\"'”’", after) {
						continue
					}
				}
			} else if !unicode.IsSpace(next) && !strings.ContainsRune(")]},;!?\"'”’", next) {
				continue
			}
		}
		jid := text[m[2]:m[3]] + "@s.whatsapp.net"
		if !seen[jid] {
			seen[jid] = true
			jids = append(jids, jid)
		}
	}
	return jids
}

// mergeMentionJIDs combines explicitly provided MentionedJID entries with
// @phone mentions auto-detected from the message text, deduplicated.
func mergeMentionJIDs(explicit []string, text string) []string {
	seen := make(map[string]bool)
	var out []string
	for _, jid := range explicit {
		if !seen[jid] {
			seen[jid] = true
			out = append(out, jid)
		}
	}
	for _, jid := range extractMentionJIDs(text) {
		if !seen[jid] {
			seen[jid] = true
			out = append(out, jid)
		}
	}
	return out
}

func Find(slice []string, val string) bool {
	for _, item := range slice {
		if item == val {
			return true
		}
	}
	return false
}

func isHTTPURL(input string) bool {
	parsed, err := url.ParseRequestURI(input)
	if err != nil {
		return false
	}
	if parsed.Scheme != "http" && parsed.Scheme != "https" {
		return false
	}
	return parsed.Host != ""
}

func fetchURLBytes(ctx context.Context, resourceURL string, limit int64) ([]byte, string, error) {
	req, err := http.NewRequestWithContext(ctx, "GET", resourceURL, nil)
	if err != nil {
		return nil, "", err
	}

	// Sites with bot protection (e.g. Mercado Livre) return 403 to Go's
	// default "Go-http-client" agent; WhatsApp's own preview fetcher UA is
	// widely allowed since sites want their links previewed in WhatsApp.
	req.Header.Set("User-Agent", "WhatsApp/2.23.20.0")
	// Do not advertise image/avif: CDNs then serve AVIF, which Go's image
	// package cannot decode (gif/png/jpeg/webp decoders are registered).
	req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8")
	req.Header.Set("Accept-Language", "pt-BR,pt;q=0.9,en;q=0.8")

	resp, err := globalHTTPClient.Do(req)
	if err != nil {
		return nil, "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return nil, "", fmt.Errorf("unexpected status code %d", resp.StatusCode)
	}

	lr := io.LimitReader(resp.Body, limit+1)
	data, err := io.ReadAll(lr)
	if err != nil {
		return nil, "", err
	}
	if int64(len(data)) > limit {
		return nil, "", fmt.Errorf("response exceeds allowed size (%d bytes)", limit)
	}

	contentType := resp.Header.Get("Content-Type")
	if contentType == "" {
		contentType = http.DetectContentType(data)
	}

	return data, contentType, nil
}

func getOpenGraphData(ctx context.Context, urlStr string, userID string) openGraphResult {
	// Check cache first
	if cachedData, found := openGraphCache.Get(urlStr); found {
		if data, ok := cachedData.(openGraphResult); ok {
			log.Debug().Str("url", urlStr).Msg("Open Graph data fetched from cache")
			return data
		}
	}

	v, err, _ := openGraphGroup.Do(urlStr, func() (res any, err error) {
		ctx, cancel := context.WithTimeout(ctx, openGraphFetchTimeout)
		defer cancel()

		// Acquire a token from the semaphore pool
		userPool := userSemaphoreManager.ForUser(userID)
		select {
		case userPool <- struct{}{}:
			defer func() { <-userPool }()
		case <-ctx.Done():
			log.Warn().Str("url", urlStr).Msg("Open Graph data fetch timed out while waiting for a worker")
			return nil, ctx.Err()
		}

		// Recover from panics and convert to error
		defer func() {
			if r := recover(); r != nil {
				stack := debug.Stack()
				log.Error().
					Interface("panic_info", r).
					Str("url", urlStr).
					Bytes("stack", stack).
					Msg("Panic recovered while fetching Open Graph data")
				err = fmt.Errorf("panic: %v", r)
			}
		}()

		// Fetch Open Graph data
		result := fetchOpenGraphData(ctx, urlStr)

		// Store in cache
		openGraphCache.Set(urlStr, result, cache.DefaultExpiration)

		return result, nil
	})

	if err != nil {
		log.Error().Err(err).Str("url", urlStr).Msg("Error fetching Open Graph data via singleflight")
		return openGraphResult{}
	}

	if v == nil {
		return openGraphResult{}
	}

	return v.(openGraphResult)
}

// Update entry in User map
func updateUserInfo(values interface{}, field string, value string) interface{} {
	log.Debug().Str("field", field).Msg("User info updated")
	// Copy-on-write: the map inside Values is shared — it lives in
	// userinfocache and is handed to request goroutines via the request
	// context. Mutating it in place races with concurrent readers (Values.Get)
	// and can crash the process with "concurrent map read and map write".
	// Build a fresh map and return a new Values; callers persist it via
	// userinfocache.Set. Use a comma-ok assertion so a nil or unexpected value
	// can't panic — it falls back to the zero Values (nil map), handled below.
	old, _ := values.(Values)
	m := make(map[string]string, len(old.m)+1)
	for k, v := range old.m {
		m[k] = v
	}
	m[field] = value
	return Values{m: m}
}

// webhook for regular messages
func callHook(myurl string, payload map[string]string, userID string) {
	callHookWithHmac(myurl, payload, userID, nil)
}

// webhook for regular messages with HMAC
func callHookWithHmac(myurl string, payload map[string]string, userID string, encryptedHmacKey []byte) {
	log.Info().Str("userID", userID).Msg("Sending POST to client with retry logic")

	client := clientManager.GetHTTPClient(userID)
	if client == nil {
		log.Warn().Str("userID", userID).Msg("HTTP client is nil for user, skipping webhook")
		return
	}

	// Retry settings
	maxRetries := 1
	if *webhookRetryEnabled {
		maxRetries = *webhookRetryCount
	}

	var lastError error

	var body interface{} = payload

	// Starts the retry loop.
	for attempt := 0; attempt < maxRetries; attempt++ {
		if attempt > 0 {
			backoffFactor := 1 << uint(attempt-1)

			// Calculate the final delay.
			delayDuration := time.Duration(*webhookRetryDelaySeconds) * time.Second * time.Duration(backoffFactor)

			log.Warn().
				Int("attempt", attempt+1).
				Dur("delay", delayDuration).
				Msg("Retrying webhook request with exponential backoff...")

			time.Sleep(delayDuration)
		}

		var req *resty.Request
		var hmacSignature string
		var marshalErr error

		format := os.Getenv("WEBHOOK_FORMAT")

		if format == "json" {
			var jsonBody []byte

			if jsonStr, ok := payload["jsonData"]; ok {
				var postmap map[string]interface{}

				if err := json.Unmarshal([]byte(jsonStr), &postmap); err == nil {
					if instanceName, ok := payload["instanceName"]; ok {
						postmap["instanceName"] = instanceName
					}
					postmap["userID"] = userID
					body = postmap
				}
			}

			// Marshal body to JSON for HMAC signature
			jsonBody, marshalErr = json.Marshal(body)
			if marshalErr != nil {
				log.Error().Err(marshalErr).Msg("Failed to marshal body for HMAC")
			}

			// Generate HMAC signature if key exists
			if len(encryptedHmacKey) > 0 && len(jsonBody) > 0 {
				var err error
				hmacSignature, err = generateHmacSignature(jsonBody, encryptedHmacKey)
				if err != nil {
					log.Error().Err(err).Msg("Failed to generate HMAC signature")
				}
			}

			req = client.R().SetHeader("Content-Type", "application/json").SetBody(body)

		} else {

			if len(encryptedHmacKey) > 0 {
				formData := url.Values{}
				for k, v := range payload {
					formData.Add(k, v)
				}
				formString := formData.Encode()
				var err error
				hmacSignature, err = generateHmacSignature([]byte(formString), encryptedHmacKey)
				if err != nil {
					log.Error().Err(err).Msg("Failed to generate HMAC signature")
				}
			}
			req = client.R().SetFormData(payload)
			body = payload
		}

		if hmacSignature != "" {
			req.SetHeader("x-hmac-signature", hmacSignature)
		}

		resp, postErr := req.Post(myurl)

		lastError = postErr

		if postErr != nil {
			log.Error().Str("error_type", fmt.Sprintf("%T", postErr)).Int("attempt", attempt+1).Msg("Webhook failed due to network/IO error")
			continue
		}

		if resp.StatusCode() < 200 || resp.StatusCode() >= 300 {
			lastError = fmt.Errorf("unexpected status code: %d. Body: %s", resp.StatusCode(), string(resp.Body()))
			log.Error().
				Int("status", resp.StatusCode()).
				Int("attempt", attempt+1).
				Msg("Webhook failed due to non-2xx status code")

			if !*webhookRetryEnabled {
				break
			}
			continue
		}

		log.Info().Int("status", resp.StatusCode()).Msg("Webhook call successful")
		return
	}

	if lastError != nil {
		log.Error().Msg("Webhook permanently failed after all retries. Sending to error queue...")

		errorPayloadMap := make(map[string]interface{})
		if p, ok := body.(map[string]string); ok {

			for k, v := range p {
				errorPayloadMap[k] = v
			}
		} else if p, ok := body.(map[string]interface{}); ok {

			errorPayloadMap = p
		}

		errorPayload := WebhookErrorPayload{
			URL:              myurl,
			Payload:          errorPayloadMap,
			UserID:           userID,
			EncryptedHmacKey: hex.EncodeToString(encryptedHmacKey),
			AttemptTime:      time.Now(),
			ErrorMessage:     lastError.Error(),
		}

		PublishDataErrorToQueue(errorPayload)
	}
}

// webhook for messages with file attachments
func callHookFile(myurl string, payload map[string]string, userID string, file string) error {
	return callHookFileWithHmac(myurl, payload, userID, file, nil)
}

// webhook for messages with file attachments and HMAC
func callHookFileWithHmac(myurl string, payload map[string]string, userID string, file string, encryptedHmacKey []byte) error {
	log.Info().Str("file", file).Msg("Sending POST with retry logic")

	client := clientManager.GetHTTPClient(userID)
	if client == nil {
		log.Warn().Str("userID", userID).Msg("HTTP client is nil for user, skipping file webhook")
		return fmt.Errorf("http client is nil for user %s", userID)
	}

	maxRetries := 1
	if *webhookRetryEnabled {
		maxRetries = *webhookRetryCount
	}

	var lastError error

	finalPayload := make(map[string]string)
	for k, v := range payload {
		finalPayload[k] = v
	}
	finalPayload["file"] = file

	// 2. Loop Retry
	for attempt := 0; attempt < maxRetries; attempt++ {
		if attempt > 0 {
			backoffFactor := 1 << uint(attempt-1)

			delayDuration := time.Duration(*webhookRetryDelaySeconds) * time.Second * time.Duration(backoffFactor)

			log.Warn().
				Int("attempt", attempt+1).
				Dur("delay", delayDuration).
				Msg("Retrying file webhook request with exponential backoff...")

			time.Sleep(delayDuration)
		}

		var hmacSignature string
		var jsonPayload []byte

		if len(encryptedHmacKey) > 0 {
			var err error
			jsonPayload, err = json.Marshal(finalPayload)
			if err != nil {
				log.Error().Err(err).Msg("Failed to marshal payload for HMAC")
			} else {
				hmacSignature, err = generateHmacSignature(jsonPayload, encryptedHmacKey)
				if err != nil {
					log.Error().Err(err).Msg("Failed to generate HMAC signature")
				}
			}
		}

		req := client.R().
			SetFiles(map[string]string{
				"file": file,
			}).
			SetFormData(finalPayload)

		if hmacSignature != "" {
			req.SetHeader("x-hmac-signature", hmacSignature)
		}

		resp, postErr := req.Post(myurl)

		lastError = postErr

		if postErr != nil {
			log.Error().Str("error_type", fmt.Sprintf("%T", postErr)).Int("attempt", attempt+1).Msg("File webhook failed due to network/IO error")
			continue
		}

		if resp.StatusCode() < 200 || resp.StatusCode() >= 300 {
			lastError = fmt.Errorf("unexpected status code: %d. Body: %s", resp.StatusCode(), string(resp.Body()))
			log.Error().
				Int("status", resp.StatusCode()).
				Int("attempt", attempt+1).
				Msg("File webhook failed due to non-2xx status code")

			if !*webhookRetryEnabled {
				break
			}
			continue
		}

		log.Info().Int("status", resp.StatusCode()).Msg("File webhook call successful")
		return nil
	}

	if lastError != nil {
		log.Error().Msg("File webhook permanently failed after all retries. Sending to error queue...")

		errorPayloadMap := make(map[string]interface{})
		for k, v := range finalPayload {
			errorPayloadMap[k] = v
		}

		errorPayload := WebhookFileErrorPayload{
			URL:              myurl,
			Payload:          errorPayloadMap,
			UserID:           userID,
			EncryptedHmacKey: hex.EncodeToString(encryptedHmacKey),
			FilePath:         file,
			AttemptTime:      time.Now(),
			ErrorMessage:     lastError.Error(),
		}

		PublishFileErrorToQueue(errorPayload)

		return fmt.Errorf("webhook failed permanently: %w", lastError)
	}

	return nil
}

func (s *server) respondWithJSON(w http.ResponseWriter, statusCode int, payload interface{}) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")

	var buf bytes.Buffer
	enc := json.NewEncoder(&buf)
	if err := enc.Encode(payload); err != nil {
		log.Error().Err(err).Msg("Failed to encode JSON response")
		http.Error(w, "internal server error", http.StatusInternalServerError)
		return
	}

	w.WriteHeader(statusCode)
	if _, err := w.Write(buf.Bytes()); err != nil {
		log.Error().Err(err).Msg("Failed to write response body")
	}
}

// ProcessOutgoingMedia handles media processing for outgoing messages with S3 support
func ProcessOutgoingMedia(userID string, contactJID string, messageID string, data []byte, mimeType string, fileName string, db *sqlx.DB) (map[string]interface{}, error) {
	// Check if S3 is enabled for this user
	var s3Config struct {
		Enabled       bool   `db:"s3_enabled"`
		MediaDelivery string `db:"media_delivery"`
	}
	err := db.Get(&s3Config, "SELECT s3_enabled, media_delivery FROM users WHERE id = $1", userID)
	if err != nil {
		log.Error().Err(err).Msg("Failed to get S3 config")
		s3Config.Enabled = false
		s3Config.MediaDelivery = "base64"
	}

	// Process S3 upload if enabled
	if s3Config.Enabled && (s3Config.MediaDelivery == "s3" || s3Config.MediaDelivery == "both") {
		ensureS3ClientForUser(userID)
		// Process S3 upload (outgoing messages are always in outbox)
		s3Data, err := GetS3Manager().ProcessMediaForS3(
			context.Background(),
			userID,
			contactJID,
			messageID,
			data,
			mimeType,
			fileName,
			false, // isIncoming = false for sent messages
		)
		if err != nil {
			log.Error().Err(err).Msg("Failed to upload media to S3")
			// Continue even if S3 upload fails
		} else {
			return s3Data, nil
		}
	}

	return nil, nil
}

// generateHmacSignature generates HMAC-SHA256 signature for webhook payload
func generateHmacSignature(payload []byte, encryptedHmacKey []byte) (string, error) {
	if len(encryptedHmacKey) == 0 {
		return "", nil
	}

	// Decrypt HMAC key
	hmacKey, err := decryptHMACKey(encryptedHmacKey)
	if err != nil {
		return "", fmt.Errorf("failed to decrypt HMAC key: %w", err)
	}

	// Generate HMAC
	h := hmac.New(sha256.New, []byte(hmacKey))
	h.Write(payload)

	return hex.EncodeToString(h.Sum(nil)), nil
}

func encryptHMACKey(plainText string) ([]byte, error) {
	if *globalEncryptionKey == "" {
		return nil, fmt.Errorf("encryption key not configured")
	}

	block, err := aes.NewCipher([]byte(*globalEncryptionKey))
	if err != nil {
		return nil, fmt.Errorf("failed to create cipher: %w", err)
	}

	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, fmt.Errorf("failed to create GCM: %w", err)
	}

	nonce := make([]byte, gcm.NonceSize())
	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
		return nil, fmt.Errorf("failed to generate nonce: %w", err)
	}

	ciphertext := gcm.Seal(nonce, nonce, []byte(plainText), nil)
	return ciphertext, nil
}

// decryptHMACKey decrypts HMAC key using AES-GCM
func decryptHMACKey(encryptedData []byte) (string, error) {
	if *globalEncryptionKey == "" {
		return "", fmt.Errorf("encryption key not configured")
	}

	block, err := aes.NewCipher([]byte(*globalEncryptionKey))
	if err != nil {
		return "", fmt.Errorf("failed to create cipher: %w", err)
	}

	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return "", fmt.Errorf("failed to create GCM: %w", err)
	}

	nonceSize := gcm.NonceSize()
	if len(encryptedData) < nonceSize {
		return "", fmt.Errorf("ciphertext too short")
	}

	nonce, ciphertext := encryptedData[:nonceSize], encryptedData[nonceSize:]
	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
	if err != nil {
		return "", fmt.Errorf("failed to decrypt: %w", err)
	}

	return string(plaintext), nil
}

func extractFirstURL(text string) string {
	match := urlRegex.FindString(text)
	if match == "" {
		return ""
	}

	return match
}
func fetchOpenGraphData(ctx context.Context, urlStr string) openGraphResult {
	pageData, _, err := fetchURLBytes(ctx, urlStr, openGraphPageMaxBytes)
	if err != nil {
		log.Warn().Err(err).Str("url", urlStr).Msg("Failed to fetch URL for Open Graph data")
		return openGraphResult{}
	}

	doc, err := goquery.NewDocumentFromReader(bytes.NewReader(pageData))
	if err != nil {
		log.Warn().Err(err).Str("url", urlStr).Msg("Failed to parse HTML for Open Graph data")
		return openGraphResult{}
	}

	title := doc.Find(`meta[property="og:title"]`).AttrOr("content", "")
	if title == "" {
		title = strings.TrimSpace(doc.Find("title").Text())
	}

	description := doc.Find(`meta[property="og:description"]`).AttrOr("content", "")
	if description == "" {
		description = doc.Find(`meta[name="description"]`).AttrOr("content", "")
	}

	var imageURLStr string
	selectors := []struct {
		selector string
		attr     string
	}{
		{`meta[property="og:image"]`, "content"},
		{`meta[property="twitter:image"]`, "content"},
		{`link[rel="apple-touch-icon"]`, "href"},
		{`link[rel="icon"]`, "href"},
	}

	for _, s := range selectors {
		imageURLStr, _ = doc.Find(s.selector).Attr(s.attr)
		if imageURLStr != "" {
			break
		}
	}

	result := openGraphResult{Title: title, Description: description}

	pageURL, err := url.Parse(urlStr)
	if err != nil {
		log.Warn().Err(err).Str("url", urlStr).Msg("Failed to parse page URL for resolving image URL")
		return result
	}

	fetchOpenGraphImage(ctx, pageURL, imageURLStr, &result)
	return result
}

func encodeJPEGThumbnail(img image.Image) []byte {
	var buf bytes.Buffer
	if err := jpeg.Encode(&buf, img, &jpeg.Options{Quality: openGraphJpegQuality}); err != nil {
		log.Warn().Err(err).Msg("Failed to encode thumbnail to JPEG")
		return nil
	}
	return buf.Bytes()
}

func fetchOpenGraphImage(ctx context.Context, pageURL *url.URL, imageURLStr string, result *openGraphResult) {
	// No image found on the page; an empty string would resolve to the page
	// URL itself and we would try to decode HTML as an image.
	if imageURLStr == "" {
		return
	}

	imageURL, err := url.Parse(imageURLStr)
	if err != nil {
		log.Warn().Err(err).Str("imageURL", imageURLStr).Msg("Failed to parse Open Graph image URL")
		return
	}

	resolvedImageURL := pageURL.ResolveReference(imageURL).String()
	imgBytes, _, err := fetchURLBytes(ctx, resolvedImageURL, openGraphImageMaxBytes)
	if err != nil {
		log.Warn().Err(err).Str("imageURL", resolvedImageURL).Msg("Failed to fetch Open Graph image")
		return
	}

	imgConfig, _, err := image.DecodeConfig(bytes.NewReader(imgBytes))
	if err != nil {
		log.Warn().Err(err).Str("imageURL", resolvedImageURL).Msg("Failed to decode Open Graph image config")
		return
	}

	if imgConfig.Width > openGraphMaxImageDim || imgConfig.Height > openGraphMaxImageDim {
		log.Warn().
			Int("width", imgConfig.Width).
			Int("height", imgConfig.Height).
			Str("imageURL", resolvedImageURL).
			Msg("Open Graph image dimensions too large")
		return
	}

	img, _, err := image.Decode(bytes.NewReader(imgBytes))
	if err != nil {
		log.Warn().Err(err).Str("imageURL", resolvedImageURL).Msg("Failed to decode Open Graph image")
		return
	}

	hqThumb := resize.Thumbnail(openGraphHQThumbnailDim, openGraphHQThumbnailDim, img, resize.Lanczos3)
	result.HQImageData = encodeJPEGThumbnail(hqThumb)
	bounds := hqThumb.Bounds()
	result.HQWidth = uint32(bounds.Dx())
	result.HQHeight = uint32(bounds.Dy())

	// Downscale the inline thumbnail from hqThumb (max 600px) instead of
	// resizing the original image (up to 4000px) a second time.
	result.ImageData = encodeJPEGThumbnail(resize.Thumbnail(openGraphThumbnailWidth, openGraphThumbnailHeight, hqThumb, resize.Lanczos3))
}

func buildStickerMetadata(packID, packName, packPublisher string, emojis []string) map[string]interface{} {
	if packID == "" && packName == "" && packPublisher == "" && len(emojis) == 0 {
		return nil
	}

	meta := make(map[string]interface{})
	if packID != "" {
		meta["sticker-pack-id"] = packID
	}
	if packName != "" {
		meta["sticker-pack-name"] = packName
	}
	if packPublisher != "" {
		meta["sticker-pack-publisher"] = packPublisher
	}
	if len(emojis) > 0 {
		meta["emojis"] = emojis
	}
	return meta
}

func buildWhatsAppEXIF(meta map[string]interface{}) []byte {
	jsonBytes, err := json.Marshal(meta)
	if err != nil {
		return nil
	}

	// WhatsApp sticker EXIF header structure
	header := []byte{
		0x49, 0x49, 0x2A, 0x00, // TIFF little-endian marker
		0x08, 0x00, 0x00, 0x00, // IFD offset
		0x01, 0x00, // Number of directory entries
		0x41, 0x57, // Tag ID (WhatsApp custom)
		0x07, 0x00, // Data type (undefined)
	}
	footer := []byte{0x16, 0x00, 0x00, 0x00} // Next IFD offset

	var buf bytes.Buffer
	buf.Write(header)
	binary.Write(&buf, binary.LittleEndian, uint32(len(jsonBytes)))
	buf.Write(footer)
	buf.Write(jsonBytes)

	return buf.Bytes()
}

func isValidWebP(data []byte) bool {
	return len(data) >= riffHeaderSize &&
		string(data[0:4]) == "RIFF" &&
		string(data[8:12]) == "WEBP"
}

func createVP8XChunk(width, height int) []byte {
	chunk := make([]byte, vp8xChunkSize)
	copy(chunk[0:4], "VP8X")
	binary.LittleEndian.PutUint32(chunk[4:8], vp8xPayloadSize)
	chunk[vp8xFlagsOffset] = vp8xFlagEXIF
	putUint24LE(chunk[vp8xWidthOffset:], width-1)
	putUint24LE(chunk[vp8xHeightOffset:], height-1)
	return chunk
}

func putUint24LE(b []byte, v int) {
	b[0] = uint8(v)
	b[1] = uint8(v >> 8)
	b[2] = uint8(v >> 16)
}

func writeChunk(buf *bytes.Buffer, tag string, data []byte) {
	buf.WriteString(tag)
	sz := make([]byte, 4)
	binary.LittleEndian.PutUint32(sz, uint32(len(data)))
	buf.Write(sz)
	buf.Write(data)
	if len(data)%2 == 1 {
		buf.WriteByte(0)
	}
}