package mediamod

import (
	"91porn-server/models"
	"encoding/json"
	"errors"
	"fmt"
	"time"

	"91porn-server/common/db"
	"91porn-server/common/log"

	"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"
)

const table = models.Media

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

func initIndex() {
	many := []mongo.IndexModel{
		{
			Keys: bson.D{{Key: "lsjId", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "sId", Value: 1}, {Key: "sortCode", Value: -1}, {Key: "createdAt", Value: -1}},
		},
		{
			Keys: bson.D{{Key: "sId", Value: 1}, {Key: "sectionSort", Value: -1}, {Key: "createdAt", Value: -1}},
		},
		{
			Keys: bson.D{{Key: "tags", Value: 1}},
		}, {
			Keys: bson.D{{Key: "tags", Value: 1}, {"isDelete", 1}, {"status", 1}, {"hot", -1}, {"createdAt", -1}},
		}, {
			Keys: bson.D{{Key: "tags", Value: 1}, {"isDelete", 1}, {"status", 1}, {"countCollect", -1}, {"createdAt", -1}},
		}, {
			Keys: bson.D{{Key: "tags", Value: 1}, {"isDelete", 1}, {"status", 1}, {"countBrowse", -1}, {"createdAt", -1}},
		}, {
			Keys: bson.D{{Key: "tags", Value: 1}, {"isDelete", 1}, {"status", 1}, {"createdAt", -1}},
		},
		{
			Keys: bson.D{{Key: "kind", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "isActive", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "specialSubjectID", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "updatedAt", Value: -1}},
		},
		{
			Keys: bson.D{{Key: "createdAt", Value: -1}},
		},
		{
			Keys: bson.D{{Key: "mediaContentId", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "title", Value: 1}},
		}, { // 年度排行需要
			Keys: bson.D{{Key: "mediaType", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {"countBrowse", -1}, {Key: "createdAt", Value: -1}},
		}, {
			Keys: bson.D{{Key: "sId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "createdAt", Value: -1}},
		}, {
			Keys: bson.D{{Key: "sId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "countLike", Value: -1}, {Key: "createdAt", Value: -1}},
		}, {
			Keys: bson.D{{Key: "sId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "countCollect", Value: -1}, {Key: "createdAt", Value: -1}},
		}, {
			Keys: bson.D{{Key: "sId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "countBrowse", Value: -1}, {Key: "createdAt", Value: -1}},
		}, {
			Keys: bson.D{{Key: "sId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "hot", Value: -1}, {Key: "createdAt", Value: -1}},
		},
		// 首页优化
		{
			Keys: bson.D{{Key: "mId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "createdAt", Value: -1}},
		}, {
			Keys: bson.D{{Key: "mId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "countLike", Value: -1}, {Key: "createdAt", Value: -1}},
		}, {
			Keys: bson.D{{Key: "mId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "countBrowse", Value: -1}, {Key: "createdAt", Value: -1}},
		}, {
			Keys: bson.D{{Key: "mId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "countCollect", Value: -1}, {Key: "createdAt", Value: -1}},
		}, {
			Keys: bson.D{{Key: "mId", Value: 1}, {Key: "status", Value: 1}, {"isDelete", 1}, {Key: "hot", Value: -1}, {Key: "createdAt", Value: -1}},
		},
		{
			Keys: bson.D{{Key: "mId", Value: 1}, {Key: "sortCode", Value: -1}, {Key: "createdAt", Value: -1}},
		},
		{
			Keys: bson.D{
				{Key: "mId", Value: 1},
				{Key: "status", Value: 1},
				{Key: "isDelete", Value: 1},
				{Key: "latestPublishedAt", Value: -1},
				{Key: "contentUpdateTime", Value: -1},
				{Key: "createdAt", Value: -1},
				{Key: "_id", Value: -1},
			},
		},
	}
	if _, err := coll(nil).CreateIndex(many); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
	}
}

// Init 初始化索引
func Init() {
	mdb = db.Init(table)
	initIndex()
}

// GetList 获取列表
func GetList(cond bson.M, skip, limit int64, sort bson.D) (res []*Media, hasNext bool, err error) {
	opts := options.Find()
	if len(sort) > 0 {
		opts.SetSort(sort)
	}
	opts = opts.SetSort(sort).SetSkip(skip).SetLimit(limit + 1)
	if err = coll(nil).Find(&res, cond, opts); err != nil {
		return
	}
	// 判断下一页
	if len(res) > int(limit) {
		hasNext = true
		res = res[:limit]
	}

	return
}

// QueryAllList 分页查询文档
func QueryAllList(filter primitive.M, opts ...*options.FindOptions) (out []*Media, err error) {
	if err = coll(nil).Find(&out, filter, opts...); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryAllList", table, "Find", err),
			log.Any("filter", filter),
			log.Any("opts", opts),
		)
		return nil, err
	}
	return
}

// QueryAllCount 查询文档条目数
func QueryAllCount(filter primitive.M) (int64, error) {
	if count, err := coll(nil).Count(filter); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryAllCount", table, "Count", err),
			log.Any("filter", filter),
		)
		return 0, err
	} else {
		return count, nil
	}
}

// GetLatestIDForESSync 固定本轮同步的 ID 上界，仅读取已有主键索引。
func GetLatestIDForESSync() (primitive.ObjectID, error) {
	var data []*Media
	opts := options.Find().SetSort(bson.D{{Key: "_id", Value: -1}}).
		SetProjection(bson.M{"_id": 1}).SetHint("_id_").SetLimit(1).SetMaxTime(30 * time.Second)
	if err := coll(nil).Find(&data, bson.M{}, opts); err != nil {
		return primitive.NilObjectID, err
	}
	if len(data) == 0 {
		return primitive.NilObjectID, nil
	}
	return data[0].ID, nil
}

// GetListForESSync 不限制更新时间上界，防止浏览等持续更新使记录逃出同步窗口。
// 使用稳定的 ID 游标，避免修改 updateTime 导致 skip 分页漏数据。
func GetListForESSync(since time.Time, after, maxID primitive.ObjectID, size int) (data []*Media, err error) {
	query := bson.M{
		"updateTime": bson.M{"$gte": since},
		"_id":        bson.M{"$gt": after, "$lte": maxID},
	}
	opts := options.Find().SetSort(bson.D{{Key: "_id", Value: 1}}).
		SetHint("_id_").SetLimit(int64(size)).SetMaxTime(30 * time.Second)
	err = coll(nil).Find(&data, query, opts)
	return
}

var MediaNotFound = errors.New("media not found")

// GetInfoByMediaCenterId 通过mediaCenterId获取详细信息
func GetInfoByMediaCenterId(mediaCenterId uint) (Media, error) {
	v := Media{}
	if err := coll(nil).FindOne(&v, bson.M{"mediaCenterId": mediaCenterId, "isDelete": false}); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInfoByMediaCenterId", table, "FindOne", err),
			log.Any("mediaCenterId", mediaCenterId),
		)
		return v, err
	}

	if v.ID.IsZero() {
		return v, MediaNotFound
	}

	return v, nil
}

// GetInfoByTitle 通过标题获取详细信息
func GetInfoByTitle(title string) (Media, error) {
	v := Media{}
	if err := coll(nil).FindOne(&v, bson.M{"title": title, "isDelete": false}); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInfoByTitle", table, "FindOne", err),
			log.Any("title", title),
		)
		return v, err
	}

	if v.ID.IsZero() {
		return v, MediaNotFound
	}

	return v, nil
}

// GetInfo 通过id获取详细信息
func GetInfo(id primitive.ObjectID) (Media, error) {
	v := Media{}
	if err := coll(nil).FindOne(&v, bson.M{"_id": id}); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetInfo", table, "FindOne", err),
			log.Any("id", id),
		)
		return v, err
	}

	if v.ID.IsZero() {
		return v, errors.New("record not found")
	}

	return v, nil
}

func GetListByIds(ids []primitive.ObjectID) (list []Media, res map[primitive.ObjectID]Media, err error) {
	if err := coll(nil).Find(&list, bson.M{"_id": bson.M{"$in": ids}}); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetListByIds", table, "Find", err),
			log.Any("ids", ids),
		)
		return nil, nil, err
	}
	res = make(map[primitive.ObjectID]Media)
	for _, v := range list {
		res[v.ID] = v
	}
	return list, res, nil
}

// IncreaseCountLikeByIDs 更新媒体点赞数
func IncreaseCountLikeByIDs(value int, ids ...primitive.ObjectID) (err error) {
	var query = bson.M{}
	if len(ids) == 1 {
		query["_id"] = ids[0]
	} else {
		query["_id"] = bson.M{"$in": ids}
	}
	if _, err = coll(nil).UpdateOne(query, bson.M{"$inc": bson.M{"countLike": value}}); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IncreaseLikeCountByID", table, "UpdateOne", err),
			log.Any("id", ids),
			log.Any("value", value),
		)
		return
	}
	return
}

// IncreaseCountShareByID 累计短剧真实分享次数，供推荐互动分计算。
func IncreaseCountShareByID(id primitive.ObjectID, value int) error {
	_, err := coll(nil).UpdateOne(bson.M{"_id": id, "mediaType": MediaTypeDrama}, bson.M{"$inc": bson.M{"countShare": value}})
	return err
}

// IncrCommentCountByID 更新媒体评论数
func IncrCommentCountByID(id primitive.ObjectID, value int) (err error) {
	if _, err = coll(nil).UpdateOne(bson.M{"_id": id}, bson.M{"$inc": bson.M{"countComment": value}}); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IncrCommentCountByID", table, "UpdateOne", err),
			log.Any("id", id),
			log.Any("value", value),
		)
		return
	}
	return
}

// QueryMediaByID 查询文档
func QueryMediaByID(filter primitive.M) (out *Media, err error) {
	if err = coll(nil).FindOne(&out, filter); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryAllList", table, "Find", err),
			log.Any("filter", filter),
		)
		return nil, err
	}
	return
}

