package model

import (
	"errors"
	"fmt"
	"github.com/codinl/go-logger"
	"github.com/jinzhu/gorm"
	"github.com/rs/zerolog/log"
	"mh-server/lib/utils"
	"mh-server/lib/wxpay"
	"sync"
	"time"
)

// gen:qs
//
//go:generate goqueryset -in user.go
type User struct {
	Model

	Uid                   uint32    `json:"uid" gorm:"column:uid;unique_index"`
	MemberLevel           uint32    `json:"member_level"`                         // 会员等级 1-用户  2-黄金会员 4-白金会员 5-黑金会员
	MemberGenre           uint32    `json:"member_genre"`                         // 会员类型
	MemberExpire          time.Time `json:"member_expire"`                        // 会员到期时间
	OpenMemberTime        time.Time `json:"open_member_time"`                     // 开通会员
	Bond                  uint32    `json:"bond"`                                 // 保证金
	WxName                string    `json:"wx_name"`                              // 昵称
	WxAvatar              string    `json:"wx_avatar"`                            // 头像
	WxOpenID              string    `json:"wx_open_id"`                           // 微信openid
	AppOpenID             string    `json:"app_open_id"`                          //
	WxUnionID             string    `json:"wx_union_id"`                          // 微信uniodid
	Tel                   string    `json:"tel"`                                  // 电话
	Gender                uint8     `json:"gender"`                               // 性别
	City                  string    `json:"city"`                                 // 城市
	Province              string    `json:"province"`                             // 省
	Country               string    `json:"country"`                              // 市
	Deposit               uint32    `json:"deposit"`                              // 押金
	UserType              uint32    `json:"user_type"`                            // 用户类型: 1-普通用户 2-店员
	XcxRoleId             uint32    `json:"xcx_role_id"`                          // 角色id
	OpenMemberChannel     string    `json:"open_member_channel" `                 // 开通会员渠道: -门店推广 -用户邀请 -兑换码
	StoreId               uint64    `json:"store_id"`                             // 门店id
	InviteCodeUrl         string    `json:"invite_code_url"`                      // 分享二维码
	LastLoginAt           time.Time `json:"last_login_at"`                        // 最近登录时间
	IP                    string    `json:"-" gorm:"type:varchar(60)"`            // ip
	InBlack               bool      `json:"in_black"`                             // 是否在黑名单
	StoreType             uint32    `json:"store_type"`                           // 1-订单门店
	CooperativeBusinessId uint32    `json:"cooperative_business_id" gorm:"index"` // 合作商id
	CooperativeName       string    `json:"cooperative_name"`                     // 合作商名称
	ShopAssistantName     string    `json:"shop_assistant_name"`                  // 店员名称
	OpenMemberLevel       uint32    `json:"open_member_level"`                    // 开通会员级别：2-黄金会员 4-白金会员 5-黑金会员
	FirstRetailOrder      time.Time `json:"first_retail_order"`                   //
	Version               uint32    `json:"-"`                                    //
	UserVm                *UserVm   `json:"user_vm" gorm:"-"`                     //
	InviteTime            time.Time `json:"invite_time"`                          //
	DepositType           uint32    `json:"deposit_type"`                         // 押金类型: 3-未充值
	//RoleId                uint32    `json:"role_id"`                              // 角色id
	//RenewalTime           time.Time `json:"renewal_time"`
	//RenewalMemberLevel    uint32    `json:"renewal_member_level"`
	//MemberLevelString string    `json:"member_level_string" gorm:"-"` // 会员类型

}

func (o *User) TableName() string {
	return "user"
}

const (
	MemberTypeConsumer = 1 // 普通用户
	MemberTypeMember   = 2 // 黄金会员
)

const (
	MemberLevelConsumer  = 1 // 普通用户
	MemberLevelGold      = 2 // 黄金会员
	MemberLevelPeriod    = 3 // 短期会员
	MemberLevelPlatinum  = 4 // 白金会员
	MemberLevelBlackGold = 5 // 黑金会员
)

const (
	DateTimeFormat = "2006-01-02"
	TimeFormat     = "2006-01-02 15:04:05"
)
const (
	OpenMemberChannelStorePromotion = "store_promotion" // 门店推荐
	OpenMemberChannelUserInvite     = "user_invite"
	OpenMemberChannelRedeemCode     = "redeem_code"
)

// gen:qs
type UserInvite struct {
	Model

	FromUid            uint32    `json:"from_uid"`              // 邀请用户id
	UserType           uint32    `json:"user_type"`             // 用户类型 1-普通用户 邀请用户类型
	StoreId            uint64    `json:"store_id"`              // 门店id            邀请用户门店
	MemberOpenTime     time.Time `json:"member_open_time"`      // 开通会员
	MemberType         uint32    `json:"member_type"`           // 被邀请用户 1-普通用户 2-会员
	MemberStatus       uint8     `json:"member_status"`         // 被邀请用户 1-未开通  2-已开通 3-已取消会员
	ToUid              uint32    `json:"to_uid"`                // 被邀请用户
	StoreType          uint32    `json:"store_type"`            // 门店类型  1-自有 2-合作商
	Action             uint32    `json:"action"`                // 1-未激活 2-激活邀请
	SpendType          uint32    `json:"spend_type"`            // 1-未开通 2-开通会员 3-续费 4-升级 5-店员推广续费
	MemberLevel        uint32    `json:"member_level"`          // 会员等级
	MemberGenre        uint32    `json:"member_genre"`          // 会员类型
	UserInviteRecordId uint32    `json:"user_invite_record_id"` // 邀请记录
	FirstInvite        uint32    `json:"first_invite"`          // 首次
	Scan               uint32    `json:"scan"`                  // 扫码
	InviteForm         uint32    `json:"invite_form"`           // 邀请方式: 1-店员邀请码续费
	RenewHide          uint32    `json:"renew_hide"`            // 自动续费
	//InviteTime         time.Time `json:"invite_time"`           // 邀请时间
	ToUser *User `json:"to_user" gorm:"-"`

	//ToUser             *UserLess `json:"to_user" gorm:"-"`      //
}

