package services

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"mime"
	"net/http"
	neturl "net/url"
	"os"
	"os/exec"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"sync"
	"time"
)

type GeminiService struct {
	APIKey            string
	Client            *http.Client
	GenerateEndpoint  string
	TranslateEndpoint string
	Debug             func(message string, data any)
	cacheMu           sync.Mutex
	visualCache       map[string]cachedVisualData
	translationCache  map[string]cachedStringValue
	expansionCache    map[string]cachedExpansionValue
}

type cachedVisualData struct {
	data      string
	mimeType  string
	expiresAt time.Time
}

type cachedStringValue struct {
	value     string
	expiresAt time.Time
}

type cachedExpansionValue struct {
	value     []string
	expiresAt time.Time
}

type AIRecommendation struct {
	Title                string `json:"title"`
	Link                 string `json:"link"`
	Snippet              string `json:"snippet"`
	ThumbnailURL         string `json:"thumbnailUrl"`
	PreviewVideoURL      string `json:"previewVideoUrl"`
	Source               string `json:"source"`
	Reason               string `json:"reason"`
	Recommended          bool   `json:"recommended"`
	Assessment           string `json:"assessment,omitempty"`
	SearchHint           string `json:"searchHint,omitempty"`
	MediaMode            string `json:"mediaMode,omitempty"`
	EmbedURL             string `json:"embedUrl,omitempty"`
	PreviewBlockedReason string `json:"previewBlockedReason,omitempty"`
	ActionLabel          string `json:"actionLabel,omitempty"`
	ActionType           string `json:"actionType,omitempty"`
	SecondaryActionLabel string `json:"secondaryActionLabel,omitempty"`
}

type QueryExpansion struct {
	Querywords []string `json:"querywords"`
}

func NewGeminiService(apiKey string) *GeminiService {
	return &GeminiService{
		APIKey:            apiKey,
		Client:            &http.Client{Timeout: 40 * time.Second},
		GenerateEndpoint:  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent",
		TranslateEndpoint: "https://translate.googleapis.com/translate_a/single",
		visualCache:       map[string]cachedVisualData{},
		translationCache:  map[string]cachedStringValue{},
		expansionCache:    map[string]cachedExpansionValue{},
	}
}

func (g *GeminiService) ExpandQuery(query string) ([]string, error) {
	cacheKey := strings.TrimSpace(query)
	if cached, ok := g.getCachedExpansion(cacheKey); ok {
		g.debug("gemini:expand_query_cache_hit", map[string]any{"query": query, "expanded": cached})
		return cached, nil
	}

	englishBase := g.TranslateQuery(query)
	expanded := buildSearchQueries(query, englishBase)
	g.setCachedExpansion(cacheKey, expanded, 15*time.Minute)
	g.debug("gemini:expand_query", map[string]any{
		"original": query,
		"english":  englishBase,
		"expanded": expanded,
	})
	return expanded, nil
}

func (g *GeminiService) TranslateSummaryToKorean(text string) (string, error) {
	trimmed := strings.TrimSpace(text)
	if trimmed == "" {
		return "", nil
	}
	cacheKey := "summary-ko\n" + trimmed
	if cached, ok := g.getCachedTranslation(cacheKey); ok {
		g.debug("gemini:summary_translate_cache_hit", map[string]any{"length": len(trimmed)})
		return cached, nil
	}
	if !looksMostlyASCII(trimmed) {
		g.setCachedTranslation(cacheKey, trimmed, 15*time.Minute)
		return trimmed, nil
	}

	g.debug("gemini:summary_translate_attempt", map[string]any{"length": len(trimmed)})
	translated, err := g.translateViaGoogleToTarget(trimmed, "ko")
	if err != nil {
		g.debug("gemini:summary_translate_error", map[string]any{"length": len(trimmed), "error": err.Error()})
		return "", err
	}
	translated = strings.TrimSpace(translated)
	if translated == "" {
		return "", fmt.Errorf("google translate summary returned empty translation")
	}
	g.debug("gemini:summary_translate_success", map[string]any{"length": len(trimmed)})
	g.setCachedTranslation(cacheKey, translated, 15*time.Minute)
	return translated, nil
}

