package collectmod

import (
	"91porn-server/common/constant"
	"91porn-server/common/db"
	"91porn-server/common/log"
	"91porn-server/models"
	"91porn-server/models/commod"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
	"time"
)

var mdb *db.MongoDB
var maxCollectTagsSize = 30

const table = models.Collect

func coll(t *db.MongoTool) *db.MongoTool {
	if t == nil {
		return mdb.Coll(table)
	}
	return t.Coll(table)
}

// initCollectIndex 初始化索引
func initIndex() {
	many := []mongo.IndexModel{
		{
			Keys: bson.D{{"uid", 1}, {"type", 1}},
		},
		{
			Keys:    bson.D{{"uid", 1}, {"type", 1}, {"objID", 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys:    bson.D{{"uniq", 1}},
			Options: options.Index().SetUnique(true),
		},
	}
	_, err := coll(nil).CreateIndex(many)
	if err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
	}
	return
}

// CollInsertOne 插入收藏消息记录
func CollInsertOne(c *Collect) (err error) {
	c.Uniq = Unique(c.UID, c.Type, c.ObjID)
	c.CreatedAt = time.Now()
	if _, err = coll(nil).InsertOne(c); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollInsertOne", table, "InsertOne", err))
		return
	}
	return
}

// CollInsertMany 插入收藏消息记录
func CollInsertMany(c *[]Collect) (err error) {
	if _, err = coll(nil).InsertMany(c); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollInsertMany", table, "InsertMany", err))
		return
	}
	return
}

// CollDeleteOne 取消收藏
func CollDeleteOne(uid uint64, cType string, objID primitive.ObjectID) (err error) {
	var query = bson.M{"uid": uid, "type": cType, "objID": objID}
	if _, err = coll(nil).DeleteOne(query); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollDeleteOne", table, "DeleteOne", err),
			log.Any("uid", uid),
			log.Any("cType", cType),
			log.Any("objID", objID),
		)
		return
	}
	return
}

// CollDeleteMany 取消收藏
func CollDeleteMany(ids []string) (err error) {
	var query = bson.M{"uniq": bson.M{"$in": ids}}
	if _, err = coll(nil).DeleteMany(query); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollDeleteMany", table, "DeleteMany", err),
			log.Any("ids", ids),
		)
		return
	}
	return
}

// CollFindOneByUidAndObjID 获取单条收藏信息 用于验证是否已经收藏
func CollFindOneByUidAndObjID(uid uint64, objID primitive.ObjectID) (data Collect, err error) {
	var query = bson.M{"uid": uid, "objID": objID}
	if err = coll(nil).FindOne(&data, query); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollFindOneByUidAndObjID", table, "FindOne", err),
			log.Any("uid", uid),
			log.Any("objID", objID),
		)
		return
	}
	return
}

// CollFindOneByUidAndObjIds 获取多条收藏信息 用于验证是否已经收藏
func CollFindOneByUidAndObjIds(uid uint64, objIDS []primitive.ObjectID) (data []Collect, err error) {
	var query = bson.M{"uid": uid, "objID": bson.M{"$in": objIDS}}
	if err = coll(nil).Find(&data, query); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollFindOneByUidAndObjIds", table, "Find", err),
			log.Any("uid", uid),
			log.Any("objIDS", objIDS),
		)
		return
	}
	return
}

// CollFindCollects 获取收藏列表
func CollFindCollects(uid uint64, cType string, stdQuery commod.StdQuery) (data []Collect, err error) {
	*stdQuery.Order = append(*stdQuery.Order, commod.OrderBy{Key: "createdAt", Desc: true})
	var query = bson.M{"uid": uid, "type": cType}
	if err = coll(nil).Find(&data, query, commod.ConvertToListQuery(stdQuery)); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollFindOneByUidAndObjID", table, "FindOne", err),
			log.Any("uid", uid),
			log.Any("objID", cType),
		)
		return
	}
	return
}