// QueryMediaByCond 查询文档
func QueryMediaByCond(filter primitive.M, opts *options.FindOptions) (out []*Media, err error) {
	if err = coll(nil).Find(&out, filter, opts); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "QueryAllList", table, "Find", err),
			log.Any("filter", filter),
		)
		return nil, err
	}
	return
}

// Insert 插入记录
func Insert(t *db.MongoTool, d Media) (data primitive.ObjectID, err error) {
	normalizeLatestPublishedAt(&d)
	result, err := coll(t).InsertOne(&d)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Insert", table, "InsertOne", err))
		return
	}
	byteID, err := json.Marshal(result.InsertedID)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Insert", table, "Marshal", err))
		return
	}
	if err = data.UnmarshalJSON(byteID); err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Insert", table, "UnmarshalJSON", err))
		return
	}
	return
}

func InsertMany(c []Media) error {
	for i := range c {
		normalizeLatestPublishedAt(&c[i])
	}
	if _, err := coll(nil).InsertMany(c); err != nil {
		log.Warn(fmt.Sprintf("METHOD-%s==> Model %s %s fail error:%+v:", "InsertMany", table, "InsertMany", err))
		return err
	}
	return nil
}

func normalizeLatestPublishedAt(media *Media) {
	if media == nil || media.Status != 1 || !media.LatestPublishedAt.IsZero() {
		return
	}
	switch {
	case !media.ContentUpdateTime.IsZero():
		media.LatestPublishedAt = media.ContentUpdateTime
	case !media.UpdateTime.IsZero():
		media.LatestPublishedAt = media.UpdateTime
	case !media.CreatedAt.IsZero():
		media.LatestPublishedAt = media.CreatedAt
	default:
		media.LatestPublishedAt = time.Now()
	}
}