type UserLess struct {
	Uid            uint32    `json:"uid"`
	MemberOpenTime time.Time `json:"member_open_time"` // 开通会员
	MemberLevel    uint32    `json:"member_level"`     // 会员等级
}

const (
	DepositRefundStatusUnconfirmed = 1 // 待确认
	DepositRefundStatusConfirmed   = 2 // 已确认
	DepositRefundStatusRefunded    = 3 // 已退款
	DepositRefundStatusRefused     = 4 // 已拒绝
)
const (
	MemberExpireDelayDailyFee = 200
)

// gen:qs
type DepositRefundRecord struct {
	Model

	Uid         uint32    `json:"uid"`
	Status      uint32    `json:"status"` //  1 // 待确认 2 // 已确认  3 // 已退款 4 // 已拒绝
	Amount      uint32    `json:"amount"`
	Operator    uint32    `json:"operator"`
	ConfirmTime time.Time `json:"confirm_time"`
	User        User      `json:"user" gorm:"-"`
}

const (
	FundTypeMemberFee         = "member_fee"          // 会员费
	FundTypeMemberDeposit     = "member_deposit"      // 押金
	FundTypeExpressFee        = "express_fee"         // 邮费
	FundTypeUpgradeMember     = "upgrade_member"      // 升级会员
	FundTypeMemberExpireDelay = "member_expire_delay" // 滞纳金
	FundTypeDepositRefund     = "deposit_refund"      // 退押金
	FundTypeExpressFeeRefund  = "express_fee_refund"  // 退邮费
	FundTypeBuyGoods          = "buy_goods"           // 购买商品
	FundTypeBuyGoodsCancel    = "buy_goods_cancel"    // 购买商品取消订单
	FundTypeBuyGoodsRefund    = "buy_goods_refund"    // 购买商品退货
	FundTypeRecycleCard       = "recycle_card"        // 回收卡带
	FundTypePostagePackageFee = "postage_package_fee" // 购买运费包
)

// gen:qs
type FundRecord struct {
	Model
	Uid           uint32 `json:"uid"  gorm:"index"`
	FundType      string `json:"fund_type"  gorm:"index"` //  -member_gold   -member_platinum  -member_black_gold
	Amount        int64  `json:"amount"`
	TransactionId string `json:"transaction_id"  gorm:"index"` // 支付单号
	OutTradeNo    string `json:"out_trade_no" gorm:"index"`
	RefundId      string `json:"refund_id"  gorm:"index"`
	PaymentNo     string `json:"payment_no"  gorm:"index"` // 付款单号
	Status        uint32 `json:"status"`                   //  1-待支付 2-已支付 3-已退款
	Remark        string `json:"remark"`                   // 备注

}

// gen:qs
type UserRentCard struct {
	Model
	Uid            uint32 `json:"uid"`
	MemberLevel    uint32 `json:"member_level"`     // 会员等级 1-用户  2-会员
	LevelRentCount uint32 `json:"level_rent_count"` // 等级借卡数量
	HaveRentCount  uint32 `json:"have_rent_count"`  // 已借卡数量
	CanRentCount   uint32 `json:"can_rent_count"`   // 可借卡数量
	Status         uint32 `json:"status"`           // 状态
}

// gen:qs
type UserMemberExpireDelay struct {
	Model

	Uid          uint32    `json:"uid" gorm:"column:uid;index"`
	MemberExpire time.Time `json:"member_expire"` // 会员到期时间
	DelayAmount  uint32    `json:"delay_amount"`
	ExpireDays   uint32    `json:"expire_days"`
	DailyFee     uint32    `json:"daily_fee"`
	IsPay        uint32    `json:"is_pay"` // 1-已支付
}

// gen:qs
type XcxRole struct {
	Model
	RoleId   uint32 `json:"role_id" gorm:"unique_index,not null"`
	RoleName string `json:"role_name" gorm:"size:255;"` // 角色名称
	RoleKey  string `json:"role_key" gorm:"size:255;"`  // 角色代码
	RoleSort int    `json:"role_sort" gorm:""`          // 角色排序
	Status   string `json:"status" gorm:"size:255;"`    // 状态:1-停用 2-正常
	Flag     string `json:"flag" gorm:"size:255;"`      //
	CreateBy string `json:"create_by" gorm:"size:255;"` //
	UpdateBy string `json:"update_by" gorm:"size:255;"` //
	Remark   string `json:"remark" gorm:"size:255;"`    // 备注

	Params  string `json:"params" gorm:"-"`
	MenuIds []int  `json:"menuIds" gorm:"-"`
	DeptIds []int  `json:"deptIds" gorm:"-"`
}

// gen:qs
type ShopperPromotionCode struct {
	Model

	Uid     uint32 `json:"uid" gorm:"column:uid;index"`
	State   uint32 `json:"state"` // 1-停用 2-使用
	Code    string `json:"code"  gorm:"index"`
	StoreId uint32 `json:"store_id"` // 门店id
	// shopper_promotion_code
}

func GetUserByUid(uid uint32) *User {
	user := new(User)
	if err := NewUserQuerySet(DB).UidEq(uid).One(user); err != nil {
		logger.Error(err, uid)
		return user
	}
	return user
}

func GetUserRentCard(uid uint32) *UserRentCard {
	userRent := new(UserRentCard)
	if err := NewUserRentCardQuerySet(DB).UidEq(uid).One(userRent); err != nil {
		logger.Error(err, uid)
		return nil
	}
	return userRent
}