// CollFindCollectsByUIDAndObjIDs 获取包含指定对象收藏列表
func CollFindCollectsByUIDAndObjIDs(uid uint64, cType string, objIDs []primitive.ObjectID) (data []Collect, err error) {
	var query = bson.M{"uid": uid, "type": cType, "objID": bson.M{"$in": objIDs}}
	if err = coll(nil).Find(&data, query); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollFindOneByUidAndObjID", table, "FindOne", err),
			log.Any("uid", uid),
			log.Any("objID", cType),
		)
		return
	}
	return
}

// CollFindCollectsByUIDAndObjId 获取包含指定对象收藏列表
func CollFindCollectsByUIDAndObjId(uid uint64, objId primitive.ObjectID) (data Collect, err error) {
	var query = bson.M{"uid": uid, "objID": objId}
	if err = coll(nil).FindOne(&data, query); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollFindCollectsByUIDAndObjId", table, "FindOne", err),
			log.Any("uid", uid),
		)
		return
	}
	return
}
func QuickList(uid uint64, cType string, skip, limit int64) ([]Collect, int64, error) {
	filter := bson.M{"uid": uid, "type": cType}
	const maxLimit = 450 //iphone 11 一屏显示3项 1页3屏 1页9项 50页450项
	opt := (&options.FindOptions{}).SetLimit(maxLimit)
	var totalList []Collect
	err := coll(nil).Find(&totalList, filter, opt) //取总共的数据 最多1000条
	if err != nil {
		return nil, 0, err
	}
	total := int64(len(totalList))
	if total == 0 {
		return []Collect{}, 0, nil
	}

	//内存中分页 skip + limit ∈ [0, total)
	if skip+limit > total {
		if skip > total {
			return []Collect{}, 0, nil
		}
		limit = total - skip
	}

	list := make([]Collect, 0, limit)
	for i := skip; i < skip+limit; i++ {
		list = append(list, totalList[i])
	}
	return list, total, err
}

// CollFindCountByUID 获取收藏数量
func CollFindCountByUID(uid uint64) (data int64, err error) {
	data, err = coll(nil).Count(bson.M{"uid": uid})
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollFindCountByUID", table, "Count", err), log.Any("uid", uid))
		return
	}
	return
}

// CollFindCountByUidAndType 更具uid/type获取标签数量
func CollFindCountByUidAndType(uid uint64, cType string) (data int64, err error) {
	var query = bson.M{"uid": uid, "type": cType, "videoCount": bson.M{"$gt": 0}}
	if data, err = coll(nil).Count(query); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollFindCountByUidAndType", table, "Count", err),
			log.Any("uid", uid),
			log.Any("cType", cType),
		)
		return
	}
	return
}

// CollFindCollectByTypeAndUID 我的收藏
func CollFindCollectByTypeAndUID(uid uint64, cType string) (cIDs []primitive.ObjectID, total int64, err error) {
	var opt options.FindOptions
	opt.SetSort(bson.M{"_id": -1}).SetLimit(4)
	query := bson.M{"uid": uid, "type": cType}
	var collects []*Collect
	if err = coll(nil).Find(&collects, query, &opt); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollFindCollectByTypeAndUID", table, "Find", err),
			log.Any("uid", uid),
			log.Any("cType", cType),
		)
		return
	}
	for _, v := range collects {
		cIDs = append(cIDs, v.ObjID)
	}
	total, err = coll(nil).Count(query)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CollFindCollectByTypeAndUID", table, "Count", err),
			log.Any("uid", uid),
			log.Any("cType", cType),
		)
		return
	}
	return
}

// CollIsExisted 是否收藏
func CollIsExisted(uid uint64, cType string, objID primitive.ObjectID) (isExists bool, err error) {
	cnt, err := coll(nil).Count(bson.M{"uid": uid, "type": cType, "objID": objID})
	isExists = false
	if err != nil || cnt == 0 {
		return
	}
	isExists = true
	return
}

