package activitymod

import (
	"context"
	"fmt"
	"stat/common/log"
	"stat/common/mongos"

	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

var dbAct *mongos.MongoTool
var dbLotCodeInfo *mongos.MongoTool
var dbLotGift *mongos.MongoTool
var dbLotGetGift *mongos.MongoTool

func Init() {
	ctx := context.Background()
	InitAct(ctx)
	InitLotCodeInfo(ctx)
	InitLotGift(ctx)
	InitLotGiftCode(ctx)
}

func InitAct(ctx context.Context) {
	// 获取数据库表
	dbAct = mongos.New(mongos.MgoManager, TN.ActivityInfo)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys: bson.D{{Key: FN.ActivityInfo.Name, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.ActivityInfo.Enable, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.ActivityInfo.SortCode, Value: -1}},
		},
		{
			Keys: bson.D{
				{Key: FN.ActivityInfo.StartTime, Value: -1},
				{Key: FN.ActivityInfo.EndTime, Value: -1},
			},
		},
	}
	if _, err := dbAct.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.ActivityInfo, err))
	}
}

func InitLotCodeInfo(ctx context.Context) {
	// 获取数据库表
	dbLotCodeInfo = mongos.New(mongos.MgoManager, TN.LottertyCodeInfo)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys: bson.D{{Key: FN.LottertyCodeInfo.LotteryCode, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.LottertyCodeInfo.ActId, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.LottertyCodeInfo.UserIp, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.LottertyCodeInfo.IsUsed, Value: 1}},
		},
	}
	if _, err := dbLotCodeInfo.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.LottertyCodeInfo, err))
	}
}
func InitLotGift(ctx context.Context) {
	// 获取数据库表
	dbLotGift = mongos.New(mongos.MgoManager, TN.LotteryGift)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys: bson.D{{Key: FN.LotteryGift.ActId, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.LotteryGift.GiftName, Value: 1}},
		},
	}
	if _, err := dbLotGift.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.LotteryGift, err))
	}
}

func InitLotGiftCode(ctx context.Context) {
	// 获取数据库表
	dbLotGetGift = mongos.New(mongos.MgoManager, TN.LotteryGetGift)

	// 初始化
	indexes := []mongo.IndexModel{
		{
			Keys: bson.D{{Key: FN.LotteryGetGift.GiftCode, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.LotteryGetGift.AppName, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.LotteryGetGift.ActId, Value: 1}},
		},
		{
			Keys: bson.D{{Key: FN.LotteryGetGift.GiftId, Value: 1}},
		},
	}
	if _, err := dbLotGetGift.CreateIndex(context.Background(), indexes); err != nil {
		panic(fmt.Sprintf("%s model set index err ==>[%+v]", TN.LotteryGetGift, err))
	}
}