// UpdateByID 根据id更新数据
func UpdateByID(t *db.MongoTool, id primitive.ObjectID, data map[string]interface{}) (int64, error) {
	cond := bson.M{"_id": id}
	return update(t, cond, data)
}

// UpdateByIDS 根据ids更新数据
func UpdateByIDS(t *db.MongoTool, ids []primitive.ObjectID, data map[string]interface{}) (int64, error) {
	cond := bson.M{"_id": bson.M{"$in": ids}}
	return update(t, cond, data)
}

// SectionVideosBySectionID 根据专题获取视频列表
func SectionVideosBySectionID(sectionID primitive.ObjectID, opts *options.FindOptions) ([]*Media, error) {
	var out []*Media
	return out, coll(nil).Find(&out, bson.M{"sId": sectionID, "isDelete": false, "status": 1}, opts)
}

type SectionWorkCount struct {
	SectionID primitive.ObjectID `bson:"_id"`
	Count     int64              `bson:"count"`
}

// CountActiveDramaBySectionIDs groups all visible short dramas for one bounded topic page.
func CountActiveDramaBySectionIDs(sectionIDs []primitive.ObjectID) (map[primitive.ObjectID]int64, error) {
	counts := make(map[primitive.ObjectID]int64, len(sectionIDs))
	if len(sectionIDs) == 0 {
		return counts, nil
	}
	var rows []SectionWorkCount
	err := coll(nil).Aggregate(&rows, []bson.M{
		{"$match": bson.M{"sId": bson.M{"$in": sectionIDs}, "mediaType": MediaTypeDrama, "status": 1, "isDelete": false}},
		{"$group": bson.M{"_id": "$sId", "count": bson.M{"$sum": 1}}},
	})
	if err != nil {
		return nil, err
	}
	for _, row := range rows {
		counts[row.SectionID] = row.Count
	}
	return counts, nil
}