func UserUpdate(user *User) error {
	if user.Uid == 0 {
		return errors.New("uid is null")
	}
	fields := make([]UserDBSchemaField, 0)
	if user.WxName != "" {
		fields = append(fields, UserDBSchema.WxName)
	}
	if user.WxAvatar != "" {
		fields = append(fields, UserDBSchema.WxAvatar)
	}
	if user.Tel != "" {
		fields = append(fields, UserDBSchema.Tel)
	}
	if user.MemberLevel != 0 {
		fields = append(fields, UserDBSchema.MemberLevel)
		fields = append(fields, UserDBSchema.MemberExpire)
	}
	if user.Deposit != 0 {
		fields = append(fields, UserDBSchema.Deposit)
	}

	if len(fields) > 0 {
		err := user.Update(DB.Where(&User{Uid: user.Uid}), fields...)
		if err != nil {
			logger.Error("err:", err)
			return err
		}
	}

	return nil
}

//OrderType: 1-物流支付 2-取消物流租卡 3-滞纳金 4-收回卡 5-退物流费 6-商城购物 7-购买商品取消订单 8-购买商品订单退货 9-升级会员 10-开通 续费 11-运费包

// gen:qs
type UserOpenMemberRecord struct {
	Model

	Uid           uint32    `json:"uid" gorm:"index"`
	OpenNo        string    `json:"open_no" gorm:"index"`
	OrderId       uint32    `json:"order_id" gorm:"index"`
	OrderType     uint32    `json:"order_type"`
	MemberLevel   uint32    `json:"member_level"`
	MemberGenre   uint32    `json:"member_genre"`
	MemberExpire  time.Time `json:"member_expire"`               // 会员到期时间
	UserCouponId  uint32    `json:"user_coupon_id" gorm:"index"` // 优惠券id
	State         uint32    `json:"state"`                       // 1-未处理 2-已处理
	DeductionDays uint32    `json:"deduction_days"`
	DeductionFee  uint32    `json:"deduction_fee"`

	Order             *Order             `json:"order"  gorm:"-"`
	ShareCardRetrieve *ShareCardRetrieve `json:"share_card_retrieve"  gorm:"-"`
	GoodsOrder        *GoodsOrder        `json:"goods_order"  gorm:"-"`
	Attach            string             `json:"attach"`
}

func (o *UserOpenMemberRecord) TableName() string {
	return "user_open_member_record"
}

func (m UserOpenMemberRecord) Insert() error {
	err := m.Create(DB)
	if err != nil {
		logger.Error("err:", err)
		return err
	}
	return nil
}

const (
	LogCorrelationOrderId            = "order_id"
	LogCorrelationOrderCard          = "order_card_id"
	LogCorrelationRecycleCardOrderId = "recycle_card_order_id"
)
const (
	OperationTypeRentCardRevert              = "rent_card_revert"
	OperationTypeRentCardDeliver             = "rent_card_deliver"
	OperationTypeGameCardGoodsInStock        = "game_card_goods_in_stock"        // 入库
	OperationTypeRecycleCardOrderImageUpdate = "recycle_card_order_image_update" // 回收卡上传图片
)

// gen:qs
type OperationLog struct {
	Model
	Uid                   uint32 `json:"uid" gorm:"index"` // 店员id
	SysUid                uint32 `json:"sys_uid" gorm:"index"`
	Description           string `json:"description"`                          // 描述
	OperationType         string `json:"operation_type" gorm:"index"`          // 操作类型
	CorrelationId         uint32 `json:"correlation_id" gorm:"index"`          // 关联id
	CorrelationName       string `json:"correlation_name" gorm:"index"`        // 关联name
	StoreId               uint32 `json:"store_id" gorm:"index"`                // 门店id
	StoreName             string `json:"store_name"`                           // 门店名称
	CooperativeName       string `json:"cooperative_name"`                     // 合作商名称
	CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
	SerialNumber          string `json:"serial_number" gorm:"index"`           // 卡编号
	Detail                string `json:"detail"`                               // 详情
	Remark                string `json:"remark"`                               // 备注
}

// gen:qs
type UserMemberDurationRecord struct {
	Model

	Uid         uint32 `json:"uid"`
	Duration    uint32 `json:"duration"`
	EventType   uint32 `json:"event_type"`   // 类型: 1-购买运费包
	MemberLevel uint32 `json:"member_level"` // 会员等级 1-用户  2-会员
}

func (m *UserOpenMemberRecord) OrderRefund(outTradeNo string) error {
	if m.Order == nil {
		return errors.New("order is nil")
	}
	if m.OpenNo == "" {
		m.OpenNo = GetOrderSn()
	}
	m.Uid = uint32(m.Order.Uid)
	m.OrderId = m.Order.ID

	err := m.Refund(outTradeNo, m.Order.PayPrice)
	if err != nil {
		logger.Error("refund err:", err)
		return err
	}

	return nil
}

func (m *UserOpenMemberRecord) MallGoodsOrderRefund(outTradeNo string) error {
	if m.GoodsOrder == nil {
		return errors.New("goods order is nil")
	}
	if m.OpenNo == "" {
		m.OpenNo = GetOrderSn()
	}
	m.Uid = uint32(m.GoodsOrder.Uid)
	m.OrderId = m.GoodsOrder.ID

	err := m.Refund(outTradeNo, m.GoodsOrder.Rm)
	if err != nil {
		logger.Error("refund err:", err)
		return err
	}

	return nil
}

