package vidhelpser

import (
	"encoding/json"
	"fmt"
	"time"

	"91porn-server/app/appg"
	"91porn-server/common/constant/redisconst"
	"91porn-server/common/log"
	"91porn-server/common/redis"
	"91porn-server/models/v/usermod"
	"91porn-server/models/v/vidmod"

	"go.mongodb.org/mongo-driver/bson/primitive"
)

func getUIDKey(uids []uint64) []string {
	format := redisconst.UserInfoKey()
	keys := make([]string, len(uids))
	for i, u := range uids {
		keys[i] = fmt.Sprintf(format, u)
	}
	return keys
}

func getTidKey(tids []primitive.ObjectID) []string {
	format := redisconst.TagInfoKey()
	keys := make([]string, len(tids))
	for i, t := range tids {
		keys[i] = fmt.Sprintf(format, t.Hex())
	}
	return keys
}

func getVidKey(vids []primitive.ObjectID) []string {
	format := redisconst.VideoInfoKey()
	keys := make([]string, len(vids))
	for i, v := range vids {
		keys[i] = fmt.Sprintf(format, v.Hex())
	}
	return keys
}

func parseUserInfo(data []interface{}) []usermod.BaseInfoVip {
	infos := make([]usermod.BaseInfoVip, 0, len(data))
	for _, d := range data {
		str, ok := d.(string)
		if !ok {
			continue
		}
		var u usermod.BaseInfoVip
		if err := json.Unmarshal([]byte(str), &u); err != nil {
			continue
		}
		infos = append(infos, u)
	}
	return infos
}

func getPublisher(info []usermod.BaseInfoVip) map[uint64]*vidmod.Publisher {
	m := make(map[uint64]*vidmod.Publisher)
	for _, u := range info {
		p := vidmod.Publisher{
			UInfo: u,
		}
		m[u.UID] = &p
	}
	return m
}

func getUnExistUID(uids []uint64, m map[uint64]*vidmod.Publisher) []uint64 {
	ids := make([]uint64, 0, len(uids))
	for _, u := range uids {
		if m[u] == nil {
			ids = append(ids, u)
		}
	}
	return ids
}

func getUsersBaseInfoFromRedis(uids []uint64) (map[uint64]*vidmod.Publisher, []uint64, error) {
	sInfo := getUIDKey(uids)
	uInfo, err := appg.Redis.MGet(sInfo...)
	if err != nil {
		log.Error("getUsersBaseInfoFromRedis error", log.Any("uids", uids), log.Any("sInfo", sInfo), log.E(err))
		return nil, uids, err
	}
	userInfo := parseUserInfo(uInfo)
	mPublisher := getPublisher(userInfo)
	unExist := getUnExistUID(uids, mPublisher)
	return mPublisher, unExist, nil
}

func setUsersBaseInfo2Redis(infos []*usermod.BaseInfoVip) error {
	format := redisconst.UserInfoKey()
	expire := redisconst.UserInfoExpire()
	for _, u := range infos {
		d, err := json.Marshal(u)
		if err != nil {
			continue
		}
		s := fmt.Sprintf(format, u.UID)
		_ = appg.Redis.Set(s, string(d), expire)
	}
	return nil
}

func parseTagInfo(data []interface{}) []vidmod.TagInfo {
	infos := make([]vidmod.TagInfo, 0, len(data))
	for _, d := range data {
		str, ok := d.(string)
		if !ok {
			continue
		}
		var t vidmod.TagInfo
		if err := json.Unmarshal([]byte(str), &t); err != nil {
			continue
		}
		infos = append(infos, t)
	}
	return infos
}

func getUnExistTID(ids []primitive.ObjectID, info []vidmod.TagInfo) []primitive.ObjectID {
	m := make(map[primitive.ObjectID]bool)
	for _, i := range info {
		m[i.ID] = true
	}
	unExist := make([]primitive.ObjectID, 0, len(ids))
	for _, i := range ids {
		if !m[i] {
			unExist = append(unExist, i)
		}
	}
	return unExist
}

func getTagsByIDsFromRedis(ids []primitive.ObjectID) ([]vidmod.TagInfo, []primitive.ObjectID, error) {
	sInfo := getTidKey(ids)
	uInfo, err := appg.Redis.MGet(sInfo...)
	if err != nil {
		log.Error("getTagsByIDsFromRedis error", log.Any("ids", ids), log.Any("sInfo", sInfo), log.E(err))
		return nil, ids, err
	}
	tagInfo := parseTagInfo(uInfo)
	unExist := getUnExistTID(ids, tagInfo)
	return tagInfo, unExist, nil
}

func setTagsByIDs2Redis(tags []vidmod.TagInfo) error {
	expire := redisconst.TagInfoExpire()
	format := redisconst.TagInfoKey()
	for _, t := range tags {
		d, err := json.Marshal(t)
		if err != nil {
			continue
		}
		s := fmt.Sprintf(format, t.ID.Hex())
		_ = appg.Redis.Set(s, string(d), expire)
	}
	return nil
}

