package mediaser

import (
	"91porn-server/app/appg"
	"91porn-server/app/service/mediatagser"
	"91porn-server/common"
	"91porn-server/common/constant"
	"91porn-server/common/constant/redisconst"
	"91porn-server/common/elastic"
	"91porn-server/common/log"
	"91porn-server/common/timeutil"
	topser "91porn-server/common/top"
	topasist "91porn-server/common/top/asistant"
	"91porn-server/common/top/dailytop"
	"91porn-server/common/top/monthtop"
	"91porn-server/common/top/weektop"
	"91porn-server/models/cache/mediadata"
	"91porn-server/models/cache/mediatagdata"
	"91porn-server/models/commod"
	"91porn-server/models/s/sectionstatmod"
	"91porn-server/models/v/likemod"
	"91porn-server/models/v/media_buy_record_mod"
	"91porn-server/models/v/mediabookshelfmod"
	"91porn-server/models/v/mediamod"
	"91porn-server/models/v/mediatagdimensionmod"
	"91porn-server/models/v/mediatagmod"
	"91porn-server/models/v/modulesectionmod"
	"fmt"
	"github.com/golang-module/carbon/v2"
	"github.com/vmihailenco/msgpack/v5"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/options"
	"strconv"
	"sync"
	"time"
)

type AppQueryListReq struct {
	commod.Page
}

type AppListRes struct {
	HasNext bool                     `json:"hasNext"`
	List    []*mediamod.AppMediaBase `json:"list"`
}

// GetList 获取列表
func (p *AppQueryListReq) GetList() AppListRes {
	var res AppListRes
	var err error
	filter := bson.M{}

	sort := bson.D{{"_id", -1}}
	// 获取列表
	var data []*mediamod.Media
	data, res.HasNext, err = mediadata.GetListFromCache(filter, int64(p.Skip()), int64(p.Limit()), sort)
	if err != nil {
		return res
	}
	// 组装返回数据
	for _, item := range data {
		tmp := &mediamod.AppMediaBase{
			ID:                 item.ID,
			SortCode:           item.SortCode,
			Status:             item.Status,
			Title:              item.Title,
			Author:             item.Anchor,
			HorizontalCover:    item.HorizontalCover,
			VerticalCover:      item.VerticalCover,
			Tags:               item.Tags,
			Summary:            item.Summary,
			TotalEpisode:       item.TotalEpisode,
			MediaType:          item.MediaType,
			MediaSubType:       item.MediaSubType,
			Kind:               item.Kind,
			PermissionIconHide: item.PermissionIconHide,
			Permission:         item.Permission,
			Price:              item.Price,
			Direction:          item.Direction,
			FreeTime:           item.FreeTime,
			CountComment:       item.CountComment,
			CountPurchases:     item.CountPurchases,
			CountBrowse:        item.CountBrowse,
			CountCollect:       item.CountCollect,
			CountLike:          item.CountLike,
			CountView:          item.CountView,
			Number:             item.Number,
			CreatedAt:          item.CreatedAt,
			UpdateTime:         item.UpdateTime,
		}
		res.List = append(res.List, tmp)
	}

	return res
}

type AppQueryInfoReq struct {
	ID string `json:"id" form:"id"` // id
}

// GetInfo 获取详情
func (p *AppQueryInfoReq) GetInfo(uid uint64) (resp *mediamod.AppMediaBase, err error) {
	oid, err := primitive.ObjectIDFromHex(p.ID)
	if err != nil {
		return resp, err
	}

	var item mediamod.Media
	item, err = mediadata.GetInfoFromCache(oid)
	if err != nil {
		log.Error("AppQueryInfoReq.GetInfo mediadata.GetInfoFromCache fail", log.Any("mediaId", p.ID), log.E(err))
		return resp, err
	}
	if item.ID.IsZero() {
		return resp, nil
	}
	if item.MediaType == mediamod.MediaTypeDrama && (item.Status != 1 || item.IsDelete) {
		return nil, fmt.Errorf("drama is inactive")
	}
	res := FillMedias([]*mediamod.Media{&item}, uid, true)
	resp = res[0]
	// 累加浏览数
	common.Go(func() {
		// 增加父级的浏览数量
		IncrCountBrowse(item.ID)
		topasist.Incr(topser.TypeMedia(item.MediaType), item.ID.Hex(), 1)
	})
	return resp, nil
}

// GetUserStatus 获取 用户状态信息 只跟media这张表有关系
func GetUserStatus(uid uint64, mediaIds []primitive.ObjectID) map[primitive.ObjectID]mediamod.MediaStatus {
	mPay := make(map[primitive.ObjectID]bool)
	hasAddBookshelf := make(map[primitive.ObjectID]bool)
	mLike := make(map[primitive.ObjectID]bool)

	var wg sync.WaitGroup
	wg.Add(3)
	common.Go(func() {
		defer wg.Done()
		mPay, _ = media_buy_record_mod.IsWholeBuyBatch(uid, mediaIds)
	})
	common.Go(func() {
		defer wg.Done()
		mLike, _ = likemod.IsLikeByType(uid, []string{constant.LikeTypeText, constant.LikeTypeComics, constant.LikeTypeCartoon, constant.LikeTypeDrama}, mediaIds)
	})
	common.Go(func() {
		defer wg.Done()
		hasAddBookshelf, _ = mediabookshelfmod.HasAddBookshelf(uid, mediaIds)
	})
	wg.Wait()
	m := map[primitive.ObjectID]mediamod.MediaStatus{}
	for _, v := range mediaIds {
		info := mediamod.MediaStatus{
			HasPaid:      mPay[v],
			HasCollected: hasAddBookshelf[v],
			HasLiked:     mLike[v],
		}
		m[v] = info
	}
	return m
}