// ListActiveDramaByInteractionScore computes the full-history ranking in MongoDB
// and only returns the requested page. The formula is:
// likes + collections*2 + comments*3 + shares*5.
func ListActiveDramaByInteractionScore(skip, limit int64) ([]*Media, error) {
	if skip < 0 {
		skip = 0
	}
	if limit <= 0 || limit > 101 {
		limit = 21
	}
	var list []*Media
	pipeline := []bson.M{
		{"$match": bson.M{"mediaType": MediaTypeDrama, "status": 1, "isDelete": false}},
		{"$addFields": bson.M{"_dramaInteractionScore": bson.M{"$add": []any{
			bson.M{"$ifNull": []any{"$countLike", 0}},
			bson.M{"$multiply": []any{bson.M{"$ifNull": []any{"$countCollect", 0}}, 2}},
			bson.M{"$multiply": []any{bson.M{"$ifNull": []any{"$countComment", 0}}, 3}},
			bson.M{"$multiply": []any{bson.M{"$ifNull": []any{"$countShare", 0}}, 5}},
		}}}},
		{"$sort": bson.D{{Key: "_dramaInteractionScore", Value: -1}, {Key: "latestPublishedAt", Value: -1}, {Key: "_id", Value: -1}}},
		{"$skip": skip},
		{"$limit": limit},
		{"$project": bson.M{"_dramaInteractionScore": 0}},
	}
	err := coll(nil).Aggregate(&list, pipeline, options.Aggregate().SetAllowDiskUse(true))
	return list, err
}

// update 更新数据
func update(t *db.MongoTool, cond primitive.M, data map[string]interface{}) (int64, error) {
	result, err := coll(t).UpdateMany(cond, bson.M{"$set": bson.M(data)})
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Update", table, "UpdateMany", err),
			log.Any("cond", cond),
			log.Any("update", data),
		)
		return 0, err
	}

	return result.ModifiedCount, nil
}

// DeleteByID 删除数据
func DeleteByID(t *db.MongoTool, id primitive.ObjectID) error {
	_, err := coll(t).UpdateOne(bson.M{"_id": id}, bson.M{"$set": bson.M{"isDelete": true}})
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil
		} else {
			log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "DeleteByID", table, "DeleteMany", err), log.Any("id", id))
		}
	}

	return err
}

// IncCollectCount 收藏次数增加
func IncCollectCount(id ObjectID, inc int) error {
	query := bson.M{"_id": id}
	update := bson.M{"$set": bson.M{"updateTime": time.Now()}, "$inc": bson.M{"countCollect": inc}}
	_, err := coll(nil).UpdateOne(query, update)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IncCollectCount", table, "UpdateOne", err),
			log.Any("id", id),
		)
		return err
	}
	return nil
}