func (g *GeminiService) TranslateQuery(query string) string {
	trimmed := strings.TrimSpace(query)
	if trimmed == "" {
		return ""
	}
	if cached, ok := g.getCachedTranslation(trimmed); ok {
		g.debug("gemini:translate_cache_hit", map[string]any{"query": trimmed, "translated": cached})
		return cached
	}
	normalizedIntent := normalizeKnownMediaPhrases(trimmed)
	if looksMostlyASCII(normalizedIntent) {
		result := strings.TrimSpace(normalizedIntent)
		g.setCachedTranslation(trimmed, result, 15*time.Minute)
		return result
	}
	if looksMostlyASCII(trimmed) {
		g.setCachedTranslation(trimmed, trimmed, 15*time.Minute)
		return trimmed
	}

	if g.APIKey != "" {
		g.debug("gemini:translate_attempt", map[string]any{"mode": "gemini", "query": trimmed})
		body := map[string]any{
			"systemInstruction": map[string]any{
				"parts": []map[string]string{
					{
						"text": "You are a professional video editor. Infer stronger stock-footage and scene-search wording from the user's keyword, and expand it into natural English that a professional editor would use to find usable footage. Output one plain English search phrase only. No labels, no quotes, no explanations.",
					},
				},
			},
			"contents": []map[string]any{
				{
					"parts": []map[string]string{
						{
							"text": "Expand this user query into a concise but editor-grade English footage search phrase suitable for stock-footage discovery: " + trimmed,
						},
					},
				},
			},
			"generationConfig": map[string]any{
				"responseMimeType": "text/plain",
				"temperature":      0.1,
				"maxOutputTokens":  40,
			},
		}

		rawText, err := g.generateText(body)
		if err == nil {
			translated := sanitizePlainEnglishLine(rawText)
			if translated != "" && !strings.EqualFold(translated, trimmed) && !isOvercompressedTranslation(trimmed, translated) {
				g.debug("gemini:translate_success", map[string]any{"mode": "gemini", "query": trimmed, "translated": translated})
				g.setCachedTranslation(trimmed, translated, 15*time.Minute)
				return translated
			}
		}
		if err != nil {
			g.debug("gemini:translate_error", map[string]any{"mode": "gemini", "query": trimmed, "error": err.Error()})
		}
	}

	g.debug("gemini:translate_attempt", map[string]any{"mode": "google", "query": trimmed})
	if translated, err := g.translateViaGoogle(trimmed); err == nil && translated != "" && isLikelyEnglishQuery(translated) && !isOvercompressedTranslation(trimmed, translated) {
		g.debug("gemini:translate_success", map[string]any{"mode": "google", "query": trimmed, "translated": translated})
		g.setCachedTranslation(trimmed, translated, 15*time.Minute)
		return translated
	}
	if translated := translateKoreanMediaTerms(normalizedIntent); translated != "" && !strings.EqualFold(translated, trimmed) {
		g.debug("gemini:translate_success", map[string]any{"mode": "dictionary", "query": trimmed, "translated": translated})
		g.setCachedTranslation(trimmed, translated, 15*time.Minute)
		return translated
	}
	g.debug("gemini:translate_fallback_original", map[string]any{"query": trimmed, "normalized": normalizedIntent})
	result := strings.TrimSpace(normalizedIntent)
	g.setCachedTranslation(trimmed, result, 15*time.Minute)
	return result
}