// GetLibrary 获取片库
func GetLibrary() (res []mediamod.AppLibrary, err error) {
	var resp []mediamod.AppLibrary

	str, err := appg.Redis.Get(redisconst.MediaLibraryInfo)
	if err != nil {
		log.Warn(fmt.Sprintf("缓存获取动漫片库信息异常:%v", err))
	}
	if str != nil {
		if err = msgpack.Unmarshal([]byte(*str), &resp); err == nil {
			return resp, nil
		}
		log.Warn(fmt.Sprintf("解析预售缓存数据异常:%v", err))
	}

	resp = append(resp, mediamod.AppLibrary{
		Key:  Video,
		Name: "动漫",
	}, mediamod.AppLibrary{
		Key:  Image,
		Name: "漫画",
	})
	for i, d := range resp {
		if d.Key == Video {
			resp[i].Kind = append(resp[i].Kind, mediamod.KindInfo{
				Key:   "1",
				Name:  "哩番",
				Cover: "cf230705/image/lm/34n/1la/2ck/7064ad102298311797d9f43b323a2ea4.png",
			}, mediamod.KindInfo{
				Key:   "2",
				Name:  "3D",
				Cover: "cf230705/image/18b/2zw/1dp/2wu/3b90ad609435c0037f7a8a90ed8e2de2.png",
			}, mediamod.KindInfo{
				Key:   "3",
				Name:  "同人动画",
				Cover: "cf230705/image/14q/5y/19x/p9/3c48b94311b361f2dcdb006200208751.png",
			})
		}
		if d.Key == Image {
			resp[i].Kind = append(resp[i].Kind, mediamod.KindInfo{
				Key:   "4",
				Name:  "单行本",
				Cover: "cf230705/image/2a4/1kk/2hi/2xg/b830c4997f21ad4351ab0880fd2bc1be.png",
			}, mediamod.KindInfo{
				Key:   "5",
				Name:  "连载漫画",
				Cover: "cf230705/image/p2/1rq/2c3/nx/ce44dfc5406ef4d20cef04a683970f4c.png",
			}, mediamod.KindInfo{
				Key:   "6",
				Name:  "韩漫",
				Cover: "cf230705/image/1ol/26f/lb/2rq/872dab8f0ccd3c4eba6cba5171630112.png",
			})
		}
	}

	// 获取 动漫、漫画纬度
	filter := bson.M{"status": 1, "isDelete": false}
	op := options.Find().SetSort(bson.D{{"sortCode", -1}})
	tagDimensions, err := mediatagdimensionmod.QueryAllList(filter, op)
	if err != nil {
		return resp, nil
	}

	if len(tagDimensions) > 0 {
		for i, m := range resp {
			for _, d := range tagDimensions {
				if m.Key == "video" && d.Type == 1 {
					for j := range resp[i].Kind {
						resp[i].Kind[j].Dimension = append(resp[i].Kind[j].Dimension, mediamod.DimensionInfo{
							Key:  d.ID.Hex(),
							Name: d.Name,
						})
					}
				}
				if m.Key == "image" && d.Type == 2 {
					for j := range resp[i].Kind {
						resp[i].Kind[j].Dimension = append(resp[i].Kind[j].Dimension, mediamod.DimensionInfo{
							Key:  d.ID.Hex(),
							Name: d.Name,
						})
					}
				}
			}
		}
	}

	// 获取所有推荐标签
	tagFilter := bson.M{"active": true, "isDelete": false, "isDiscovery": true}
	tagOp := options.Find().SetSort(bson.D{{"sort", -1}})
	mediaTags, err := mediatagmod.QueryAllList(tagFilter, tagOp)
	if err != nil {
		return resp, nil
	}

	if len(mediaTags) > 0 {
		for i, m := range resp {
			for _, t := range mediaTags {
				if m.Key == "video" && t.Type == 1 && (t.Kind == 1 || t.Kind == 2 || t.Kind == 3) {
					for j := range resp[i].Kind {
						for d, k := range resp[i].Kind[j].Dimension {
							kindStr := strconv.Itoa(t.Kind)
							if t.Dimension == k.Name && resp[i].Kind[j].Key == kindStr {
								resp[i].Kind[j].Dimension[d].Tag = append(resp[i].Kind[j].Dimension[d].Tag, mediamod.TagInfo{
									ID:   t.ID.Hex(),
									Name: t.Name,
								})
							}
						}
					}
				}
				if m.Key == "image" && t.Type == 2 && (t.Kind == 4 || t.Kind == 5 || t.Kind == 6) {
					for j := range resp[i].Kind {
						for d, k := range resp[i].Kind[j].Dimension {
							kindStr := strconv.Itoa(t.Kind)
							if t.Dimension == k.Name && resp[i].Kind[j].Key == kindStr {
								resp[i].Kind[j].Dimension[d].Tag = append(resp[i].Kind[j].Dimension[d].Tag, mediamod.TagInfo{
									ID:   t.ID.Hex(),
									Name: t.Name,
								})
							}
						}
					}
				}
			}
		}
	}
	common.Go(func() {
		bytes, _ := msgpack.Marshal(resp)
		if err = appg.Redis.Set(redisconst.MediaLibraryInfo, bytes, 11*time.Minute); err != nil {
			log.Warn(fmt.Sprintf("保存预售缓存数据异常:%v", err))
		}
	})
	return resp, nil
}