//InsertOneActivityInfo 插入一个活动信息
func InsertOneActivityInfo(ctx context.Context, data *ActivityInfo) error {
	if _, err := dbAct.InsertOne(ctx, data); err != nil {
		log.Warn("activitymod:InsertOneActivityInfo db.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

//FindOneActivityInfo 查找一个活动信息
func FindOneActivityInfo(ctx context.Context, filter bson.M) (*ActivityInfo, error) {
	var data ActivityInfo
	if err := dbAct.FindOneEx(ctx, &data, filter); err != nil {
		log.Warn("activitymod:FindOneActivityInfo db.FindOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}

	return &data, nil
}

//DelOneActivityInfo 删除一个活动信息
func DelOneActivityInfo(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbAct.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("activitymod:DelOneActivityInfo db.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateOneActivityInfo 更新一个活动信息
func UpdateOneActivityInfo(ctx context.Context, filter bson.M, update bson.M) error {
	result, err := dbAct.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("activitymod:UpdateOneActivityInfo activitymod:UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	if result.MatchedCount == 0 {
		return mongo.ErrNoDocuments
	}
	return nil
}

//CountActivityInfos 统计活动信息数量
func CountActivityInfos(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbAct.Count(ctx, filter)
	if err != nil {
		log.Warn("activitymod:CountActivityInfos db.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateManyActivityInfo 更新满足条件的活动信息
func UpdateManyActivityInfo(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbAct.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyActivityInfo db.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//FindManyActivityInfo 查找一批活动信息数据
func FindManyActivityInfo(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (ActivityInfoList, error) {
	data := make(ActivityInfoList, 0)
	if err := dbAct.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("activitymod:FindManyActivityInfo db.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

//FindManyActivityInfoWithBind 用自己定义结构查找一批活动信息数据
func FindManyActivityInfoWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOptions) error {
	if err := dbAct.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("activitymod:FindManyActivityInfoWithBind db.Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//InsertOneLottertyCodeInfo 插入一个抽奖码信息
func InsertOneLottertyCodeInfo(ctx context.Context, data *LottertyCodeInfo) error {
	if _, err := dbLotCodeInfo.InsertOne(ctx, data); err != nil {
		log.Warn("activitymod:InsertOneLottertyCodeInfo db.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

//FindOneLottertyCodeInfo 查找一个抽奖码信息
func FindOneLottertyCodeInfo(ctx context.Context, filter bson.M) (*LottertyCodeInfo, error) {
	var data LottertyCodeInfo
	if err := dbLotCodeInfo.FindOneEx(ctx, &data, filter); err != nil {
		log.Warn("LottertyCodeInfo:FindOneLottertyCodeInfo activitymod:FindOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &data, nil
}

//DelOneLottertyCodeInfo 删除一个抽奖码信息
func DelOneLottertyCodeInfo(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbLotCodeInfo.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("LottertyCodeInfo:DelOneLottertyCodeInfo activitymod:DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateOneLottertyCodeInfo 更新一个抽奖码信息
func UpdateOneLottertyCodeInfo(ctx context.Context, filter bson.M, update bson.M) error {
	result, err := dbLotCodeInfo.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("UpdateOneLottertyCodeInfo activitymod:UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	if result.MatchedCount == 0 {
		return mongo.ErrNoDocuments
	}
	return nil
}

//CountLottertyCodeInfos 统计抽奖码信息数量
func CountLottertyCodeInfos(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbLotCodeInfo.Count(ctx, filter)
	if err != nil {
		log.Warn("LottertyCodeInfo:CountLottertyCodeInfos activitymod:Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateManyLottertyCodeInfo 更新满足条件的抽奖码信息
func UpdateManyLottertyCodeInfo(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbLotCodeInfo.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyLottertyCodeInfo activitymod:UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//FindManyLottertyCodeInfo 查找一批抽奖码信息数据
func FindManyLottertyCodeInfo(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (LottertyCodeInfoList, error) {
	data := make(LottertyCodeInfoList, 0)
	if err := dbLotCodeInfo.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("LottertyCodeInfo:FindManyLottertyCodeInfo activitymod:Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

//FindManyLottertyCodeInfoWithBind 用自己定义结构查找一批抽奖码信息数据
func FindManyLottertyCodeInfoWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOptions) error {
	if err := dbLotCodeInfo.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("LottertyCodeInfo:FindManyLottertyCodeInfoWithBind activitymod:Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//InsertOneLotteryGift 插入一个奖品信息
func InsertOneLotteryGift(ctx context.Context, data *LotteryGift) error {
	if _, err := dbLotGift.InsertOne(ctx, data); err != nil {
		log.Warn("activitymod:InsertOneLotteryGift db.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

//FindOneLotteryGift 查找一个奖品信息
func FindOneLotteryGift(ctx context.Context, filter bson.M) (*LotteryGift, error) {
	var data LotteryGift
	if err := dbLotGift.FindOneEx(ctx, &data, filter); err != nil {
		log.Warn("LotteryGift:FindOneLotteryGift dbLotGift.FindOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &data, nil
}

//DelOneLotteryGift 删除一个奖品信息
func DelOneLotteryGift(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbLotGift.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("LotteryGift:DelOneLotteryGift dbLotGift.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateOneLotteryGift 更新一个奖品信息
func UpdateOneLotteryGift(ctx context.Context, filter bson.M, update bson.M) error {
	result, err := dbLotGift.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("UpdateOneLotteryGift dbLotGift.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	if result.MatchedCount == 0 {
		return mongo.ErrNoDocuments
	}
	return nil
}

//CountLotteryGifts 统计奖品信息数量
func CountLotteryGifts(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbLotGift.Count(ctx, filter)
	if err != nil {
		log.Warn("LotteryGift:CountLotteryGifts dbLotGift.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateManyLotteryGift 更新满足条件的奖品信息
func UpdateManyLotteryGift(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbLotGift.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyLotteryGift dbLotGift.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//FindManyLotteryGift 查找一批奖品信息数据
func FindManyLotteryGift(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (LotteryGiftList, error) {
	data := make(LotteryGiftList, 0)
	if err := dbLotGift.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("LotteryGift:FindManyLotteryGift dbLotGift.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

//FindManyLotteryGiftWithBind 用自己定义结构查找一批奖品信息数据
func FindManyLotteryGiftWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOptions) error {
	if err := dbLotGift.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("LotteryGift:FindManyLotteryGiftWithBind dbLotGift.Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//InsertOneLotteryGetGift 插入一个中奖兑换相关信息
func InsertOneLotteryGetGift(ctx context.Context, media *LotteryGetGift) error {
	if _, err := dbLotGetGift.InsertOne(ctx, media); err != nil {
		log.Warn("activitymod:InsertOneLotteryGetGift dbLotGetGift.InsertOne failed", log.E(err))
		return err
	}
	return nil
}

//FindOneLotteryGetGift 查找一个中奖兑换相关信息
func FindOneLotteryGetGift(ctx context.Context, filter bson.M) (*LotteryGetGift, error) {
	var data LotteryGetGift
	if err := dbLotGetGift.FindOneEx(ctx, &data, filter); err != nil {
		log.Warn("LotteryGetGift:FindOneLotteryGetGift dbLotGetGift.FindOne failed",
			log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return &data, nil
}

//DelOneLotteryGetGift 删除一个中奖兑换相关信息
func DelOneLotteryGetGift(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbLotGetGift.DeleteOne(ctx, filter)
	if err != nil {
		log.Warn("LotteryGetGift:DelOneLotteryGetGift dbLotGetGift.DeleteOne failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateOneLotteryGetGift 更新一个中奖兑换相关信息
func UpdateOneLotteryGetGift(ctx context.Context, filter bson.M, update bson.M) error {
	result, err := dbLotGetGift.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Warn("UpdateOneLotteryGetGift dbLotGetGift.UpdateOne failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	if result.MatchedCount == 0 {
		return mongo.ErrNoDocuments
	}
	return nil
}

//CountLotteryGetGifts 统计中奖兑换相关信息数量
func CountLotteryGetGifts(ctx context.Context, filter bson.M) (int64, error) {
	count, err := dbLotGetGift.Count(ctx, filter)
	if err != nil {
		log.Warn("LotteryGetGift:CountLotteryGetGifts dbLotGetGift.Count failed",
			log.E(err), log.Any("filter", filter))
		return 0, err
	}
	return count, nil
}

//UpdateManyLotteryGetGift 更新满足条件的中奖兑换相关信息
func UpdateManyLotteryGetGift(ctx context.Context, filter bson.M, update bson.M) error {
	_, err := dbLotGetGift.UpdateMany(ctx, filter, update)
	if err != nil {
		log.Warn("user:UpdateManyLotteryGetGift dbLotGetGift.UpdateMany failed",
			log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}

//FindManyLotteryGetGift 查找一批渠道中奖兑换相关信息
func FindManyLotteryGetGift(ctx context.Context, filter bson.M, opts ...*options.FindOptions) (LotteryGetGiftList, error) {
	data := make(LotteryGetGiftList, 0)
	if err := dbLotGetGift.Find(ctx, &data, filter, opts...); err != nil {
		log.Warn("LotteryGetGift:FindManyLotteryGetGift dbLotGetGift.Find failed", log.E(err), log.Any("filter", filter))
		return nil, err
	}
	return data, nil
}

//FindManyLotteryGetGiftWithBind 用自己定义结构查找一批渠道中奖兑换相关信息
func FindManyLotteryGetGiftWithBind(ctx context.Context, bind interface{}, filter bson.M, opts ...*options.FindOptions) error {
	if err := dbLotGetGift.Find(ctx, bind, filter, opts...); err != nil {
		log.Warn("LotteryGetGift:FindManyLotteryGetGiftWithBind dbLotGetGift.Find failed", log.E(err), log.Any("filter", filter))
		return err
	}
	return nil
}