package controller

import (
	"errors"
	"fmt"
	"github.com/codinl/go-logger"
	"github.com/gin-gonic/gin"
	"mh-server/lib/auth"
	"mh-server/lib/status"
	"mh-server/lib/utils"
	"mh-server/lib/wxpay"
	"mh-server/model"
	"time"
)

const (
	MemberFee  = 299 * 100 // 会员费
	DepositFee = 300 * 100 // 押金费
)

type OpenMemberReq struct {
	MemberLevel  uint32 `json:"member_level"`   // 会员等级
	MemberGenre  uint32 `json:"member_genre"`   // 会员标记: 黄金会员:90天-201  180天-202
	UserCouponId uint32 `json:"user_coupon_id"` // 优惠券id
}

func HistoryBrowsingList(c *gin.Context) {
	req := struct {
		Page     int `json:"page"`
		PageSize int `json:"page_size"`
	}{
		Page:     1,
		PageSize: 10,
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	gameCardList, totalPage, err := model.GetHistoryBrowsingList(uc.Uid, req.Page, req.PageSize)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"game_card_list": gameCardList,
		"cur_page":       req.Page,
		"total_page":     totalPage,
	}

	RespOK(c, ret)
	return
}

func HistoryBrowsingDel(c *gin.Context) {
	req := struct {
		GameCardIds []uint64 `json:"game_card_id" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	if len(req.GameCardIds) > 0 {
		err := model.NewHistoryBrowsingQuerySet(model.DB.Unscoped()).UidEq(uint64(uc.Uid)).GameCardIdIn(req.GameCardIds...).Delete()
		if err != nil {
			logger.Error("err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}

	RespOK(c, nil)
	return
}

func CollectionList(c *gin.Context) {
	req := struct {
		Page     int `json:"page"`
		PageSize int `json:"page_size"`
	}{
		Page:     1,
		PageSize: 10,
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	gameCardList, totalPage, err := model.GetGameCardCollectionList(uc.Uid, req.Page, req.PageSize)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"game_card_list": gameCardList,
		"cur_page":       req.Page,
		"total_page":     totalPage,
	}

	RespOK(c, ret)
	return
}

func CollectionAdd(c *gin.Context) {
	req := struct {
		GameCardId uint64 `json:"game_card_id" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	collection := model.Collection{
		Uid:        uint64(uc.Uid),
		GameCardId: req.GameCardId,
	}
	err := collection.Create(model.DB)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, nil)
	return
}