// gen:qs
type InviteMemberReport struct {
	Model
	Uid            uint32 `json:"uid" gorm:"index"`      // 店员uid
	StoreId        uint32 `json:"store_id" gorm:"index"` // 门店id
	GoldCount      uint32 `json:"gold_count"`            // 黄金数量
	PlatinumCount  uint32 `json:"platinum_count"`        // 白金数量
	BlackGoldCount uint32 `json:"black_gold_count"`      // 黑金数量
	//ReportTime            string `json:"report_time" gorm:"index"`             // 业绩时间
	Date                  string `json:"date" gorm:"index"`                    // 业绩时间
	DeductAmount          uint32 `json:"deduct_amount"`                        // 店员提成
	CooperativeBusinessId uint32 `json:"cooperative_business_id" gorm:"index"` // 合作商id
	CooperativeName       string `json:"cooperative_name"`                     // 合作商名称
	GoldDeduct            uint32 `json:"gold_deduct"`                          // 黄金会员提成
	PlatinumDeduct        uint32 `json:"platinum_deduct"`                      // 白金会员提成
	BlackGoldDeduct       uint32 `json:"black_gold_deduct"`                    // 黑金会员提成
	RenewalGoldCount      uint32 `json:"renewal_gold_count"`                   // 续费黄金会员数量
	RenewalPlatinumCount  uint32 `json:"renewal_platinum_count"`               // 续费白金会员数量
	RenewalBlackGoldCount uint32 `json:"renewal_black_gold_count"`             // 续费黑金会员数量
	// invite_member_report
	User *User `json:"user" gorm:"-"`
}

func (m *UserOpenMemberRecord) Refund(outTradeNo string, amount uint32) error {
	configInfo, err := PayConfigInfo()
	if err != nil {
		logger.Error("config info err:", err)
		return err
	}
	//configInfo.NotifyUrl = "https://dev.switch.deovo.com:8004/api/v1/wxpay_refund/notice"
	err = m.Insert()
	if err != nil {
		logger.Error("insert user open member record err:", err)
		return err
	}

	orderRefund := wxpay.OrderRefund{
		OutTradeNo:  outTradeNo,
		OutRefundNo: m.OpenNo,
		NotifyUrl:   configInfo.RefundNotifyUrl,
		Amount: wxpay.OrderRefundAmount{
			Refund:   amount,
			Total:    amount,
			Currency: "CNY",
		},
	}

	err = wxpay.HmRefundTransaction(orderRefund)
	if err != nil {
		logger.Error("err:", err)
		return err
	}
	//err = wxpay.TransactionOrderRefund(orderRefund)
	//if err != nil {
	//	logger.Error("err:", err)
	//	return err
	//}

	//FundRecord{
	//	Uid:           m.Uid,
	//	FundType:      FundTypeExpressFeeRefund,
	//	Amount:        int64(m.Order.PayPrice) * (-1),
	//	TransactionId: "",
	//	OutTradeNo:    "",
	//	Status:        0,
	//	Remark:        "",
	//}
	return nil
}

//func (m *UserOpenMemberRecord) ShareCardRetrieveRefund(outTradeNo string) error {
//	//if m.ShareCardRetrieve == nil {
//	//	return errors.New("order is nil")
//	//}
//	//if m.OpenNo == "" {
//	//	m.OpenNo = GetShareCardRetrieveOrderSn()
//	//}
//	//m.Uid = uint32(m.Order.Uid)
//	//m.OrderId = m.ShareCardRetrieve.ID
//	//configInfo, err := PayConfigInfo()
//	//if err != nil {
//	//	logger.Error("config info err:", err)
//	//	return err
//	//}
//	//
//	//err = m.Insert()
//	//if err != nil {
//	//	logger.Error("insert user open member record err:", err)
//	//	return err
//	//}
//	//
//	//orderRefund := wxpay.OrderRefund{
//	//	OutTradeNo:  outTradeNo,
//	//	OutRefundNo: m.OpenNo,
//	//	NotifyUrl:   configInfo.NotifyUrl,
//	//	Amount: wxpay.OrderRefundAmount{
//	//		Refund:   m.ShareCardRetrieve.PayAmount,
//	//		Total:    m.ShareCardRetrieve.PayAmount,
//	//		Currency: "CNY",
//	//	},
//	//}
//	//err = wxpay.TransactionOrderRefund(orderRefund)
//	//if err != nil {
//	//	logger.Error("err:", err)
//	//	return err
//	//}
//	return nil
//}

func (m *UserOpenMemberRecord) GetByOpenNo() error {
	err := NewUserOpenMemberRecordQuerySet(DB).OpenNoEq(m.OpenNo).One(m)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return err
	}
	return nil
}

// gen:qs
type CommonProblem struct {
	Model

	Question string `json:"question"`
	Answer   string `json:"answer" gorm:"type:text"`
	Sort     uint32 `json:"sort" gorm:"index"`
}

type GroupSendMessageTemplate struct {
	Model

	Title    string    `json:"title" `
	Message  string    `json:"message"`
	UserType uint32    `json:"user_type" gorm:"index,column:user_type"` // 1-所有用户 2-会员 3-非会员 4-指定用户
	SendTime time.Time `json:"send_time"`
	Tels     string    `json:"tels"`
	Status   uint32    `json:"status"` // 1-待发送 2-已发送
}

func (*CommonProblem) TableName() string {
	return "common_problem"
}

func (*CommonProblem) List() ([]CommonProblem, error) {
	commons := make([]CommonProblem, 0)
	err := NewCommonProblemQuerySet(DB).OrderDescBySort().All(&commons)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return commons, err
	}
	return commons, err
}

func (m *User) AppletQRCodeUpdate() error {
	num, err := NewUserQuerySet(DB).UidEq(m.Uid).GetUpdater().SetInviteCodeUrl(m.InviteCodeUrl).UpdateNum()
	if err != nil || num != 1 {
		logger.Error("AppletQRCodeUpdate err")
		return errors.New("AppletQRCodeUpdate err")
	}
	return nil
}

type UserInviteListReq struct {
	Page       int    `json:"page"`
	PageSize   int    `json:"page_size"`
	Uid        uint32 `json:"uid"`
	MemberType int    `json:"member_type"` // 0-全部 1-普通用户 2-会员
	SpendType  uint32 `json:"spend_type"`  //   2-开通会员 3-续费
	StartTime  string `json:"start_time"`  // 开始时间
	EndTime    string `json:"end_time"`    // 结束时间
}

type UserInviteListResp struct {
	Page      int `json:"page"`
	TotalPage int `json:"total_page"`
	//List      []UserInviteList `json:"list"`
	List  []UserInvite `json:"list"`
	Count int          `json:"count"`
}

