/*
 * @Description: In User Settings Edit
 * @Author: your name
 * @Date: 2019-08-29 19:55:45
 * @LastEditTime: 2019-08-30 19:39:56
 * @LastEditors: Please set LastEditors
 */
package txnmod

import (
	"fmt"
	"math"
	"time"

	"91porn-server/common/db"
	"91porn-server/common/log"
	"91porn-server/common/pageopt"
	"91porn-server/common/timeutil"
	"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"
)

const table = models.Transaction

// InitIndex 设置index
func initIndex() {
	coll := coll(nil)
	many := []mongo.IndexModel{
		{
			Keys: bson.D{{Key: "uid", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "purchaseOrder", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "uid", Value: 1}, {Key: "createdAt", Value: -1}},
		},
		{
			Keys: bson.D{{Key: "amount", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "actualAmount", Value: 1}},
		},
		{
			Keys: bson.D{{Key: "createdAt", Value: 1}},
		},
		{
			Keys:    bson.D{{Key: "uniqueOrder", Value: 1}},
			Options: options.Index().SetSparse(true).SetUnique(true),
		},

		{
			Keys: bson.D{{Key: "tranType", Value: 1}, {Key: "createdAt", Value: -1}},
			//	Options: options.Index().SetUnique(true).SetSparse(true),
		},
		{
			Keys:    bson.D{{Key: "tranType", Value: 1}, {Key: "districtCode", Value: 1}, {Key: "promSeqe", Value: 1}, {Key: "createdAt", Value: -1}},
			Options: options.Index().SetSparse(true),
		},
		{
			Keys:    bson.D{{Key: "tranType", Value: 1}, {Key: "districtCode", Value: 1}, {Key: "promSeqe", Value: 1}, {Key: "sysType", Value: 1}, {Key: "createdAt", Value: -1}},
			Options: options.Index().SetSparse(true),
		},
		{
			Keys: bson.D{{Key: "tranTypeInt", Value: 1}, {Key: "createdAt", Value: -1}},
		},
		{
			Keys:    bson.D{{Key: "tranTypeInt", Value: 1}, {Key: "districtCode", Value: 1}, {Key: "promSeqe", Value: 1}, {Key: "createdAt", Value: -1}},
			Options: options.Index().SetSparse(true),
		},
		{
			Keys:    bson.D{{Key: "tranTypeInt", Value: 1}, {Key: "districtCode", Value: 1}, {Key: "promSeqe", Value: 1}, {Key: "sysType", Value: 1}, {Key: "createdAt", Value: -1}},
			Options: options.Index().SetSparse(true),
		},
		{
			Keys:    bson.D{{Key: "isDirect", Value: 1}, {Key: "createdAt", Value: -1}},
			Options: options.Index().SetSparse(true),
		},

		{
			Keys:    bson.D{{Key: "uid", Value: 1}, {Key: "tranTypeInt", Value: 1}, {Key: "money", Value: 1}, {Key: "fruitCoin", Value: 1}, {Key: "createdAt", Value: -1}},
			Options: options.Index().SetSparse(true),
		},
		{
			Keys:    bson.D{{Key: "deductType", Value: 1}, {Key: "createdAt", Value: -1}},
			Options: options.Index().SetSparse(true),
		},
	}
	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)
}

// Insert 新增
func InsertTransactionLog(mt *db.MongoTool, t *TransactionLog) error {
	//Insert  插入一条交易流水
	t.CreatedAt = time.Now()
	if _, err := coll(mt).InsertOne(t); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "InsertTransactionLog", table, "InsertOne", err))
		return err
	}
	return nil
}

func InsertManyTransactionLog(mt *db.MongoTool, trans []TransactionLog) error {
	ops := options.InsertMany().SetOrdered(false)
	if _, err := coll(mt).InsertMany(trans, ops); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "InsertTransactionLog", table, "InsertOne", err))
		return err
	}
	return nil
}

// FindMany 查询所有
func FindTransactionLogs(filter bson.M, opts *options.FindOptions) (total int64, data []*TransactionLog, err error) {
	data = make([]*TransactionLog, 0)
	if err = coll(nil).Find(&data, filter, opts); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindTransactionLogs", table, "Find", err),
			log.Any("filter", filter),
		)
		return
	}
	total, err = coll(nil).Count(filter)
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindTransactionLogs", table, "Count", err),
			log.Any("filter", filter),
		)
	}
	return
}

