package payaudiobookmod

import (
	"fmt"
	"time"

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

	"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.PayAudioBook

// initIndex 初始化索引
func initIndex() {
	many := []mongo.IndexModel{
		{
			Keys:    bson.D{{Key: "uid", Value: 1}, {Key: "objID", Value: 1}},
			Options: options.Index().SetUnique(true),
		},
		{
			Keys: bson.D{{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)
}

// Insert 插入一条购买记录
func Insert(p PayAudioBookHistory, t *db.MongoTool) error {
	now := time.Now()
	f := bson.M{
		"uid":   p.UID,
		"objID": p.ObjID,
	}
	set := bson.M{
		"$addToSet":    bson.M{"episodeNumberSet": bson.M{"$each": p.EpisodeNumberSet}},
		"$set":         bson.M{"updatedAt": now},
		"$setOnInsert": bson.M{"createdAt": now},
	}
	if _, err := coll(t).UpsertOne(f, set); err != nil {
		log.Error("InsertVideoPayRecord error", log.Any("p", p), log.E(err))
		return err
	}
	return nil
}

func FindManyPayAudioBookHistoryByUID(uid uint64) ([]*PayAudioBookHistory, error) {
	vl := make([]*PayAudioBookHistory, 0)
	if err := coll(nil).Find(&vl, bson.M{"uid": uid}); err != nil {
		log.Error("FindManyPayAudioBookHistoryByUID error", log.Any("uid", uid), log.E(err))
		return nil, err
	}
	return vl, nil
}

// 判断当前视频是否有人购买过
func IsVidIfBePay(id primitive.ObjectID) bool {
	var pay *PayAudioBookHistory
	if err := coll(nil).FindOne(&pay, bson.M{"videoID": id}); err != nil {
		log.Error("IsVidIfBePay error", log.Any("videoID", id), log.E(err))
		return false
	}
	return pay != nil
}

// DelVideoPayRecord 删除一条购买记录
func DelVideoPayRecord(videoID primitive.ObjectID, uid uint64) error {
	if _, err := coll(nil).DeleteOne(bson.M{"videoID": videoID, "uid": uid}); err != nil {
		log.Error("DelVideoPayRecord DeleteOne error", log.Any("videoID", videoID), log.Any("uid", uid))
		return err
	}
	return nil
}

func FindByUIDAndObjID(uid uint64, objID primitive.ObjectID) (data PayAudioBookHistory, err error) {
	if err = coll(nil).FindOne(&data, bson.M{"uid": uid, "objID": objID}); err != nil {
		log.Error("FindByUID error", log.Any("uid", uid), log.E(err))
		return
	}
	return
}

func FindByUID(uid uint64, pageNumber int64, pageSize int64) ([]*PayAudioBookHistory, bool, error) {
	data := make([]*PayAudioBookHistory, 0)
	skip := (pageNumber - 1) * pageSize
	limit := pageSize + 1
	opt := options.FindOptions{
		Skip:  &skip,
		Limit: &limit,
		Sort:  bson.D{{Key: "createdAt", Value: -1}},
	}
	if err := coll(nil).Find(&data, bson.M{"uid": uid}, &opt); err != nil {
		log.Error("FindByUID error", log.Any("uid", uid), log.E(err))
		return nil, false, err
	}
	hasNext := false
	if len(data) > int(pageSize) {
		hasNext = true
		data = data[:pageSize]
	}
	return data, hasNext, nil
}