func (g *GeminiService) generateText(body map[string]any) (string, error) {
	rawBody, _ := json.Marshal(body)
	endpoint := strings.TrimRight(g.GenerateEndpoint, "?") + "?key=" + g.APIKey
	resp, err := g.Client.Post(endpoint, "application/json", bytes.NewReader(rawBody))
	if err != nil {
		return "", fmt.Errorf("gemini request failed: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 300 {
		data, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
		return "", fmt.Errorf("gemini returned status %d: %s", resp.StatusCode, strings.TrimSpace(string(data)))
	}

	var payload struct {
		Candidates []struct {
			Content struct {
				Parts []struct {
					Text string `json:"text"`
				} `json:"parts"`
			} `json:"content"`
		} `json:"candidates"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
		return "", fmt.Errorf("gemini response decode failed: %w", err)
	}
	if len(payload.Candidates) == 0 || len(payload.Candidates[0].Content.Parts) == 0 {
		return "", fmt.Errorf("gemini returned no candidates")
	}
	return payload.Candidates[0].Content.Parts[0].Text, nil
}

func (g *GeminiService) Recommend(query string, candidates []SearchResult) ([]AIRecommendation, error) {
	if g.APIKey == "" {
		return nil, fmt.Errorf("gemini api key is not configured")
	}
	if len(candidates) == 0 {
		return []AIRecommendation{}, nil
	}
	if len(candidates) == 1 {
		return g.recommendSingleCandidate(query, candidates[0])
	}
	g.debug("gemini:vision_start", map[string]any{
		"query":          query,
		"candidateCount": len(candidates),
	})

	type geminiPart map[string]any
	parts := []geminiPart{
		{
			"text": buildGeminiVisionInstruction(query, len(candidates)),
		},
	}

	maxImages := min(len(candidates), 10)
	visualCount := 0
	for idx := 0; idx < maxImages; idx++ {
		img, mimeType, err := g.fetchCandidateVisualInlineData(candidates[idx])
		if err != nil {
			g.debug("gemini:vision_candidate_visual_error", map[string]any{
				"index":  idx,
				"link":   candidates[idx].Link,
				"source": candidates[idx].Source,
				"error":  err.Error(),
			})
			continue
		}
		visualCount++
		parts = append(parts,
			geminiPart{"text": fmt.Sprintf("Candidate %d: title=%s source=%s link=%s", idx, candidates[idx].Title, candidates[idx].Source, candidates[idx].Link)},
			geminiPart{"inlineData": map[string]string{"mimeType": mimeType, "data": img}},
		)
	}
	if visualCount == 0 {
		return nil, fmt.Errorf("no candidate thumbnails or preview frames could be fetched for gemini vision")
	}
	g.debug("gemini:vision_visuals_prepared", map[string]any{
		"query":           query,
		"visualCount":     visualCount,
		"maxImages":       maxImages,
		"maxOutputTokens": geminiVisionMaxOutputTokens(visualCount),
	})

	body := map[string]any{
		"contents": []map[string]any{
			{"parts": parts},
		},
		"generationConfig": map[string]any{
			"responseMimeType": "text/plain",
			"temperature":      0.1,
			"maxOutputTokens":  geminiVisionMaxOutputTokens(visualCount),
		},
	}

	rawBody, _ := json.Marshal(body)
	endpoint := strings.TrimRight(g.GenerateEndpoint, "?") + "?key=" + g.APIKey
	resp, err := g.Client.Post(endpoint, "application/json", bytes.NewReader(rawBody))
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 300 {
		data, _ := io.ReadAll(io.LimitReader(resp.Body, 2048))
		return nil, fmt.Errorf("gemini vision returned status %d: %s", resp.StatusCode, strings.TrimSpace(string(data)))
	}

	var payload struct {
		Candidates []struct {
			Content struct {
				Parts []struct {
					Text string `json:"text"`
				} `json:"parts"`
			} `json:"content"`
		} `json:"candidates"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
		return nil, fmt.Errorf("gemini vision response decode failed: %w", err)
	}
	if len(payload.Candidates) == 0 || len(payload.Candidates[0].Content.Parts) == 0 {
		return nil, fmt.Errorf("gemini vision returned no candidates")
	}

	rawText := payload.Candidates[0].Content.Parts[0].Text
	parsed, recoveredPartial, err := parseGeminiVisionRecommendations(rawText)
	if err != nil {
		return nil, fmt.Errorf("gemini vision JSON extraction failed: %w", err)
	}
	if recoveredPartial {
		g.debug("gemini:vision_partial_json_recovered", map[string]any{
			"query":               query,
			"candidateCount":      len(candidates),
			"recommendationCount": len(parsed.Recommendations),
		})
	}

	recommendations := make([]AIRecommendation, 0, len(parsed.Recommendations))
	for _, rec := range parsed.Recommendations {
		if rec.Index < 0 || rec.Index >= len(candidates) {
			continue
		}
		src := candidates[rec.Index]
		recommended := rec.Recommended || strings.EqualFold(strings.TrimSpace(rec.Verdict), "yes")
		assessment := normalizeAssessment(rec.Assessment, recommended)
		recommendations = append(recommendations, AIRecommendation{
			Title:           src.Title,
			Link:            src.Link,
			Snippet:         src.Snippet,
			ThumbnailURL:    src.ThumbnailURL,
			PreviewVideoURL: src.PreviewVideoURL,
			Source:          src.Source,
			Reason:          normalizeKoreanReason(rec.Reason),
			Recommended:     recommended,
			Assessment:      assessment,
			SearchHint:      normalizeSearchHint(rec.SearchHint),
		})
	}
	g.debug("gemini:vision_complete", map[string]any{
		"query":               query,
		"recommendationCount": len(recommendations),
	})

	return recommendations, nil
}

func (g *GeminiService) recommendSingleCandidate(query string, candidate SearchResult) ([]AIRecommendation, error) {
	g.debug("gemini:vision_start", map[string]any{
		"query":          query,
		"candidateCount": 1,
		"mode":           "single_candidate_recovery",
	})

	img, mimeType, err := g.fetchCandidateVisualInlineData(candidate)
	if err != nil {
		g.debug("gemini:vision_candidate_visual_error", map[string]any{
			"index":  0,
			"link":   candidate.Link,
			"source": candidate.Source,
			"error":  err.Error(),
		})
		return nil, err
	}

	g.debug("gemini:vision_visuals_prepared", map[string]any{
		"query":           query,
		"visualCount":     1,
		"maxImages":       1,
		"maxOutputTokens": 120,
		"mode":            "single_candidate_recovery",
	})

	body := map[string]any{
		"contents": []map[string]any{
			{
				"parts": []map[string]any{
					{
						"text": `You are a professional video editor. Analyze the single provided visual for the user's keyword.
Return plain text only with exactly these 5 lines:
verdict: Yes or No
assessment: positive or unclear or irrelevant or inappropriate
recommended: true or false
reason_ko: very short Korean reason
search_hint: short English stock-footage hint or empty
No JSON. No markdown. No extra text.
User query: ` + query,
					},
					{"text": fmt.Sprintf("Candidate 0: title=%s source=%s link=%s", candidate.Title, candidate.Source, candidate.Link)},
					{"inlineData": map[string]string{"mimeType": mimeType, "data": img}},
				},
			},
		},
		"generationConfig": map[string]any{
			"responseMimeType": "text/plain",
			"temperature":      0.1,
			"maxOutputTokens":  120,
		},
	}

	rawText, err := g.generateText(body)
	if err != nil {
		return nil, err
	}
	rec, err := parseSingleCandidateVisionText(rawText)
	if err != nil {
		return nil, fmt.Errorf("gemini single-candidate parse failed: %w; raw=%q", err, truncateForError(rawText, 200))
	}

	recommended := rec.Recommended || strings.EqualFold(strings.TrimSpace(rec.Verdict), "yes")
	assessment := normalizeAssessment(rec.Assessment, recommended)
	result := AIRecommendation{
		Title:           candidate.Title,
		Link:            candidate.Link,
		Snippet:         candidate.Snippet,
		ThumbnailURL:    candidate.ThumbnailURL,
		PreviewVideoURL: candidate.PreviewVideoURL,
		Source:          candidate.Source,
		Reason:          normalizeKoreanReason(rec.Reason),
		Recommended:     recommended,
		Assessment:      assessment,
		SearchHint:      normalizeSearchHint(rec.SearchHint),
	}

	g.debug("gemini:vision_complete", map[string]any{
		"query":               query,
		"recommendationCount": 1,
		"mode":                "single_candidate_recovery",
	})
	return []AIRecommendation{result}, nil
}

func buildGeminiVisionInstruction(query string, _ int) string {
	return `You are a professional video editor. Analyze whether each provided visual is suitable as a usable scene or shot for the user's requested keyword.
Return plain text only.
Return exactly one line per analyzed candidate in this exact format:
index|verdict|assessment|recommended|reason_ko|search_hint
Rules:
- index: integer candidate index
- verdict: Yes or No
- assessment: positive or unclear or irrelevant or inappropriate
- recommended: true or false
- reason_ko: very short Korean reason without line breaks and without |
- search_hint: short English stock-footage phrase or empty, without |
Do not include markdown fences, JSON, bullets, numbering, or any other text.
Prefer cinematic b-roll, stock footage, editorial footage, clean composition, usable establishing shots, and professional media thumbnails.
Avoid clickbait faces, exaggerated expressions, meme aesthetics, low-information thumbnails, sensational text overlays, or gossip-style imagery.
User query: ` + query
}

func geminiVisionMaxOutputTokens(candidateCount int) int {
	switch {
	case candidateCount <= 1:
		return 120
	case candidateCount == 2:
		return 180
	case candidateCount == 3:
		return 240
	case candidateCount == 4:
		return 300
	default:
		return 360
	}
}

type geminiVisionParsedPayload struct {
	Recommendations []struct {
		Index       int    `json:"index"`
		Verdict     string `json:"verdict"`
		Reason      string `json:"reason"`
		Recommended bool   `json:"recommended"`
		Assessment  string `json:"assessment"`
		SearchHint  string `json:"searchHint"`
	} `json:"recommendations"`
}

func parseGeminiVisionRecommendations(raw string) (geminiVisionParsedPayload, bool, error) {
	if parsed, ok := parseGeminiVisionLines(raw); ok {
		return parsed, false, nil
	}

	jsonText, err := extractJSONObject(raw)
	if err == nil {
		var parsed geminiVisionParsedPayload
		if unmarshalErr := json.Unmarshal([]byte(jsonText), &parsed); unmarshalErr != nil {
			return geminiVisionParsedPayload{}, false, fmt.Errorf("json parse failed: %w; raw=%q", unmarshalErr, truncateForError(raw, 200))
		}
		return parsed, false, nil
	}

	objects := extractCompleteRecommendationObjects(raw)
	if len(objects) == 0 {
		return geminiVisionParsedPayload{}, false, err
	}

	parsed := geminiVisionParsedPayload{
		Recommendations: make([]struct {
			Index       int    `json:"index"`
			Verdict     string `json:"verdict"`
			Reason      string `json:"reason"`
			Recommended bool   `json:"recommended"`
			Assessment  string `json:"assessment"`
			SearchHint  string `json:"searchHint"`
		}, 0, len(objects)),
	}
	for _, objectText := range objects {
		var item struct {
			Index       int    `json:"index"`
			Verdict     string `json:"verdict"`
			Reason      string `json:"reason"`
			Recommended bool   `json:"recommended"`
			Assessment  string `json:"assessment"`
			SearchHint  string `json:"searchHint"`
		}
		if unmarshalErr := json.Unmarshal([]byte(objectText), &item); unmarshalErr != nil {
			continue
		}
		parsed.Recommendations = append(parsed.Recommendations, item)
	}
	if len(parsed.Recommendations) == 0 {
		return geminiVisionParsedPayload{}, false, err
	}
	return parsed, true, nil
}

func parseGeminiVisionLines(raw string) (geminiVisionParsedPayload, bool) {
	lines := strings.Split(strings.ReplaceAll(strings.TrimSpace(raw), "\r\n", "\n"), "\n")
	parsed := geminiVisionParsedPayload{
		Recommendations: make([]struct {
			Index       int    `json:"index"`
			Verdict     string `json:"verdict"`
			Reason      string `json:"reason"`
			Recommended bool   `json:"recommended"`
			Assessment  string `json:"assessment"`
			SearchHint  string `json:"searchHint"`
		}, 0, len(lines)),
	}

	for _, line := range lines {
		trimmed := strings.TrimSpace(strings.Trim(line, "`"))
		if trimmed == "" {
			continue
		}
		parts := strings.SplitN(trimmed, "|", 6)
		if len(parts) != 6 {
			continue
		}
		index, err := strconv.Atoi(strings.TrimSpace(parts[0]))
		if err != nil {
			continue
		}
		parsed.Recommendations = append(parsed.Recommendations, struct {
			Index       int    `json:"index"`
			Verdict     string `json:"verdict"`
			Reason      string `json:"reason"`
			Recommended bool   `json:"recommended"`
			Assessment  string `json:"assessment"`
			SearchHint  string `json:"searchHint"`
		}{
			Index:       index,
			Verdict:     strings.TrimSpace(parts[1]),
			Assessment:  strings.TrimSpace(parts[2]),
			Recommended: strings.EqualFold(strings.TrimSpace(parts[3]), "true") || strings.EqualFold(strings.TrimSpace(parts[3]), "yes"),
			Reason:      strings.TrimSpace(parts[4]),
			SearchHint:  strings.TrimSpace(parts[5]),
		})
	}
	return parsed, len(parsed.Recommendations) > 0
}

type singleCandidateVisionResponse struct {
	Verdict     string
	Assessment  string
	Recommended bool
	Reason      string
	SearchHint  string
}

func parseSingleCandidateVisionText(raw string) (singleCandidateVisionResponse, error) {
	lines := strings.Split(strings.ReplaceAll(strings.TrimSpace(raw), "\r\n", "\n"), "\n")
	result := singleCandidateVisionResponse{}
	for _, line := range lines {
		trimmed := strings.TrimSpace(line)
		if trimmed == "" {
			continue
		}
		parts := strings.SplitN(trimmed, ":", 2)
		if len(parts) != 2 {
			continue
		}
		key := strings.ToLower(strings.TrimSpace(parts[0]))
		value := strings.TrimSpace(parts[1])
		switch key {
		case "verdict":
			result.Verdict = value
		case "assessment":
			result.Assessment = value
		case "recommended":
			result.Recommended = strings.EqualFold(value, "true") || strings.EqualFold(value, "yes")
		case "reason_ko":
			result.Reason = value
		case "search_hint":
			result.SearchHint = value
		}
	}
	if strings.TrimSpace(result.Verdict) == "" {
		return singleCandidateVisionResponse{}, fmt.Errorf("missing verdict line")
	}
	return result, nil
}

func extractCompleteRecommendationObjects(text string) []string {
	cleaned := strings.TrimSpace(text)
	cleaned = strings.TrimPrefix(cleaned, "```json")
	cleaned = strings.TrimPrefix(cleaned, "```")
	cleaned = strings.TrimSuffix(cleaned, "```")
	cleaned = strings.TrimSpace(cleaned)

	recommendationsIndex := strings.Index(cleaned, `"recommendations"`)
	if recommendationsIndex == -1 {
		return nil
	}
	arrayStart := strings.Index(cleaned[recommendationsIndex:], "[")
	if arrayStart == -1 {
		return nil
	}
	arrayStart += recommendationsIndex

	objects := make([]string, 0, 4)
	inString := false
	escaped := false
	objectDepth := 0
	objectStart := -1

	for idx := arrayStart + 1; idx < len(cleaned); idx++ {
		ch := cleaned[idx]
		if escaped {
			escaped = false
			continue
		}
		if ch == '\\' && inString {
			escaped = true
			continue
		}
		if ch == '"' {
			inString = !inString
			continue
		}
		if inString {
			continue
		}
		switch ch {
		case '{':
			if objectDepth == 0 {
				objectStart = idx
			}
			objectDepth++
		case '}':
			if objectDepth == 0 {
				continue
			}
			objectDepth--
			if objectDepth == 0 && objectStart >= 0 {
				objects = append(objects, cleaned[objectStart:idx+1])
				objectStart = -1
			}
		case ']':
			if objectDepth == 0 {
				return objects
			}
		}
	}
	return objects
}

func (g *GeminiService) BuildSupplementalQueries(query string, existing []string, reviewed []AIRecommendation) ([]string, error) {
	baseExisting := make([]string, 0, len(existing))
	for _, item := range existing {
		trimmed := strings.TrimSpace(item)
		if trimmed != "" {
			baseExisting = append(baseExisting, trimmed)
		}
	}
	if len(baseExisting) == 0 {
		baseExisting = append(baseExisting, query)
	}

	positive := make([]string, 0, 3)
	negativeHints := make([]string, 0, 4)
	sourceCounts := map[string]int{}
	for _, item := range reviewed {
		sourceCounts[item.Source]++
		if item.Assessment == "positive" && len(positive) < 3 {
			positive = append(positive, truncateForError(strings.TrimSpace(item.Title), 80))
		}
		if (item.Assessment == "irrelevant" || item.Assessment == "inappropriate" || item.Assessment == "unclear") && item.SearchHint != "" && len(negativeHints) < 4 {
			negativeHints = append(negativeHints, item.SearchHint)
		}
	}

	if g.APIKey == "" {
		return nil, fmt.Errorf("gemini api key is not configured")
	}

	body := map[string]any{
		"systemInstruction": map[string]any{
			"parts": []map[string]string{{
				"text": "You generate improved stock-footage search phrases. Return 3 to 5 plain English search phrases only, one per line, no numbering, no quotes, no explanations.",
			}},
		},
		"contents": []map[string]any{{
			"parts": []map[string]string{{
				"text": fmt.Sprintf("Original query: %s\nExisting search phrases: %s\nPositive candidate titles: %s\nNegative or weak search hints: %s\nSource distribution: Envato=%d, Artgrid=%d, Google Video=%d\nGenerate improved English search phrases that avoid weak or irrelevant results and increase provider diversity.",
					query,
					strings.Join(baseExisting, " | "),
					strings.Join(positive, " | "),
					strings.Join(negativeHints, " | "),
					sourceCounts["Envato"],
					sourceCounts["Artgrid"],
					sourceCounts["Google Video"],
				),
			}},
		}},
		"generationConfig": map[string]any{
			"responseMimeType": "text/plain",
			"temperature":      0.3,
			"maxOutputTokens":  120,
		},
	}

	rawText, err := g.generateText(body)
	if err != nil {
		return nil, err
	}
	queries := parseSupplementalQueryLines(rawText)
	if len(queries) == 0 {
		return nil, fmt.Errorf("gemini returned no supplemental queries")
	}
	return queries, nil
}

func (g *GeminiService) debug(message string, data any) {
	if g != nil && g.Debug != nil {
		g.Debug(message, data)
	}
}

func fetchImageAsInlineData(client *http.Client, imageURL, referer string) (string, string, error) {
	if strings.TrimSpace(imageURL) == "" {
		return "", "", fmt.Errorf("image url is empty")
	}
	req, reqErr := newBrowserStyleImageRequest(imageURL, referer)
	if reqErr != nil {
		return "", "", reqErr
	}
	resp, err := client.Do(req)
	if err != nil {
		return "", "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 300 {
		return "", "", fmt.Errorf("thumbnail fetch failed with %d", resp.StatusCode)
	}

	contentType := resp.Header.Get("Content-Type")
	mimeType, _, _ := mime.ParseMediaType(contentType)
	if mimeType == "" || !strings.HasPrefix(mimeType, "image/") {
		mimeType = "image/jpeg"
	}

	data, err := io.ReadAll(io.LimitReader(resp.Body, 2*1024*1024))
	if err != nil {
		return "", "", err
	}
	return base64.StdEncoding.EncodeToString(data), mimeType, nil
}

func (g *GeminiService) getCachedVisual(key string) (string, string, bool) {
	g.cacheMu.Lock()
	defer g.cacheMu.Unlock()

	entry, ok := g.visualCache[key]
	if !ok {
		return "", "", false
	}
	if time.Now().After(entry.expiresAt) {
		delete(g.visualCache, key)
		return "", "", false
	}
	return entry.data, entry.mimeType, true
}

func (g *GeminiService) setCachedVisual(key, data, mimeType string, ttl time.Duration) {
	g.cacheMu.Lock()
	defer g.cacheMu.Unlock()

	g.visualCache[key] = cachedVisualData{
		data:      data,
		mimeType:  mimeType,
		expiresAt: time.Now().Add(ttl),
	}
}

func (g *GeminiService) getCachedTranslation(key string) (string, bool) {
	g.cacheMu.Lock()
	defer g.cacheMu.Unlock()

	entry, ok := g.translationCache[key]
	if !ok {
		return "", false
	}
	if time.Now().After(entry.expiresAt) {
		delete(g.translationCache, key)
		return "", false
	}
	return entry.value, true
}

func (g *GeminiService) setCachedTranslation(key, value string, ttl time.Duration) {
	g.cacheMu.Lock()
	defer g.cacheMu.Unlock()

	g.translationCache[key] = cachedStringValue{
		value:     value,
		expiresAt: time.Now().Add(ttl),
	}
}

func (g *GeminiService) getCachedExpansion(key string) ([]string, bool) {
	g.cacheMu.Lock()
	defer g.cacheMu.Unlock()

	entry, ok := g.expansionCache[key]
	if !ok {
		return nil, false
	}
	if time.Now().After(entry.expiresAt) {
		delete(g.expansionCache, key)
		return nil, false
	}
	cloned := make([]string, len(entry.value))
	copy(cloned, entry.value)
	return cloned, true
}

func (g *GeminiService) setCachedExpansion(key string, value []string, ttl time.Duration) {
	g.cacheMu.Lock()
	defer g.cacheMu.Unlock()

	cloned := make([]string, len(value))
	copy(cloned, value)
	g.expansionCache[key] = cachedExpansionValue{
		value:     cloned,
		expiresAt: time.Now().Add(ttl),
	}
}

func newBrowserStyleImageRequest(imageURL, referer string) (*http.Request, error) {
	req, err := http.NewRequest(http.MethodGet, imageURL, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36")
	req.Header.Set("Accept", "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8")
	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
	if strings.TrimSpace(referer) != "" {
		req.Header.Set("Referer", referer)
	}
	return req, nil
}

func (g *GeminiService) fetchCandidateVisualInlineData(candidate SearchResult) (string, string, error) {
	lastErr := fmt.Errorf("candidate has no thumbnail or preview video")
	if candidate.PreviewVideoURL != "" && (candidate.Source == "Envato" || candidate.Source == "Artgrid") {
		cacheKey := "frame\n" + candidate.PreviewVideoURL
		if data, mimeType, ok := g.getCachedVisual(cacheKey); ok {
			return data, mimeType, nil
		}
		data, mimeType, err := extractFrameFromVideo(candidate.PreviewVideoURL)
		if err == nil {
			g.setCachedVisual(cacheKey, data, mimeType, 10*time.Minute)
			return data, mimeType, nil
		}
		lastErr = err
	}
	if candidate.ThumbnailURL != "" {
		if isLowValueThumbnail(candidate.ThumbnailURL) {
			g.debug("gemini:vision_candidate_rejected_low_value", map[string]any{
				"link":         candidate.Link,
				"source":       candidate.Source,
				"thumbnailUrl": candidate.ThumbnailURL,
			})
			lastErr = fmt.Errorf("candidate thumbnail is low value")
		} else {
			cacheKey := "image\n" + candidate.ThumbnailURL
			if data, mimeType, ok := g.getCachedVisual(cacheKey); ok {
				return data, mimeType, nil
			}
			data, mimeType, err := fetchImageAsInlineData(g.Client, candidate.ThumbnailURL, candidate.Link)
			if err == nil {
				g.setCachedVisual(cacheKey, data, mimeType, 10*time.Minute)
				return data, mimeType, nil
			}
			lastErr = err
		}
	}
	if fallbackThumbnail := deriveThumbnail(candidate.Link); fallbackThumbnail != "" && fallbackThumbnail != candidate.ThumbnailURL {
		cacheKey := "image\n" + fallbackThumbnail
		if data, mimeType, ok := g.getCachedVisual(cacheKey); ok {
			return data, mimeType, nil
		}
		data, mimeType, err := fetchImageAsInlineData(g.Client, fallbackThumbnail, candidate.Link)
		if err == nil {
			g.setCachedVisual(cacheKey, data, mimeType, 10*time.Minute)
			return data, mimeType, nil
		}
		lastErr = err
	}
	if candidate.PreviewVideoURL != "" {
		cacheKey := "frame\n" + candidate.PreviewVideoURL
		if data, mimeType, ok := g.getCachedVisual(cacheKey); ok {
			return data, mimeType, nil
		}
		data, mimeType, err := extractFrameFromVideo(candidate.PreviewVideoURL)
		if err != nil {
			lastErr = err
		} else {
			g.setCachedVisual(cacheKey, data, mimeType, 10*time.Minute)
			return data, mimeType, nil
		}
	}
	return "", "", lastErr
}

func extractFrameFromVideo(videoURL string) (string, string, error) {
	tempDir, err := os.MkdirTemp("", "gemini-frame-*")
	if err != nil {
		return "", "", err
	}
	defer os.RemoveAll(tempDir)

	framePath := filepath.Join(tempDir, "frame.jpg")
	cmd := exec.Command("ffmpeg", "-y", "-ss", "00:00:00.500", "-i", videoURL, "-frames:v", "1", "-q:v", "2", framePath)
	output, err := cmd.CombinedOutput()
	if err != nil {
		return "", "", fmt.Errorf("ffmpeg frame extraction failed: %s", strings.TrimSpace(string(output)))
	}

	data, err := os.ReadFile(framePath)
	if err != nil {
		return "", "", err
	}
	return base64.StdEncoding.EncodeToString(data), "image/jpeg", nil
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func extractJSONObject(text string) (string, error) {
	cleaned := strings.TrimSpace(text)
	cleaned = strings.TrimPrefix(cleaned, "```json")
	cleaned = strings.TrimPrefix(cleaned, "```")
	cleaned = strings.TrimSuffix(cleaned, "```")
	cleaned = strings.TrimSpace(cleaned)

	start := strings.Index(cleaned, "{")
	if start == -1 {
		return "", fmt.Errorf("no JSON object start found in %q", truncateForError(cleaned, 200))
	}

	depth := 0
	inString := false
	escaped := false
	for i := start; i < len(cleaned); i++ {
		ch := cleaned[i]
		if escaped {
			escaped = false
			continue
		}
		if ch == '\\' && inString {
			escaped = true
			continue
		}
		if ch == '"' {
			inString = !inString
			continue
		}
		if inString {
			continue
		}
		switch ch {
		case '{':
			depth++
		case '}':
			depth--
			if depth == 0 {
				return cleaned[start : i+1], nil
			}
		}
	}
	return "", fmt.Errorf("no complete JSON object found in %q", truncateForError(cleaned, 200))
}

func truncateForError(text string, limit int) string {
	trimmed := strings.TrimSpace(text)
	if len(trimmed) <= limit {
		return trimmed
	}
	return trimmed[:limit] + "..."
}

func normalizeKoreanReason(reason string) string {
	trimmed := strings.TrimSpace(reason)
	if trimmed == "" {
		return "시각 정보가 제한적이지만 검색 의도와의 관련성을 기준으로 평가했습니다."
	}
	return trimmed
}

func normalizeAssessment(assessment string, recommended bool) string {
	switch strings.ToLower(strings.TrimSpace(assessment)) {
	case "positive", "unclear", "irrelevant", "inappropriate":
		return strings.ToLower(strings.TrimSpace(assessment))
	}
	if recommended {
		return "positive"
	}
	return "unclear"
}

func normalizeSearchHint(text string) string {
	trimmed := strings.Join(strings.Fields(strings.TrimSpace(strings.Trim(text, "\"'`"))), " ")
	if trimmed == "" {
		return ""
	}
	if len(trimmed) > 80 {
		return trimmed[:80]
	}
	return trimmed
}

func parseSupplementalQueryLines(text string) []string {
	lines := strings.Split(text, "\n")
	seen := map[string]bool{}
	queries := make([]string, 0, 5)
	for _, line := range lines {
		trimmed := strings.TrimSpace(strings.Trim(line, "\"'`-0123456789. "))
		if trimmed == "" {
			continue
		}
		key := strings.ToLower(trimmed)
		if seen[key] {
			continue
		}
		seen[key] = true
		queries = append(queries, trimmed)
		if len(queries) >= 5 {
			break
		}
	}
	return queries
}

func buildSearchQueries(originalQuery, englishQuery string) []string {
	base := strings.TrimSpace(englishQuery)
	if base == "" {
		base = strings.TrimSpace(originalQuery)
	}
	candidates := []string{
		base,
		strings.ReplaceAll(base, "pov", "point of view"),
		base + " stock footage",
		base + " b-roll",
		base + " cinematic footage",
		base + " editorial footage",
		base + " establishing shot",
	}
	seen := map[string]bool{}
	queries := make([]string, 0, len(candidates))
	for _, item := range candidates {
		trimmed := strings.TrimSpace(strings.Join(strings.Fields(item), " "))
		if trimmed == "" {
			continue
		}
		key := strings.ToLower(trimmed)
		if seen[key] {
			continue
		}
		seen[key] = true
		queries = append(queries, trimmed)
	}
	return queries
}

func sanitizePlainEnglishLine(text string) string {
	lines := strings.Split(text, "\n")
	for _, line := range lines {
		line = strings.TrimSpace(strings.Trim(line, "\"'`"))
		if line == "" {
			continue
		}
		lower := strings.ToLower(line)
		for _, prefix := range []string{"translation:", "english:", "translated query:"} {
			if strings.HasPrefix(lower, prefix) {
				line = strings.TrimSpace(line[len(prefix):])
				lower = strings.ToLower(line)
			}
		}
		if strings.HasPrefix(lower, "here is") || strings.HasPrefix(lower, "the translation") {
			continue
		}
		if line != "" {
			return line
		}
	}
	return ""
}

func looksMostlyASCII(text string) bool {
	ascii := 0
	runes := []rune(text)
	for _, r := range runes {
		if r <= 127 {
			ascii++
		}
	}
	return ascii >= len(runes)*8/10
}

func isLikelyEnglishQuery(text string) bool {
	alpha := 0
	nonASCII := 0
	for _, r := range text {
		switch {
		case r >= 'A' && r <= 'Z', r >= 'a' && r <= 'z':
			alpha++
		case r > 127:
			nonASCII++
		}
	}
	return alpha > 0 && nonASCII == 0
}

func translateKoreanMediaTerms(query string) string {
	replacements := []struct {
		korean  string
		english string
	}{
		{korean: "사이버 펑크 도시", english: "cyberpunk city"},
		{korean: "사이버펑크 도시", english: "cyberpunk city"},
		{korean: "사이버 펑크", english: "cyberpunk"},
		{korean: "사이버펑크", english: "cyberpunk"},
		{korean: "네온 도시", english: "neon city"},
		{korean: "미래 도시", english: "futuristic city"},
		{korean: "숲속", english: "forest"},
		{korean: "다정한", english: "affectionate"},
		{korean: "항공샷", english: "aerial shot"},
		{korean: "사람들", english: "people"},
		{korean: "행복한", english: "happy"},
		{korean: "커플", english: "couple"},
		{korean: "연인", english: "lovers"},
		{korean: "도시", english: "city"},
		{korean: "야경", english: "night city"},
		{korean: "거리", english: "street"},
		{korean: "골목", english: "alley"},
		{korean: "바다", english: "ocean"},
		{korean: "해변", english: "beach"},
		{korean: "노을", english: "sunset"},
		{korean: "자연", english: "nature"},
		{korean: "드론", english: "drone"},
		{korean: "인파", english: "crowd"},
		{korean: "공원", english: "park"},
		{korean: "숲", english: "forest"},
		{korean: "비", english: "rain"},
		{korean: "눈", english: "snow"},
		{korean: "산", english: "mountain"},
	}
	sort.SliceStable(replacements, func(i, j int) bool {
		return len([]rune(replacements[i].korean)) > len([]rune(replacements[j].korean))
	})

	translated := strings.TrimSpace(query)
	for _, replacement := range replacements {
		translated = strings.ReplaceAll(translated, replacement.korean, replacement.english)
	}
	translated = strings.Join(strings.Fields(translated), " ")
	return strings.TrimSpace(translated)
}

func normalizeKnownMediaPhrases(query string) string {
	normalized := strings.TrimSpace(query)
	replacements := []struct {
		from string
		to   string
	}{
		{from: "사이버 펑크 도시", to: "cyberpunk city"},
		{from: "사이버펑크 도시", to: "cyberpunk city"},
		{from: "사이버 펑크", to: "cyberpunk"},
		{from: "사이버펑크", to: "cyberpunk"},
	}
	for _, replacement := range replacements {
		normalized = strings.ReplaceAll(normalized, replacement.from, replacement.to)
	}
	return strings.Join(strings.Fields(normalized), " ")
}

func isOvercompressedTranslation(original, translated string) bool {
	originalWords := len(strings.Fields(strings.TrimSpace(original)))
	translatedWords := len(strings.Fields(strings.TrimSpace(translated)))
	if originalWords < 2 || translatedWords >= 2 {
		return false
	}
	lower := strings.ToLower(strings.TrimSpace(translated))
	for _, allow := range []string{"cyberpunk", "nightlife", "cityscape"} {
		if lower == allow {
			return false
		}
	}
	return true
}

func (g *GeminiService) translateViaGoogle(query string) (string, error) {
	return g.translateViaGoogleToTarget(query, "en")
}

func (g *GeminiService) translateViaGoogleToTarget(query, targetLanguage string) (string, error) {
	baseURL := g.TranslateEndpoint
	if strings.TrimSpace(baseURL) == "" {
		baseURL = "https://translate.googleapis.com/translate_a/single"
	}
	targetLanguage = strings.TrimSpace(targetLanguage)
	if targetLanguage == "" {
		targetLanguage = "en"
	}
	endpoint := baseURL + "?client=gtx&sl=auto&tl=" + neturl.QueryEscape(targetLanguage) + "&dt=t&q=" + neturl.QueryEscape(query)
	resp, err := g.Client.Get(endpoint)
	if err != nil {
		return "", err
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 300 {
		return "", fmt.Errorf("google translate fallback returned status %d", resp.StatusCode)
	}

	var payload []any
	if err := json.NewDecoder(resp.Body).Decode(&payload); err != nil {
		return "", err
	}
	if len(payload) == 0 {
		return "", fmt.Errorf("google translate fallback returned no payload")
	}
	top, ok := payload[0].([]any)
	if !ok {
		return "", fmt.Errorf("google translate fallback returned unexpected payload")
	}

	var builder strings.Builder
	for _, part := range top {
		segment, ok := part.([]any)
		if !ok || len(segment) == 0 {
			continue
		}
		if text, ok := segment[0].(string); ok {
			builder.WriteString(text)
		}
	}
	translated := strings.TrimSpace(builder.String())
	if translated == "" {
		return "", fmt.Errorf("google translate fallback returned empty translation")
	}
	return translated, nil
}