// getTotalCnt 获取标签视频总数
func getTotalCnt(cond bson.M) (int64, error) {
	total, err := coll(nil).Count(cond)
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "getTotalCnt", table, "Count", err),
			log.Any("cond", cond),
		)
		return 0, err
	}
	return total, nil
}

// GetSkipSize 计算跳转
func getSkipSize(page, size uint64, cond bson.M) (uint64, uint64, int64, error) {
	total, err := getTotalCnt(cond)
	if err != nil {
		return 0, 0, 0, err
	}
	totalpages := uint64(math.Ceil(float64(total) / float64(size)))
	if page > totalpages {
		page = totalpages
	}
	if page < 1 {
		page = 1
	}
	return (page - 1) * size, totalpages, total, nil
}

// GetCoinLogs 条件获取金币日志(时间倒序)
func GetCoinLogs(page, size uint64, cond map[string]interface{}) ([]*TransactionLog, uint64, int64, error) {
	if !hasLedgerUID(bson.M(cond)) {
		// Preserve the existing global listing and export path until the fund
		// collection has an approved index for cross-user time queries.
		skip, totalPages, total, err := getSkipSize(page, size, bson.M(cond))
		if err != nil {
			return nil, 0, 0, err
		}
		opts := options.Find().SetSort(bson.D{{Key: "createdAt", Value: -1}}).
			SetSkip(int64(skip)).SetLimit(int64(size))
		var rows []*TransactionLog
		err = coll(nil).Find(&rows, bson.M(cond), opts)
		return rows, totalPages, total, err
	}
	return getLedgerCoinLogs(page, size, bson.M(cond))
}

func GetTranTypes() (data []interface{}, err error) {
	data, err = coll(nil).Distinct("tranType", bson.M{})
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetTranTypes", table, "Distinct", err))
		return nil, err
	}
	for _, kind := range []string{AiGirlfriendTransferIn.Key(), AiGirlfriendTransferOut.Key()} {
		found := false
		for _, existing := range data {
			if existing == kind {
				found = true
				break
			}
		}
		if !found {
			data = append(data, kind)
		}
	}
	return
}

// FindManyByTime 查询所有
func FindManyByTime(uid uint64, start time.Time, end time.Time) (data []*TransactionLog, err error) {
	data = make([]*TransactionLog, 0)
	opts := options.FindOptions{
		Sort: bson.D{{Key: "createdAt", Value: -1}},
	}
	if err = coll(nil).Find(&data, bson.M{"uid": uid, "createdAt": bson.M{"$gte": start, "$lt": end}}, &opts); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindManyByTime", table, "Find", err),
			log.Any("uid", uid),
			log.Any("start", start),
			log.Any("end", end),
		)
		return
	}
	return
}

// HasNext 查询所有
func HasNext(uid uint64, start time.Time) (hasNext bool, err error) {
	var data TransactionLog
	if err = coll(nil).FindOne(&data, bson.M{"uid": uid, "createdAt": bson.M{"$lt": start}}); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "HasNext", table, "FindOne", err),
			log.Any("uid", uid),
			log.Any("start", start),
		)
		return
	}
	return !data.ID.IsZero(), err
}

// LastTime 查询所有
func LastTime(uid uint64, end time.Time) (data TransactionLog, err error) {
	opt := options.FindOneOptions{
		Sort: bson.D{{Key: "createdAt", Value: -1}},
	}
	if err = coll(nil).FindOne(&data, bson.M{"uid": uid, "createdAt": bson.M{"$lt": end}}, &opt); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "LastTime", table, "FindOne", err),
			log.Any("uid", uid),
			log.Any("end", end),
		)
		return
	}
	return data, nil
}

func GetBuyVipCountMapByHour(discCode string, start, end time.Time, mats ...Matcher) ([]int, map[int]int64, int64, error) {
	payVIP := PayVIP.Key()
	mats = append(mats,
		(&TranTypeMatch{&payVIP}).New(),
		(&DistrictCodeMatch{&discCode}).New(),
		(&CreatedAtGTEAndLTMatch{GTE: &start, LT: &end}).New())
	filter := pageopt.MergeM(mats)
	opt := (&options.FindOptions{}).SetProjection(M{
		"createdAt": 1,
	})
	var list []struct {
		CreatedAt time.Time `bson:"createdAt"` //创建时间
	}
	if err := coll(nil).Find(&list, filter, opt); err != nil {
		log.Error("txnmod GetBuyVipCountMap error", log.E(err))
		return nil, nil, 0, err
	}
	m := make(map[int]int64)
	startH := start.Hour()
	lastH := end.Hour() + (end.Day()-start.Day())*24
	hs := make([]int, lastH-startH+1)
	for i, j := startH, 0; i <= lastH; i++ {
		hs[j] = i
		m[i] = 0
		j++
	}
	var total int64
	for _, v := range list {
		hour := v.CreatedAt.Hour() + (v.CreatedAt.Day()-start.Day())*24
		m[hour] += 1
		total++
	}
	return hs, m, total, nil
}

