package controller

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

func UserShareCardBillCreate(c *gin.Context) {
	req := struct {
		GameCardList []model.CardInfo `json:"game_card_list"`
		StoreId      uint32           `json:"store_id"`
		SendCardType uint32           `json:"send_card_type"` // 1-送卡 2-邮寄
	}{}
	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
	}
	if len(req.GameCardList) == 0 || req.StoreId == 0 || req.SendCardType == 0 {
		logger.Error(errors.New("req err"))
		RespJson(c, status.Unauthorized, nil)
		return
	}
	user := model.GetUserByUid(uc.Uid)
	if user == nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	if user.MemberLevel != 2 && user.MemberLevel != 4 && user.MemberLevel != 5 {
		logger.Error("user not is  member err:")
		RespJson(c, status.NotMember, nil)
		return
	}

	billSn := model.GetShareCardBillSn()
	begin := model.DB.Begin()
	shareCardBill := &model.UserShareCardBill{
		Uid:          uc.Uid,
		BillSn:       billSn,
		State:        model.ShareCardBillStateInCheck,
		SendCardType: req.SendCardType,
		StoreId:      req.StoreId,
	}
	err := begin.Create(shareCardBill).Error
	if err != nil {
		begin.Rollback()
		logger.Error("user share card bill create err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	for _, info := range req.GameCardList {
		var cardBill = model.ShareCardBillGame{
			UserShareCardBillId: shareCardBill.ID,
			Uid:                 uc.Uid,
			GameCardId:          info.GameCardId,
			BillSn:              billSn,
			Count:               info.Count,
			State:               model.ShareCardStateInCheck,
		}
		err := begin.Create(&cardBill).Error
		if err != nil {
			begin.Rollback()
			logger.Error("share card bill game create err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}

	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("share card bill game create err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, nil)
	return
}

func ShareCardBillSendCard(c *gin.Context) {
	req := struct {
		UserShareCardBillId uint32 `json:"user_share_card_bill_id"`
		ExpressCompany      string `json:"express_company"` // 物流公司
		ExpressNo           string `json:"express_no"`      // 物流单号
	}{}
	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
	}
	begin := model.DB.Begin()
	_, err := model.NewUserShareCardBillQuerySet(begin).IDEq(req.UserShareCardBillId).GetUpdater().
		SetExpressCompany(req.ExpressCompany).SetExpressNo(req.ExpressNo).UpdateNum()
	//SetState(model.ShareCardBillStateSentCard).UpdateNum()
	if err != nil {
		begin.Rollback()
		logger.Error("update user share card bill  err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//_, err = model.NewShareCardBillGameQuerySet(begin).UserShareCardBillIdEq(req.UserShareCardBillId).GetUpdater().
	//	SetState(model.ShareCardStateSentCard).UpdateNum()
	//if err != nil {
	//	begin.Rollback()
	//	logger.Error("update user share card bill  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
	}
	RespOK(c, nil)
	return
}

func UserShareCardGameList(c *gin.Context) {
	req := struct {
		Label    string `json:"label"`
		Page     int    `json:"cur_page"`
		PageSize int    `json:"page_size"`
	}{}
	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
	//}
	list, totalPage, err := model.GetUserShareCardGameList(0, req.Page, req.PageSize, req.Label)
	if err != nil {
		logger.Error("share card bill game create err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"list":       list,
		"cur_page":   req.Page,
		"total_page": totalPage,
	}
	RespOK(c, ret)
	return
}

func UserShareCardBillList(c *gin.Context) {
	req := struct {
		State    string `json:"state"`
		Page     int    `json:"cur_page"`
		PageSize int    `json:"page_size"`
	}{}
	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
	}
	list, totalPage, err := model.GetUserShareCardBillList(uc.Uid, req.Page, req.PageSize, req.State)
	if err != nil {
		logger.Error("share card bill game create err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"list":       list,
		"cur_page":   req.Page,
		"total_page": totalPage,
	}
	RespOK(c, ret)
	return
}

func UserShareCardBillInfo(c *gin.Context) {
	req := struct {
		UserShareCardBillId uint32 `json:"user_share_card_bill_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
	}
	cardBill, err := model.GetUserShareCardBill(uc.Uid, req.UserShareCardBillId)
	if err != nil {
		logger.Error("share card bill game err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, cardBill)
	return
}

func UserShareCardBillCancel(c *gin.Context) {
	req := struct {
		UserShareCardBillId uint32 `json:"user_share_card_bill_id"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	var shareCardBill model.UserShareCardBill
	err := model.NewUserShareCardBillQuerySet(model.DB).IDEq(req.UserShareCardBillId).One(&shareCardBill)
	if err != nil {
		logger.Error("user share card bill err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if shareCardBill.State != model.ShareCardBillStateInCheck &&
		shareCardBill.State != model.ShareCardBillStateInSendCard {
		logger.Error("user share card bill err")
		RespJson(c, status.ShareCardBillStateCancelError, nil)
		return
	}
	begin := model.DB.Begin()
	_, err = model.NewUserShareCardBillQuerySet(begin).IDEq(req.UserShareCardBillId).GetUpdater().
		SetState(model.ShareCardBillStateCancel).UpdateNum()
	if err != nil {
		begin.Rollback()
		logger.Error("update user share card bill  err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	_, err = model.NewShareCardBillGameQuerySet(begin).UserShareCardBillIdEq(req.UserShareCardBillId).GetUpdater().
		SetState(model.ShareCardStateCancel).UpdateNum()
	if err != nil {
		begin.Rollback()
		logger.Error("update user share card bill  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
	}

	RespOK(c, nil)
	return
}

func UserShareCardMyCard(c *gin.Context) {
	req := struct {
		State    string `json:"state"`
		Page     int    `json:"cur_page"`
		PageSize int    `json:"page_size"`
	}{}
	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
	}
	list, totalPage, cardCount, err := model.GetUserShareCardMyCardList(uc.Uid, req.Page, req.PageSize, req.State)
	if err != nil {
		logger.Error("share card bill game create err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	dateVm, err := model.GetUserShareCardDateVmInfo(uc.Uid)
	if err != nil {
		logger.Error("get user share card date vm err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"yesterday_vm": dateVm.Vm,
		"total_vm":     dateVm.TotalVm,
		"card_count":   cardCount,
		"list":         list,
		"cur_page":     req.Page,
		"total_page":   totalPage,
	}
	RespOK(c, ret)
	return
}

func UserShareCardVmRecord(c *gin.Context) {
	req := struct {
		GameCardGoodsId uint32 `json:"game_card_goods_id"`
		Page            int    `json:"cur_page"`
		PageSize        int    `json:"page_size"`
	}{}
	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
	}
	list, totalPage, err := model.GetUserShareCardVmList(uc.Uid, req.Page, req.PageSize, req.GameCardGoodsId)
	if err != nil {
		logger.Error("share card bill game create err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"list":       list,
		"cur_page":   req.Page,
		"total_page": totalPage,
	}
	RespOK(c, ret)
	return
}

func ShareCardRetrieveCreate(c *gin.Context) {
	req := model.ShareCardRetrieveCreateReq{}
	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
	user := model.GetUserByUid(uc.Uid)
	if user == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	count, err := model.NewShareCardRetrieveCardQuerySet(model.DB).SerialNumberIn(req.SerialNumbers...).
		//StateIn(model.RetrieveStateInCheck).Count()
		PayStateEq(2).StateNotIn(model.RetrieveStateCheckLose, model.RetrieveStateCancel).Count()
	if err != nil {
		logger.Error("share card retrieve card err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if count > 0 {
		logger.Error("serial number has applied")
		RespJson(c, status.ShareCardRetrieveExistAppliedCard, nil)
		return
	}
	//req.Amount = 40 // TODO  测试数据
	retrieve, err := req.RetrieveCreate()
	if err != nil {
		logger.Error("share card retrieve create err:", err)
		if err.Error() == "before_6_month" {
			RespJson(c, status.CardRetrieveBefore6Month, nil)
		} else {
			RespJson(c, status.InternalServerError, nil)
		}

		return
	}
	if req.RetrieveCardType == 1 {
		RespOK(c, nil)
		return
	}
	//user := model.GetUserByUid(uc.Uid)
	//if user == nil {
	//	RespJson(c, status.Unauthorized, nil)
	//	return
	//}
	configInfo, err := model.PayConfigInfo()
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//webPay, err := wxpay.WebPay(retrieve.OrderSn, req.Amount, user.WxOpenID, "N", wxpay.WxPayShareCardRetrieve, configInfo.NotifyUrl)
	//if err != nil {
	//	logger.Error(errors.New("WebPay err"))
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	err = model.UserOpenMemberRecord{Uid: uc.Uid, OpenNo: retrieve.OrderSn, OrderId: retrieve.ID, OrderType: 1, Attach: wxpay.WxPayShareCardRetrieve}.Insert()
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}
	webPay, err := wxpay.HmJsPayUnifiedOrder(retrieve.OrderSn, req.Amount, user.WxOpenID, configInfo.NotifyUrl)
	if err != nil {
		logger.Error(errors.New("WebPay err"))
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"web_pay": webPay,
	}
	RespOK(c, ret)
	return
}

func ShareCardRetrieveList(c *gin.Context) {
	req := model.ShareCardRetrieveListReq{}
	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
	list, totalPage, err := req.List()
	if err != nil {
		logger.Error("share card retrieve list  err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"list":       list,
		"cur_page":   req.Page,
		"total_page": totalPage,
	}
	RespOK(c, ret)
	return
}

func ShareCardRetrieveDetail(c *gin.Context) {
	req := struct {
		ShareCardRetrieveId uint32 `json:"share_card_retrieve_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
	//}
	//req.Uid = uc.Uid

	info, err := model.GetShareCardRetrieveInfo(req.ShareCardRetrieveId)
	if err != nil {
		logger.Error("share card retrieve list  err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//ret := map[string]interface{}{
	//}
	RespOK(c, info)
	return
}

func ShareCardRetrieveCancel(c *gin.Context) {
	req := struct {
		ShareCardRetrieveId uint32 `json:"share_card_retrieve_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
	//}
	//req.Uid = uc.Uid

	//info, err := model.GetShareCardRetrieveInfo(req.ShareCardRetrieveId)
	//if err != nil {
	//	logger.Error("share card retrieve list  err:", err)
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}
	var retrieve model.ShareCardRetrieve
	err := model.NewShareCardRetrieveQuerySet(model.DB).IDEq(req.ShareCardRetrieveId).One(&retrieve)
	if err != nil {
		logger.Error("share card retrieve   err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if retrieve.State != model.RetrieveStateInCheck {
		logger.Error("state  err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	var refundOrderSn string
	if retrieve.RetrieveCardType == 2 {
		refundOrderSn = model.GetShareCardRetrieveOrderSn()
		err = model.UserOpenMemberRecord{Uid: uint32(retrieve.Uid), OpenNo: refundOrderSn, OrderId: retrieve.ID, OrderType: 2}.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("config info err:", err)
			return
		}

		orderRefund := wxpay.OrderRefund{
			OutTradeNo:  retrieve.OrderSn,
			OutRefundNo: refundOrderSn,
			NotifyUrl:   configInfo.RefundNotifyUrl,
			Amount: wxpay.OrderRefundAmount{
				Refund:   retrieve.PayAmount,
				Total:    retrieve.PayAmount,
				Currency: "CNY",
			},
		}
		//bytes, _ := json.Marshal(order)
		//fmt.Println("订单取消:", string(bytes))
		orderRefundJson, _ := json.Marshal(&orderRefund)
		fmt.Println("订单取消 orderRefundJson:", string(orderRefundJson))
		//err = wxpay.WxPayOrderRefund(orderRefund)
		err = wxpay.TransactionOrderRefund(orderRefund)
		if err != nil {
			logger.Error("err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

	}

	begin := model.DB.Begin()
	qs := model.NewShareCardRetrieveQuerySet(begin).IDEq(req.ShareCardRetrieveId).GetUpdater().
		SetState(model.RetrieveStateCancel).SetPickupCode("已取消")
	if refundOrderSn != "" {
		qs = qs.SetRefundOrderSn(refundOrderSn)
	}
	_, err = qs.UpdateNum()
	if err != nil {
		logger.Error("update share card retrieve err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	_, err = model.NewShareCardRetrieveCardQuerySet(begin).ShareCardRetrieveIdEq(req.ShareCardRetrieveId).GetUpdater().
		SetState(model.RetrieveStateCancel).UpdateNum()
	if err != nil {
		logger.Error("update share card retrieve card err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	err = begin.Commit().Error
	if err != nil {
		logger.Error("commit  err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//ret := map[string]interface{}{
	//}
	RespOK(c, nil)
	return
}

func ShareCardRetrieveConfirm(c *gin.Context) {
	req := struct {
		ShareCardRetrieveId uint32 `json:"share_card_retrieve_id"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}

	begin := model.DB.Begin()
	_, err := model.NewShareCardRetrieveQuerySet(begin).IDEq(req.ShareCardRetrieveId).GetUpdater().
		SetState(model.RetrieveStateReceivedCard).UpdateNum()
	if err != nil {
		logger.Error("update share card retrieve err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	_, err = model.NewShareCardRetrieveCardQuerySet(begin).ShareCardRetrieveIdEq(req.ShareCardRetrieveId).GetUpdater().
		SetState(model.RetrieveStateReceivedCard).UpdateNum()
	if err != nil {
		logger.Error("update share card retrieve card err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	err = begin.Commit().Error
	if err != nil {
		logger.Error("commit  err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, nil)
	return
}

func CardIssueCreate(c *gin.Context) {
	req := struct {
		RelevanceId   uint32 `json:"relevance_id"` // 关联id
		ObtainType    string `json:"obtain_type"`  // 卡类型
		Problem       string `json:"problem"`      // 问题
		Remark        string `json:"remark"`
		TransportType uint32 `json:"transport_type"`  // 1-送卡到门店 2-邮寄
		UserAddressId uint32 `json:"user_address_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
	}
	count, err := model.NewCardIssueFeedbackQuerySet(model.DB).RelevanceIdEq(req.RelevanceId).
		StateNe(model.CardIssueStateCanceled).Count()
	if err != nil {
		logger.Error("card issue feedback count err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if count > 0 {
		logger.Error("card issue feedback exist")
		RespJson(c, status.IssueFeedbackRepetition, nil)
		return
	}
	var feedback *model.CardIssueFeedback
	if req.ObtainType == "retrieve_card" {
		var shareCardRetrieveCard model.ShareCardRetrieveCard
		err := model.NewShareCardRetrieveCardQuerySet(model.DB).IDEq(req.RelevanceId).One(&shareCardRetrieveCard)
		if err != nil {
			logger.Error("share card retrieve err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if shareCardRetrieveCard.Uid != uc.Uid {
			logger.Error("feedback uid  err:")
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if !shareCardRetrieveCard.ReceiptTime.IsZero() && shareCardRetrieveCard.ReceiptTime.
			AddDate(0, 0, 2).Before(time.Now()) {
			logger.Error("receipt time is over 48 hour:")
			RespJson(c, status.IssueFeedbackReceiptTimeOver48Hour, nil)
			return
		}
		feedback = &model.CardIssueFeedback{
			Uid:             shareCardRetrieveCard.Uid,
			GameCardId:      shareCardRetrieveCard.GameCardId,
			SerialNumber:    shareCardRetrieveCard.RetrieveSerialNumber,
			GameCardGoodsId: shareCardRetrieveCard.GameCardGoodsId,
			StoreId:         shareCardRetrieveCard.StoreId,
			RelevanceId:     shareCardRetrieveCard.ID,
			ObtainType:      req.ObtainType,
			Problem:         req.Problem,
			Remark:          req.Remark,
			State:           model.CardIssueStateFollowing,
			TransportType:   req.TransportType,
			UserAddressId:   req.UserAddressId,
		}
	} else if req.ObtainType == "rent_card" {
		var orderCard model.OrderCard
		err := model.NewOrderCardQuerySet(model.DB).IDEq(req.RelevanceId).One(&orderCard)
		if err != nil {
			logger.Error("order err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if uint32(orderCard.Uid) != uc.Uid {
			logger.Error("order uid  err:")
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if !orderCard.ReceiptTime.IsZero() && orderCard.ReceiptTime.
			Before(time.Now()) {
			logger.Error("receipt time is over 48 hour:")
			RespJson(c, status.InternalServerError, nil)
			return
		}
		feedback = &model.CardIssueFeedback{
			Uid:             uint32(orderCard.Uid),
			GameCardId:      uint32(orderCard.GameCardId),
			SerialNumber:    orderCard.SerialNumber,
			GameCardGoodsId: uint32(orderCard.GameCardGoodsId),
			StoreId:         uint32(orderCard.StoreId),
			RelevanceId:     orderCard.ID,
			ObtainType:      req.ObtainType,
			Problem:         req.Problem,
			Remark:          req.Remark,
			State:           model.CardIssueStateFollowing,
			TransportType:   req.TransportType,
			UserAddressId:   req.UserAddressId,
		}
		_, err = model.NewOrderCardQuerySet(model.DB).IDEq(req.RelevanceId).GetUpdater().SetIssueType(1).UpdateNum()
		if err != nil {
			logger.Error("order err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	} else {
		logger.Error("obtain type err:")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	err = model.DB.Create(feedback).Error
	if err != nil {
		logger.Error("create feedback err:")
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, nil)
	return
}

func CardIssueCancel(c *gin.Context) {
	req := struct {
		CardIssueFeedbackId uint32 `json:"card_issue_feedback_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
	//}
	var cardIssueFeedback model.CardIssueFeedback
	err := model.NewCardIssueFeedbackQuerySet(model.DB).IDEq(req.CardIssueFeedbackId).One(&cardIssueFeedback)
	if err != nil {
		logger.Error("card issue feedback err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if cardIssueFeedback.State != model.CardIssueStateFollowing {
		logger.Error("state err:")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	_, err = model.NewCardIssueFeedbackQuerySet(model.DB).IDEq(req.CardIssueFeedbackId).GetUpdater().
		SetState(model.CardIssueStateCanceled).UpdateNum()
	if err != nil {
		logger.Error("update card issue feedback err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if cardIssueFeedback.ObtainType == model.ObtainTypeRentCard {
		_, err = model.NewOrderCardQuerySet(model.DB).IDEq(cardIssueFeedback.RelevanceId).GetUpdater().
			SetIssueType(2).UpdateNum()
		if err != nil {
			logger.Error("order err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}
	RespOK(c, nil)
	return
}
func CardIssueList(c *gin.Context) {
	req := struct {
		Uid      uint32 `json:"uid"`
		State    string `json:"state"`
		Page     int    `json:"cur_page"`
		PageSize int    `json:"page_size"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	//uc := &auth.UserClaims{
	//	Uid: 49393347,
	//}
	if uc == nil {
		logger.Error("user err")
		RespJson(c, status.Unauthorized, nil)
		return
	}
	var issueFeedbacks []model.CardIssueFeedback
	qs := model.NewCardIssueFeedbackQuerySet(model.DB).UidEq(uc.Uid)
	if req.State != "" {
		qs = qs.StateEq(req.State)
	}

	count, err := qs.Count()
	if err != nil {
		logger.Error("count card issue feedback err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	page := req.Page - 1
	if page < 0 {
		page = 0
	}
	if req.PageSize == 0 {
		req.PageSize = 10
	}
	totalPage := count/req.PageSize + 1

	err = qs.OrderDescByID().Offset(page * req.PageSize).Limit(req.PageSize).All(&issueFeedbacks)
	if err != nil && err != model.RecordNotFound {
		logger.Error("card issue feedback err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	issueFeedbacks = model.CardIssueFeedbackListSetGame(issueFeedbacks)
	ret := map[string]interface{}{
		"list":       issueFeedbacks,
		"cur_page":   req.Page,
		"total_page": totalPage,
	}
	RespOK(c, ret)
	return
}

func CardIssueInfo(c *gin.Context) {
	req := struct {
		CardIssueFeedbackId uint32 `json:"card_issue_feedback_id"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	var issueFeedback model.CardIssueFeedback
	err := model.NewCardIssueFeedbackQuerySet(model.DB).IDEq(req.CardIssueFeedbackId).One(&issueFeedback)
	if err != nil {
		logger.Error("card issue feedback err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//model.GetImpo()

	var store model.Store
	err = model.NewStoreQuerySet(model.DB).IDEq(issueFeedback.StoreId).One(&store)
	if err != nil && err != model.RecordNotFound {
		logger.Error("store err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	var gameCard model.GameCard
	err = model.NewGameCardQuerySet(model.DB).IDEq(issueFeedback.GameCardId).One(&gameCard)
	if err != nil && err != model.RecordNotFound {
		logger.Error("game card err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	var userAddress model.UserAddress
	err = model.NewUserAddressQuerySet(model.DB).IDEq(issueFeedback.UserAddressId).One(&userAddress)
	if err != nil && err != model.RecordNotFound {
		logger.Error("game card err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	issueFeedback.Store = &store
	issueFeedback.GameCard = &gameCard
	issueFeedback.UserAddress = &userAddress

	RespOK(c, issueFeedback)
	return
}

func CardIssueDeliver(c *gin.Context) {
	req := struct {
		CardIssueFeedbackId uint32 `json:"card_issue_feedback_id"`
		ExpressCompany      string `json:"express_company"`    // 物流公司
		ExpressCompanyNo    string `json:"express_company_no"` // 物流公司编号
		ExpressNo           string `json:"express_no"`         // 物流单号
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("parameter err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	//var issueFeedback model.CardIssueFeedback
	_, err := model.NewCardIssueFeedbackQuerySet(model.DB).IDEq(req.CardIssueFeedbackId).GetUpdater().
		SetExpressCompany(req.ExpressCompany).SetExpressCompanyNo(req.ExpressCompanyNo).
		SetExpressNo(req.ExpressNo).UpdateNum()
	if err != nil {
		logger.Error("card issue feedback err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//model.GetImpo()

	RespOK(c, nil)
	return
}