//type UserInviteList struct {
//	User       User       `json:"user"`
//	UserInvite UserInvite `json:"user_invite"`
//}

func (m *UserInviteListReq) InviteUserList() (*UserInviteListResp, error) {
	list := make([]User, 0)
	resp := &UserInviteListResp{
		Page: m.Page,
		List: make([]UserInvite, 0),
	}
	page := m.Page - 1
	if page < 0 {
		page = 0
	}

	if m.PageSize == 0 {
		m.PageSize = 10
	}

	qs := NewUserInviteQuerySet(DB).FromUidEq(m.Uid).ActionEq(2)
	if m.MemberType != 0 {
		qs = qs.MemberTypeEq(uint32(m.MemberType))
		if m.MemberType == 2 {
			user := GetUserByUid(m.Uid)
			//qs = qs.FirstInviteNe(1).SpendTypeEq(2)
			//qs = qs.SpendTypeEq(2)
			//qs = qs.SpendTypeNotIn([]uint32{3, 4}...)
			if user.CooperativeBusinessId == 1 {
				if m.SpendType != 0 {
					qs = qs.SpendTypeEq(m.SpendType)
					if m.SpendType == 3 {
						qs = qs.InviteFormEq(1)
					}
				} else {
					qs = qs.SpendTypeIn([]uint32{2, 3}...)
				}
			} else {
				qs = qs.SpendTypeNotIn([]uint32{3, 4}...)
			}
		}
	}
	if m.MemberType == 0 && m.SpendType != 0 {
		qs = qs.SpendTypeEq(m.SpendType)
		if m.SpendType == 3 {
			qs = qs.InviteFormEq(1)
		}
	}
	if m.StartTime != "" {
		parse, err := time.Parse(DateTimeFormat, m.StartTime)
		if err != nil {
			logger.Errorf("err:%#v", err)
			return resp, err
		}
		if m.MemberType == 2 {
			qs = qs.MemberOpenTimeGte(parse)
		} else {
			qs = qs.CreatedAtGte(parse)
		}
	}
	if m.EndTime != "" {
		parse, err := time.Parse(DateTimeFormat, m.EndTime)
		if err != nil {
			logger.Errorf("err:%#v", err)
			return resp, err
		}
		if m.MemberType == 2 {
			qs = qs.MemberOpenTimeLte(parse.AddDate(0, 0, 1))
		} else {
			qs = qs.CreatedAtLte(parse.AddDate(0, 0, 1))
		}
	}

	count, err := qs.Count()
	if err != nil {
		logger.Error("err:", err)
		return resp, err
	}
	resp.TotalPage = count/m.PageSize + 1
	resp.Count = count

	var invites []UserInvite
	//err = qs.Offset(page * m.PageSize).Limit(m.PageSize).OrderDescByID().All(&invites)
	err = qs.OrderDescByCreatedAt().Offset(page * m.PageSize).Limit(m.PageSize).OrderDescByMemberOpenTime().All(&invites)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return resp, err
	}
	//if len(invites) == 0 {
	//	return resp, nil
	//}
	uids := make([]uint32, 0)
	//inviteMap := make(map[uint32]UserInvite, 0)
	for i, _ := range invites {
		uids = append(uids, invites[i].ToUid)
		//inviteMap[invites[i].ToUid] = invites[i]
		if invites[i].MemberStatus != 1 {
			invites[i].CreatedAt = invites[i].MemberOpenTime
		}
	}
	if len(uids) == 0 {
		return resp, nil
	}
	err = NewUserQuerySet(DB).UidIn(uids...).All(&list)
	if err != nil {
		logger.Error("err:", err)
		return resp, err
	}

	userMap := make(map[uint32]User, 0)
	for i, _ := range list {
		userMap[list[i].Uid] = list[i]
	}
	for i, _ := range invites {
		user, ok1 := userMap[uids[i]]
		if ok1 {
			invites[i].ToUser = &user
		}
	}
	//users := make([]User, 0)
	//users := make([]UserInviteList, 0)
	//for i, _ := range uids {
	//	user, ok1 := userMap[uids[i]]
	//	invite, ok2 := inviteMap[uids[i]]
	//	if !ok1 || !ok2 {
	//		continue
	//	}
	//	userInvite := UserInviteList{
	//		User:       user,
	//		UserInvite: invite,
	//	}
	//	users = append(users, userInvite)
	//}
	resp.List = invites

	return resp, nil
}

func GetOrderSn() string {
	var orderSn string
	for {
		//orderSn = utils.GetSerialNo32HEXString()
		orderSn = utils.GenSerialNo()
		count, err := NewUserOpenMemberRecordQuerySet(DB).OpenNoEq(orderSn).Count()
		if err != nil {
			logger.Error("err:", err)
		}
		if count == 0 {
			break
		}
	}
	return orderSn
}

func GetShareCardBillSn() string {
	var billSn string
	for {
		//billSn = utils.GetSerialNo32HEXString()
		billSn = utils.GenSerialNo()
		count, err := NewUserShareCardBillQuerySet(DB).BillSnEq(billSn).Count()
		if err != nil {
			logger.Error("err:", err)
		}
		if count == 0 {
			break
		}
	}
	return billSn
}

func GetShareCardRetrieveOrderSn() string {
	var orderSn string
	for {
		//orderSn = utils.GetSerialNo32HEXString()
		orderSn = utils.GenSerialNo()
		count, err := NewShareCardRetrieveQuerySet(DB).OrderSnEq(orderSn).Count()
		if err != nil {
			logger.Error("err:", err)
		}
		if count == 0 {
			break
		}
	}
	return orderSn
}

func (m *User) Edit() {
	err := DB.Save(m).Error
	if err != nil {
		logger.Error("err:", err)
	}
	return
}