func parseVideoInfo(data []interface{}) []*vidmod.VideoModel {
	infos := make([]*vidmod.VideoModel, 0, len(data))
	for _, d := range data {
		str, ok := d.(string)
		if !ok {
			continue
		}
		var v vidmod.VideoModel
		if err := json.Unmarshal([]byte(str), &v); err != nil {
			continue
		}
		infos = append(infos, &v)
	}
	return infos
}

func getUnExistVID(ids []primitive.ObjectID, info []*vidmod.VideoModel) []primitive.ObjectID {
	m := make(map[primitive.ObjectID]bool)
	for _, i := range info {
		m[i.ID] = true
	}
	unExist := make([]primitive.ObjectID, 0, len(ids))
	for _, i := range ids {
		if !m[i] {
			unExist = append(unExist, i)
		}
	}
	return unExist
}

func getVideoListByIDsFromRedis(ids []primitive.ObjectID) ([]*vidmod.VideoModel, []primitive.ObjectID, error) {
	sInfo := getVidKey(ids)
	uInfo, err := appg.Redis.MGet(sInfo...)
	if err != nil {
		log.Error("getVideoListByIDsFromRedis error", log.Any("ids", ids), log.Any("sInfo", sInfo), log.E(err))
		return nil, ids, err
	}
	videoInfo := parseVideoInfo(uInfo)
	unExist := getUnExistVID(ids, videoInfo)
	return videoInfo, unExist, nil
}

func setVideoListByIDs2Redis(infos []*vidmod.VideoModel) error {
	expire := redisconst.VideoInfoExpire()
	format := redisconst.VideoInfoKey()
	for _, v := range infos {
		d, err := json.Marshal(v)
		if err != nil {
			continue
		}
		s := fmt.Sprintf(format, v.ID.Hex())
		_ = appg.Redis.Set(s, string(d), expire)
	}
	return nil
}

func getNewestNewsFromRedis(page, size uint64, recentMinute time.Time) ([]string, error) {
	key := redisconst.NewestNewsKey(recentMinute)
	start := (page - 1) * size
	end := page*size - 1
	ids, err := appg.Redis.ZRange(key, int64(start), int64(end))
	if err != nil {
		log.Error("getNewestNewsFromRedis error", log.Any("page", page), log.Any("size", size), log.E(err))
	}
	return ids, err
}

func getNewestNewsFromRedis_old(page, size uint64) ([]string, error) {
	key := redisconst.NewestNewsKey_old()
	start := (page - 1) * size
	end := page*size - 1
	ids, err := appg.Redis.ZRange(key, int64(start), int64(end))
	if err != nil {
		log.Error("getNewestNewsFromRedis error", log.Any("page", page), log.Any("size", size), log.E(err))
	}
	return ids, err
}

func getNewestShortVideoFromRedis(page, size uint64) ([]string, error) {
	key := redisconst.NewestShortVideoKey()
	start := (page - 1) * size
	end := page*size - 1
	ids, err := appg.Redis.ZRange(key, int64(start), int64(end))
	if err != nil {
		log.Error("getNewestNewsFromRedis error", log.Any("page", page), log.Any("size", size), log.E(err))
	}
	return ids, err
}

func news2RedisZ(ids []string) []redis.Member {
	if len(ids) == 0 {
		return []redis.Member{}
	}
	members := make([]redis.Member, 0, len(ids))
	for k, v := range ids {
		if v != "" {
			members = append(members, redis.Member{Score: float64(k), Member: v})
		}
	}
	return members
}

func setNewestNews2Redis(ids []string, recentMinute time.Time) {
	key := redisconst.NewestNewsKey(recentMinute)
	expird := redisconst.NewestNewsExpire()
	if _, err := appg.Redis.Del(key); err != nil {
		return
	}
	values := news2RedisZ(ids)
	if _, err := appg.Redis.ZAdd(key, values...); err != nil {
		return
	}
	_, _ = appg.Redis.ExpireKeAt(key, time.Now().Add(expird))
}

func setNewestNews2Redis_old(ids []string) {
	key := redisconst.NewestNewsKey_old()
	expird := redisconst.NewestNewsExpire()
	if _, err := appg.Redis.Del(key); err != nil {
		return
	}
	values := news2RedisZ(ids)
	if _, err := appg.Redis.ZAdd(key, values...); err != nil {
		return
	}
	_, _ = appg.Redis.ExpireKeAt(key, time.Now().Add(expird))
}

func setNewestShortVideo2Redis(ids []string) {
	key := redisconst.NewestShortVideoKey()
	expird := redisconst.NewestNewsExpire()
	if _, err := appg.Redis.Del(key); err != nil {
		return
	}
	values := news2RedisZ(ids)
	if _, err := appg.Redis.ZAdd(key, values...); err != nil {
		return
	}
	_, _ = appg.Redis.ExpireKeAt(key, time.Now().Add(expird))
}

func incComment(vid primitive.ObjectID) {
	infos, _, err := getVideoListByIDsFromRedis([]primitive.ObjectID{vid})
	if err != nil || len(infos) == 0 {
		return
	}
	if infos[0] == nil {
		return
	}
	infos[0].CommentCount++
	infos[0].FakeCommentCount++
	_ = setVideoListByIDs2Redis(infos)
}