func LibrarySearch(in mediamod.AppLibraryReq) (data mediamod.AppElasticSearchLibraryResponse, err error) {
	var resp mediamod.AppElasticSearchLibraryResponse
	from := int64((in.PageNumber - 1) * (in.PageSize))
	size := int64(in.PageSize + 1)

	must := elastic.A{
		{"term": elastic.M{"mediaType.keyword": HandleMediaType(in.MediaType)}},
	}

	// 历史同步数据可能为同一个业务标签生成多个 ID。片库按标签名合并这些
	// ID，避免搜索结果返回的某个旧 ID 在标签详情页查不到同名内容。
	tagIds := HandleTagIds(expandMediaTagAliases(in.TagIds))
	must = append(must, tagIds...)

	short := HandleLibraryShort(in)
	// 根据数据结构组装数据
	query := elastic.M{
		"query": elastic.M{
			"bool": elastic.M{
				"must": must,
			},
		},
		"sort": short,
		"from": from,
		"size": size,
	}

	res, err := mediamod.SearchByCondWithTotal(query)
	if err != nil {
		return resp, nil
	}
	hasNext := false
	if uint64(len(res.Hits)) > in.PageSize {
		res.Hits = res.Hits[:in.PageSize]
		hasNext = true
	}
	esMedias := make([]mediamod.ESMedia, len(res.Hits))
	for i := range res.Hits {
		esMedias[i] = res.Hits[i].Source
	}

	videosIDs := make([]primitive.ObjectID, len(esMedias))
	for i, v := range esMedias {
		videosIDs[i] = v.ID
	}
	if len(videosIDs) > int(size) {
		hasNext = true
		videosIDs = videosIDs[:size]
	}
	log.Info(fmt.Sprintf("search media mIds:%v", videosIDs))

	mediaList, _, err := mediadata.GetListFromCache(in.Filter(videosIDs), 0, int64(in.Limit()), in.Options())
	if err != nil {
		return resp, err
	}
	mediaList = orderMediaByIDs(mediaList, videosIDs)
	resp.HasNext = hasNext

	if len(mediaList) <= 0 {
		return resp, nil
	}

	tagIDs := make([]primitive.ObjectID, 0)
	for _, item := range mediaList {
		tagIDs = append(tagIDs, item.Tags...)
	}
	tagMap := mediatagser.GetTagsByIDs2Map(tagIDs)

	for _, item := range mediaList {
		tags, tagDetails := buildDedupTagsAndDetails(item.Tags, tagMap)
		data := &mediamod.AppMediaBase{
			ID:                 item.ID,
			SortCode:           item.SortCode,
			Status:             item.Status,
			Title:              item.Title,
			Author:             item.Anchor,
			HorizontalCover:    item.HorizontalCover,
			VerticalCover:      item.VerticalCover,
			Tags:               tags,
			TagDetails:         tagDetails,
			Summary:            item.Summary,
			TotalEpisode:       item.TotalEpisode,
			UpdateStatus:       item.UpdateStatus,
			MediaType:          item.MediaType,
			MediaSubType:       item.MediaSubType,
			Kind:               item.Kind,
			PermissionIconHide: item.PermissionIconHide,
			Permission:         item.Permission,
			Price:              item.Price,
			Direction:          item.Direction,
			FreeTime:           item.FreeTime,
			CountComment:       item.CountComment,
			CountPurchases:     item.CountPurchases,
			CountBrowse:        item.CountBrowse,
			CountCollect:       item.CountCollect,
			CountLike:          item.CountLike,
			CountView:          item.CountView,
			Number:             item.Number,
			CreatedAt:          item.CreatedAt,
			UpdateTime:         item.UpdateTime,
		}
		resp.List = append(resp.List, data)
	}
	resp.HasNext = hasNext
	common.Go(func() {
		if len(videosIDs) > 0 {
			//HandleDiffVideo(vidMods, videosIDs)
		}
	})
	return resp, nil
}

// orderMediaByIDs keeps the final response in the exact order returned by Elasticsearch.
// MongoDB's $in query does not preserve the input ID order, and its copy of a sort field
// can briefly differ from Elasticsearch while indexes are being synchronized.
func orderMediaByIDs(mediaList []*mediamod.Media, ids []primitive.ObjectID) []*mediamod.Media {
	mediaByID := make(map[primitive.ObjectID]*mediamod.Media, len(mediaList))
	for _, item := range mediaList {
		if item != nil {
			mediaByID[item.ID] = item
		}
	}

	ordered := make([]*mediamod.Media, 0, len(mediaList))
	for _, id := range ids {
		if item, ok := mediaByID[id]; ok {
			ordered = append(ordered, item)
		}
	}
	return ordered
}

func HandleShort(key int) elastic.A {
	return elastic.A{{mediamod.AppLibrarySortField(key): elastic.M{"order": "desc"}}}
}

func HandleLibraryShort(in mediamod.AppLibraryReq) elastic.A {
	if HandleMediaType(in.MediaType) == mediamod.MediaTypeDrama && in.SortType == 1 {
		return elastic.A{
			{"sortCode": elastic.M{"order": "desc"}},
			{"createdAt": elastic.M{"order": "desc"}},
		}
	}
	return HandleShort(in.SortType)
}

func HandleTagIds(tagIds []string) elastic.A {
	var tagIdsValue = elastic.A{}
	var allTagIds []primitive.ObjectID
	if len(tagIds) > 0 {
		for t := range tagIds {
			id, err := primitive.ObjectIDFromHex(tagIds[t])
			if err != nil || id.IsZero() {
				continue
			}
			allTagIds = append(allTagIds, id)
		}
	}
	allTagIds = deduplicateObjectIDs(allTagIds)

	tagIdsValue = append(tagIdsValue,
		elastic.M{"terms": elastic.M{"tags.keyword": allTagIds}},
	)

	return tagIdsValue
}

func expandMediaTagAliases(tagIDs []string) []string {
	expanded := make([]primitive.ObjectID, 0, len(tagIDs))
	for _, value := range tagIDs {
		id, err := primitive.ObjectIDFromHex(value)
		if err != nil || id.IsZero() {
			continue
		}
		expanded = append(expanded, id)

		tag, tagErr := mediatagdata.GetInfoFromCache(id)
		if tagErr != nil || tag.Name == "" {
			continue
		}
		aliases, aliasErr := mediatagdata.GetTagIdsByNameFromCache(tag.Name)
		if aliasErr == nil {
			expanded = append(expanded, aliases...)
		}
	}

	expanded = deduplicateObjectIDs(expanded)
	result := make([]string, len(expanded))
	for i, id := range expanded {
		result[i] = id.Hex()
	}
	return result
}

func deduplicateObjectIDs(ids []primitive.ObjectID) []primitive.ObjectID {
	seen := make(map[primitive.ObjectID]struct{}, len(ids))
	result := make([]primitive.ObjectID, 0, len(ids))
	for _, id := range ids {
		if id.IsZero() {
			continue
		}
		if _, ok := seen[id]; ok {
			continue
		}
		seen[id] = struct{}{}
		result = append(result, id)
	}
	return result
}