// 从给定的uniq列表中获取收藏状态映射:uniq->Statue
// uniq通过uniq()获取
func CltStatueMap(uniqList []string) (map[string]bool, error) {
	if len(uniqList) == 0 {
		return make(map[string]bool), nil
	}

	filter := bson.M{
		"uniq": bson.M{"$in": uniqList},
	}
	existCltList := make([]Collect, 0, len(uniqList))
	err := coll(nil).Find(&existCltList, filter)
	if err != nil {
		return nil, err
	}
	m := make(map[string]bool, len(existCltList))
	//初始化
	for _, uniq := range uniqList {
		m[uniq] = false
	}
	//已经收藏的
	for _, v := range existCltList {
		m[v.Uniq] = true
	}
	return m, nil
}

// IsCollectVideos 是否收藏视频
func IsCollectVideos(uid uint64, videoIDs []primitive.ObjectID) (map[primitive.ObjectID]bool, error) {
	m := make(map[primitive.ObjectID]bool)
	videoIDs = uniqueVideoIDs(videoIDs)
	if len(videoIDs) == 0 {
		return m, nil
	}

	var infos []Collect
	query := collectVideoStatusFilter(uid, videoIDs)
	opts := options.Find().SetProjection(bson.M{"_id": 0, "objID": 1})
	if err := coll(nil).Find(&infos, query, opts); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IsCollectVideos", table, "Find", err),
			log.Any("uid", uid),
			log.Any("videoIDs", videoIDs),
		)
		return m, err
	}
	for _, i := range infos {
		m[i.ObjID] = true
	}
	return m, nil
}

func collectVideoStatusFilter(uid uint64, videoIDs []primitive.ObjectID) bson.M {
	return bson.M{
		"uid": uid,
		"type": bson.M{"$in": []string{
			constant.CollectTypeSP,
			constant.CollectTypeShort,
			constant.CollectTypeCover,
			constant.CollectTypePIC,
			constant.CollectTypeSEED_LINK,
			constant.CollectTypeAiPlaza,
		}},
		"objID": bson.M{"$in": videoIDs},
	}
}

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

// GetLocsCollectCnt2Map 获取位置的收藏数
func GetLocsCollectCnt2Map(locIDs []primitive.ObjectID) (map[primitive.ObjectID]int, error) {
	if locIDs == nil {
		locIDs = []primitive.ObjectID{}
	}
	m := make(map[primitive.ObjectID]int)
	var data []CityCount
	p := []bson.M{
		{"$match": bson.M{"type": constant.CollectTypeLocation, "objID": bson.M{"$in": locIDs}}},
		{"$group": bson.M{"_id": "$objID", "count": bson.M{"$sum": 1}}},
	}
	if err := coll(nil).Aggregate(&data, p); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetLocsCollectCnt2Map", table, "Aggregate", err), log.Any("locIDs", locIDs))
		return nil, err
	}
	for _, d := range data {
		m[d.ID] = d.Count
	}
	return m, nil
}

// MyCollectTags 获取收藏标签
func MyCollectTags(uid uint64, top int) ([]primitive.ObjectID, error) {
	var ids []primitive.ObjectID
	stdQuery := commod.StdQuery{Page: &commod.PageBy{Num: 1, Size: uint64(top)}, Order: &[]commod.OrderBy{}}
	data, err := CollFindCollects(uid, constant.CollectTypeTag, stdQuery)
	if err != nil {
		return ids, nil
	}
	for _, d := range data {
		ids = append(ids, d.ObjID)
	}
	return ids, nil
}

// 根据标签id获取收藏列表
func GetCollectTagList(uid uint64, tagsID []primitive.ObjectID) (data []Collect, err error) {
	if tagsID == nil || uid == 0 {
		return
	}
	var query = bson.M{
		"uid":   uid,
		"type":  constant.CollectTypeTag,
		"objID": bson.M{"$in": tagsID},
	}
	err = coll(nil).Find(&data, query)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetCollectTagList", table, "Find", err),
			log.Any("uid", uid),
			log.Any("tagsID", tagsID),
		)
		return
	}
	return
}