func GetWxPayExpressFeeRefundRecord(orderId uint32) (string, error) {
	var openMemberRecord UserOpenMemberRecord
	//err := NewUserOpenMemberRecordQuerySet(DB).OrderIdEq(orderId).OrderTypeEq(1).
	//OrderDescByID().Limit(1).One(&openMemberRecord)
	err := NewUserOpenMemberRecordQuerySet(DB).OrderIdEq(orderId).OrderDescByID().
		Limit(1).One(&openMemberRecord)
	if err != nil {
		logger.Error("err:", err)
		return "", err
	}
	return openMemberRecord.OpenNo, nil
}

func GetDepositRefundRecordList(uid uint32) ([]DepositRefundRecord, error) {
	var deposits []DepositRefundRecord
	err := NewDepositRefundRecordQuerySet(DB).UidEq(uid).OrderDescByID().All(&deposits)
	if err != nil {
		logger.Error("deposit refund record err:", err)
		return deposits, err
	}
	return deposits, nil
}

var userMutexMap map[string]*sync.Mutex

func GetUserMutexMap() map[string]*sync.Mutex {
	if userMutexMap == nil {
		userMutexMap = make(map[string]*sync.Mutex, 0)
	}
	return userMutexMap
}

func GetUserMutex(mutexKey string) *sync.Mutex {
	mutexMap := GetUserMutexMap()
	if v, ok := mutexMap[mutexKey]; ok {
		return v
	} else {
		mutexMap[mutexKey] = new(sync.Mutex)
		return mutexMap[mutexKey]
	}
}

//func AuthLoginMutex(uid uint32) *sync.Mutex {
//	return GetUserMutex(fmt.Sprintf("AuthLogin:%d", uid))
//}

var AuthLoginMutex = sync.Mutex{}

func OrderCardUserRentCard(uid uint32, count uint32, memberConfig *MemberConfig, gdb *gorm.DB) error {
	//UserRentCard{}
	if gdb == nil {
		gdb = DB
	}
	var userRentCard UserRentCard
	err := NewUserRentCardQuerySet(DB).UidEq(uid).One(&userRentCard)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return err
	}
	if err == RecordNotFound {
		user := GetUserByUid(uid)
		if user == nil {
			logger.Error("user nil")
			return errors.New("user nil")
		}
		if memberConfig == nil {
			memberConfig, err = GetMemberConfig(user.MemberLevel, user.MemberGenre)
			if err != nil {
				logger.Error("GetMemberConfig err:", err)
				return err
			}
		}
		rentCard := &UserRentCard{
			Uid:            uid,
			MemberLevel:    user.MemberLevel,
			LevelRentCount: memberConfig.CardMax,
			HaveRentCount:  uint32(count),
			CanRentCount:   uint32(memberConfig.CardMax - count),
			Status:         0,
		}
		err := gdb.Create(rentCard).Error
		if err != nil {
			logger.Error("err", err)
			return err
		}
		return nil
	}
	sql := fmt.Sprintf(
		"UPDATE user_rent_card SET have_rent_count=have_rent_count+%d ,can_rent_count=can_rent_count-%d WHERE uid = %d",
		count, count, uid)
	err = gdb.Exec(sql).Error
	if err != nil {
		logger.Error("err", err)
		return err
	}
	return nil
}

func ShoppingCartCreateOrder(uid uint32, cards []CardInfo) {
	cardIds := make([]uint64, 0, len(cards))
	for i, _ := range cards {
		cardIds = append(cardIds, uint64(cards[i].GameCardId))
	}
	err := NewShoppingCartQuerySet(DB).UidEq(uint64(uid)).GameCardIdIn(cardIds...).Delete()
	if err != nil {
		logger.Error("err:", err)
	}
	return
}

func ShoppingCartCreateOrderByOrder(order Order) {
	var orderCards []OrderCard
	err := NewOrderCardQuerySet(DB).OrderIdEq(order.ID).All(&orderCards)
	if err != nil {
		logger.Error("err:", err.Error())
	}
	cardIds := make([]uint64, 0, len(orderCards))
	for i, _ := range orderCards {
		cardIds = append(cardIds, uint64(orderCards[i].GameCardId))
	}
	err = NewShoppingCartQuerySet(DB).UidEq(uint64(order.Uid)).GameCardIdIn(cardIds...).Delete()
	if err != nil {
		logger.Error("err:", err)
	}
	return
}

func CreateUserRentCardByMemberLevel(uid, memberLevel, cardMax uint32) {
	var userRentCard UserRentCard
	err := NewUserRentCardQuerySet(DB).UidEq(uid).One(&userRentCard)
	if err != nil && err != RecordNotFound {
		logger.Error("UserRentCard err:", err)
		return
	}

	if err == RecordNotFound {
		userRentCard = UserRentCard{
			Uid:            uid,
			MemberLevel:    memberLevel,
			LevelRentCount: cardMax,
			HaveRentCount:  0,
			CanRentCount:   cardMax,
			Status:         0,
		}
		err := DB.Create(&userRentCard).Error
		if err != nil {
			logger.Error("UserRentCard create err:", err)
		}
		return
	}
	_, err = NewUserRentCardQuerySet(DB).IDEq(userRentCard.ID).GetUpdater().
		SetMemberLevel(memberLevel).
		SetCanRentCount(cardMax - userRentCard.HaveRentCount).
		SetLevelRentCount(cardMax).UpdateNum()
	if err != nil {
		logger.Error("update err:", err)
	}
}