func Search(uid uint64, in mediamod.AppSearchReq) (resp mediamod.AppElasticSearchResponse, err error) {
	var mediaType constant.AcgNewsType
	switch in.Kind {
	case 1:
		mediaType = mediamod.MediaTypeVideo
	case 2:
		mediaType = mediamod.MediaTypeImage
	case 3:
		mediaType = mediamod.MediaTypeText
	case 4:
		mediaType = mediamod.MediaTypeDrama
	default:
		return resp, nil
	}
	if in.Kind == 4 {
		defer normalizeDramaSearchLists(&resp)
	}

	resp, err = searchByKeyWord(uid, in, mediaType)
	if err != nil {
		return resp, err
	}

	// 本项目使用 关键字 搜索tag名
	in.TagName = in.KeyWord

	var tagIDFilter interface{}
	var responseTagID primitive.ObjectID
	if in.Kind == 4 {
		tagIDs, tagErr := mediatagdata.GetTagIdsByNameFromCache(in.TagName)
		if tagErr != nil {
			log.Error("通过标签搜索短剧错误", log.Any("TagName", in.TagName), log.E(tagErr))
			return resp, tagErr
		}
		if len(tagIDs) == 0 {
			return resp, nil
		}
		tagIDFilter = bson.M{"$in": tagIDs}
		responseTagID = tagIDs[0]
	} else {
		tag, tagErr := mediatagdata.GetTagByNameFromCache(in.TagName)
		if tagErr != nil {
			log.Error("通过标签搜索ACG内容错误", log.Any("TagName", in.TagName), log.E(tagErr))
			return resp, tagErr
		}
		if tag.ID.IsZero() {
			return resp, nil
		}
		tagIDFilter = tag.ID
		responseTagID = tag.ID
	}
	filter := bson.M{
		"mediaType": mediaType,
		"tags":      tagIDFilter,
		"status":    1,
		"isDelete":  false,
	}
	sort := bson.D{{Key: "createdAt", Value: -1}} // 默认最新
	switch in.SortType {
	case 1:
		// 最新
		sort = bson.D{{Key: "createdAt", Value: -1}}
	case 2:
		//最多观看
		sort = bson.D{{Key: "countBrowse", Value: -1}}
	}
	if in.Kind == 4 {
		sort = in.Options()
	}
	mediaList, _, err := mediadata.GetListFromCache(filter, 0, 6, sort)
	if err != nil {
		log.Error("通过标签搜索ACG内容错误", log.Any("filter", filter), log.E(err))
		return
	}
	if in.Kind == 4 {
		resp.TagMediaList = FillMedias(mediaList, uid, true)
	} else {
		resp.TagMediaList = mapLegacySearchMedias(mediaList, true)
	}
	resp.TagID = responseTagID.Hex()

	return resp, nil
}

func normalizeDramaSearchLists(resp *mediamod.AppElasticSearchResponse) {
	if resp.List == nil {
		resp.List = []*mediamod.AppMediaBase{}
	}
	if resp.TagMediaList == nil {
		resp.TagMediaList = []*mediamod.AppMediaBase{}
	}
}

func searchByKeyWord(uid uint64, in mediamod.AppSearchReq, mediaType string) (resp mediamod.AppElasticSearchResponse, err error) {
	esMedias, err := mediamod.DirectSearch(in.KeyWord, mediaType, int64(in.Skip()), int64(in.Limit()+1))
	if err != nil {
		log.Error("搜索ACG内容错误", log.E(err))
		return resp, nil
	}
	esMediasLen := len(esMedias)
	if esMediasLen == 0 {
		return resp, err
	}
	if esMediasLen > int(in.PageSize) {
		resp.HasNext = true
		esMedias = esMedias[:esMediasLen-1]
	}
	var mIds []primitive.ObjectID
	for _, v := range esMedias {
		mIds = append(mIds, v.ID)
	}
	filter := bson.M{"_id": bson.M{"$in": mIds}, "mediaType": mediaType, "status": 1, "isDelete": false}

	sort := in.Options()
	keepSearchOrder := in.Kind == 4 && in.SortType != 2
	if keepSearchOrder {
		sort = bson.D{}
	}
	mediaList, _, err := mediadata.GetListFromCache(filter, 0, int64(in.PageSize), sort)
	if err != nil {
		return resp, err
	}

	if len(mediaList) <= 0 {
		return resp, nil
	}

	if keepSearchOrder {
		// MongoDB 的 $in 不保留 ID 顺序，恢复短剧关键词搜索的相关度顺序。
		mediaList = orderMediaByIDs(mediaList, mIds)
	}
	if in.Kind == 4 {
		resp.List = FillMedias(mediaList, uid, true)
	} else {
		resp.List = mapLegacySearchMedias(mediaList, false)
	}

	return resp, nil
}

func mapLegacySearchMedias(mediaList []*mediamod.Media, tagResult bool) []*mediamod.AppMediaBase {
	result := make([]*mediamod.AppMediaBase, 0, len(mediaList))
	for _, item := range mediaList {
		data := &mediamod.AppMediaBase{
			ID: item.ID, SortCode: item.SortCode, Status: item.Status, Title: item.Title,
			HorizontalCover: item.HorizontalCover, VerticalCover: item.VerticalCover,
			Tags: item.Tags, Summary: item.Summary, TotalEpisode: item.TotalEpisode,
			UpdateStatus: item.UpdateStatus, MediaType: item.MediaType, Kind: item.Kind,
			PermissionIconHide: item.PermissionIconHide, Permission: item.Permission,
			Price: item.Price, Direction: item.Direction, FreeTime: item.FreeTime,
			CountComment: item.CountComment, CountPurchases: item.CountPurchases,
			CountBrowse: item.CountBrowse, CountCollect: item.CountCollect,
			CountLike: item.CountLike, CountView: item.CountView, Number: item.Number,
			CreatedAt: item.CreatedAt, UpdateTime: item.UpdateTime,
		}
		if tagResult {
			data.Author = item.Anchor
			data.MediaSubType = item.MediaSubType
		}
		result = append(result, data)
	}
	return result
}

