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"
)

func UserRedeemCodeList(c *gin.Context) {
	req := &struct {
		Status string `json:"status"`
	}{}
	if c.ShouldBindJSON(req) != nil {
		logger.Errorf("para err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

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

	RespOK(c, codeList)
}

func UserConvertRedeemCode(c *gin.Context) {
	req := &struct {
		SerialCode string `json:"serial_code"`
	}{}
	if c.ShouldBindJSON(req) != nil {
		logger.Errorf("para err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	err := model.UserRedeemCodeConvert(uc.Uid, req.SerialCode)
	if err != nil {
		logger.Errorf("err:%#v", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, nil)
}

func UserMemberRenewalState(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	user := model.GetUserByUid(uc.Uid)
	if !user.IsMember() {
		RespOK(c, map[string]interface{}{
			"is_pop":            true,
			"is_member_renewal": false,
		})
		return
	}
	var activityMemberRenewal model.ActivityMemberRenewal
	//err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).StateEq(1).
	//	One(&activityMemberRenewal)
	err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).OrderDescByID().
		Limit(1).One(&activityMemberRenewal)
	if err != nil && err != model.RecordNotFound {
		logger.Error("activity member renewal err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	isPop := true

	if err == model.RecordNotFound || uint32(user.MemberExpire.Unix()) != activityMemberRenewal.MemberSerial {
		//if user.MemberExpire.Before(utils.Now().AddDate(0, 1, 0)) &&
		//	user.MemberExpire.After(utils.Now()) {
		if user.MemberExpire.Before(utils.Now().AddDate(0, 0,
			model.GetActivityRenewalConfig().PopTrap)) {
			activityMemberRenewal = model.ActivityMemberRenewal{
				ActivityId:   1,
				Uid:          uc.Uid,
				State:        1,
				StartTime:    utils.Now(),
				IsPop:        true,
				MemberLevel:  user.MemberLevel,
				MemberSerial: uint32(user.MemberExpire.Unix()),
			}

			err = model.DB.Create(&activityMemberRenewal).Error
			if err != nil {
				logger.Error("create activity member renewal err:", err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
			go func() {
				renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, model.UserRenewalLogActionPop)
				userLog := &model.UserRenewalLog{
					Uid:          uc.Uid,
					Action:       model.UserRenewalLogActionPop,
					MemberExpire: user.MemberExpire,
					Type:         0,
					RenewalNum:   renewalLog.RenewalNum + 1,
					Serial:       uint32(user.MemberExpire.Unix()),
				}
				_ = userLog.Add()
			}()

			isPop = false
		}
	}
	if activityMemberRenewal.StartTime.AddDate(0, 0,
		model.GetActivityRenewalConfig().ActivityContinuity).Before(utils.Now()) {
		activityMemberRenewal.State = 3
		_, err = model.NewActivityMemberRenewalQuerySet(model.DB).IDEq(activityMemberRenewal.ID).GetUpdater().
			SetState(3).UpdateNum()
		if err != nil {
			logger.Error("update num err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}
	isMemberRenewal := false
	if activityMemberRenewal.State == 1 {
		isMemberRenewal = true
	}
	ret := make(map[string]interface{}, 0)
	ret["is_pop"] = isPop
	ret["is_member_renewal"] = isMemberRenewal

	RespOK(c, ret)
	return
}

func UserMemberRenewalInfo(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	//uc := auth.UserClaims{Uid: 5640286}
	var renewal model.ActivityMemberRenewal
	err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).
		StateEq(1).One(&renewal)
	if err != nil && err != model.RecordNotFound {
		logger.Error("renewal err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if err == model.RecordNotFound {
		RespJson(c, status.InternalServerError, nil)
		return
	}
	var coupons []model.Coupon
	err = model.NewCouponQuerySet(model.DB).ActivityIdEq(renewal.ActivityId).All(&coupons)
	if err != nil {
		logger.Error("coupons err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	var userCoupons []model.UserCoupon
	//err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(renewal.ActivityId).
	//	StateEq(1).All(&userCoupons)
	now := time.Now()
	err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(renewal.ActivityId).
		ActiveStartLte(now).ActiveEndGte(now).All(&userCoupons)
	if err != nil {
		logger.Error("userCoupons err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	user := model.GetUserByUid(uc.Uid)
	exist, err := model.QueryRecordExist(
		fmt.Sprintf("SELECT * FROM user_renewal_log WHERE uid = %d AND action=2 AND serial=%d",
			uc.Uid, user.MemberExpire.Unix()))
	if err != nil {
		logger.Error("user log exist err:", err)
	}
	if err == nil && !exist {
		go func() {
			renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, model.UserRenewalLogActionEnterActivity)
			userLog := &model.UserRenewalLog{
				Uid:          uc.Uid,
				Action:       model.UserRenewalLogActionEnterActivity,
				MemberExpire: user.MemberExpire,
				Type:         0,
				RenewalNum:   renewalLog.RenewalNum + 1,
				Serial:       uint32(user.MemberExpire.Unix()),
			}
			_ = userLog.Add()
		}()
	}
	userCouponMap := make(map[uint32]*model.UserCoupon, 0)
	for i, _ := range userCoupons {
		userCouponMap[userCoupons[i].CouponId] = &userCoupons[i]
	}

	for i, _ := range coupons {
		_, ok := userCouponMap[coupons[i].ID]
		if ok {
			coupons[i].IsDraw = true
		}
	}
	down := int64(model.GetActivityRenewalConfig().ActivityContinuity)*24*3600 - (utils.Now().Unix() - renewal.StartTime.Unix())
	ret := map[string]interface{}{
		"coupon_list": coupons,
		"renewal":     renewal,
		"time_down":   down,
	}
	RespOK(c, ret)
	return
}

func UserMemberRenewalCouponDraw(c *gin.Context) {
	req := &struct {
		CouponIds []uint32 `json:"coupon_ids" binding:"required"`
	}{}
	if c.ShouldBindJSON(req) != nil {
		logger.Errorf("para err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}
	if len(req.CouponIds) == 0 {
		logger.Errorf("para err")
		RespOK(c, nil)
		return
	}
	user := model.GetUserByUid(uc.Uid)
	var activityMemberRenewal model.ActivityMemberRenewal
	err := model.NewActivityMemberRenewalQuerySet(model.DB).UidEq(uc.Uid).OrderDescByID().
		Limit(1).One(&activityMemberRenewal)
	if err != nil {
		logger.Error("activity member renewal err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if !user.IsMember() ||
		activityMemberRenewal.State == 3 {
		logger.Error("user coupon err")
		RespJson(c, status.InternalServerError, 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).IDIn(req.CouponIds...).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
		}

		go func() {
			action := 0
			if coupons[i].MemberLevel == 2 {
				action = model.UserRenewalLogActionPickGold
			} else if coupons[i].MemberLevel == 4 {
				action = model.UserRenewalLogActionPickPlatinum
			} else if coupons[i].MemberLevel == 5 {
				action = model.UserRenewalLogActionPickBlackGold
			}
			renewalLog, _ := model.GetActionUserRenewalLog(uc.Uid, uint32(action))
			userLog := &model.UserRenewalLog{
				Uid:          uc.Uid,
				Action:       uint32(action),
				MemberExpire: user.MemberExpire,
				Type:         0,
				RenewalNum:   renewalLog.RenewalNum + 1,
				Serial:       uint32(user.MemberExpire.Unix()),
			}
			_ = userLog.Add()
		}()

		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, model.GetActivityRenewalConfig().CouponValidity),
			MemberLevel:  coupons[i].MemberLevel,
		}

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

	RespOK(c, nil)
	return
}

func PostagePackageBuy(c *gin.Context) {
	//req := struct {
	//}{}
	//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
	}
	//uc = new(auth.UserClaims)
	//uc.Uid = 14531402
	user := model.GetUserByUid(uc.Uid)
	if user == nil {
		logger.Error("user is nil")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if !user.IsMember() || user.MemberExpire.Before(time.Now()) {
		logger.Error("user  not member")
		RespJson(c, status.NotMember, nil)
		return
	}
	info, err := model.PostagePackageFeeConfigInfo()
	if err != nil {
		logger.Error("postage package fee err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	orderSn := model.GetOrderSn()
	err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: orderSn, MemberLevel: user.MemberLevel,
		OrderType: 11, UserCouponId: 0, Attach: wxpay.WxPayPostagePackage}.Insert()
	if err != nil {
		logger.Error(errors.New("web pay 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, info.PostagePackageFee, user.WxOpenID, "N", wxpay.WxPayPostagePackage, configInfo.NotifyUrl)
	//if err != nil {
	//	logger.Error(errors.New("web pay err"))
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	webPay, err := wxpay.HmJsPayUnifiedOrder(orderSn, info.PostagePackageFee, user.WxOpenID, configInfo.NotifyUrl)
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	go func() {
		action, err := model.IsFirstUserAction(uc.Uid, 2)
		if err != nil {
			logger.Error("user action exist err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		first := uint32(0)
		if !action {
			first = 1
		}
		log := &model.UserActionLog{
			Uid:        uc.Uid,
			ActionType: 2,
			First:      first,
		}
		err = model.DB.Create(log).Error
		if err != nil {
			logger.Error("create user action log err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}()
	tips := fmt.Sprintf("支付成功，会员已延长%d天", model.GetPostagePackageMemberDuration(user.MemberLevel))
	ret := map[string]interface{}{
		"web_pay": webPay,
		"tip":     tips,
	}
	RespOK(c, ret)
	return
}

func UserCouponList(c *gin.Context) {
	req := struct {
		PageIdx      int    `json:"page_idx"`
		PageSize     int    `json:"page_size"`
		ActivityType uint32 `json:"activity_type"` // 活动类型 1-会员续费  2-关注公众号 3-运费包
	}{}
	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}
	user := model.GetUserByUid(uc.Uid)
	if user == nil {
		logger.Error("user err")
		RespJson(c, status.InternalServerError, nil)
		return
	}

	page := req.PageIdx - 1
	if page < 0 {
		page = 0
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}

	qs := model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).StateEq(1)
	if req.ActivityType != 0 {
		qs = qs.ActivityTypeEq(3)
	}
	count, err := qs.Count()
	if err != nil {
		logger.Error("count err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	totalPage := count/req.PageSize + 1

	var coupons []model.UserCoupon
	err = qs.OrderAscByID().Offset(page * req.PageSize).Limit(req.PageSize).All(&coupons)
	if err != nil && err != model.RecordNotFound {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	for i, _ := range coupons {
		if !user.IsMember() && coupons[i].ActivityType == 1 {
			coupons[i].Availability = 1
		} else {
			coupons[i].Availability = 2
		}
	}
	ret := map[string]interface{}{
		"list":       coupons,
		"total_page": totalPage,
		"page_idx":   req.PageIdx,
	}
	RespOK(c, ret)
	return
}

func PostagePackageInfo(c *gin.Context) {
	//req := struct {
	//}{}
	//if err := c.ShouldBindJSON(&req); err != nil {
	//	logger.Error(err)
	//	RespJson(c, status.BadRequest, nil)
	//	return
	//}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}
	action, err := model.IsFirstUserAction(uc.Uid, 1)
	if err != nil {
		logger.Error("user action exist err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	first := uint32(0)
	if !action {
		first = 1
	}
	log := model.UserActionLog{
		Uid:        uc.Uid,
		ActionType: 1,
		First:      first,
	}
	err = model.DB.Create(log).Error
	if err != nil {
		logger.Error("create user action log err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, nil)
	return
}

func MemberRenewalUserCouponList(c *gin.Context) {
	req := struct {
		PageIdx  int    `json:"page_idx"`
		PageSize int    `json:"page_size"`
		State    uint32 `json:"state"` // 1-未使用 2-已使用 3-已过期
	}{}
	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
	}

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

	page := req.PageIdx - 1
	if page < 0 {
		page = 0
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}

	qs := model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid)
	if req.State != 0 {
		qs = qs.StateEq(req.State)
	}
	count, err := qs.Count()
	if err != nil {
		logger.Error("count err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	totalPage := count/req.PageSize + 1
	var coupons []model.UserCoupon
	err = qs.OrderDescByID().Offset(page * req.PageSize).Limit(req.PageSize).All(&coupons)
	if err != nil && err != model.RecordNotFound {
		logger.Error("coupons err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	ids := make([]uint32, 0)
	for i, _ := range coupons {
		if coupons[i].ActiveEnd.Before(time.Now()) && coupons[i].State != 3 {
			ids = append(ids, coupons[i].ID)
			coupons[i].State = 3
		}
	}

	list := make([]model.UserCoupon, 0, len(coupons))
	for i, _ := range coupons {
		if !user.IsMember() && coupons[i].ActivityType == 1 {
			continue
		}
		if user.MemberGenre == 201 || user.MemberGenre == 202 {
			coupons[i].Availability = 1
		}
		list = append(list, coupons[i])
	}

	if len(ids) > 0 {
		err = model.NewUserCouponQuerySet(model.DB).IDIn(ids...).GetUpdater().SetState(3).Update()
		if err != nil {
			logger.Error("update user coupon err:", err)
		}
	}
	ret := map[string]interface{}{
		"list":       list,
		"total_page": totalPage,
		"page_idx":   req.PageIdx,
	}
	RespOK(c, ret)
	return
}