package controller

import (
	"encoding/json"
	"fmt"
	"github.com/codinl/go-logger"
	"github.com/gin-gonic/gin"
	"github.com/medivhzhan/weapp"
	"golang.org/x/sync/errgroup"
	"mh-server/config"
	"mh-server/lib/auth"
	"mh-server/lib/status"
	"mh-server/lib/utils"
	"mh-server/lib/utils/crypt"
	"mh-server/model"
	"time"
)

// AuthLogin 用户登陆
// @Summary 用户登陆
// @Tags 用户鉴权
// @Produce json
// @Accept json
// @Param request body model.AuthLoginReq true "用户登陆模型"
// @Success 200 {object} model.AuthLoginResp
// @Router /api/v1/auth/login [post]
func AuthLogin(c *gin.Context) {
	req := new(model.AuthLoginReq)

	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	fmt.Println("WxAppId", config.AppConfig.WxAppId)
	fmt.Println("WxAppSecret", config.AppConfig.WxAppSecret)
	model.AuthLoginMutex.Lock()
	defer model.AuthLoginMutex.Unlock()

	resp, err := weapp.Login(config.AppConfig.WxAppId, config.AppConfig.WxAppSecret, req.Code)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	if resp.SessionKey == "" {
		logger.Error("Get SessionKey Fail")
		RespJson(c, status.BadRequest, nil)
		return
	}
	fmt.Println("用户信息 resp:", resp)
	logger.Infof("OpenID=%+v", resp.OpenID)
	logger.Info("resp.UnionID=", resp.UnionID)

	// 解析手机号
	phone, err := weapp.DecryptPhoneNumber(resp.SessionKey, req.EncryptedData, req.Iv)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//// 解析用户数据
	//userInfo, err := weapp.DecryptUserInfo(req.RawData, req.EncryptedData, req.Signature, req.Iv, resp.SessionKey)
	//if err != nil {
	//	logger.Error(err)
	//	RespJson(c, status.BadRequest, nil)
	//	return
	//}
	//fmt.Println("用户信息 userInfo:", userInfo)

	var user = model.User{}
	sqlErr := model.NewUserQuerySet(model.DB).WxOpenIDEq(resp.OpenID).One(&user)
	if sqlErr != nil && sqlErr != model.RecordNotFound {
		logger.Error("WxOpenIDEq:", sqlErr)
		RespJson(c, status.DBOperateError, nil)
		return
	}

	fmt.Println("InviteUid:", req.InviteUid)
	nowTime := time.Now()

	if req.InviteUid != 0 && req.InviteUid != user.Uid && user.Uid != 0 { // 入参有邀请人id且非本人
		inviteUser := model.GetUserByUid(req.InviteUid)
		effectiveStoreInfo, err := model.GetUserEffectiveStore(req.InviteUid)
		if err != nil {
			RespJson(c, status.InviteUserFail, nil)
			return
		}
		//user.StoreId = uint64(effectiveStoreInfo.StoreID)

		if user.StoreId == 0 && user.Uid != 0 { // 用户所属门店id为空则更新
			_, err = model.NewUserQuerySet(model.DB).UidEq(user.Uid).GetUpdater().SetStoreId(effectiveStoreInfo.StoreID).
				UpdateNum()
			if err != nil {
				logger.Error("update err:", err)
			}
		}

		if inviteUser.UserType == 2 && user.Uid != 0 { // 店员邀请
			exist, err := model.QueryRecordExist(
				fmt.Sprintf("SELECT * FROM user_invite_record WHERE to_uid = %d AND from_uid = %d ",
					user.Uid, req.InviteUid))
			if err != nil {
				logger.Error("query err:", err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
			if !exist { // 未邀请过，则添加邀请记录：首次邀请记录
				firstInviteRecord := &model.UserInviteRecord{
					ToUid:       user.Uid,
					FromUid:     req.InviteUid,
					StoreId:     effectiveStoreInfo.StoreID,
					Action:      2,       // 激活邀请
					SpendType:   1,       // 未开通
					MemberLevel: 0,       // 0，未开通会员
					First:       1,       // 首次
					Scan:        1,       // 扫码次数
					ActionTime:  nowTime, // 激活时间
				}
				err = model.DB.Create(firstInviteRecord).Error
				if err != nil {
					logger.Error("create user invite record err:", err)
				}
			}
			// 已经邀请过，则更新扫码记录
			inviteRecord := &model.UserInviteRecord{
				ToUid:       user.Uid,
				FromUid:     req.InviteUid,
				StoreId:     effectiveStoreInfo.StoreID,
				Action:      1, // 未激活
				SpendType:   1, // 未开通
				MemberLevel: 0,
				First:       0,
				Scan:        1,
				ActionTime:  nowTime,
			}
			err = model.DB.Create(inviteRecord).Error
			if err != nil {
				logger.Error("create user invite record err:", err)
			}
			// UserInvite 邀请主要
			var inviteNew model.UserInvite
			inviteErr := model.NewUserInviteQuerySet(model.DB).ToUidEq(user.Uid).FromUidEq(req.InviteUid).ActionEq(1).
				SpendTypeEq(1).One(&inviteNew) // action:1-未激活 spend_type:1-未开通
			if inviteErr != nil && inviteErr != model.RecordNotFound {
				// 是否存在未开通
				logger.Error("user invite err:", err)
			}
			fmt.Println("inviteErr:", inviteErr)
			fmt.Printf("inviteNew:%#v \n", inviteNew)
			if inviteErr == model.RecordNotFound { // 邀请表没记录
				memberLevel := user.MemberLevel
				if memberLevel == 0 {
					memberLevel = model.MemberLevelUser // 普通会员
				}
				invite := &model.UserInvite{
					FromUid:            req.InviteUid,              // 邀请人用户id
					UserType:           inviteUser.UserType,        // 邀请人用户类型
					StoreId:            effectiveStoreInfo.StoreID, // 邀请人门店ID --- 邀请人如果有多家门店：优先取有效期短的门店，如果有效期相同则取门店id小的门店
					MemberOpenTime:     time.Time{},                // 开通会员时间
					MemberType:         memberLevel,                // 被邀请用户类型
					MemberStatus:       1,                          // 被邀请用户会员状态 1-未开通
					ToUid:              user.Uid,                   // 被邀请用户id
					Action:             1,                          // 未激活
					SpendType:          1,                          // 未开通
					UserInviteRecordId: inviteRecord.ID,            // 邀请记录id
					FirstInvite:        1,                          // 首次邀请标志：1 首次邀请 0 非首次
					Scan:               1,                          // 扫码次数
				}
				fmt.Println("创建邀请:", invite)
				//count, err := model.NewUserInviteQuerySet(model.DB).FromUidEq(req.InviteUid).ToUidEq(user.Uid).Count()
				//if err != nil {
				//	logger.Error(err)
				//	RespJson(c, status.InternalServerError, nil)
				//	return
				//}
				//if count == 0 {
				//}
				if err := invite.Create(model.DB); err != nil {
					logger.Error(err)
					RespJson(c, status.InternalServerError, nil)
					return
				}
			}

			if inviteErr == nil { // 邀请表有记录则更新邀请记录ID
				//err = model.NewUserInviteQuerySet(model.DB).IDEq(inviteNew.ID).GetUpdater().
				//	SetFromUid(req.InviteUid).SetStoreId(inviteUser.StoreId).SetUserInviteRecordId(inviteRecord.ID).Update()
				err = model.NewUserInviteQuerySet(model.DB).IDEq(inviteNew.ID).GetUpdater().SetCreatedAt(nowTime).
					SetUserInviteRecordId(inviteRecord.ID).Update()
				if err != nil {
					logger.Error("from uid update user invite err:", err, req.InviteUid)
				}
			}
		}
	}

	// 不存在则创建新用户
	if sqlErr == model.RecordNotFound {
		// 通过手机号判断之前是否有数据
		sqlErr = model.NewUserQuerySet(model.DB).TelEq(phone.PhoneNumber).One(&user)
		if sqlErr != nil && sqlErr != model.RecordNotFound {
			logger.Error("WxOpenIDEq:", sqlErr)
			RespJson(c, status.DBOperateError, nil)
			return
		}

		if sqlErr != model.RecordNotFound { // 手机号有记录
			if user.WxOpenID == "" { // 微信openid为空，只是线下购物时新建了用户，则更新补充数据
				user.WxOpenID = resp.OpenID
				user.WxUnionID = resp.UnionID
				user.LastLoginAt = nowTime
				user.MemberLevel = model.MemberLevelUser // 普通会员
				//user.WxName = userInfo.Nickname
				//user.WxAvatar = userInfo.Avatar
				user.CreatedAt = nowTime
				err = model.UserUpdate(&user)
				if err != nil {
					logger.Error("WxOpenIDEq:", err)
					RespJson(c, status.DBOperateError, nil)
					return
				}
			}
		} else {
			user = model.User{
				WxOpenID:    resp.OpenID,
				WxUnionID:   resp.UnionID,
				LastLoginAt: nowTime,
				MemberLevel: model.MemberLevelUser, // 普通会员
				Tel:         phone.PhoneNumber,
			}
			user.Uid = createUid() // 新建uid

			inviteUser := model.GetUserByUid(req.InviteUid)
			effectiveStoreInfo, err := model.GetUserEffectiveStore(req.InviteUid)
			if err != nil {
				RespJson(c, status.InviteUserFail, nil)
				return
			}

			var eg errgroup.Group
			if req.InviteUid != 0 && inviteUser.UserType == model.UserTypeShopAssistant { // 如果入参有邀请人id，并且是店员，则新增2条邀请记录
				inviteRecordFirst := &model.UserInviteRecord{
					ToUid:       user.Uid,
					FromUid:     req.InviteUid,
					StoreId:     effectiveStoreInfo.StoreID,
					Action:      2, // 激活邀请
					SpendType:   1, // 未开通
					MemberLevel: 0, // 未开通会员
					First:       1, // 首次邀请
					Scan:        1,
					ActionTime:  nowTime,
				}
				err = model.DB.Create(inviteRecordFirst).Error
				if err != nil {
					logger.Error("create user invite record err:", err)
				}

				inviteRecord := &model.UserInviteRecord{
					ToUid:       user.Uid,
					FromUid:     req.InviteUid,
					StoreId:     effectiveStoreInfo.StoreID,
					Action:      1, // 1-未激活
					SpendType:   1, // 未开通
					MemberLevel: 0, // 未开通会员
					First:       0,
					Scan:        1,
					ActionTime:  nowTime,
				}
				err = model.DB.Create(inviteRecord).Error
				if err != nil {
					logger.Error("create user invite record err:", err)
				}

				inviteUser := model.GetUserByUid(req.InviteUid)
				user.StoreId = effectiveStoreInfo.StoreID
				user.UserType = model.UserTypeConsumer
				user.CooperativeBusinessId = inviteUser.CooperativeBusinessId
				user.CooperativeName = inviteUser.CooperativeName

				invite := &model.UserInvite{
					FromUid:            req.InviteUid,
					UserType:           inviteUser.UserType,
					StoreId:            effectiveStoreInfo.StoreID,
					MemberType:         model.MemberLevelUser,
					ToUid:              user.Uid,
					MemberStatus:       1, // 1-未开通
					Action:             1, // 1-未激活
					SpendType:          1, // 未开通
					UserInviteRecordId: inviteRecord.ID,
					Scan:               1,
				}
				eg.Go(func() error {
					if err := invite.Create(model.DB); err != nil {
						logger.Error(err)
						RespJson(c, status.InternalServerError, nil)
						return err
					}
					return nil
				})
			}

			fmt.Println("新用户:", user.WxOpenID)
			eg.Go(func() error {
				if err := user.Create(model.DB); err != nil {
					logger.Error(err)
					RespJson(c, status.InternalServerError, nil)
					return err
				}
				return nil
			})
			err = eg.Wait()
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
		}

		newAccessToken, err := auth.CreateAccessToken(user.Uid)
		if err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		fmt.Println("JwtUserRefreshKey:", config.AppConfig.JwtUserRefreshKey)
		fmt.Println("JwtUserRefreshExpire:", config.AppConfig.JwtUserRefreshExpire)
		newRefreshToken, err := auth.CreateToken(user.Uid, config.AppConfig.JwtUserRefreshKey, config.AppConfig.JwtUserRefreshExpire)
		if err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		refreshToken := &model.UserRefreshToken{
			Uid:   user.Uid,
			Token: newRefreshToken,
		}
		err = refreshToken.Create(model.DB)
		if err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		ret := model.AuthLoginResp{
			AccessToken:     newAccessToken,
			AccessExpire:    config.AppConfig.JwtUserAccessExpire,
			RefreshToken:    refreshToken.Token,
			RefreshExpire:   config.AppConfig.JwtUserRefreshExpire,
			Uid:             user.Uid,
			AccessCreatedAt: nowTime,
		}

		RespJson(c, status.OK, ret)
		return
	}

	fmt.Println(" user:", user.Uid)
	// 旧用户
	newAccessToken, err := auth.CreateAccessToken(user.Uid)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
	}

	newRefreshToken, err := auth.CreateToken(user.Uid, config.AppConfig.JwtUserRefreshKey, config.AppConfig.JwtUserRefreshExpire)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	refreshToken, err := model.UserRefreshTokenGetOrUpdate(user.Uid, newRefreshToken)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	err = model.NewUserQuerySet(model.DB).WxOpenIDEq(resp.OpenID).GetUpdater().SetLastLoginAt(time.Now()).Update()
	if err != nil && err != model.RecordNotFound {
		logger.Error(err)
	}

	ret := model.AuthLoginResp{
		AccessToken:     newAccessToken,
		AccessExpire:    config.AppConfig.JwtUserAccessExpire,
		RefreshToken:    refreshToken.Token,
		RefreshExpire:   config.AppConfig.JwtUserRefreshExpire,
		Uid:             user.Uid,
		AccessCreatedAt: nowTime,
	}

	RespJson(c, status.OK, ret)
	return

}

func UserInfoUpload(c *gin.Context) {
	req := struct {
		Uid           uint32 `json:"uid" binding:"required"`
		Code          string `json:"code" binding:"required"`
		EncryptedData string `json:"encrypted_data" binding:"required"`
		RawData       string `json:"raw_data" binding:"required"`
		Signature     string `json:"signature" binding:"required"`
		Iv            string `json:"iv" binding:"required"`
		//UserInfo      weapp.Userinfo `json:"user_info" binding:"required"`
	}{}

	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	resp, err := weapp.Login(config.AppConfig.WxAppId, config.AppConfig.WxAppSecret, req.Code)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	if resp.SessionKey == "" {
		logger.Error("Get SessionKey Fail")
		RespJson(c, status.BadRequest, nil)
		return
	}

	userInfo, err := weapp.DecryptUserInfo(req.RawData, req.EncryptedData, req.Signature, req.Iv, resp.SessionKey)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	logger.Infof("userInfo=%+v", userInfo)

	user := new(model.User)
	if err := model.NewUserQuerySet(model.DB).UidEq(req.Uid).One(user); err == nil {
		user.WxUnionID = userInfo.UnionID
		//user.WxName = req.UserInfo.Nickname
		//user.WxAvatar = req.UserInfo.Avatar
		//user.Gender = uint8(req.UserInfo.Gender)
		//user.City = req.UserInfo.City
		//user.Province = req.UserInfo.Province
		//user.Country = req.UserInfo.Country
		//user.MemberLevel = 1

		user.WxName = userInfo.Nickname
		user.WxAvatar = userInfo.Avatar
		user.Gender = uint8(userInfo.Gender)
		user.Province = userInfo.Province
		user.City = userInfo.City
		user.Country = userInfo.Country

		as := model.UserDBSchema
		if err := user.Update(model.DB, as.WxUnionID, as.WxName, as.WxAvatar, as.Gender, as.City, as.Province, as.Country, as.MemberLevel); err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}

	RespOK(c, nil)
}

// UserData 获取用户数据
// @Summary 获取用户数据
// @Tags 用户信息
// @Produce json
// @Accept json
// @Success 200 {object} model.User
// @Router /api/v1/user/data [post]
func UserData(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	m := new(model.User)
	if err := model.NewUserQuerySet(model.DB).UidEq(uc.Uid).One(m); err != nil && err != model.RecordNotFound {
		logger.Error(err)
		RespJson(c, status.Unauthorized, nil)
		return
	}

	var sysUser model.SysUser
	if err := model.NewSysUserQuerySet(model.DB).UidEq(uc.Uid).One(&sysUser); err != nil && err != model.RecordNotFound {
		logger.Error(err)
		RespJson(c, status.Unauthorized, nil)
		return
	}

	var userVm model.UserVm
	err := model.NewUserVmQuerySet(model.DB).UidEq(uc.Uid).One(&userVm)
	if err != nil && err != model.RecordNotFound {
		logger.Error("err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if err == model.RecordNotFound {
		userVm = model.UserVm{
			Uid: uc.Uid,
			Vm:  0,
		}
		err = model.DB.Create(&userVm).Error
		if err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}
	m.UserVm = &userVm
	if sysUser.StoreData != "" {
		sysUser.StoreList = deserializeStoreData(sysUser.StoreData)
	}
	m.StoreList = sysUser.StoreList
	m.RoleId = uint32(sysUser.RoleId)
	ret := m
	RespOK(c, ret)
	return
}

// 反序列化 StoreData
func deserializeStoreData(storeData string) []model.StoreInfo {
	var StoreData []model.StoreInfo
	if err := json.Unmarshal([]byte(storeData), &StoreData); err != nil {
		// 可以根据实际情况处理反序列化失败的情况
		logger.Println("反序列化 StoreData 失败:", err)
	}
	return StoreData
}

// 找一个可以用的Uid
func createUid() uint32 {
	for {
		uid := utils.GenUid()
		if count, err := model.NewUserQuerySet(model.DB).UidEq(uid).Count(); err == nil && count > 0 {
			continue
		}
		return uid
	}
}

func TokenRefresh(c *gin.Context) {
	req := struct {
		RefreshToken string `json:"refresh_token" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}

	userJwt := auth.NewJWT(config.AppConfig.JwtUserRefreshKey)
	uc, err := userJwt.ParseToken(req.RefreshToken)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.RefreshTokenInvalid, nil)
		return
	}

	// 从数据库获取用户的refresh_token
	m := new(model.UserRefreshToken)
	if err := model.NewUserRefreshTokenQuerySet(model.DB).UidEq(uc.Uid).One(m); err == nil {
		if req.RefreshToken == m.Token {
			newAccessToken, err := auth.CreateToken(uc.Uid, config.AppConfig.JwtUserAccessKey, config.AppConfig.JwtUserAccessExpire)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}

			newRefreshToken, err := auth.CreateToken(uc.Uid, config.AppConfig.JwtUserRefreshKey, config.AppConfig.JwtUserRefreshExpire)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}

			refreshToken, err := model.UserRefreshTokenGetOrUpdate(uc.Uid, newRefreshToken)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}

			now := time.Now()
			logger.Info("now.Unix=", now.Unix())
			RespJson(c, status.OK, map[string]interface{}{
				"access_token":       newAccessToken,
				"access_expire":      config.AppConfig.JwtUserAccessExpire,
				"refresh_token":      refreshToken.Token,
				"refresh_expire":     config.AppConfig.JwtUserRefreshExpire,
				"uid":                uc.Uid,
				"access_created_at":  now,
				"refresh_created_at": refreshToken.CreatedAt,
			})
			return
		} else {
			RespJson(c, status.BadRequest, nil)
			return
		}
	} else {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

}

func UserTel(c *gin.Context) {
	req := struct {
		Code          string `json:"code" `
		EncryptedData string `json:"encrypted_data" `
		Iv            string `json:"iv" `
	}{}
	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 req.Code != "" && req.EncryptedData != "" && req.Iv != "" {
		resp, err := weapp.Login(config.AppConfig.WxAppId, config.AppConfig.WxAppSecret, req.Code)
		if err != nil {
			RespJson(c, status.BadRequest, nil)
			return
		}

		phone, err := weapp.DecryptPhoneNumber(resp.SessionKey, req.EncryptedData, req.Iv)
		if err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		_ = model.NewUserQuerySet(model.DB).UidEq(uc.Uid).GetUpdater().SetTel(phone.PhoneNumber).Update()

		RespJson(c, status.OK, map[string]interface{}{
			"tel": phone.PurePhoneNumber,
		})
		return
	} else {
		user := model.GetUserByUid(uc.Uid)
		if user.Tel != "" {
			RespJson(c, status.OK, map[string]interface{}{
				"tel": user.Tel,
			})
			return
		}
	}

	RespJson(c, status.OK, map[string]interface{}{
		"tel": "",
	})

	return
}

//func StepConfig(c *gin.Context) {
//	stepConfig := model.GetStepConfig()
//	RespJson(c, status.OK, stepConfig)
//}

func UserInviteAppletQRCode(c *gin.Context) {
	req := struct {
		Uid uint32 `json:"uid" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil || req.Uid == 0 {
		RespJson(c, status.BadRequest, nil)
		return
	}
	user := model.GetUserByUid(req.Uid)
	if user.InviteCodeUrl == "" && user.Uid != 0 {
		//shareCode, err := crypt.GenShareCode(req.Uid)
		shareCode, err := crypt.GenDrawShareCode("", "", "", req.Uid)
		if err != nil {
			logger.Error("err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		user.InviteCodeUrl = shareCode
		user.AppletQRCodeUpdate()
	}

	RespOK(c, user)
}

func UserInviteList(c *gin.Context) {
	req := model.UserInviteListReq{}
	if c.ShouldBindJSON(&req) != nil || req.Uid == 0 {
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}
	if req.Uid == 0 {
		req.Uid = uc.Uid
	}
	fmt.Println("req.MemberType:", req.MemberType)
	fmt.Printf("req.MemberType:%#v \n", req)
	fmt.Printf("req.MemberType:%+v \n", req)

	resp, err := req.InviteUserList()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, resp)
}

// NewUserInviteRecordList 会员推广记录
// @Summary 会员推广记录
// @Tags 会员推广, V1.2.0
// @Produce json
// @Accept json
// @Param request body model.NewUserInviteRecordReq true "会员推广记录模型"
// @Success 200 {object} model.UserInviteRecordListResp
// @Router /api/v1/user/new_invite_list [post]
func NewUserInviteRecordList(c *gin.Context) {
	req := new(model.NewUserInviteRecordReq)
	if c.ShouldBindJSON(req) != nil {
		logger.Errorf("para err")
		RespJson(c, status.BadRequest, nil)
		return
	}

	resp, err := req.NewList()
	if err != nil {
		logger.Errorf("err:", err)
		RespJson(c, status.InternalServerError, "查询失败")
		return
	}

	RespOK(c, resp)
}

func UserCodeToCoupon(c *gin.Context) {
	req := &struct {
		Code string `json:"code"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}

	if len(req.Code) == 6 {
		user := model.GetUserByUid(uc.Uid)
		if user == nil {
			logger.Error("user is nil")
			RespJson(c, status.Unauthorized, nil)
			return
		}

		if !user.IsMember() { // 判断用户是否为会员
			logger.Error("user is not member")
			RespJson(c, status.UserNotMember, nil)
			return
		}

		//if user.OpenMemberTime.IsZero() {
		//	logger.Error("user is not member")
		//	RespJson(c, status.UserNotMember, nil)
		//	return
		//}

		var shopperPromotionCode model.ShopperPromotionCode
		err := model.NewShopperPromotionCodeQuerySet(model.DB).CodeEq(req.Code).One(&shopperPromotionCode)
		if err != nil {
			logger.Error("shopper promotion code err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		//model.UserCoupon{}

		exist, err := model.QueryRecordExist(fmt.Sprintf(
			"SELECT * FROM user_coupon WHERE uid=%d AND approach=1 AND activity_id=1 AND state=1 AND promotional_sales=%d ",
			uc.Uid, shopperPromotionCode.Uid))
		if err != nil {
			logger.Error("exist err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if exist {
			logger.Error("coupon received err:", err)
			RespJson(c, status.CouponReceived, nil)
			return
		}

		count, err := model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).
			ApproachEq(1).StateEq(1).Count()
		if err != nil {
			logger.Error("count user coupon err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if count >= 3 {
			logger.Error("coupon count gte 3")
			RespJson(c, status.CouponReceived, nil)
			return
		}
		var userCoupons []model.UserCoupon
		err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityTypeEq(1).
			StateEq(1).All(&userCoupons)
		if err != nil {
			logger.Error("coupons err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		userCouponMap := make(map[uint32]int, 0)
		for i, _ := range userCoupons {
			userCouponMap[userCoupons[i].CouponId] = i
		}

		var coupons []model.Coupon
		err = model.NewCouponQuerySet(model.DB).ActivityIdEq(1).All(&coupons)
		if err != nil {
			logger.Error("coupons err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		for i, _ := range coupons {
			_, ok := userCouponMap[coupons[i].ID]
			if ok {
				continue
			}

			userCoupon := &model.UserCoupon{
				Uid:              uc.Uid,
				CouponId:         coupons[i].ID,
				CouponType:       coupons[i].CouponType,
				ActivityType:     coupons[i].ActivityType,
				ActivityId:       coupons[i].ActivityId,
				Value:            coupons[i].Value,
				State:            1,
				ActiveStart:      time.Now(),
				ActiveEnd:        time.Now().AddDate(0, 0, 30),
				UseTime:          time.Time{},
				MemberLevel:      coupons[i].MemberLevel,
				Approach:         1,
				PromotionalSales: shopperPromotionCode.Uid,
				RedeemCode:       shopperPromotionCode.Code,
			}

			err = model.DB.Create(userCoupon).Error
			if err != nil {
				logger.Error("user coupon err:", err)
				continue
			}
		}

		RespOK(c, nil)
		return
	}
	var redeemCode model.RedeemCode
	err := model.NewRedeemCodeQuerySet(model.DB).SerialCodeEq(req.Code).One(&redeemCode)
	if err != nil {
		logger.Error("redeem code err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if req.Code != "DC5709BC7375B9F5FA89D0" && redeemCode.Status != model.RedeemCodeStatusHold {
		logger.Error("redeem code status err")
		RespJson(c, status.InternalServerError, nil)
		return
	}

	var coupon model.Coupon
	err = model.NewCouponQuerySet(model.DB).IDEq(redeemCode.CouponId).One(&coupon)
	if err != nil {
		logger.Error("coupon err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	exist, err := model.QueryRecordExist(fmt.Sprintf(
		"SELECT * FROM user_coupon WHERE uid=%d AND activity_type=%d", uc.Uid, coupon.ActivityType))
	if err != nil {
		logger.Error("exist err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if exist {
		logger.Error("user have coupon ")
		RespJson(c, status.UserFocusHasCoupon, nil)
		return
	}
	begin := model.DB.Begin()
	userCoupon := &model.UserCoupon{
		Uid:          uc.Uid,
		CouponId:     coupon.ID,
		CouponType:   coupon.CouponType,
		ActivityType: coupon.ActivityType,
		ActivityId:   coupon.ActivityId,
		Value:        coupon.Value,
		State:        1,
		ActiveStart:  time.Now(),
		UseTime:      time.Time{},
		MemberLevel:  0,
	}
	userCoupon.ActiveEnd = userCoupon.ActiveStart.AddDate(0, 0, 7)
	err = userCoupon.Create(begin)
	if err != nil {
		begin.Rollback()
		logger.Error("create user coupon")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	err = model.NewRedeemCodeQuerySet(begin).IDEq(redeemCode.ID).GetUpdater().SetStatus("used").Update()
	if err != nil {
		begin.Rollback()
		logger.Error("update status err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	err = model.NewPublicRecordQuerySet(model.DB).RedeemCodeIdEq(redeemCode.ID).GetUpdater().
		SetRedeemCodeState(3).Update()
	if err != nil {
		logger.Error("update public record State err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//resp, err := req.InviteUserList()
	//if err != nil {
	//	logger.Error("err:", err)
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}

	RespOK(c, nil)
}