func HandleMediaType(key string) string {
	var moduleTypeValue string
	switch key {
	case "video":
		moduleTypeValue = mediamod.MediaTypeVideo
	case "image":
		moduleTypeValue = mediamod.MediaTypeImage
	case "text":
		moduleTypeValue = mediamod.MediaTypeText
	case "drama":
		moduleTypeValue = mediamod.MediaTypeDrama
	default:
		moduleTypeValue = mediamod.MediaTypeVideo
	}
	return moduleTypeValue
}

func HandleKindType(key string) int {
	var kindValue int
	switch key {
	case "1":
		kindValue = mediamod.RiFan
	case "2":
		kindValue = mediamod.ThreeD
	case "3":
		kindValue = mediamod.FanAnimation
	case "4":
		kindValue = mediamod.Offprint
	case "5":
		kindValue = mediamod.ComicStrip
	case "6":
		kindValue = mediamod.KoreanCartoon
	default:
		kindValue = mediamod.RiFan
	}
	return kindValue
}

type AppGetTopicReq struct {
	SID      string `json:"sId" form:"sId"`           // 专题ID
	Kind     int    `json:"kind" form:"kind"`         // 种类(1、哩番,2、3D,3、同人动画,4、单行本,5、连载漫画,6、韩漫 7、小说 ）
	SortType int    `form:"sortType" bson:"sortType"` // 排序   1-最新 2-最多观看 3-最多喜欢（收藏）
	Type     int    `json:"type" form:"type"`         // 0-默认专题这些页面获取  1-首页获取(猜你喜欢)
	commod.Page
}

func (p *AppGetTopicReq) Filter() bson.M {
	var query = bson.M{}
	id, _ := primitive.ObjectIDFromHex(p.SID)
	if p.Type != 1 && p.SID != "" {
		query["sId"] = id
	}
	if p.Kind > 0 {
		query["kind"] = p.Kind
	}
	if p.Type == 1 {
		// 获取专题的模块id
		sId, _ := primitive.ObjectIDFromHex(p.SID)
		section, _ := modulesectionmod.GetBySectionByID(sId)
		query["mId"] = section.SubModuleID
	}
	query["status"] = 1
	query["isDelete"] = false
	return query
}

func (p *AppGetTopicReq) Options() bson.D {
	var sort bson.D
	switch p.SortType {
	case 1:
		// 1、最新
		sort = bson.D{{"createdAt", -1}}
	case 2:
		// 2、最多观看
		sort = bson.D{{"countBrowse", -1}}
	case 3:
		// 3 最多喜欢（收藏）
		sort = bson.D{{"countCollect", -1}}
	case 4: // 4 热评排序
		sort = bson.D{{"hot", -1}, {"createdAt", -1}}
	default:
		sort = bson.D{{"createdAt", -1}}
	}
	return sort
}

type AppGetTopicRes struct {
	HasNext bool                     `json:"hasNext" bson:"hasNext"` // 是否有下一页
	Section AppSection               `json:"section" bson:"section"` // 播单详情
	List    []*mediamod.AppMediaBase `json:"list" bson:"list"`       // 列表
}

type AppSection struct {
	ID           primitive.ObjectID `json:"id"             bson:"id"`         // ID
	Name         string             `json:"name"    bson:"name" `             // 播单名称
	Cover        string             `json:"cover"   bson:"cover"`             // 播单封面
	Count        int64              `json:"count" bson:"count"`               // 作品数量
	Type         int                `json:"type" bson:"type"`                 // 播单类型
	LikeCount    int64              `json:"likeCount" bson:"likeCount"`       // 点赞数量
	CommentCount int64              `json:"commentCount" bson:"commentCount"` // 评论数量
	UserID       uint64             `json:"userId" bson:"userId"`             // 用户ID
	UserName     string             `json:"userName" bson:"userName"`         // 用户名称
	Portrait     string             `json:"portrait" bson:"portrait"`         // 用户头像
	//MediaStatus  mediamod.MediaStatus `json:"mediaStatus" bson:"mediaStatus"`   // 媒体状态
}

func (p *AppGetTopicReq) getTopicListHomePage() (res AppGetTopicRes, err error) {
	mediaList, hasNext, err := mediadata.GetListFromCache(p.Filter(), int64(p.Skip()), int64(p.Limit()), p.Options())
	if err != nil {
		return res, err
	}
	res.List = FillNotStatusMedias(mediaList, false)
	res.HasNext = hasNext
	return
}

// GetTopicList 获取详情
func (p *AppGetTopicReq) GetTopicList(uid uint64) (res AppGetTopicRes, err error) {
	if p.Type == 1 {
		return p.getTopicListHomePage()
	}
	// 获取播单数据
	sId, _ := primitive.ObjectIDFromHex(p.SID)
	section, err := modulesectionmod.GetBySectionByID(sId)
	if err != nil {
		return res, err
	}

	res, err = p.getMediaList(uid, section)
	common.Go(func() {
		t := time.Now()
		date := t.Add(-12 * time.Hour).Local().Format("2006-01-02")
		sectionstatmod.UpsertSectionHits(sId, date)
	})
	return
}

