MeBox/internal/handler/metadata_enrich.go

package handler

import (
	"context"
	"net/url"
	"path"
	"regexp"
	"strconv"
	"strings"
	"sync"
	"time"

	"go.uber.org/zap"

	"github.com/ShukeBta/MediaStationGo/internal/model"
	"github.com/ShukeBta/MediaStationGo/internal/service"
)

var metadataNoiseRE = regexp.MustCompile(`(?i)(自动订阅|订阅|全集|合集|complete|batch|season\s*\d+|s\d{1,2}|s\d{1,2}e\d{1,3}|第\s*\d+\s*季|第\s*\d+\s*[集话話期]|2160p|1080p|720p|4k|uhd|bluray|blu-ray|web-?dl|hdtv|remux|x26[45]|h\.?26[45]|hevc|avc|hdr10?\+?|dovi|dv|atmos|aac|ddp?5\.1|truehd|flac)`)
var metadataYearRE = regexp.MustCompile(`(?:19|20)\d{2}`)

var displayMetadataCache sync.Map

type cachedDisplayMetadata struct {
	value     displayMetadata
	expiresAt time.Time
}

func enrichSubscriptionArtwork(ctx context.Context, svc *service.Container, sub *model.Subscription) {
	if svc == nil || sub == nil {
		return
	}
	// 已有图片且媒体展示字段也齐全时才跳过;否则仍需查一次补 年份/评分/类型 等
	// 富通知字段(老订阅只存了 poster/overview 的情况)。
	if strings.TrimSpace(sub.PosterURL) != "" && strings.TrimSpace(sub.BackdropURL) != "" &&
		sub.Year > 0 && sub.Rating > 0 && strings.TrimSpace(sub.Genres) != "" {
		return
	}
	meta := lookupDisplayMetadata(ctx, svc, sub.Name, sub.Filter, sub.MediaType)
	if meta.Title == "" && meta.PosterURL == "" && meta.BackdropURL == "" && meta.Overview == "" {
		return
	}
	if strings.TrimSpace(sub.Source) == "" {
		sub.Source = meta.Source
	}
	if strings.TrimSpace(sub.PosterURL) == "" {
		sub.PosterURL = meta.PosterURL
	}
	if strings.TrimSpace(sub.BackdropURL) == "" {
		sub.BackdropURL = meta.BackdropURL
	}
	if strings.TrimSpace(sub.Overview) == "" {
		sub.Overview = meta.Overview
	}
	if strings.TrimSpace(sub.OriginalName) == "" {
		sub.OriginalName = meta.OriginalName
	}
	if strings.TrimSpace(sub.OriginalLanguage) == "" {
		sub.OriginalLanguage = meta.OriginalLanguage
	}
	if sub.Year <= 0 && meta.Year > 0 {
		sub.Year = meta.Year
	}
	if sub.Rating <= 0 && meta.Rating > 0 {
		sub.Rating = meta.Rating
	}
	if strings.TrimSpace(sub.Genres) == "" {
		sub.Genres = meta.Genres
	}
}

func enrichAndPersistSubscriptions(ctx context.Context, svc *service.Container, items []model.Subscription) {
	for i := range items {
		before := items[i]
		enrichSubscriptionArtwork(ctx, svc, &items[i])
		if before.Source == items[i].Source &&
			before.PosterURL == items[i].PosterURL &&
			before.BackdropURL == items[i].BackdropURL &&
			before.Overview == items[i].Overview &&
			before.OriginalName == items[i].OriginalName &&
			before.OriginalLanguage == items[i].OriginalLanguage &&
			before.Year == items[i].Year &&
			before.Rating == items[i].Rating &&
			before.Genres == items[i].Genres {
			continue
		}
		updates := map[string]any{}
		if before.Source != items[i].Source {
			updates["source"] = items[i].Source
		}
		if before.PosterURL != items[i].PosterURL {
			updates["poster_url"] = items[i].PosterURL
		}
		if before.BackdropURL != items[i].BackdropURL {
			updates["backdrop_url"] = items[i].BackdropURL
		}
		if before.Overview != items[i].Overview {
			updates["overview"] = items[i].Overview
		}
		if before.OriginalName != items[i].OriginalName {
			updates["original_name"] = items[i].OriginalName
		}
		if before.OriginalLanguage != items[i].OriginalLanguage {
			updates["original_language"] = items[i].OriginalLanguage
		}
		if before.Year != items[i].Year {
			updates["year"] = items[i].Year
		}
		if before.Rating != items[i].Rating {
			updates["rating"] = items[i].Rating
		}
		if before.Genres != items[i].Genres {
			updates["genres"] = items[i].Genres
		}
		if len(updates) == 0 {
			continue
		}
		if err := svc.Repo.DB.WithContext(ctx).Model(&model.Subscription{}).Where("id = ?", items[i].ID).Updates(updates).Error; err != nil {
			svc.Log.Debug("subscription artwork backfill failed", zap.String("id", items[i].ID), zap.Error(err))
		}
	}
}