func MemberExpireDelaying(uid uint32) (map[string]interface{}, error) {
	ret := make(map[string]interface{}, 0)
	ret["is_surrender"] = 0
	ret["expire_days"] = 0
	ret["daily_fee"] = MemberExpireDelayDailyFee
	ret["delay_amount"] = 0
	var user User
	err := NewUserQuerySet(DB).UidEq(uid).One(&user)
	if err != nil {
		logger.Error("user err:", err)
		return ret, err
	}
	var userMemberExpireDelay UserMemberExpireDelay
	err = NewUserMemberExpireDelayQuerySet(DB).UidEq(uid).MemberExpireEq(user.MemberExpire).One(&userMemberExpireDelay)
	if err != nil && err != RecordNotFound {
		logger.Error("user member expire delay err:", err)
		return ret, err
	}
	if err == nil {
		if userMemberExpireDelay.IsPay != 1 {
			ret["is_surrender"] = 1
			ret["expire_days"] = userMemberExpireDelay.ExpireDays
			ret["daily_fee"] = userMemberExpireDelay.DailyFee
			ret["delay_amount"] = userMemberExpireDelay.DelayAmount
		}
		return ret, nil
	}
	var orderCard OrderCard
	err = NewOrderCardQuerySet(DB).UidEq(uid).CardStatusIn([]uint32{1, 2, 3, 4}...).OrderDescByOrderId().One(&orderCard)
	if err != nil && err != RecordNotFound {
		logger.Error("order card err:", err)
		return ret, err
	}

	if err == RecordNotFound {
		var order Order
		err = NewOrderQuerySet(DB).UidEq(uint64(uid)).CardStatusIn([]uint8{1, 2, 3, 4}...).OrderDescByID().Limit(1).One(&order)
		if err != nil && err != RecordNotFound {
			logger.Error("order card err:", err)
			return ret, err
		}
		orderCard.RevertTime = order.RevertTime
		orderCard.CardStatus = uint32(order.CardStatus)
	}
	deadline := orderCard.RevertTime
	if orderCard.CardStatus > 0 && orderCard.CardStatus != 4 {
		deadline = time.Now()
	}
	if user.MemberLevel == 3 {
		deadline = time.Unix(1647925200, 0)
	}

	if user.MemberExpire.AddDate(0, 0, 1).Before(deadline) {
		days := (deadline.Unix() - user.MemberExpire.Unix()) / 24 / 3600
		if user.MemberLevel != 3 || (user.MemberLevel == 3 && days > 7) {
			ret["is_surrender"] = 1
			ret["expire_days"] = days
			ret["delay_amount"] = days * MemberExpireDelayDailyFee
			delay := &UserMemberExpireDelay{
				Uid:          uid,
				MemberExpire: user.MemberExpire,
				DelayAmount:  uint32(days) * MemberExpireDelayDailyFee,
				ExpireDays:   uint32(days),
				DailyFee:     MemberExpireDelayDailyFee,
				IsPay:        0,
			}
			err := delay.Create(DB)
			if err != nil {
				logger.Error("delay create err:", err)
			}
		}
	}
	return ret, nil
}

func (m *OperationLog) AddLog() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("recover err:", err)
		}
	}()
	go func() {
		err := DB.Create(m).Error
		if err != nil {
			logger.Error("create operation log err:")
		}
	}()
}

type InviteMemberReportListReq struct {
	PageNum  int    `json:"page_num"`
	PageSize int    `json:"page_size"`
	Uid      uint32 `json:"uid"`
}

func (m *InviteMemberReportListReq) List() ([]InviteMemberReport, int, error) {
	var memberReport []InviteMemberReport
	qs := NewInviteMemberReportQuerySet(DB).UidEq(m.Uid)
	count, err := qs.Count()
	if err != nil {
		logger.Error("err:", err)
		return memberReport, 0, err
	}
	page := m.PageNum - 1
	if page < 0 {
		page = 0
	}
	if m.PageSize == 0 {
		m.PageSize = 10
	}
	totalPage := count/m.PageSize + 1

	err = qs.Offset(page * m.PageSize).Limit(m.PageSize).OrderDescByID().All(&memberReport)
	if err != nil && err != RecordNotFound {
		logger.Error("err:", err)
		return memberReport, totalPage, err
	}

	assistant := GetUserByUid(m.Uid)
	cooperative := new(CooperativeBusiness)
	cooperative.ID = assistant.CooperativeBusinessId
	cooperative.SetAssistantMemberDeductConfig(uint32(assistant.StoreId))
	fmt.Println("CooperativeBusinessId:", assistant.CooperativeBusinessId, assistant.StoreId)
	fmt.Println("CooperativeAssistantMemberDeduct:", cooperative.CooperativeAssistantMemberDeduct)
	if len(memberReport) > 0 {
		memberReport[len(memberReport)-1].GoldDeduct = cooperative.CooperativeAssistantMemberDeduct.GoldDeduct
		memberReport[len(memberReport)-1].PlatinumDeduct = cooperative.CooperativeAssistantMemberDeduct.PlatinumDeduct
		memberReport[len(memberReport)-1].BlackGoldDeduct = cooperative.CooperativeAssistantMemberDeduct.BlackGoldDeduct

		report := memberReport[len(memberReport)-1]
		fmt.Println("report:", report)
		memberReport[len(memberReport)-1].DeductAmount += report.GoldCount * report.GoldDeduct
		memberReport[len(memberReport)-1].DeductAmount += report.PlatinumCount * report.PlatinumDeduct
		memberReport[len(memberReport)-1].DeductAmount += report.BlackGoldCount * report.BlackGoldDeduct
	}

	return memberReport, totalPage, nil
}

func GetUserMap(ids []uint32) (map[uint32]*User, error) {
	userMap := make(map[uint32]*User, 0)
	if len(ids) == 0 {
		return userMap, nil
	}
	var users []User
	err := NewUserQuerySet(DB).UidIn(ids...).All(&users)
	if err != nil {
		logger.Error("user  err:", err)
		return userMap, err
	}
	for i, _ := range users {
		userMap[users[i].Uid] = &users[i]
	}
	return userMap, nil
}

func (u *User) SetVm() error {
	var userVm UserVm
	err := NewUserVmQuerySet(DB).UidEq(u.Uid).One(&userVm)
	if err != nil {
		log.Error().Msgf("UserVm err:%#v", err)
		return err
	}
	u.UserVm = &userVm
	return nil
}