// FindIncome 查询所有
func FindIncome(uid uint64, pageNumebr, pageSize uint64) (data []*TransactionLog, hasNext bool, err error) {
	data = make([]*TransactionLog, 0)
	f := bson.M{"uid": uid, "actualAmount": bson.M{"$gt": 0}}
	skip := int64(pageSize * (pageNumebr - 1))
	limit := int64(pageSize + 1)
	opts := options.FindOptions{
		Skip:  &skip,
		Limit: &limit,
		Sort:  bson.D{{Key: "createdAt", Value: -1}},
	}
	if err = coll(nil).Find(&data, f, &opts); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindTransactionLogs", table, "Find", err),
			log.Any("filter", f),
		)
		return
	}
	if len(data) > int(pageSize) {
		hasNext = true
		data = data[:pageSize]
	}
	return
}

// FindPoxyIncomeOfMonth 查询每月收益
func FindPoxyIncomeOfMonth(uid uint64) (totalMoney int64, totalPerfomance int64, err error) {
	firstDay, lastDay := timeutil.MonthStartEndTime(time.Now())
	pipelines := []bson.M{
		{"$match": bson.M{"uid": uid, "tranTypeInt": ProxyIncome, "createdAt": bson.M{"$gte": firstDay, "$lt": lastDay}}},
		{"$group": bson.M{"_id": nil, "totalMoney": bson.M{"$sum": "$actualAmount"}, "totalPerformance": bson.M{"$sum": "$performance"}}},
		{"$project": bson.M{"totalMoney": 1, "totalPerformance": 1}},
	}
	type res struct {
		TotalMoney       int64 `bson:"totalMoney"`
		TotalPerformance int64 `bson:"totalPerformance"`
	}
	data := make([]res, 0)
	if err = coll(nil).Aggregate(&data, pipelines); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindIncomeOfMonth", table, "Aggregate", err), log.Any("uid", uid))
		return
	}
	if len(data) > 0 {
		totalMoney = data[0].TotalMoney
		totalPerfomance = data[0].TotalPerformance
	}
	return
}

// FindTransactionLogsByTransType 查询所有
func FindTransactionLogsByTransType(uid uint64, pageNumber int64, pageSize int64, tranType TransType) (data []*TransactionLog, hasNext bool, err error) {
	data = make([]*TransactionLog, 0)
	skip := (pageNumber - 1) * pageSize
	limit := pageSize + 1
	opts := options.FindOptions{
		Skip:  &skip,
		Limit: &limit,
		Sort:  bson.D{{Key: "createdAt", Value: -1}},
	}
	if err = coll(nil).Find(&data, bson.M{"uid": uid, "tranTypeInt": tranType}, &opts); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindTransactionLogsByTransType", table, "Find", err), log.Any("uid", uid))
		return
	}
	if len(data) > int(pageSize) {
		hasNext = true
		data = data[:pageSize]
	}
	return
}

// GetProxyIncomeForToday 查询所有
func GetProxyIncomeForToday(uid uint64, start time.Time, end time.Time) (data []AgentIncomeRes, err error) {
	pipelines := []bson.M{
		{"$match": bson.M{"uid": uid, "tranTypeInt": ProxyIncome, "createdAt": bson.M{"$gte": start, "$lt": end}}},
		{"$group": bson.M{"_id": "$agentLevel", "totalAmount": bson.M{"$sum": "$actualAmount"}, "totalPerformance": bson.M{"$sum": "$performance"}}},
		{"$project": bson.M{"totalAmount": 1, "totalPerformance": 1}},
	}
	data = make([]AgentIncomeRes, 0)
	if err = coll(nil).Aggregate(&data, pipelines); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetProxyIncomeOfDay", table, "Find", err), log.Any("uid", uid))
		return
	}
	return
}

