package app

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"regexp"
	"strconv"
	"strings"
	"time"
)

var sortMetadataMetric = regexp.MustCompile(`(?i)^\d+(?:\.\d+)?(?:亿|万|千|w|k|m|b)?\+?(?:次播放|次观看|人看过|热度|播放|观看|次)?\+?$`)

func hasSortMetric(value string) bool {
	return sortMetadataMetric.MatchString(strings.NewReplacer(",", "", "，", "", " ", "", "\t", "").Replace(value))
}

func hasCompleteSortMetadata(drama Drama) bool {
	if providerReleaseDate(drama.OnlineDate) == "" || !hasSortMetric(drama.Views) {
		return false
	}
	switch dramaProvider(drama) {
	case sourceHongguo, sourceHuangdou:
		return hasSortMetric(drama.Heat)
	case sourceHuangguoAI, sourceHuangguoVideo:

		return true
	}
	return false
}

func providerReleaseDate(value string) string {
	value = strings.TrimSpace(value)
	if stamp, err := time.Parse(time.RFC3339Nano, value); err == nil {
		value = stamp.In(providerChinaTime).Format("2006-01-02")
	}
	date := normalizeDate(value)
	if parsed, err := time.Parse("2006-01-02", date); err != nil || parsed.Year() < 2000 || parsed.Year() > 2100 {
		return ""
	}
	return date
}

func providerTimestampDate(value string) string {
	stamp, err := strconv.ParseInt(strings.TrimSpace(value), 10, 64)
	if err != nil || stamp <= 0 {
		return ""
	}
	if stamp > 100_000_000_000 {
		stamp /= 1000
	}
	date := time.Unix(stamp, 0).In(providerChinaTime)
	if date.Year() < 2000 || date.Year() > 2100 {
		return ""
	}
	return date.Format("2006-01-02")
}

func (d *Downloader) fetchDramaSortMetadata(ctx context.Context, drama Drama) (Drama, error) {
	source, id, ok := splitProviderDramaID(drama.ID)
	patch := Drama{ID: drama.ID, Source: source, SourceID: id}
	if !ok {
		return patch, errors.New("无效的剧集 ID")
	}
	needCover := needsHongguoCoverAddress(drama)
	if hasCompleteSortMetadata(drama) && !huangguoNeedsContentMetadata(drama) && !needCover && !needsHuangdouVIPMetadata(drama) {
		return patch, nil
	}
	switch source {
	case sourceHongguo:
		if !hongguoNumericID.MatchString(id) {
			return patch, errors.New("无效的红果剧集 ID")
		}
		var failures []error
		if providerReleaseDate(drama.OnlineDate) == "" {
			body, err := d.fetchProviderText(ctx, hongguoBaseURL+"/detail?series_id="+url.QueryEscape(id), hongguoBaseURL+"/")
			if err == nil {
				var web Drama
				web, err = parseHongguoSortDetail(body, id)
				patch = mergeDramaMetadata(web, patch)
			}
			if err != nil {
				failures = append(failures, err)
			}
		}
		needMetrics := !hasSortMetric(drama.Heat) || !hasSortMetric(drama.Views)
		if !needMetrics && (!needCover || bestDramaCover(patch) != "") {
			return patch, errors.Join(failures...)
		}
		result, appErr := d.hongguoAppRequest(ctx, http.MethodPost, "/novel/player/video_detail/v1/", nil, map[string]any{"series_id": id})
		if appErr == nil {
			row := nestedMap(result, "data", "video_data")
			if mapString(row, "series_id_str", "series_id") != id {
				appErr = errors.New("红果详情返回了其他剧集")
			} else {
				patch.Title = mapString(row, "series_title", "series_name")
				if needMetrics {
					patch.Heat = hongguoHeat(row)
					patch.Views = normalizeViews(mapString(row, "series_play_cnt", "play_cnt"))
				}
				if needCover {
					if cover := hongguoCoverAddress(mapString(row, "series_cover", "cover")); cover != "" {
						patch.Cover, patch.CoverURL = cover, cover
					}
				}
			}
		}
		if appErr != nil {
			failures = append(failures, appErr)
		}
		return patch, errors.Join(failures...)
	case sourceHuangdou:
		if !rankingSourceID.MatchString(id) {
			return patch, errors.New("无效的黄豆剧集 ID")
		}
		row, err := d.huangdouDetail(ctx, id)
		if err != nil {
			return patch, err
		}
		patch.VIP = huangdouVIPFlag(row)
		patch.Title = mapString(row, "name", "title")
		patch.OnlineDate = providerReleaseDate(mapString(row, "issue_date"))
		patch.Views = normalizeViews(mapString(row, "click"))
		patch.Heat = mapString(row, "hot_rate")
		if !hasSortMetric(patch.Heat) && !hasSortMetric(drama.Heat) {

			keyword := firstNonEmpty(patch.Title, drama.DisplayTitle())
			var decoded any
			if err := newHuangdouAPIClient(d).call(ctx, "/drama/list", map[string]any{"keywords": keyword, "page": "1", "page_size": "50"}, &decoded); err != nil {
				return patch, err
			}
			matched := false
			for _, item := range huangdouList(decoded) {
				if strings.TrimPrefix(mapString(item, "id", "drama_id"), "rp_") == id {
					matched = true
					patch.Heat = mapString(item, "hot_rate")
					break
				}
			}
			if !matched {
				return patch, errors.New("黄豆热度查询未返回所请求剧集，可稍后重试")
			}
		}
		return patch, nil
	case sourceHuangguoAI, sourceHuangguoVideo:
		pageURL, err := huangguoSortDetailURL(source, id)
		if err != nil {
			return patch, err
		}
		body, err := d.fetchProviderText(ctx, pageURL, providerRefererForURL(pageURL, ""))
		if err != nil {
			return patch, err
		}
		return parseHuangguoSortDetail(body, pageURL, patch)
	}
	return patch, errors.New("该站源暂无资料补齐接口")
}