func CollectionCancel(c *gin.Context) {
	req := struct {
		GameCardIds []uint64 `json:"game_card_id" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("para err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	if len(req.GameCardIds) > 0 {
		err := model.NewCollectionQuerySet(model.DB.Unscoped()).UidEq(uint64(uc.Uid)).GameCardIdIn(req.GameCardIds...).Delete()
		if err != nil {
			logger.Error("err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}

	RespOK(c, nil)
	return
}

func UserInfoUpdate(c *gin.Context) {
	req := struct {
		WxName   string `json:"wx_name"`   // 昵称
		WxAvatar string `json:"wx_avatar"` // 头像
		Tel      string `json:"tel"`       // 电话
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	user := &model.User{
		Uid:      uc.Uid,
		WxName:   req.WxName,
		WxAvatar: req.WxAvatar,
		Tel:      req.Tel,
	}
	err := model.UserUpdate(user)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, nil)
	return
}

// OpenMember 开通会员
// @Summary 开通会员
// @Tags 零售订单
// @Produce json
// @Accept json
// @Param request body OpenMemberReq true "开通会员模型"
// @Success 200 {object} RespRet
// @Router /api/v1/user/open_member [post]
func OpenMember(c *gin.Context) {
	req := new(OpenMemberReq)
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	fmt.Println("req:", req)
	user := model.GetUserByUid(uc.Uid)

	memberConfig, err := model.GetMemberConfig(req.MemberLevel, req.MemberGenre)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//totalFee := uint32(MemberFee + DepositFee)
	////totalFee = uint32(3) // TODO 测试 上线修改
	//if user.Deposit == 300 {
	//	totalFee = MemberFee
	//	//	//totalFee = uint32(1) // TODO 测试 上线修改
	//}

	fmt.Println("configInfo.MemberFee : configInfo.DepositFee", memberConfig.MemberFee, memberConfig.MemberDeposit)
	totalFee := memberConfig.MemberFee + memberConfig.MemberDeposit - user.Deposit
	if user.Deposit == memberConfig.MemberDeposit {
		totalFee = memberConfig.MemberFee
	}
	if totalFee == 0 {
		logger.Error(errors.New("totalFee is 0"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//短期会员不可用优惠券
	if req.UserCouponId != 0 && req.MemberGenre != model.MemberGenreQuarter && req.MemberGenre != model.MemberGenreHalfYear {
		var coupon model.UserCoupon
		err = model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&coupon)
		if err != nil {
			logger.Error("coupon err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		// 用户已开通会员且优惠券可用
		if user.IsMember() && coupon.Uid == uc.Uid && coupon.MemberLevel == req.MemberLevel &&
			coupon.ActivityId == 1 && coupon.State == 1 {
			totalFee -= coupon.Value

			if coupon.RedeemCode == "" { // 优惠券兑换码为空，则记录用户续费日志
				go func() {
					action := 0
					if coupon.MemberLevel == 2 {
						action = model.UserRenewalLogActionUseGold
					} else if coupon.MemberLevel == 4 {
						action = model.UserRenewalLogActionUsePlatinum
					} else if coupon.MemberLevel == 5 {
						action = model.UserRenewalLogActionUseBlackGold
					}
					renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, uint32(action))
					userLog := &model.UserRenewalLog{
						Uid:          uc.Uid,
						Action:       uint32(action),
						MemberExpire: user.MemberExpire,
						Type:         1,
						RenewalNum:   renewalLog.RenewalNum + 1,
						Serial:       uint32(user.MemberExpire.Unix()),
					}
					_ = userLog.Add()
				}()
			}
		} else if coupon.State == 1 && coupon.ActivityType == 2 { // 关注公众号领取的优惠券
			totalFee -= coupon.Value
		} else { // 不符合优惠条件
			req.UserCouponId = 0
		}
	}

	orderSn := model.GetOrderSn()
	// 备注：只有会员续费使用优惠券才会记录优惠券id：req.UserCouponId
	err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn, MemberLevel: req.MemberLevel,
		UserCouponId: req.UserCouponId, Attach: wxpay.WxPayMember, MemberGenre: req.MemberGenre}.Insert()
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	configInfo, err := model.PayConfigInfo()
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	genre, err := model.GetPaymentGenre()
	if err != nil {
		genre = 2
		logger.Error("payment method", err)
	}
	//选择支付渠道，15号之前走微信，15号之后走河马付
	if genre == model.PaymentGenreWx {
		webPay, err := wxpay.WebPay(orderSn, totalFee, user.WxOpenID, "N", wxpay.WxPayMember, configInfo.NotifyUrl)
		if err != nil {
			logger.Error(errors.New("WebPay err"))
			RespJson(c, status.InternalServerError, nil)
			return
		}
		RespOK(c, webPay)
	} else {
		webPay, err := wxpay.HmJsPayUnifiedOrder(orderSn, totalFee, user.WxOpenID, configInfo.NotifyUrl)
		if err != nil {
			logger.Error(errors.New("WebPay err"))
			RespJson(c, status.InternalServerError, nil)
			return
		}
		RespOK(c, webPay)
	}

	return
}

func UpgradeMember(c *gin.Context) {
	req := struct {
		MemberLevel  uint32 `json:"member_level"` // 昵称
		MemberGenre  uint32 `json:"member_genre"`
		UserCouponId uint32 `json:"user_coupon_id"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	user := model.GetUserByUid(uc.Uid)
	//if user.MemberLevel != 2 && user.MemberLevel != 4 {
	//	logger.Error("MemberLevel err:")
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}

	if user.Gender != 0 {
		logger.Error("user member genre err:")
		RespJson(c, status.ShortMemberNotUpgradeMember, nil)
		return
	}
	if req.MemberGenre == 0 { //区分是升级哪种会员 白金：400  黑金：500
		req.MemberGenre = model.GetMemberGenreFromLevel(req.MemberLevel)
	}

	originalMemberConfig, err := model.GetMemberConfig(user.MemberLevel, user.MemberGenre)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	memberConfig, err := model.GetMemberConfig(req.MemberLevel, req.MemberGenre)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	raiseTime, err := time.Parse("2006-01-02 15:04:05", "2022-01-01 00:00:00")
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	memberFee := originalMemberConfig.MemberFee
	if user.OpenMemberTime.Before(raiseTime) {
		memberFee = 29900
	}

	// 补押金
	depositMendFee := int64(memberConfig.MemberDeposit) - int64(user.Deposit)

	count, err := model.NewUserRedeemCodeQuerySet(model.DB).UidEq(uc.Uid).CodeTypeEq(model.CodeTypeMemberCard30).
		StatusEq(model.RedeemCodeStatusUsed).Count()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	fmt.Println("count:", count)
	// 抵扣天数
	deductionDays := int64(0)
	deductionTime := user.MemberExpire.Unix() - int64(count*30*24*3600) - time.Now().Unix() + 1*3600
	if deductionTime < 0 {
		deductionTime = 0
	}
	if deductionTime > 0 {
		deductionDays = deductionTime / int64(24*3600)
	}
	memberYare := 0
	memberMendFee := int64(0)

	//// 抵扣金
	//deductionFee := (((int64(memberFee) * deductionDays) / 365) / 100) * 100

	// 2024-06-07修改，解决短期升级白金/黑金多收费问题
	memberDays := int64(0)
	switch req.MemberGenre {
	case 201:
		memberDays = 90
	case 202:
		memberDays = 180
	default:
		memberDays = 365
	}
	logger.Info("req.MemberGenre is:", req.MemberGenre)
	logger.Info("memberDays is:", memberDays)
	// 抵扣金
	deductionFee := (((int64(memberFee) * deductionDays) / memberDays) / 100) * 100

	if deductionDays < 365 {
		memberYare = 1
		// 补会员费
		memberMendFee = int64(memberConfig.MemberFee*uint32(memberYare)) - deductionFee
	} else {
		// 补会员费
		memberMendFee = int64((int64(memberConfig.MemberFee)*deductionDays)/365) - deductionFee
	}

	totalFee := int64(depositMendFee) + memberMendFee
	//if memberMendFee < 0 {
	//	depositMendFee = depositMendFee + memberMendFee
	//}
	fmt.Println("depositMendFee : memberMendFee", depositMendFee, memberMendFee)

	if totalFee == 0 {
		logger.Error(errors.New("totalFee is 0"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//totalFee := memberConfig.MemberFee + memberConfig.MemberDeposit
	//if user.Deposit == memberConfig.MemberDeposit {
	//	totalFee = memberConfig.MemberFee
	//}
	if totalFee == 0 {
		logger.Error(errors.New("totalFee is 0"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//会员升级时（MemberGenre = 0 || 400 || 500）才能使用优惠券
	if req.UserCouponId != 0 && (req.MemberGenre == 0 || req.MemberGenre == 400 || req.MemberGenre == 500) {
		var coupon model.UserCoupon
		err = model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&coupon)
		if err != nil {
			logger.Error("coupon err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		if user.IsMember() && coupon.Uid == uc.Uid && coupon.MemberLevel == req.MemberLevel &&
			coupon.ActivityId == 1 && coupon.State == 1 && coupon.ActiveEnd.After(time.Now()) {
			totalFee -= int64(coupon.Value)

			go func() {
				action := 0
				if coupon.MemberLevel == 2 {
					action = model.UserRenewalLogActionUseGold
				} else if coupon.MemberLevel == 4 {
					action = model.UserRenewalLogActionUsePlatinum
				} else if coupon.MemberLevel == 5 {
					action = model.UserRenewalLogActionUseBlackGold
				}
				renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, uint32(action))
				userLog := &model.UserRenewalLog{
					Uid:          uc.Uid,
					Action:       uint32(action),
					MemberExpire: user.MemberExpire,
					Type:         2,
					RenewalNum:   renewalLog.RenewalNum + 1,
					Serial:       uint32(user.MemberExpire.Unix()),
				}
				_ = userLog.Add()
			}()
		} else if coupon.State == 1 && coupon.ActivityType == 2 {
			totalFee -= int64(coupon.Value)
		} else {
			req.UserCouponId = 0
		}
	}

	totalFee += 50
	totalFee = (totalFee / 100) * 100

	//webPay, err := wxpay.WebPay(uid, totalFee, user.WxOpenID, "N", wxpay.WxPayMember)
	//if err != nil {
	//	logger.Error(errors.New("WebPay err"))
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	//orderSn := utils.GetSerialNo32HEXString()
	memberExpire := time.Time{}
	if deductionDays < 365 {
		memberExpire = time.Now().AddDate(1*int(memberYare), 0, count*30)
	} else {
		memberExpire = time.Now().AddDate(0, 0, count*30+int(deductionDays))
	}
	orderSn := model.GetOrderSn()
	err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn,
		MemberLevel: req.MemberLevel, OrderType: 9, MemberExpire: memberExpire,
		UserCouponId: req.UserCouponId, Attach: wxpay.WxPayUpgradeMember, MemberGenre: req.MemberGenre}.Insert()
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	configInfo, err := model.PayConfigInfo()
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//webPay, err := wxpay.WebPay(orderSn, uint32(totalFee), user.WxOpenID, "N", wxpay.WxPayUpgradeMember,
	//	configInfo.NotifyUrl)
	//if err != nil {
	//	logger.Error(errors.New("WebPay err"))
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	webPay, err := wxpay.HmJsPayUnifiedOrder(orderSn, uint32(totalFee), user.WxOpenID, configInfo.NotifyUrl)
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, webPay)
}

func UpgradeMemberInfo(c *gin.Context) {
	req := struct {
		MemberLevel  uint32 `json:"member_level"` // 昵称
		MemberGenre  uint32 `json:"member_genre"`
		UserCouponId uint32 `json:"user_coupon_id"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	user := model.GetUserByUid(uc.Uid)
	//if user.MemberLevel != 2 && user.MemberLevel != 4 {
	//	logger.Error("MemberLevel err:")
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}

	//configInfo, err := model.PayConfigInfo()
	//if err != nil {
	//	logger.Error("err:", err)
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	originalMemberConfig, err := model.GetMemberConfig(user.MemberLevel, user.MemberGenre)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	memberConfig, err := model.GetMemberConfig(req.MemberLevel, req.MemberGenre)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	raiseTime, err := time.Parse("2006-01-02 15:04:05", "2022-01-01 00:00:00")
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	memberFee := originalMemberConfig.MemberFee
	if user.OpenMemberTime.Before(raiseTime) {
		memberFee = 29900
	}

	// 补押金
	depositMendFee := int64(memberConfig.MemberDeposit) - int64(user.Deposit)

	count, err := model.NewUserRedeemCodeQuerySet(model.DB).UidEq(uc.Uid).CodeTypeEq(model.CodeTypeMemberCard30).
		StatusEq(model.RedeemCodeStatusUsed).Count()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	fmt.Println("count:", count)
	// 抵扣天数
	deductionDays := int64(0)
	deductionTime := user.MemberExpire.Unix() - int64(count*30*24*3600) - time.Now().Unix() + 1*3600
	if deductionTime < 0 {
		deductionTime = 0
	}
	if deductionTime > 0 {
		deductionDays = deductionTime / int64(24*3600)
	}
	//memberYare := deductionDays/365 + 1
	//// 抵扣金
	//deductionFee := (((int64(memberFee) * deductionDays) / 365) / 100) * 100
	//
	//// 补会员费
	//memberMendFee := int64(memberConfig.MemberFee*uint32(memberYare)) - deductionFee

	memberYare := 0
	memberMendFee := int64(0)
	// 抵扣金
	deductionFee := (((int64(memberFee) * deductionDays) / 365) / 100) * 100
	if deductionDays < 365 {
		memberYare = 1
		// 补会员费
		memberMendFee = int64(memberConfig.MemberFee*uint32(memberYare)) - deductionFee
	} else {
		// 补会员费
		memberMendFee = int64((int64(memberConfig.MemberFee)*deductionDays)/365) - deductionFee
	}

	totalFee := int64(depositMendFee) + memberMendFee
	//if memberMendFee < 0 {
	//	depositMendFee = depositMendFee + memberMendFee
	//}
	fmt.Println("depositMendFee : memberMendFee", depositMendFee, memberMendFee)

	if totalFee == 0 {
		logger.Error(errors.New("totalFee is 0"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	var coupon model.UserCoupon
	if req.UserCouponId != 0 && req.MemberGenre == 0 {
		err = model.NewUserCouponQuerySet(model.DB).IDEq(req.UserCouponId).One(&coupon)
		if err != nil {
			logger.Error("coupon err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		if user.IsMember() && coupon.Uid == uc.Uid && coupon.MemberLevel == req.MemberLevel &&
			coupon.ActivityId == 1 && coupon.State == 1 && coupon.ActiveEnd.After(time.Now()) {
			totalFee -= int64(coupon.Value)

			// TODO 不用添加数据

		} else if coupon.State == 1 && coupon.ActivityType == 2 {
			totalFee -= int64(coupon.Value)
		} else {
			req.UserCouponId = 0
		}
		fmt.Println("totalFee:", totalFee)
	}

	totalFee += 50
	totalFee = (totalFee / 100) * 100

	RespOK(c, map[string]interface{}{
		"deduction_fee":    deductionFee,   // 会员抵扣费
		"deduction_days":   deductionDays,  // 会员抵扣天数
		"member_mend_fee":  memberMendFee,  // 会员补费
		"deposit_mend_fee": depositMendFee, // 补押金
		"total_fee":        totalFee,       // 总费用
		"coupon":           coupon.Value,
	})
}

func PayDeposit(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	user := model.GetUserByUid(uc.Uid)
	orderSn := model.GetOrderSn()
	err := model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn, Attach: wxpay.WxPayDeposit}.Insert()
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	level := user.MemberLevel
	if level == model.MemberLevelPeriod {
		level = model.MemberLevelGold
	}
	//configInfo, err := model.PayConfigInfo()
	//if err != nil {
	//	logger.Error("err:", err)
	//	return
	//}
	memberConfig, err := model.GetMemberConfig(level, user.MemberGenre)
	if err != nil {
		logger.Error("GetMemberConfig err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	totalFee := memberConfig.MemberDeposit
	if totalFee == 0 || user.Deposit == totalFee {
		logger.Error(errors.New("totalFee is 0"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//totalFee = 1 //  测试
	configInfo, err := model.PayConfigInfo()
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//webPay, err := wxpay.WebPay(orderSn, totalFee, user.WxOpenID, "N", wxpay.WxPayDeposit, configInfo.NotifyUrl)
	//if err != nil {
	//	logger.Error(errors.New("WebPay err"))
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	webPay, err := wxpay.HmJsPayUnifiedOrder(orderSn, totalFee, user.WxOpenID, configInfo.NotifyUrl)
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, webPay)
}

func CommonProblemList(c *gin.Context) {
	common := &model.CommonProblem{}
	list, err := common.List()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	RespOK(c, list)
	return
}

func RefundDeposit(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	user := model.GetUserByUid(uc.Uid)
	if user.Deposit == 0 {
		logger.Error("deposit is 0")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if user.DepositType == 3 {
		logger.Error("deposit restraint")
		RespJson(c, status.DepositRestraint, nil)
		return
	}
	unreturnedOrders, err := model.IsUserHaveUnreturnedOrder(user.Uid)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if unreturnedOrders {
		logger.Error("unreturnedOrders")
		RespJson(c, status.HaveUnreturnedOrders, nil)
		return
	}

	resp, err := model.MemberExpireDelaying(uc.Uid)
	if err != nil {
		logger.Errorf("err:%#v", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	isSurrender, _ := resp["is_surrender"]

	if isSurrender == 0 {
		count, err := model.NewDepositRefundRecordQuerySet(model.DB).UidEq(uc.Uid).StatusNotIn(model.DepositRefundStatusRefunded, model.DepositRefundStatusRefused).Count()
		if err != nil || count > 0 {
			logger.Error("count is not 0")
			RespJson(c, status.RefundDepositSubmitted, nil)
			return
		}
		record := &model.DepositRefundRecord{
			Uid:         uc.Uid,
			Status:      model.DepositRefundStatusUnconfirmed,
			Amount:      user.Deposit,
			Operator:    0,
			ConfirmTime: time.Time{},
		}

		err = model.DB.Create(record).Error
		if err != nil {
			logger.Error("err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}

	RespOK(c, resp)
}

func UserDepositRefundRecordList(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	resp, err := model.GetDepositRefundRecordList(uc.Uid)
	if err != nil {
		logger.Errorf("err:%#v", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, resp)
}

func UserMemberExpireDelayingInfo(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	unreturnedOrders, err := model.IsUserHaveUnreturnedOrder(uc.Uid)
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if unreturnedOrders {
		logger.Error("unreturnedOrders")
		RespJson(c, status.HaveUnreturnedOrders, nil)
		return
	}

	resp, err := model.MemberExpireDelaying(uc.Uid)
	if err != nil {
		logger.Errorf("err:%#v", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, resp)
}

func UserMemberExpireDelayingPay(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	var user model.User
	err := model.NewUserQuerySet(model.DB).UidEq(uc.Uid).One(&user)
	if err != nil {
		logger.Error("user err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	var userMemberExpireDelay model.UserMemberExpireDelay
	err = model.NewUserMemberExpireDelayQuerySet(model.DB).UidEq(uc.Uid).MemberExpireEq(user.MemberExpire).One(&userMemberExpireDelay)
	if err != nil {
		logger.Error("user member expire delay err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	configInfo, err := model.PayConfigInfo()
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	orderSn := model.GetOrderSn()
	err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn, OrderId: 0, OrderType: 3, Attach: wxpay.WxPayMemberExpireDelay}.Insert()
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//userMemberExpireDelay.DelayAmount = userMemberExpireDelay.DelayAmount / 100 // 测试TODO
	//webPay, err := wxpay.WebPay(orderSn, uint32(userMemberExpireDelay.DelayAmount), user.WxOpenID, "N", wxpay.WxPayMemberExpireDelay, configInfo.NotifyUrl)
	//if err != nil {
	//	logger.Error(errors.New("WebPay err"))
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	webPay, err := wxpay.HmJsPayUnifiedOrder(orderSn, uint32(userMemberExpireDelay.DelayAmount), user.WxOpenID, configInfo.NotifyUrl)
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	ret := make(map[string]interface{}, 0)
	ret["is_surrender"] = 1
	ret["expire_days"] = userMemberExpireDelay.ExpireDays
	ret["daily_fee"] = userMemberExpireDelay.DailyFee
	ret["delay_amount"] = userMemberExpireDelay.DelayAmount
	ret["web_pay"] = webPay
	RespOK(c, ret)
	return
}

func MemberConfigList(c *gin.Context) {
	//uc := auth.GetCurrentUser(c)
	//if uc == nil {
	//	RespJson(c, status.Unauthorized, nil)
	//	return
	//}

	resp, err := model.MemberConfigInfo()
	if err != nil {
		logger.Errorf("err:%#v", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, resp)
}

func UserAttendance(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	//model.NewUserAttendanceRecordQuerySet()
	todayZero := utils.TodayZeroDateFormat()
	recordExist, err := model.QueryRecordExist(
		fmt.Sprintf("SELECT * FROM user_attendance_record WHERE attendance_date = '%s' AND uid=%d", todayZero, uc.Uid))
	if err != nil {
		logger.Error("record exist err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if recordExist {
		logger.Error("user  consecutive")
		RespJson(c, status.TodayAttendance, nil)
		return
	}

	configInfo, err := model.AttendanceVmConfigInfo()
	if err != nil {
		logger.Error("attendance vm config info err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	attendanceTime := time.Now()
	record := &model.UserAttendanceRecord{
		Uid:            uc.Uid,
		AttendanceTime: attendanceTime,
		Vm:             configInfo.VmDay1,
		AttendanceDate: todayZero,
	}

	var userAttendance model.UserAttendance
	err = model.NewUserAttendanceQuerySet(model.DB).UidEq(uc.Uid).One(&userAttendance)
	if err != nil && err != model.RecordNotFound {
		logger.Error("user attendance err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if err == model.RecordNotFound {
		userAttendance = model.UserAttendance{
			Uid:             uc.Uid,
			LatestTime:      attendanceTime,
			ConsecutiveDays: 1,
			IndexDay:        1,
		}
		err = model.DB.Create(&userAttendance).Error
		if err != nil {
			logger.Error("create user attendance err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		err = record.Add(model.VmEventAttendance, "签到获得积分")
		if err != nil {
			logger.Error("add user attendance record err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		RespOK(c, nil)
		return
	}

	var attendanceRecord model.UserAttendanceRecord
	err = model.NewUserAttendanceRecordQuerySet(model.DB).UidEq(uc.Uid).OrderDescByID().Limit(1).One(&attendanceRecord)
	if err != nil && err != model.RecordNotFound {
		logger.Error(" user attendance record err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if attendanceRecord.AttendanceDate == "" ||
		attendanceRecord.AttendanceDate != utils.TodayZeroAddDaysDateFormat(-1) {
		err = record.Add(model.VmEventAttendance, "签到获得积分")
		if err != nil {
			logger.Error("add user attendance record err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		_, err = model.NewUserAttendanceQuerySet(model.DB).UidEq(uc.Uid).GetUpdater().SetConsecutiveDays(1).
			SetIndexDay(1).SetLatestTime(time.Now()).UpdateNum()
		if err != nil {
			logger.Error("update user attendance  err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		RespOK(c, nil)
		return
	}

	userAttendance.ConsecutiveDays += 1
	userAttendance.IndexDay = userAttendance.ConsecutiveDays % 7
	if userAttendance.IndexDay == 0 {
		userAttendance.IndexDay = 7
	}

	record.Vm = configInfo.Vm(userAttendance.ConsecutiveDays)
	err = record.Add(model.VmEventAttendance, "签到获得积分")
	if err != nil {
		logger.Error("add user attendance record err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	_, err = model.NewUserAttendanceQuerySet(model.DB).UidEq(uc.Uid).GetUpdater().
		SetConsecutiveDays(userAttendance.ConsecutiveDays).
		SetIndexDay(userAttendance.IndexDay).SetLatestTime(time.Now()).UpdateNum()
	if err != nil {
		logger.Error("update user attendance  err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, nil)
	return
}

func UserAttendanceDetail(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	list := make([]model.AttendanceInfo, 0, 7)

	configInfo, err := model.AttendanceVmConfigInfo()
	if err != nil {
		logger.Error("attendance vm config info err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	todayZero := utils.TodayZeroDateFormat()
	//var attendanceRecord model.UserAttendanceRecord
	//err = model.NewUserAttendanceRecordQuerySet(model.DB).UidEq(uc.Uid).AttendanceDateEq(utils.TodayZeroAddDaysDateFormat(-1)).One(&attendanceRecord)
	//if err != nil && err != model.RecordNotFound {
	//	logger.Error("user attendance record err:")
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	recordExist, err := model.QueryRecordExist(
		fmt.Sprintf("SELECT * FROM user_attendance_record WHERE attendance_date in ('%s','%s') AND uid=%d",
			utils.TodayZeroAddDaysDateFormat(-1), todayZero, uc.Uid))
	if err != nil {
		logger.Error("record exist err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	if !recordExist {
		for i := 0; i < 7; i++ {
			info := model.AttendanceInfo{
				IndexDay: uint32(i) + 1,
				Date:     utils.TodayZeroAddDaysDateFormat(i),
				State:    1,
				Vm:       configInfo.Vm(uint32(i) + 1),
			}
			list = append(list, info)
		}
		ret := map[string]interface{}{
			"list":          list,
			"is_attendance": 1,
		}
		RespOK(c, ret)
		return
	}

	var attendanceRecord model.UserAttendanceRecord
	//err = model.NewUserAttendanceRecordQuerySet(model.DB).UidEq(uc.Uid).AttendanceDateEq(todayZero).One(&attendanceRecord)
	err = model.NewUserAttendanceRecordQuerySet(model.DB).UidEq(uc.Uid).OrderDescByID().
		Limit(1).One(&attendanceRecord)
	if err != nil && err != model.RecordNotFound {
		logger.Error("user attendance record err:")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	var userAttendance model.UserAttendance
	err = model.NewUserAttendanceQuerySet(model.DB).UidEq(uc.Uid).One(&userAttendance)
	if err != nil && err != model.RecordNotFound {
		logger.Error("user attendance record err:")
		RespJson(c, status.InternalServerError, nil)
		return
	}

	attendanceDays := int(userAttendance.ConsecutiveDays % 7)
	if attendanceDays == 0 && attendanceRecord.AttendanceDate == todayZero {
		attendanceDays = 7
	}
	//attendanceDays += 1
	days := attendanceDays
	for i := 0; i < 7; i++ {
		state := uint32(1)
		if attendanceDays > 0 {
			state = 2
		}
		date := utils.TodayZeroAddDaysDateFormat(i - days)
		if attendanceRecord.AttendanceDate == todayZero {
			date = utils.TodayZeroAddDaysDateFormat(i + 1 - days)
		}
		info := model.AttendanceInfo{
			IndexDay: uint32(i) + 1,
			//Date:     utils.TodayZeroAddDaysDateFormat((-1) * (7 - i)),
			//Date:  utils.TodayZeroAddDaysDateFormat(i + 1 - days),
			//Date:  utils.TodayZeroAddDaysDateFormat(i - days),
			Date:  date,
			State: state,
			Vm:    configInfo.Vm(uint32(i) + 1),
		}

		list = append(list, info)
		attendanceDays--
	}

	isAttendance := 1
	if attendanceRecord.AttendanceDate == todayZero {
		isAttendance = 2
	}
	ret := map[string]interface{}{
		"list":          list,
		"is_attendance": isAttendance,
	}
	RespOK(c, ret)
	return
}

// InviteMemberReportList 店员邀请会员业绩报表
// @Summary 店员邀请会员业绩报表
// @Tags 会员推广, V1.2.0
// @Produce json
// @Accept json
// @Param request body model.InviteMemberReportListReq true "店员邀请会员业绩报表模型"
// @Success 200 {object} model.InviteMemberReportListResp
// @Router /api/v1/cooperative_business/invite_report [post]
func InviteMemberReportList(c *gin.Context) {
	req := model.InviteMemberReportListReq{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	req.Uid = uc.Uid
	assistant := model.GetUserByUid(uc.Uid)
	if assistant.UserType != 2 {
		logger.Error("not assistant")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	list, totalPage, err := req.List()
	if err != nil {
		logger.Errorf("err:%#v", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := model.InviteMemberReportListResp{
		List:      list,
		CurPage:   req.PageNum,
		TotalPage: totalPage,
	}

	RespOK(c, ret)
	return
}

// 升级 1-黄金会员 2-白金会员 3-黑金会员
// 开通会员
// 升级会员
// 订单
// 购物车
// 押金

//  会员列表 开通会员 下订单 借卡 还卡
//  会员升级
//  299会员 升级
//  订单 会员导数据
//  退押金记录