// GetIncomeByType 查询所有
func GetIncomeByType(uid uint64, tp TransType, start time.Time, end time.Time) (totalAmount float64, totalPer int64, err error) {
	match := bson.M{"uid": uid, "tranTypeInt": tp, "createdAt": bson.M{"$gte": start, "$lt": end}}
	log.Info(fmt.Sprintf("%v", match))
	pipelines := []bson.M{
		{"$match": match},
		{"$group": bson.M{"_id": nil, "totalAmount": bson.M{"$sum": "$actualAmount"}, "totalPerformance": bson.M{"$sum": "$performance"}}},
		{"$project": bson.M{"totalAmount": 1, "totalPerformance": 1}},
	}
	var res struct {
		TotalAmount      float64 `bson:"totalAmount"`
		TotalPerformance int64   `bson:"totalPerformance"`
	}
	if err = coll(nil).AggregateDecode(&res, pipelines); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "GetProxyIncomeOfDay", table, "Find", err), log.Any("uid", uid))
		return
	}
	totalAmount = res.TotalAmount
	totalPer = res.TotalPerformance
	return
}

// IsProxyExist 代理分成是否存在
func IsProxyExist(uid uint64, objId primitive.ObjectID) bool {
	filter := bson.M{"uid": uid, "purchaseOrder": objId, "tranType": ProxyIncome.Key()}
	count, err := coll(nil).Count(filter)
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IsProxyExist", table, "Count", count), log.Any("uid", uid), log.Any("objId", objId))
		//查询异常的时候, 默认不分成, 用户找来可以人工修复, 项目不能亏
		return true
	}
	if count > 0 {
		return true
	}
	return false
}

// Income 收益
func Income(uid uint64, start time.Time, end time.Time) (totalAmount float64, err error) {
	return sumLedgerAmount(uid, start, end, true)
}

// Expenditure 支出
func Expenditure(uid uint64, start time.Time, end time.Time) (totalAmount float64, err error) {
	return sumLedgerAmount(uid, start, end, false)
}

// Ibills 账单
func Ibills(uid uint64, pageNumebr, pageSize uint64, start time.Time, end time.Time) (data []TransactionLog, hasNext bool, err error) {
	data = make([]TransactionLog, 0)
	f := bson.M{
		"uid":       uid,
		"createdAt": bson.M{"$gte": start, "$lt": end},
		"tranTypeInt": bson.M{"$in": []TransType{
			AiGirlfriendTransferIn, AiGirlfriendTransferOut, Rchg, PayVID, WithdrawTransfer, PayVIP, WithdrawRefund, AdminCreaditAmount, AdminDebitAmount, OfficialRech, MeetingCard,
			GameCoin, ChaseScore, PayReward, Other, LouFeng, AudioBook, LouFengRefund, LouFengDiscount, GameRewards, VipCardGive,
			LouFengMianFei, LuckyDraw, PayAvVID, TranType_WLSysGive, SignBoon, JewelBoxBoon, LouFengConsumerRebate, ChessRechargePolite,
			JiuGongGeDraw, CurrencyGive, GoldCouplePayVID, BookLoufeng, Active2023Cost, Active2023Reward, RaffleDeduction, PrizeRecord,
			DailyTaskAdsClick, DailyTaskUserInvite, OnceTaskBuyVIP, OnceTaskBindMobile, ReceiveIntegral, BuyVIP, IntegralExchangeVip,
			ReceiveIntegral, ProxyIncome, WorksIncome, SendMsgDebitIncomeGold, SendMsgDebitIncomeGoldReturn, SendMsgDebitAmountGold,
			SendMsgDebitAmountGoldReturn, AiChangefaceDebitGold, AiChangefaceDebitGoldReturn, AiChangefaceDebitInComeGold, AiChangefaceDebitIncomeGoldReturn,
			AiChangeFaceImgDebitGold, AiChangeFaceImgReturnGold, AiUndressDebitFreeTimes, AiUndressDebitFreeTimesReturn, AiUndressDebitIncomeGold,
			AiUndressDebitIncomeGoldReturn, AiChangeFaceImgDebitIncomeGold, AiChangeFaceImgReturnIncomeGold, AiChangeFaceImgDebitFreeTimes,
			AiChangeFaceImgDebitFreeTimesReturn, AiUndress, AiUndressRefund, AiUndressInc, AiUndressIncBackend, AiUndressDebitGold, AiUndressDebitGoldReturn,
			VipCardGiveAiUndressFreeCount, AdminAddDownloadCount, AdminDebitDownloadCount, BuyAdvanceVIP, BuyBalanceVIP, BuyGameAdvanceVIP,
			BuyWhoringCard, ReSignDebitAmount, SuccessSignReturnAmount, GodCommentAward, IntegralExchangeAICount, AiMateCurrencyExchange,
			AiImageToVideoDebitGold, AiImageToVideoDebitGoldReturn, AiImageToVideoDebitInComeGold, AiImageToVideoDebitIncomeGoldReturn,
			AiTextToImageDebitGold, AiTextToImageDebitGoldReturn, AiTextToImageDebitInComeGold, AiTextToImageDebitIncomeGoldReturn, BuyAcg,
			AiTextToNovelDebitGold, AiTextToNovelDebitGoldReturn, AiTextToNovelDebitInComeGold, AiTextToNovelDebitIncomeGoldReturn,
		}},
		//"amount": bson.M{"$ne": 0},
		"$or": []bson.M{
			bson.M{"amount": bson.M{"$ne": 0}},
			bson.M{"integral": bson.M{"$ne": 0}},
			bson.M{"tranTypeInt": bson.M{"$in": []TransType{AiGirlfriendTransferIn, AiGirlfriendTransferOut}}},
		},
	}
	if pageSize == 0 || pageSize >= uint64(maxLedgerWindow) {
		return nil, false, fmt.Errorf("invalid ledger page size")
	}
	if pageNumebr == 0 {
		pageNumebr = 1
	}
	if pageNumebr-1 > uint64(maxLedgerWindow)/pageSize {
		return nil, false, fmt.Errorf("ledger query window is too large; narrow the time range")
	}
	rows, err := findLedgerRows(f, int64(pageSize*(pageNumebr-1)), int64(pageSize+1))
	if err != nil {
		return nil, false, err
	}
	hasNext = len(rows) > int(pageSize)
	if hasNext {
		rows = rows[:pageSize]
	}
	for _, row := range rows {
		data = append(data, *row)
	}
	return data, hasNext, nil
}

