package likeser

import (
	"sync"
	"time"

	"91porn-server/app/service/searcher"
	"91porn-server/common"
	"91porn-server/common/log"
	"91porn-server/models/v/likemod"
	"91porn-server/models/v/usermod"
	"go.mongodb.org/mongo-driver/bson/primitive"
)

type VideoRes = searcher.VideoRes

type UserBInfo = usermod.BaseInfo

type ObjectID = primitive.ObjectID

type Like = likemod.Like

type Record struct {
	//点赞者UID
	LUID uint64 `json:"lUID"`
	//点赞者名字
	LName string `json:"lName"`
	//点赞者头像
	LPortrait string `json:"lPortrait"`
	//点赞类型  video:对视频点赞  comment:对评论点赞
	LType string `json:"lType"`
	//点赞时间
	LTime time.Time `json:"lTime"`
	//视屏信息
	Video VideoRes `json:"video"`
}

type RecordPage struct {
	HasNext bool     `json:"hasNext"`
	List    []Record `json:"list"`
}

func RecordPages(uid uint64, skip, limit int64) (RecordPage, error) {
	limitEx := limit + 1
	likeList, err := likemod.ListByLikedUserID(uid, skip, limitEx)
	if err != nil {
		return RecordPage{}, err
	}
	hasNext := false
	if len(likeList) > int(limit) {
		hasNext = true
		likeList = likeList[:limit]
	}
	vidMap := make(map[ObjectID]ObjectID, len(likeList)) //object->vid map
	vids := make([]ObjectID, 0, len(likeList))
	cmtIDs := make([]ObjectID, 0, len(likeList))
	uids := make([]uint64, 0, len(likeList))

	for _, v := range likeList {
		if v.Type == "video" {
			vids = append(vids, v.ObjID) //视屏ID
			vidMap[v.ObjID] = v.ObjID
		} else if v.Type == "comment" {
			cmtIDs = append(cmtIDs, v.ObjID) //评论ID
		}
		uids = append(uids, v.UserID)
	}

	var (
		wg           = sync.WaitGroup{}
		videoResList []VideoRes
		userInfos    []*UserBInfo
	)
	wg.Add(2)
	common.Go(func() {
		defer wg.Done()
		list, err := searcher.GetVideoResList(uid, vids)
		if err != nil {
			log.Error("commentser GetVideoResList faild", log.E(err))
		}
		videoResList = list
	})
	common.Go(func() {
		defer wg.Done()
		list, err := usermod.GetUsersBaseInfo(uids)
		if err != nil {
			log.Error("commentser GetUsersBaseInfo faild", log.E(err))
		}
		userInfos = list
	})
	wg.Wait()
	videoResMap := make(map[ObjectID]VideoRes, len(videoResList))
	for _, v := range videoResList {
		vidp := v.VideoInfo.ID
		if vidp != nil {
			videoResMap[*vidp] = v
		}
	}
	userInfoMap := make(map[uint64]*usermod.BaseInfo, len(userInfos))
	for _, v := range userInfos {
		userInfoMap[v.UID] = v
	}
	recordList := tRecordList(likeList, vidMap, videoResMap, userInfoMap)
	return RecordPage{
		hasNext,
		recordList,
	}, nil
}

func tRecordList(likeList []Like,
	vidMap map[ObjectID]ObjectID,
	videoResMap map[ObjectID]VideoRes,
	userInfoMap map[uint64]*usermod.BaseInfo,
) []Record {
	recordList := make([]Record, 0, len(likeList))
	for _, v := range likeList {
		userInfo, ok := userInfoMap[v.UserID]
		if !ok {
			continue
		}
		vid, ok := vidMap[v.ObjID]
		if !ok {
			continue
		}
		videoRes, ok := videoResMap[vid]
		if !ok {
			continue
		}
		record := Record{
			LUID:      userInfo.UID,
			LName:     userInfo.Name,
			LPortrait: userInfo.Portrait,
			LType:     v.Type,
			LTime:     v.CreatedAt,
			Video:     videoRes,
		}
		recordList = append(recordList, record)
	}
	return recordList
}