// 获取专题相关的acg
func (p *AppGetTopicReq) getMediaList(uid uint64, section modulesectionmod.Section) (res AppGetTopicRes, err error) {
	var (
		mediaContentIds []primitive.ObjectID
		mStatus         map[primitive.ObjectID]mediamod.MediaStatus
	)

	mediaContentIds = append(mediaContentIds, section.ID)

	mediaList, hasNext, err := mediadata.GetListFromCache(p.Filter(), int64(p.Skip()), int64(p.Limit()), p.Options())
	if err != nil {
		return res, err
	}
	res.HasNext = hasNext

	//if len(mediaList) <= 0 {
	//	var wg sync.WaitGroup
	//	wg.Add(1)
	//	common.Go(func() {
	//		defer wg.Done()
	//		mStatus = GetUserStatus(uid, mediaContentIds)
	//	})
	//	wg.Wait()
	//	res.Section.MediaStatus = mStatus[section.ID]
	//	return res, nil
	//}

	for _, m := range mediaList {
		mediaContentIds = append(mediaContentIds, m.ID)
	}

	//var wg sync.WaitGroup
	//wg.Add(1)
	//common.Go(func() {
	//	defer wg.Done()
	//	mStatus = GetUserStatus(uid, mediaContentIds)
	//})
	//wg.Wait()
	//res.Section.MediaStatus = mStatus[section.ID]

	for _, item := range mediaList {
		data := &mediamod.AppMediaBase{
			ID:                 item.ID,
			SortCode:           item.SortCode,
			Status:             item.Status,
			Title:              item.Title,
			Author:             item.Anchor,
			HorizontalCover:    item.HorizontalCover,
			VerticalCover:      item.VerticalCover,
			UpdateStatus:       item.UpdateStatus,
			Tags:               item.Tags,
			Summary:            item.Summary,
			TotalEpisode:       item.TotalEpisode,
			MediaType:          item.MediaType,
			MediaSubType:       item.MediaSubType,
			Kind:               item.Kind,
			PermissionIconHide: item.PermissionIconHide,
			Permission:         item.Permission,
			Price:              item.Price,
			Direction:          item.Direction,
			FreeTime:           item.FreeTime,
			CountComment:       item.CountComment,
			CountPurchases:     item.CountPurchases,
			CountBrowse:        item.CountBrowse,
			CountCollect:       item.CountCollect,
			CountLike:          item.CountLike,
			CountView:          item.CountView,
			Number:             item.Number,
			MediaStatus:        mStatus[item.ID],
			CreatedAt:          item.CreatedAt,
			UpdateTime:         item.UpdateTime,
		}
		res.List = append(res.List, data)
	}

	return res, nil
}

type AppRecommendReq struct {
	TagId     string `json:"tagId" form:"tagId"`         // 标签id
	MediaType string `json:"mediaType" form:"mediaType"` // 媒体类型 "video":视频,"image":图片,"text":小说
	IsAudio   bool   `json:"isAudio" form:"isAudio"`     // 是否是音频小说
	commod.Page
}

func (p *AppRecommendReq) Filter(media *mediamod.Media) bson.M {
	var query = bson.M{
		"mediaType": media.MediaType,
		"isDelete":  false,
	}
	return query
}

func (p *AppRecommendReq) Options() bson.D {
	sort := bson.D{{"_id", -1}, {"createdAt", -1}}
	return sort
}

type AppRecommendRes struct {
	HasNext bool              `json:"hasNext" bson:"hasNext"` // 是否有下一页
	List    []*MediaRecommend `json:"list" bson:"list"`       // 推荐动漫/小说详情页列表
}

type ComicsRecommend struct {
	SimilarRecommend []*mediamod.AppMediaBase `json:"similarRecommend"` // 相似推荐
	HotRecommend     []*MediaRecommend        `json:"hotRecommend"`     // 热门推荐
	DiamondFeatured  []*MediaRecommend        `json:"diamondFeatured"`  // 钻石精选
}

type MediaRecommend struct {
	ID              primitive.ObjectID    `json:"id" bson:"_id,omitempty"`                // 文档id
	Title           string                `json:"title" bson:"title"`                     // 标题
	HorizontalCover string                `json:"horizontalCover" bson:"horizontalCover"` // 横版封面
	VerticalCover   string                `json:"verticalCover" bson:"verticalCover"`     // 竖版封面
	Tags            []primitive.ObjectID  `json:"tags" bson:"tags"`                       // 标签
	TagDetails      []mediamod.TagDetail  `json:"tagDetails" bson:"tagDetails"`           // 标签对象
	TotalEpisode    int                   `json:"totalEpisode" bson:"totalEpisode"`       // 总集数
	UpdateStatus    int                   `json:"updateStatus" bson:"updateStatus"`       // 更新状态 1-连载中 2-已完结
	MediaType       string                `json:"mediaType" bson:"mediaType"`             // 媒体类型 "video":视频,"image":图片,"text":小说
	MediaSubType    mediamod.MediaSubType `json:"mediaSubType" bson:"mediaSubType"`       // 子类型 ，暂时只有小说使用 0-默认文本小说 1-有声小说
	Permission      int                   `json:"permission" bson:"permission"`           // 收听权限  0:会员 1:金币购买 2:免费
	Price           int64                 `json:"price" bson:"price"`                     // 价格(整部购买的类型 小说 cos 写真)
	Direction       int64                 `json:"direction" bson:"direction"`             // 排版方向 0横 1竖(冗余字段)
	CurrentEpisode  int                   `json:"currentEpisode" bson:"currentEpisode"`   // 当前更新的集数
	Anchor          string                `json:"anchor" bson:"anchor"`                   // 作者
}

// GetList 获取推荐列表
func (p *AppRecommendReq) GetList(uid uint64) (res AppRecommendRes, err error) {
	tagId, _ := primitive.ObjectIDFromHex(p.TagId)
	// 获取动漫/小说推荐
	filter := bson.M{"mediaType": p.MediaType}
	if !tagId.IsZero() {
		filter["tags"] = tagId
	}
	if p.IsAudio {
		filter["mediaSubType"] = 1
	}
	list, hasNext, err := mediadata.GetListFromCache(filter, int64(p.Skip()), int64(p.Limit()), bson.D{{Key: "countLike", Value: -1}, {Key: "createdAt", Value: -1}})
	if err != nil {
		return
	}
	res.HasNext = hasNext
	for _, v := range list {
		res.List = append(res.List, p.MediaToMediaRecommend(v))
	}
	return res, nil
}