// HasNextMonth 查询当前月之前的最迟数据的的时间
func HasNextMonth(uid uint64, start time.Time) (data TransactionLog, err error) {
	opt := options.FindOne()
	opt.Sort = bson.D{{Key: "createdAt", Value: -1}}
	err = coll(nil).FindOne(&data, bson.M{"uid": uid, "createdAt": bson.M{"$lt": start}})
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "HasNext", table, "FindOne", err),
			log.Any("uid", uid),
			log.Any("start", start),
		)
		return
	}
	return
}

func BuyLoufengCount(uid uint64) (int64, error) {
	return coll(nil).Count(bson.M{"uid": uid, "tranTypeInt": bson.M{"$in": []TransType{LouFeng, BookLoufeng}}})
}

// 时间内购买VIP次数
func BuyVipCount(start, end time.Time, mats ...Matcher) (int64, error) {
	payVIP := PayVIP.Key()
	mats = append(mats, (&TranTypeMatch{&payVIP}).New(), (&CreatedAtGTEAndLTMatch{GTE: &start, LT: &end}).New())
	filter := pageopt.MergeM(mats)
	count, err := coll(nil).Count(filter)
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "BuyVipCount", table, "Count", err))
	}
	return count, err
}

// //产品购买记录
func BuyProductLog(uid uint64, tranTypeInt TransType, pids []primitive.ObjectID) (data []TransactionLog, err error) {
	objIDs := make([]string, len(pids))
	for i := range pids {
		objIDs[i] = pids[i].Hex()
	}
	data = make([]TransactionLog, 0)
	opt := options.FindOptions{
		Sort: bson.D{{Key: "createdAt", Value: -1}},
	}
	f := bson.M{"uid": uid, "tranTypeInt": tranTypeInt, "productID": bson.M{"$in": objIDs}}
	if err = coll(nil).Find(&data, f, &opt); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "BuyProductLog", table, "Find", err))
		return
	}
	return
}

// 产品购买记录 单个
func BuyProductLogSingle(uid uint64, tranTypeInt TransType, pid string) (data TransactionLog, err error) {
	f := bson.M{"uid": uid, "tranTypeInt": tranTypeInt, "productID": pid}
	if err = coll(nil).FindOne(&data, f); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "BuyProductLogSingle", table, "Find", err))
		return
	}
	return
}