// IncContentPurchasesCount 子集购买次数增加
func IncContentPurchasesCount(id ObjectID, inc int) error {
	query := bson.M{"_id": id}
	update := bson.M{"$set": bson.M{"updateTime": time.Now()}, "$inc": bson.M{"countContentPurchases": inc}}
	_, err := coll(nil).UpdateOne(query, update)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IncPurchasesCount", table, "UpdateOne", err),
			log.Any("id", id),
		)
		return err
	}
	return nil
}

// IncPurchasesCount 购买次数增加
func IncPurchasesCount(id ObjectID, inc int) error {
	return IncPurchasesCountWithTool(nil, id, inc)
}

func IncPurchasesCountWithTool(t *db.MongoTool, id ObjectID, inc int) error {
	query := bson.M{"_id": id}
	update := bson.M{"$set": bson.M{"updateTime": time.Now()}, "$inc": bson.M{"countPurchases": inc}}
	_, err := coll(t).UpdateOne(query, update)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IncPurchasesCount", table, "UpdateOne", err),
			log.Any("id", id),
		)
		return err
	}
	return nil
}

// IncBrowseCount 浏览次数增加
func IncBrowseCount(id ObjectID, inc int) error {
	query := bson.M{"_id": id}
	update := bson.M{"$set": bson.M{"updateTime": time.Now()}, "$inc": bson.M{"countBrowse": inc}}
	_, err := coll(nil).UpdateOne(query, update)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IncBrowseCount", table, "UpdateOne", err),
			log.Any("id", id),
		)
		return err
	}
	return nil
}

func Bulk(models []mongo.WriteModel) error {
	_, err := coll(nil).Bulk(models, options.BulkWrite().SetOrdered(false))
	return err
}

func GetListByLsjIds(lsjIds []string) ([]Media, error) {
	filter := bson.M{
		"lsjId": bson.M{"$in": lsjIds},
	}
	var ms []Media
	return ms, coll(nil).Find(&ms, filter)
}

func GetListByLsjId(lsjId string) (Media, error) {
	filter := bson.M{
		"lsjId": lsjId,
	}
	var ms Media
	return ms, coll(nil).FindOne(&ms, filter)
}

// UpdateMany 根据ids更新数据
func UpdateMany(t *db.MongoTool, filter bson.M, data bson.M) (int64, error) {
	result, err := coll(t).UpdateMany(filter, data)
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "Update", table, "UpdateMany", err),
			log.Any("cond", filter),
			log.Any("update", data),
		)
		return 0, err
	}

	return result.ModifiedCount, nil
}

// FindForReviewBatch 按 _id 游标分页扫描上架 Media，用于内容审查任务
// 仅扫描 status=1（上架）
func FindForReviewBatch(lastID primitive.ObjectID, limit int64) ([]*Media, error) {
	cond := bson.M{"status": 1}
	if !lastID.IsZero() {
		cond["_id"] = bson.M{"$gt": lastID}
	}
	opts := options.Find().
		SetSort(bson.D{{Key: "_id", Value: 1}}).
		SetLimit(limit)
	var list []*Media
	if err := coll(nil).Find(&list, cond, opts); err != nil {
		return nil, err
	}
	return list, nil
}

// CountForReview 上架 Media 总数；条件与 FindForReviewBatch 保持一致
func CountForReview() (int64, error) {
	return coll(nil).Count(bson.M{"status": 1})
}

// UpdateForReview 内容审查通过后回写文本字段
// title 对应 Media.Title，content 对应 Media.Summary
func UpdateForReview(id primitive.ObjectID, title, content string) error {
	set := bson.M{}
	if title != "" {
		set["title"] = title
	}
	if content != "" {
		set["summary"] = content
	}
	if len(set) == 0 {
		return nil
	}
	set["updateTime"] = time.Now()
	_, err := coll(nil).UpdateOne(bson.M{"_id": id}, bson.M{"$set": set})
	return err
}

// OffShelfManyForReview 内容审查命中后批量下架 Media（status -> 0）
// 仅当前 status=1 的会被改动
func OffShelfManyForReview(ids []primitive.ObjectID) error {
	if len(ids) == 0 {
		return nil
	}
	_, err := coll(nil).UpdateMany(
		bson.M{"_id": bson.M{"$in": ids}, "status": 1},
		bson.M{"$set": bson.M{"status": 0, "updateTime": time.Now()}},
	)
	return err
}