func enrichAndPersistDownloadRows(ctx context.Context, svc *service.Container, rows []model.DownloadTask) {
	for i := range rows {
		before := rows[i]
		title := strings.TrimSpace(rows[i].Title)
		if title == "" {
			title = downloadDisplayTitle(rows[i].URL)
			rows[i].Title = title
		}
		needsMeta := strings.TrimSpace(rows[i].PosterURL) == "" || strings.TrimSpace(rows[i].BackdropURL) == "" ||
			strings.TrimSpace(rows[i].Overview) == "" || rows[i].Year <= 0 || rows[i].Rating <= 0 ||
			strings.TrimSpace(rows[i].Genres) == "" || strings.TrimSpace(rows[i].OriginalName) == "" ||
			strings.TrimSpace(rows[i].OriginalLanguage) == ""
		if needsMeta {
			meta := enrichDownloadTaskMeta(ctx, svc, service.DownloadTaskMeta{
				Title:            rows[i].Title,
				PosterURL:        rows[i].PosterURL,
				BackdropURL:      rows[i].BackdropURL,
				Overview:         rows[i].Overview,
				OriginalName:     rows[i].OriginalName,
				OriginalLanguage: rows[i].OriginalLanguage,
				Year:             rows[i].Year,
				Rating:           rows[i].Rating,
				Genres:           rows[i].Genres,
			}, firstNonEmptyString(rows[i].Title, rows[i].URL), rows[i].MediaType)
			rows[i].Title = firstNonEmptyString(rows[i].Title, meta.Title)
			rows[i].PosterURL = meta.PosterURL
			rows[i].BackdropURL = meta.BackdropURL
			rows[i].Overview = meta.Overview
			rows[i].OriginalName = meta.OriginalName
			rows[i].OriginalLanguage = meta.OriginalLanguage
			rows[i].Year = meta.Year
			rows[i].Rating = meta.Rating
			rows[i].Genres = meta.Genres
		}
		if before.Title == rows[i].Title &&
			before.PosterURL == rows[i].PosterURL &&
			before.BackdropURL == rows[i].BackdropURL &&
			before.Overview == rows[i].Overview &&
			before.OriginalName == rows[i].OriginalName &&
			before.OriginalLanguage == rows[i].OriginalLanguage &&
			before.Year == rows[i].Year &&
			before.Rating == rows[i].Rating &&
			before.Genres == rows[i].Genres {
			continue
		}
		updates := map[string]any{}
		if before.Title != rows[i].Title {
			updates["title"] = rows[i].Title
		}
		if before.PosterURL != rows[i].PosterURL {
			updates["poster_url"] = rows[i].PosterURL
		}
		if before.BackdropURL != rows[i].BackdropURL {
			updates["backdrop_url"] = rows[i].BackdropURL
		}
		if before.Overview != rows[i].Overview {
			updates["overview"] = rows[i].Overview
		}
		if before.OriginalName != rows[i].OriginalName {
			updates["original_name"] = rows[i].OriginalName
		}
		if before.OriginalLanguage != rows[i].OriginalLanguage {
			updates["original_language"] = rows[i].OriginalLanguage
		}
		if before.Year != rows[i].Year {
			updates["year"] = rows[i].Year
		}
		if before.Rating != rows[i].Rating {
			updates["rating"] = rows[i].Rating
		}
		if before.Genres != rows[i].Genres {
			updates["genres"] = rows[i].Genres
		}
		if len(updates) == 0 {
			continue
		}
		if err := svc.Repo.DB.WithContext(ctx).Model(&model.DownloadTask{}).Where("id = ?", rows[i].ID).Updates(updates).Error; err != nil {
			svc.Log.Debug("download artwork backfill failed", zap.String("id", rows[i].ID), zap.Error(err))
		}
	}
}