// 产品购买记录
func BuyProductLogWithPage(uid uint64, tranTypeInt TransType, page commod.Page) (data []TransactionLog, hasNext bool, err error) {
	data = make([]TransactionLog, 0)
	skip := int64(page.Skip())
	limit := int64(page.Limit() + 1)
	opts := options.FindOptions{
		Skip:  &skip,
		Limit: &limit,
		Sort:  bson.D{{Key: "createdAt", Value: -1}},
	}
	f := bson.M{"uid": uid, "tranTypeInt": tranTypeInt}
	if tranTypeInt == PayAvVID {
		f["productID"] = bson.M{"$exists": true}
	}
	if err = coll(nil).Find(&data, f, &opts); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "BuyProductLog", table, "Find", err))
		return
	}
	if uint64(len(data)) > page.PageSize {
		hasNext = true
		data = data[:page.PageSize]
	}
	return
}

// Income 账单
func WorksIncomebills(uid uint64, pageNumebr, pageSize uint64) (data []TransactionLog, hasNext bool, err error) {
	data = make([]TransactionLog, 0)
	f := bson.M{"uid": uid, "tranTypeInt": WorksIncome}
	skip := int64(pageSize * (pageNumebr - 1))
	limit := int64(pageSize + 1)
	opts := options.FindOptions{
		Skip:  &skip,
		Limit: &limit,
		Sort:  bson.D{{Key: "createdAt", Value: -1}},
	}
	if err = coll(nil).Find(&data, f, &opts); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "FindTransactionLogs", table, "Find", err),
			log.Any("filter", f),
		)
		return
	}
	if len(data) > int(pageSize) {
		hasNext = true
		data = data[:pageSize]
	}
	return
}

// 是否购买了某个产品
func IsBuyProduct(uid uint64, id primitive.ObjectID, tranTypeInt TransType) (bool, error) {
	f := bson.M{"uid": uid, "productID": id.Hex(), "tranTypeInt": tranTypeInt}
	count, err := coll(nil).Count(f)
	if err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "BuyVipCount", table, "Count", count))
		return false, err
	}
	return count > 0, nil
}

// QueryAll 条件查询列表
func QueryAll(filter bson.M, opts ...*options.FindOptions) ([]TransactionLog, error) {
	var items []TransactionLog
	return items, coll(nil).Find(&items, filter, opts...)
}

// TransStat 交易统计
func TransStat(start, end time.Time) ([]TransactionR, error) {
	var items []TransactionR
	f := bson.M{"createdAt": bson.M{"$gt": start, "$lte": end}, "tranTypeInt": LouFeng}
	return items, coll(nil).Find(&items, f)
}

// IncomeLeaderboard 收益榜单
func IncomeLeaderboard(bind interface{}, filter bson.M, limit int) error {
	pip := []bson.M{
		{"$match": filter},
		{"$group": bson.M{"_id": "$uid", "income": bson.M{"$sum": "$actualAmount"}}},
		{"$sort": bson.M{"income": -1}},
		{"$limit": limit},
	}
	if err := coll(nil).Aggregate(bind, pip); err != nil {
		log.Info(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "IncomeLeaderboard", table, "Aggregate", err))
		return err
	}
	return nil
}

// FindByCond 根据条件查询
func FindByCond(filter primitive.M) (TransactionLog, error) {
	opt := options.FindOneOptions{
		Sort: bson.D{{Key: "createdAt", Value: -1}},
	}
	var data TransactionLog
	if err := coll(nil).FindOne(&data, filter, &opt); err != nil {
		log.Warn(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "LastTime", table, "FindByCond", err),
			log.Any("filter", filter),
		)
		return data, err
	}
	return data, nil
}

// CheckRepurchaseByTransTypes 判断是否购买过，返回yes/no
func CheckRepurchaseByTransTypes(uid uint64, types []TransType) (isRepurchase string, err error) {
	if len(types) == 0 {
		return "no", nil
	}
	has, err := coll(nil).Exists(bson.M{"uid": uid, "tranTypeInt": bson.M{"$in": types}})
	if err != nil {
		log.Error(fmt.Sprintf("[METHOD-%s]==> Model %s %s fail error:%+v:", "CheckRepurchaseByTransTypes", table, "Exists", err),
			log.Any("uid", uid),
			log.Any("types", types),
		)
		return "no", err
	}
	if has {
		return "yes", nil
	}
	return "no", nil
}