func (p *AppRecommendReq) MediaToMediaRecommend(media *mediamod.Media) *MediaRecommend {
	return &MediaRecommend{
		ID:              media.ID,
		Title:           media.Title,
		HorizontalCover: media.HorizontalCover,
		VerticalCover:   media.VerticalCover,
		Tags:            media.Tags,
		TagDetails:      media.TagDetails,
		TotalEpisode:    media.TotalEpisode,
		UpdateStatus:    media.UpdateStatus,
		MediaType:       media.MediaType,
		MediaSubType:    media.MediaSubType,
		Permission:      media.Permission,
		Price:           media.Price,
		CurrentEpisode:  media.CurrentEpisode,
		Direction:       media.Direction,
		Anchor:          media.Anchor,
	}
}

type RankingReq struct {
	Type      int    `json:"type" form:"type"`           // 1-日榜 2-周榜 3-月榜 4-总榜 5-年榜
	MediaType string `json:"mediaType" form:"mediaType"` // video 动画 image 漫画 text 小说
	commod.Page
}

type RankingResp struct {
	List    []*mediamod.AppMediaBase `json:"list"`
	HasNext bool                     `json:"hasNext"`
}

const (
	DailyRank = 1 // 日榜
	WeekRank  = 2 // 周榜
	MonthRank = 3 // 周榜
	AllRank   = 4 // 总榜
	YearRank  = 5 // 年榜 180天
)

func (q *RankingReq) List() (res RankingResp, err error) {
	start := time.Now()
	defer func() {
		t := time.Now().UnixMilli() - start.UnixMilli()
		log.Info("RankList", log.Any("ranking.Typ", q.Type), log.Any("耗时", fmt.Sprintf("%v ms", t)))
	}()
	switch q.Type {
	case DailyRank, WeekRank, MonthRank:
		// 日榜
		res, err = q.getRank(q.Type, q.MediaType)

	case AllRank, YearRank:
		res, err = q.getAllRank(q.MediaType, q.Type == YearRank)
	}
	return
}

func (q *RankingReq) getAllRank(mediaType string, isYear bool) (res RankingResp, err error) {
	// 通过id获取media
	filter := bson.M{"mediaType": mediaType, "status": 1, "isDelete": false}
	if isYear {
		filter["createdAt"] = bson.M{"$gte": timeutil.BeginningOfDay(time.Now())}
	}
	mediaList, hasNext, err := mediadata.GetListFromCache(filter, int64(q.Skip()), int64(q.Limit()), bson.D{{Key: "countBrowse", Value: -1}})
	if err != nil {
		return
	}

	res.List = FillNotStatusMedias(mediaList, false)
	res.HasNext = hasNext
	return res, nil
}

func (q *RankingReq) getRank(rankinType int, mediaType string) (res RankingResp, err error) {
	var list []string
	var hasNext bool
	switch rankinType {
	case DailyRank:
		list, _, hasNext = dailytop.GetTopByPage(topser.TypeMedia(mediaType), int64(q.Skip()), int64(q.Limit()))
	case WeekRank:
		list, _, hasNext = weektop.GetTopByPage(topser.TypeMedia(mediaType), int64(q.Skip()), int64(q.Limit()))
	case MonthRank:
		list, _, hasNext = monthtop.GetTopByPage(topser.TypeMedia(mediaType), int64(q.Skip()), int64(q.Limit()))
	default:
		return
	}

	ids := []primitive.ObjectID{}
	for _, v := range list {
		id, _ := primitive.ObjectIDFromHex(v)
		if id.IsZero() {
			continue
		}
		ids = append(ids, id)
	}
	// 通过id获取media
	mediaList, _, err := mediadata.GetListFromCache(bson.M{"_id": bson.M{"$in": ids}}, 0, int64(q.Limit()), bson.D{})
	if err != nil {
		return
	}
	mediaMap := make(map[primitive.ObjectID]*mediamod.Media)
	for _, v := range mediaList {
		mediaMap[v.ID] = v
	}
	for _, id := range ids {
		item, ok := mediaMap[id]
		if !ok {
			topasist.Remove(topser.TypeMedia(mediaType), id.Hex())
			continue
		}
		if item.Status != 1 {
			topasist.Remove(topser.TypeMedia(mediaType), id.Hex())
		}
		res.List = append(res.List, FillNotStatusMedias([]*mediamod.Media{item}, false)...)
	}
	res.HasNext = hasNext
	return res, nil

}

type HotReq struct {
	Type      int    `json:"type" form:"type"`           // 0-最新热播 1-本月最热 2-上月最热
	MediaType string `json:"mediaType" form:"mediaType"` // video 动画（默认不填显示这个） image 漫画 text 小说
	commod.Page
}

type HotResp struct {
	List    []*mediamod.AppMediaBase `json:"list"`
	HasNext bool                     `json:"hasNext"`
}

func (p *HotReq) List() (resp HotResp, err error) {
	filter := bson.M{
		"status":    1,
		"isDelete":  false,
		"mediaType": "video", // 默认展示动漫
	}
	now := time.Now()
	year, month, day := now.Date()
	// 获取今日最后一刻的时间，这里不能直接使用now去做筛选条件，不然根据这些筛选条件生成的redis key，会一直变，导致一直没有命中缓存
	now = time.Date(year, month, day, 23, 59, 59, 0, now.Location())
	// 默认最新热播
	start := now.AddDate(0, 0, -7)
	end := now
	switch p.Type {
	case 1:
		// 本月最热
		start = now.AddDate(0, -1, 0)
	case 2:
		// 上月最热
		start = now.AddDate(0, -2, 0)
		end = now.AddDate(0, -1, 0)
	default:
		// 判断是否是本周三,再往前多查7天
		if carbon.Now().DayOfWeek() <= 3 {
			start = now.AddDate(0, 0, -14)
		}
	}
	if p.MediaType != "" {
		filter["mediaType"] = p.MediaType
	}
	filter["createdAt"] = bson.M{"$gte": start, "$lt": end}

	mediaList, hasNext, err := mediadata.GetListFromCache(filter, int64(p.Skip()), int64(p.Limit()), bson.D{{Key: "countCollect", Value: -1}})
	if err != nil {
		return
	}
	for _, item := range mediaList {
		tmp := &mediamod.AppMediaBase{
			ID:                 item.ID,
			SortCode:           item.SortCode,
			Status:             item.Status,
			Title:              item.Title,
			Author:             item.Anchor,
			HorizontalCover:    item.HorizontalCover,
			VerticalCover:      item.VerticalCover,
			Tags:               item.Tags,
			Summary:            item.Summary,
			TotalEpisode:       item.TotalEpisode,
			MediaType:          item.MediaType,
			MediaSubType:       item.MediaSubType,
			Kind:               item.Kind,
			PermissionIconHide: item.PermissionIconHide,
			Permission:         item.Permission,
			Price:              item.Price,
			Direction:          item.Direction,
			FreeTime:           item.FreeTime,
			CountComment:       item.CountComment,
			CountPurchases:     item.CountPurchases,
			CountBrowse:        item.CountBrowse,
			CountCollect:       item.CountCollect,
			CountLike:          item.CountLike,
			CountView:          item.CountView,
			Number:             item.Number,
			CreatedAt:          item.CreatedAt,
			UpdateTime:         item.UpdateTime,
		}
		resp.List = append(resp.List, tmp)
	}
	resp.HasNext = hasNext
	return
}