func huangguoSortDetailURL(source, id string) (string, error) {
	if source == sourceHuangguoVideo {
		parts := strings.Split(id, "/")
		if len(parts) == 1 {
			parts = []string{"series", id}
		}
		if len(parts) != 2 || (parts[0] != "series" && parts[0] != "video") || !rankingSourceID.MatchString(parts[1]) {
			return "", errors.New("无效的黄果剧集 ID")
		}
		return huangguoVideoBaseURL + "/" + parts[0] + "/" + url.PathEscape(parts[1]), nil
	}
	if source != sourceHuangguoAI || !rankingSourceID.MatchString(id) {
		return "", errors.New("无效的黄果剧集 ID")
	}
	return huangguoAIBaseURL + "/detail/" + url.PathEscape(id) + "/", nil
}

func parseHongguoSortDetail(body, id string) (Drama, error) {
	row := nestedMap(routerLoaderMap(parseRouterData(body), "detail_page", "detail_"), "seriesDetail")
	if mapString(row, "series_id", "series_id_str") != id || mapString(row, "series_name", "series_title") == "" {
		return Drama{}, errors.New("红果网页详情与请求剧集不符")
	}
	patch := hongguoDramaFromAny(row, "")
	patch.Title = mapString(row, "series_name", "series_title")
	patch.Name = patch.Title
	patch.OnlineDate = providerTimestampDate(mapString(row, "first_visible_time"))
	if cover := hongguoCoverAddress(mapString(row, "series_cover", "cover")); cover != "" {
		patch.Cover, patch.CoverURL = cover, cover
	}
	return patch, nil
}

func parseHuangguoSortDetail(body, pageURL string, patch Drama) (Drama, error) {
	type entry struct {
		Type      string `json:"@type"`
		ID        string `json:"@id"`
		URL       string `json:"url"`
		Name      string `json:"name"`
		Published string `json:"datePublished"`
		Uploaded  string `json:"uploadDate"`
		Image     any    `json:"image"`
		Thumbnail any    `json:"thumbnailUrl"`
	}
	expected, _ := url.Parse(pageURL)
	matched := false
	for _, block := range rankingJSONLD.FindAllStringSubmatch(body, -1) {
		var graph struct {
			Graph []entry `json:"@graph"`
			entry
		}
		if json.Unmarshal([]byte(block[1]), &graph) != nil {
			continue
		}
		for _, row := range append(graph.Graph, graph.entry) {
			if row.Type != "WebPage" && row.Type != "VideoObject" && row.Type != "TVSeries" && row.Type != "Movie" {
				continue
			}
			actual, err := url.Parse(firstNonEmpty(row.URL, row.ID))
			if err != nil || actual.Host != "" && !strings.EqualFold(actual.Host, expected.Host) && providerSourceForURL(actual.String()) != patch.Source || strings.TrimRight(actual.Path, "/") != strings.TrimRight(expected.Path, "/") || row.Name == "" || patch.Source == sourceHuangguoAI && huangguoTitleNeedsRepair(row.Name, patch.SourceID) {
				continue
			}
			matched = true
			patch.Title = row.Name
			if address := firstNonEmpty(providerCoverAddress(row.Image, pageURL), providerCoverAddress(row.Thumbnail, pageURL)); address != "" {
				patch.Cover, patch.CoverURL = address, address
			}
			if date := providerReleaseDate(firstNonEmpty(row.Uploaded, row.Published)); date != "" && (patch.OnlineDate == "" || row.Type == "VideoObject") {
				patch.OnlineDate = date
			}
		}
	}
	if !matched {
		return patch, fmt.Errorf("黄果详情没有返回所请求剧集的元数据")
	}
	if bestDramaCover(patch) == "" {
		for _, tag := range coverMetaTag.FindAllString(body, -1) {
			if strings.ToLower(extractAttr(tag, "property", "name")) == "og:image" {
				if address := providerCoverAddress(extractAttr(tag, "content"), pageURL); address != "" {
					patch.Cover, patch.CoverURL = address, address
					break
				}
			}
		}
	}
	markup := huangguoNonContent.ReplaceAllString(body, "")
	metaBlock := huangguoClassBlock(markup, "hg-web-detail__meta")
	meta := cleanText(metaBlock)
	patch.Views = normalizeViews(firstMatchText(reViewsText, meta))
	if patch.OnlineDate == "" && strings.Contains(meta, "上线") {
		patch.OnlineDate = providerReleaseDate(firstMatchText(reDateText, meta))
	}
	if patch.Source == sourceHuangguoAI {
		episode := firstNonEmpty(extractAttr(metaBlock, "data-ep-base"), meta)
		if count := episodeIndex(episode, 0); count > 0 {
			patch.TotalEpisode, patch.EpisodeCount = count, count
		}
	}
	return patch, nil
}