func enrichDownloadTorrentViews(ctx context.Context, svc *service.Container, views []service.DownloadTorrentView) {
	cache := map[string]displayMetadata{}
	for i := range views {
		if strings.TrimSpace(views[i].PosterURL) != "" && strings.TrimSpace(views[i].BackdropURL) != "" {
			continue
		}
		query := firstNonEmptyString(views[i].Title, views[i].Name)
		cacheKey, _ := metadataSearchQuery(query)
		meta, ok := cache[cacheKey]
		if !ok {
			meta = lookupDisplayMetadata(ctx, svc, query, "", "")
			cache[cacheKey] = meta
		}
		if strings.TrimSpace(views[i].PosterURL) == "" {
			views[i].PosterURL = meta.PosterURL
		}
		if strings.TrimSpace(views[i].BackdropURL) == "" {
			views[i].BackdropURL = meta.BackdropURL
		}
		if strings.TrimSpace(views[i].Overview) == "" {
			views[i].Overview = meta.Overview
		}
		if (views[i].Title == "" || views[i].Title == views[i].Name) && meta.Title != "" {
			views[i].Title = meta.Title
		}
	}
}

func enrichDownloadTaskMeta(ctx context.Context, svc *service.Container, meta service.DownloadTaskMeta, fallbackTitle, mediaType string) service.DownloadTaskMeta {
	if strings.TrimSpace(meta.Title) == "" {
		meta.Title = strings.TrimSpace(downloadDisplayTitle(fallbackTitle))
	}
	// 仅当展示字段都齐时才跳过查询(含媒体富通知所需的年份/评分/类型/原始信息)。
	if strings.TrimSpace(meta.PosterURL) != "" && strings.TrimSpace(meta.BackdropURL) != "" &&
		strings.TrimSpace(meta.Overview) != "" && meta.Year > 0 && meta.Rating > 0 &&
		strings.TrimSpace(meta.Genres) != "" && strings.TrimSpace(meta.OriginalName) != "" &&
		strings.TrimSpace(meta.OriginalLanguage) != "" {
		return meta
	}
	found := lookupDisplayMetadata(ctx, svc, meta.Title, fallbackTitle, mediaType)
	if strings.TrimSpace(meta.Title) == "" {
		meta.Title = found.Title
	}
	if strings.TrimSpace(meta.PosterURL) == "" {
		meta.PosterURL = found.PosterURL
	}
	if strings.TrimSpace(meta.BackdropURL) == "" {
		meta.BackdropURL = found.BackdropURL
	}
	if strings.TrimSpace(meta.Overview) == "" {
		meta.Overview = found.Overview
	}
	if strings.TrimSpace(meta.OriginalName) == "" {
		meta.OriginalName = found.OriginalName
	}
	if strings.TrimSpace(meta.OriginalLanguage) == "" {
		meta.OriginalLanguage = found.OriginalLanguage
	}
	if meta.Year <= 0 && found.Year > 0 {
		meta.Year = found.Year
	}
	if meta.Rating <= 0 && found.Rating > 0 {
		meta.Rating = found.Rating
	}
	if strings.TrimSpace(meta.Genres) == "" {
		meta.Genres = found.Genres
	}
	return meta
}

func downloadDisplayTitle(raw string) string {
	raw = strings.TrimSpace(raw)
	if raw == "" {
		return ""
	}
	if u, err := url.Parse(raw); err == nil {
		if dn := strings.TrimSpace(u.Query().Get("dn")); dn != "" {
			if decoded, err := url.QueryUnescape(dn); err == nil && strings.TrimSpace(decoded) != "" {
				return strings.TrimSpace(decoded)
			}
			return dn
		}
		if u.Host != "" {
			base := path.Base(u.Path)
			if base != "." && base != "/" && base != "" {
				base = strings.TrimSuffix(base, path.Ext(base))
				return strings.TrimSpace(base)
			}
		}
	}
	return raw
}