type MyBuyReq struct {
	MediaType string `json:"mediaType" form:"mediaType"` // video 动画 image 漫画 text 小说 drama 短剧
	commod.Page
}

type MyBuyResp struct {
	List    []*mediamod.AppMediaBase `json:"list"`
	HasNext bool                     `json:"hasNext"`
	Total   int64                    `json:"total"`
}

func (p *MyBuyReq) List(uid uint64) (resp MyBuyResp, err error) {
	if p.MediaType == mediamod.MediaTypeDrama {
		buyList, total, hasNext, queryErr := media_buy_record_mod.GetMyBuyMediaIDs(uid, p.MediaType, p.Skip(), p.Limit())
		if queryErr != nil {
			return resp, queryErr
		}
		ids := make([]primitive.ObjectID, 0, len(buyList))
		for _, item := range buyList {
			ids = append(ids, item.MediaID)
		}
		_, mediaMap, queryErr := mediamod.GetListByIds(ids)
		if queryErr != nil {
			return resp, queryErr
		}
		ordered := make([]*mediamod.Media, 0, len(ids))
		for _, id := range ids {
			media, ok := mediaMap[id]
			if !ok || media.MediaType != mediamod.MediaTypeDrama || media.Status != 1 || media.IsDelete {
				continue
			}
			copy := media
			ordered = append(ordered, &copy)
		}
		resp.List = FillMedias(ordered, uid, true)
		if resp.List == nil {
			resp.List = make([]*mediamod.AppMediaBase, 0)
		}
		resp.Total, resp.HasNext = total, hasNext
		return resp, nil
	}
	res, hasNext, err := media_buy_record_mod.GetMyBuy(uid, p.MediaType, p.Skip(), p.Limit())
	if err != nil {
		return
	}
	ids := []primitive.ObjectID{}
	for _, v := range res {
		ids = append(ids, v.MediaId)
	}
	mediaList, _, err := mediamod.GetListByIds(ids)
	if err != nil {
		return
	}
	for _, item := range mediaList {
		tmp := &mediamod.AppMediaBase{
			ID:                 item.ID,
			SortCode:           item.SortCode,
			Status:             item.Status,
			Title:              item.Title,
			Author:             item.Anchor,
			HorizontalCover:    item.HorizontalCover,
			VerticalCover:      item.VerticalCover,
			Tags:               item.Tags,
			Summary:            item.Summary,
			TotalEpisode:       item.TotalEpisode,
			MediaType:          item.MediaType,
			MediaSubType:       item.MediaSubType,
			Kind:               item.Kind,
			PermissionIconHide: item.PermissionIconHide,
			Permission:         item.Permission,
			Price:              item.Price,
			Direction:          item.Direction,
			FreeTime:           item.FreeTime,
			CountComment:       item.CountComment,
			CountPurchases:     item.CountPurchases,
			CountBrowse:        item.CountBrowse,
			CountCollect:       item.CountCollect,
			CountLike:          item.CountLike,
			CountView:          item.CountView,
			Number:             item.Number,
			CreatedAt:          item.CreatedAt,
			UpdateTime:         item.UpdateTime,
		}
		resp.List = append(resp.List, tmp)
	}
	resp.HasNext = hasNext
	return
}

type (
	AppGetMediaListByTagReq struct {
		commod.Page
		TagId    string `form:"tagId"    json:"tagId"`
		SortType int    `form:"sortType" json:"sortType"` // 排序 1-最新 2-最热 3-最多收藏
	}
	AppGetMediaListByTagRep = AppListRes
)

type TagMediaListReq struct {
	TagID    string `form:"tagID" json:"tagID" binding:"required"`       // 标签id
	SortType int    `form:"sortType" json:"sortType" binding:"required"` //排序类型 1最多播放，2、最新，3、 最多收藏 "
	commod.Page
}

type TagMediaListResp struct {
	HasNext bool                     `json:"hasNext"`
	List    []*mediamod.AppMediaBase `json:"list"`
}

func (p *TagMediaListReq) GetList() (resp TagMediaListResp, err error) {
	tagId, _ := primitive.ObjectIDFromHex(p.TagID)
	if tagId.IsZero() {
		return
	}
	filter := bson.M{
		"tags":     tagId,
		"isDelete": false,
		"status":   1,
	}

	sort := bson.D{{"createdAt", -1}}
	switch p.SortType {
	case 1:
		sort = bson.D{{"countBrowse", -1}, {"createdAt", -1}}
	case 2:
		sort = bson.D{{"createdAt", -1}}
	case 3:
		sort = bson.D{{"countCollect", -1}, {"createdAt", -1}}
	case 4:
		sort = bson.D{{"hot", -1}, {"createdAt", -1}}
	}
	// 获取列表
	var data []*mediamod.Media
	data, resp.HasNext, err = mediadata.GetListFromCache(filter, int64(p.Skip()), int64(p.Limit()), sort)
	if err != nil {
		return
	}
	resp.List = FillNotStatusMedias(data, false)

	return resp, nil
}