package modulevidmod

import (
	"context"
	"fmt"
	"time"

	"91porn-server/common"
	"91porn-server/common/db"
	"91porn-server/models"
	"91porn-server/models/commod"

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

var mdb *db.MongoDB

const table = models.SectionVideo

// InitIndex 设置index
func initIndex() {
	many := []mongo.IndexModel{
		{
			Keys:    bson.D{{Key: "sectionID", Value: 1}, {Key: "videoID", Value: 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys: bson.D{{Key: "sectionID", Value: 1}, {Key: "sortCode", Value: -1}, {Key: "videoReviewedAt", Value: -1}},
		},
		{
			Keys: bson.D{{Key: "sectionID", Value: 1}, {Key: "newsType", Value: 1}, {Key: "sortCode", Value: -1}, {Key: "videoReviewedAt", Value: -1}},
		},
		// 改类型的时候，需要根据videoID变更newsType
		{
			Keys: bson.D{{Key: "videoID", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "sectionID", Value: 1}, {Key: "createdAt", Value: -1}},
		},
	}
	if _, err := coll(nil).CreateIndex(many); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", table, err))
	}
}

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

// InsertOne 插入一条数据
func InsertOne(p *SectionVideo) error {
	p.CreatedAt = time.Now()
	_, err := coll(nil).InsertOne(p)
	return err
}

func UpdateNewsTypeByVideoID(videoID primitive.ObjectID, newsType string) (err error) {
	filter := bson.M{"videoID": videoID}
	_, err = coll(nil).UpdateOne(filter, bson.M{"$set": bson.M{"newsType": newsType}})
	return err
}

// UpdateOne 更新一条数据
func UpdateOne(set *EditSelector) error {
	set.UpdatedAt = time.Now()
	var filter primitive.M
	if set.ID != nil && !set.ID.IsZero() {
		filter = bson.M{"_id": set.ID}
	} else if set.SectionID != nil && !set.SectionID.IsZero() && set.VideoID != nil && !set.VideoID.IsZero() {
		filter = bson.M{"sectionID": set.SectionID, "videoID": set.VideoID}
	}
	_, err := coll(nil).UpdateOne(filter, bson.M{"$set": set})
	return err
}

// DeleteOne 删除一条数据
func DeleteOne(id primitive.ObjectID) (err error) {
	_, err = coll(nil).DeleteById(id)
	return
}

// BatchDeleteVideo 批量删除专题下视频
func BatchDeleteVideo(ctx context.Context, sectionID primitive.ObjectID, vids []primitive.ObjectID) error {
	_, err := coll(nil).DeleteMany(bson.M{"sectionID": sectionID, "videoID": bson.M{"$in": vids}})
	return err
}

// DeleteManyVideo 批量删除专题下视频
func DeleteManyVideo(ids []primitive.ObjectID) error {
	_, err := coll(nil).DeleteMany(bson.M{"_id": bson.M{"$in": ids}})
	return err
}

// DeleteManyByVids 批量删除专题下视频,根据视频ID
func DeleteManyByVids(vids []primitive.ObjectID) error {
	_, err := coll(nil).DeleteMany(bson.M{"videoID": bson.M{"$in": vids}})
	return err
}

// Search 根据条件检索
func Search(q *QuerySelector, page commod.Page) (videos []SectionVideo, hasNext bool, total int64, err error) {
	filter, err := common.ToBsonM(q)
	if err != nil {
		return
	}
	skip := int64(page.Skip())
	limit := int64(page.Limit() + 1)
	opts := options.FindOptions{
		Skip:  &skip,
		Limit: &limit,
		Sort:  page.GetSort(),
	}
	if err = coll(nil).Find(&videos, filter, &opts); err != nil {
		return
	}
	total, err = coll(nil).Count(filter)
	if uint64(len(videos)) > page.Limit() {
		hasNext = true
		videos = videos[:page.Limit()]
	}
	return
}

// Find 查询所有
func Find(filter primitive.M, opts ...*options.FindOptions) ([]SectionVideo, error) {
	var videos []SectionVideo
	return videos, coll(nil).Find(&videos, filter, opts...)
}

func GetBySectionIDWithPage(sectionID primitive.ObjectID, page commod.Page) (videoIDs []primitive.ObjectID, hasNext bool, err error) {
	projection := bson.D{
		{Key: "_id", Value: 0},
		{Key: "videoID", Value: 1},
	}
	opts := options.FindOptions{}
	size := page.Limit()
	opts.SetProjection(projection).SetSort(page.GetSort()).SetSkip(int64(page.Skip())).SetLimit(int64(size + 1))
	var p []struct {
		VideoID primitive.ObjectID `bson:"videoID"`
	}
	if err = coll(nil).Find(&p, bson.M{"sectionID": sectionID}, &opts); err != nil {
		return
	}
	if uint64(len(p)) > size {
		hasNext = true
		p = p[:size]
	}
	videoIDs = make([]primitive.ObjectID, len(p))
	for i, v := range p {
		videoIDs[i] = v.VideoID
	}
	return
}

// GetSectionVideosBySectionID 根据专题获取视频列表
func GetSectionVideosBySectionID(sectionID primitive.ObjectID) (list []SectionVideo, err error) {
	err = coll(nil).Find(&list, bson.M{"sectionID": sectionID}, options.Find().SetSort(bson.D{{Key: "sortCode", Value: -1}, {Key: "videoReviewedAt", Value: -1}}))
	return
}

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

func GetVideosBySectionIDs(sectionIDs []primitive.ObjectID) (list []SectionVideo, err error) {
	err = coll(nil).Find(&list, bson.M{"sectionID": bson.M{"$in": sectionIDs}})
	return
}

// GetSectionVideosBySectionIDSort 根据专题获取视频列表
func GetSectionVideosBySectionIDSort(sectionID primitive.ObjectID, limit int64) (list []SectionVideo, err error) {
	err = coll(nil).Find(&list, bson.M{"sectionID": sectionID}, options.Find().SetSort(bson.D{{Key: "SortCode", Value: -1}}).SetLimit(limit))
	return
}

func GetBySectionIDAndVids(sectionID primitive.ObjectID, vids []primitive.ObjectID) (videos []SectionVideo, err error) {
	filter := bson.M{"videoID": bson.M{"$in": vids}}
	if !sectionID.IsZero() {
		filter["sectionID"] = sectionID
	}
	err = coll(nil).Find(&videos, filter)
	return
}

func GetBySectionID(sectionID primitive.ObjectID, isSorted bool) (videoIDs []primitive.ObjectID, err error) {
	projection := bson.D{
		{Key: "_id", Value: 0},
		{Key: "videoID", Value: 1},
	}
	opts := options.FindOptions{}
	opts.SetProjection(projection)
	var p []struct {
		VideoID primitive.ObjectID `bson:"videoID"`
	}
	filter := bson.M{"sectionID": sectionID}
	if isSorted {
		filter["sortCode"] = bson.M{"$gt": 0}
		opts.SetSort(bson.D{{Key: "sortCode", Value: -1}, {Key: "videoReviewedAt", Value: -1}})
	}
	if err = coll(nil).Find(&p, filter, &opts); err != nil {
		return
	}
	videoIDs = make([]primitive.ObjectID, len(p))
	for i, v := range p {
		videoIDs[i] = v.VideoID
	}
	return
}

func InsertMany(records []SectionVideo) error {
	opts := options.InsertMany().SetOrdered(false)
	_, err := coll(nil).InsertMany(records, opts)
	if !db.IsMongoDupKey(err) {
		return err
	}
	return nil
}

func GetSectionsByVideoId(id primitive.ObjectID) ([]SectionVideo, error) {
	if id.IsZero() {
		return nil, nil
	}
	var svs []SectionVideo
	return svs, coll(nil).Find(&svs, bson.M{"videoID": id})
}

func GetSectionsByVideoIds(ids []primitive.ObjectID) ([]SectionVideo, error) {
	var svs []SectionVideo
	return svs, coll(nil).Find(&svs, bson.M{"videoID": bson.M{"$in": ids}})
}