type displayMetadata struct {
	Source           string
	Title            string
	OriginalName     string
	OriginalLanguage string
	PosterURL        string
	BackdropURL      string
	Overview         string
	Year             int
	Rating           float32
	Genres           string
}

func lookupDisplayMetadata(ctx context.Context, svc *service.Container, title, fallback, mediaType string) displayMetadata {
	if svc == nil {
		return displayMetadata{}
	}
	query, year := metadataSearchQuery(title, fallback)
	if query == "" {
		return displayMetadata{}
	}
	searchType := normalizeMetadataMediaType(mediaType)
	cacheKey := searchType + ":" + strconv.Itoa(year) + ":" + strings.ToLower(query)
	if cached, ok := displayMetadataCache.Load(cacheKey); ok {
		entry := cached.(cachedDisplayMetadata)
		if time.Now().Before(entry.expiresAt) {
			return entry.value
		}
		displayMetadataCache.Delete(cacheKey)
	}
	searchCtx, cancel := context.WithTimeout(ctx, 12*time.Second)
	defer cancel()
	results := service.SearchExternalMedia(searchCtx, query, year, searchType, svc.TMDb, svc.Douban, svc.Bangumi)
	if len(results) == 0 {
		displayMetadataCache.Store(cacheKey, cachedDisplayMetadata{expiresAt: time.Now().Add(30 * time.Minute)})
		return displayMetadata{}
	}
	best := results[0]
	for _, item := range results {
		if searchType != "" && item.MediaType != "" && item.MediaType != searchType && !(searchType == "tv" && item.MediaType == "anime") {
			continue
		}
		if strings.TrimSpace(item.PosterURL) != "" {
			best = item
			break
		}
	}
	originalLanguage := ""
	if len(best.Languages) > 0 {
		originalLanguage = strings.TrimSpace(best.Languages[0])
	}
	meta := displayMetadata{
		Source:           best.Source,
		Title:            best.Title,
		OriginalName:     best.OriginalName,
		OriginalLanguage: originalLanguage,
		PosterURL:        best.PosterURL,
		BackdropURL:      best.BackdropURL,
		Overview:         best.Overview,
		Year:             best.Year,
		Rating:           best.Rating,
		Genres:           strings.Join(best.Genres, ","),
	}
	displayMetadataCache.Store(cacheKey, cachedDisplayMetadata{value: meta, expiresAt: time.Now().Add(12 * time.Hour)})
	return meta
}

func metadataSearchQuery(values ...string) (string, int) {
	for _, value := range values {
		query := strings.TrimSpace(value)
		if query == "" || strings.Contains(query, "://") {
			continue
		}
		year := 0
		if yearLoc := metadataYearRE.FindStringIndex(query); len(yearLoc) == 2 {
			yearText := query[yearLoc[0]:yearLoc[1]]
			year, _ = strconv.Atoi(yearText)
			query = query[:yearLoc[1]]
		}
		query = stripBracketNoise(query)
		query = metadataNoiseRE.ReplaceAllString(query, " ")
		query = strings.NewReplacer("_", " ", ".", " ", "-", " ", "|", " ", "/", " ").Replace(query)
		query = strings.Join(strings.Fields(query), " ")
		query = strings.TrimSpace(query)
		if query != "" {
			return query, year
		}
	}
	return "", 0
}

func stripBracketNoise(value string) string {
	replacer := strings.NewReplacer("[", " ", "]", " ", "【", " ", "】", " ", "(", " ", ")", " ")
	return replacer.Replace(value)
}

func normalizeMetadataMediaType(mediaType string) string {
	switch strings.ToLower(strings.TrimSpace(mediaType)) {
	case "movie":
		return "movie"
	case "anime":
		return "anime"
	case "tv", "series", "show", "variety", "综艺":
		return "tv"
	default:
		return ""
	}
}

func firstNonEmptyString(values ...string) string {
	for _, value := range values {
		if strings.TrimSpace(value) != "" {
			return strings.TrimSpace(value)
		}
	}
	return ""
}