package jingangmod

import (
	"91porn-server/app/appg"
	"91porn-server/common"
	"91porn-server/common/constant/redisconst"
	"91porn-server/common/db"
	"91porn-server/common/log"
	"91porn-server/common/redis"
	"91porn-server/models"
	"91porn-server/web/webg"
	"errors"
	"fmt"
	"github.com/vmihailenco/msgpack/v5"
	"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.Jingang

var mdb *db.MongoDB

// InitIndex 设置index
func initIndex() {
	coll := coll(nil)
	many := []mongo.IndexModel{
		{
			Keys: bson.D{{Key: "status", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "sort", Value: -1}},
		},
	}
	if _, err := coll.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)
}

func Init() {
	mdb = db.Init(table)
	initIndex()
}

func GetJGListValid(t *db.MongoTool) ([]*JGModel, error) {
	var jms []*JGModel
	result, err := appg.Redis.Get(redisconst.JanGangQuCacheKey)
	if err != nil {
		log.Error(fmt.Sprintf("JanGangQuCacheKey redis获取数据异常:%v", err))
		return jms, err
	}
	if result == nil {
		opts := options.Find().SetSort(bson.D{{Key: "sort", Value: 1}})
		err := coll(t).Find(&jms, bson.M{"status": 1}, opts)
		if err == nil && len(jms) > 0 {
			if bytes, mErr := msgpack.Marshal(jms); mErr == nil {
				common.Go(func() {
					appg.Redis.Set(redisconst.JanGangQuCacheKey, bytes, redisconst.JanGangQuCacheExpire)
				})
			}
		}

		return jms, err
	}

	if err = msgpack.Unmarshal([]byte(*result), &jms); err != nil {
		log.Error(fmt.Sprintf("JanGangQuCacheKey msgpack Unmarshal err:%v", err))
		return jms, err
	}
	return jms, err
}

func AddJingang(t *db.MongoTool, j JingangModel) (*primitive.ObjectID, error) {
	ir, err := coll(t).InsertOne(j)
	if err != nil {
		return nil, err
	}
	oid, ok := ir.InsertedID.(primitive.ObjectID)
	if !ok {
		return nil, errors.New("unexpected inserted objectid")
	}
	return &oid, nil
}

func EditJingang(t *db.MongoTool, id primitive.ObjectID, update bson.M) error {
	_, err := coll(t).UpdateOne(bson.M{"_id": id}, bson.M{"$set": update})
	return err
}

func DeleteJingang(t *db.MongoTool, id primitive.ObjectID) error {
	_, err := coll(t).DeleteById(id)
	return err
}

func GetAllJingangList(t *db.MongoTool, skip, limit uint64) ([]JingangModel, error) {
	var jms []JingangModel
	opts := options.Find().SetSort(bson.D{{Key: "sort", Value: 1}})
	if skip > 0 {
		opts.SetSkip(int64(skip))
	}
	if limit > 0 {
		opts.SetLimit(int64(limit))
	}
	return jms, coll(t).Find(&jms, bson.M{}, opts)
}

func GetAllJingangCount(t *db.MongoTool) (int64, error) {
	return coll(t).Count(bson.M{})
}

func getRedis() *redis.Client {
	if appg.Redis != nil {
		return appg.Redis
	}
	return webg.Redis
}