func UserInviteListSetToUser(list []UserInvite) {
	//ids := make([]uint32, 0, len(list))
	//for i, _ := range list {
	//	ids = append(ids, list[i].ToUid)
	//}
	//
	//userMap, err := GetUserMap(ids)
	//if err != nil {
	//	logger.Error("user map err:", err)
	//	return
	//}

	//for i, _ := range list {
	//	v, ok := userMap[list[i].ToUid]
	//	if ok {
	//
	//		list[i].ToUser = &UserLess{
	//			Uid:            v.Uid,
	//			MemberOpenTime: v.OpenMemberTime,
	//			MemberLevel:    v.MemberLevel,
	//		}
	//	}
	//}
}

// gen:qs
type MemberStatisticDaily struct {
	Model

	MemberLevel  uint32    `json:"member_level"`
	Date         string    `json:"date"`
	DateTime     time.Time `json:"date_time"`
	Increase     uint32    `json:"increase"`
	Expire       uint32    `json:"expire"`
	Net          uint32    `json:"net"`
	Accumulative uint32    `json:"accumulative"`
}

func StorePromotion(inviteUid, uid uint32, inviteUser, user *User) error {
	//inviteUid := uint32(0)
	//uid := uint32(0)
	if inviteUser == nil {
		inviteUser = GetUserByUid(inviteUid)
	}
	if user == nil {
		user = GetUserByUid(uid)
	}

	if user == nil || inviteUser == nil {
		logger.Error("user inviteUser is nil")
		return errors.New("user inviteUser is nil")
	}
	nowTime := time.Now()

	if inviteUser.UserType == 2 && user.Uid != 0 {
		exist, err := QueryRecordExist(
			fmt.Sprintf("SELECT * FROM user_invite_record WHERE to_uid = %d AND from_uid = %d ",
				user.Uid, inviteUid))
		if err != nil {
			logger.Error("query err:", err)
			return err
		}
		if !exist {
			firstInviteRecord := &UserInviteRecord{
				ToUid:       user.Uid,
				FromUid:     inviteUid,
				Action:      2,
				SpendType:   1,
				MemberLevel: 0,
				First:       1,
				Scan:        1,
				ActionTime:  nowTime,
			}
			err = DB.Create(firstInviteRecord).Error
			if err != nil {
				logger.Error("create user invite record err:", err)
			}
			// 添加首次扫码
		}
		// 扫码记录
		inviteRecord := &UserInviteRecord{
			ToUid:       user.Uid,
			FromUid:     inviteUid,
			Action:      1,
			SpendType:   1,
			MemberLevel: 0,
			First:       0,
			Scan:        1,
			ActionTime:  nowTime,
		}
		err = DB.Create(inviteRecord).Error
		if err != nil {
			logger.Error("create user invite record err:", err)
		}
		// UserInvite 邀请主要
		var inviteNew UserInvite
		inviteErr := NewUserInviteQuerySet(DB).ToUidEq(user.Uid).FromUidEq(inviteUid).ActionEq(1).
			SpendTypeEq(1).One(&inviteNew)
		if inviteErr != nil && inviteErr != RecordNotFound {
			// 是否存在未开通
			logger.Error("user invite err:", err)
		}
		//fmt.Println("inviteErr:", inviteErr)
		//fmt.Printf("inviteNew:%#v \n", inviteNew)
		if inviteErr == RecordNotFound {
			memberLevel := user.MemberLevel
			if memberLevel == 0 {
				memberLevel = MemberTypeConsumer
			}
			invite := &UserInvite{
				FromUid:            inviteUid,
				UserType:           inviteUser.UserType,
				StoreId:            inviteUser.StoreId,
				MemberOpenTime:     nowTime,
				MemberType:         memberLevel,
				MemberStatus:       1,
				ToUid:              user.Uid,
				Action:             1,
				SpendType:          1,
				UserInviteRecordId: inviteRecord.ID,
				FirstInvite:        0, // TODO
				Scan:               1,
				InviteForm:         1,
			}
			fmt.Println("创建邀请:", invite)
			if err := invite.Create(DB); err != nil {
				logger.Error(err)
				return err
			}
		}

		if inviteErr == nil {
			err = NewUserInviteQuerySet(DB).IDEq(inviteNew.ID).GetUpdater().SetCreatedAt(nowTime).
				SetUserInviteRecordId(inviteRecord.ID).SetInviteForm(1).Update()
			if err != nil {
				logger.Error("from uid update user invite err:", err, inviteUid)
			}
		}
	}

	return nil
}

func GetMemberGenreFromLevel(level uint32) uint32 {
	switch level {
	case 4: //白金
		return 400
	case 5: //黑金
		return 500
	}
	return 0
}

//// todo
//var userCoupon model.UserCoupon
//err := model.NewUserCouponQuerySet(model.DB).IDEq(record.UserCouponId).One(&userCoupon)
//if err != nil {
//logger.Error("user coupon err:", err)
//}
//	// UserInviteRecord
//	// user_invite
//	if userCoupon.PromotionalSales == 0 {
//		logger.Error("promotional sales  is null")
//	} else {
//		inviteCouponUser := model.GetUserByUid(userCoupon.PromotionalSales)
//		if inviteCouponUser != nil {
//			userCouponInvite := &model.UserInvite{
//				FromUid:            userCoupon.PromotionalSales,
//				UserType:           inviteCouponUser.UserType, // user.UserType
//				StoreId:            inviteCouponUser.StoreId,
//				MemberOpenTime:     newTime,
//				MemberType:         2,
//				MemberStatus:       2,
//				ToUid:              user.Uid,
//				StoreType:          inviteCouponUser.StoreType,
//				Action:             1,
//				SpendType:          spendType,
//				MemberLevel:        record.MemberLevel,
//				UserInviteRecordId: 0,
//				FirstInvite:        1,
//			}
//
//			err = userCouponInvite.Create(model.DB)
//			if err != nil {
//				logger.Error("create user coupon invite err:", err)
//			}
//		}
//	}