package controller

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

func GameCassetteList(c *gin.Context) {
	req := struct {
		Keyword  string `json:"keyword"`
		PageNum  int    `json:"page_num"`
		PageSize int    `json:"page_size"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	cassettes, count, err := xianmai.GameCassetteList(req.Keyword, req.PageNum, req.PageSize)
	if err != nil {
		logger.Error("game cassette err", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if count == 0 {
		count = 1
	}
	ret := map[string]interface{}{
		//"count":      count,
		"list":       cassettes,
		"pageIndex":  req.PageNum,
		"pageSize":   req.PageSize,
		"total_page": count,
	}

	RespOK(c, ret)
	return
}

func GameCheckGoods(c *gin.Context) {
	req := xianmai.GameCheckGoodsReq{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	resp, err := req.Get()
	if err != nil {
		logger.Error("game cassette err", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, resp)
	return
}

func GameEvaluation(c *gin.Context) {
	req := xianmai.GameEvaluationReq{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}
	price, err := req.Evaluation()
	if err != nil {
		logger.Error("game cassette err", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	info, err := model.RecycleCardConfigInfo()
	if err != nil {
		logger.Error("config err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	if info.RebateRate > 0 && info.RebateRate < 10000 {
		price = (price * int(10000-info.RebateRate)) / 100
	} else {
		price = price * 100
	}
	if price > 70000 {
		logger.Error("price err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	price = (price / 100) * 100
	//price = 40 // TODO
	ret := map[string]interface{}{
		"price": price,
	}
	RespOK(c, ret)
	return
}

func RecycleCardCreateOrder(c *gin.Context) {
	req := xianmai.GameEvaluationReq{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON 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
	}
	//uc = &auth.UserClaims{Uid: 8588420}
	order, err := model.RecycleCardOrderCreate(uc.Uid, req)
	if err != nil {
		logger.Error("game cassette err", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, order)
	return
}

func RecycleCardOrderList(c *gin.Context) {
	req := model.RecycleCardOrderListReq{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON 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
	}
	//uc = &auth.UserClaims{Uid: 8588420}
	req.Uid = uc.Uid
	orders, totalPage, err := req.List()
	if err != nil {
		logger.Error("game cassette err", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"list":       orders,
		"cur_page":   req.PageIdx,
		"total_page": totalPage,
	}

	RespOK(c, ret)
	return
}

func RecycleCardOrderDetail(c *gin.Context) {
	req := struct {
		OrderId uint32 `json:"order_id" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON 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
	//}
	//uc = &auth.UserClaims{Uid: 8588420}

	var order model.RecycleCardOrder
	err := model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).One(&order)
	if err != nil {
		logger.Error("game cassette err", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	user := model.GetUserByUid(order.Uid)
	order.User = user
	store, err := model.GetStore(order.StoreId)
	if err != nil {
		logger.Error("order store err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	order.Store = store
	RespOK(c, order)
	return
}

func RecycleCardOrderCancel(c *gin.Context) {
	req := struct {
		OrderId uint32 `json:"order_id" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON err")
		RespJson(c, status.BadRequest, nil)
		return
	}

	var order model.RecycleCardOrder
	err := model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).One(&order)
	if err != nil {
		logger.Error("game cassette err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if order.State != 1 {
		logger.Error("order state err")
		RespJson(c, status.StateNotCancel, nil)
		return
	}
	err = model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).GetUpdater().
		SetState(4).Update()
	if err != nil {
		logger.Error("game cassette err", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	order.State = 4
	RespOK(c, order)
	return
}

func RecycleCardOrderImageUpdate(c *gin.Context) {
	req := struct {
		OrderId uint32 `json:"order_id" binding:"required"`
		Images  string `json:"images" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON 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
	}

	//uc = &auth.UserClaims{Uid: 8588420}
	assistant := model.GetUserByUid(uc.Uid)
	if assistant.UserType != 2 {
		logger.Error("not assistant")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	var order model.RecycleCardOrder
	err := model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).One(&order)
	if err != nil {
		logger.Error("order err:%#v", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if order.State != 1 {
		logger.Error("order state err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	userInfo := model.GetUserByUid(order.Uid)
	if userInfo == nil {
		logger.Error("user info err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//order.Price = 40 // TODO

	transfer, err := wxpay.Transfer(order.Price, userInfo.WxOpenID, "回收卡带")
	if err != nil {
		logger.Error("err:", err)
		if err.Error() == "account balance insufficient" {
			RespJson(c, status.MoneySufficient, nil)
		} else {
			RespJson(c, status.InternalServerError, nil)
		}

		return
	}

	err = model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).GetUpdater().
		SetImages(req.Images).SetState(2).SetCheckTime(time.Now()).
		SetAssistantName(assistant.ShopAssistantName).SetRetrieveState(1).Update()
	if err != nil {
		logger.Error("game cassette err", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	fundRecord := &model.FundRecord{
		Uid:        order.Uid,
		FundType:   model.FundTypeRecycleCard,
		Amount:     int64(order.Price) * (-1),
		OutTradeNo: transfer.PartnerTradeNo,
		PaymentNo:  transfer.PaymentNo,
		Status:     2,
		Remark:     "回收卡带",
		//TransactionId: ,
	}
	err = model.DB.Create(fundRecord).Error
	if err != nil {
		logger.Error("create fund record err:", err)
	}

	operationLog := &model.OperationLog{
		Uid:                   assistant.Uid,
		Description:           "回收卡带转款",
		OperationType:         model.OperationTypeRecycleCardOrderImageUpdate,
		CorrelationId:         order.ID,
		CorrelationName:       model.LogCorrelationRecycleCardOrderId,
		StoreId:               uint32(assistant.StoreId),
		StoreName:             "",
		CooperativeName:       assistant.CooperativeName,
		CooperativeBusinessId: assistant.CooperativeBusinessId,
		Detail:                "",
	}
	operationLog.AddLog()

	RespOK(c, nil)
	return
}

func RecycleCardOrderCheck(c *gin.Context) {
	req := struct {
		OrderId   uint32 `json:"order_id" binding:"required"`
		CheckType uint32 `json:"check_type" binding:"required"` // 1-拒绝
	}{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON 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
	}
	var order model.RecycleCardOrder
	err := model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).One(&order)
	if err != nil {
		logger.Error("recycle card order err:", err)
		return
	}
	if order.State != 1 {
		logger.Error("order state err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//uc = &auth.UserClaims{Uid: 8588420}
	assistant := model.GetUserByUid(uc.Uid)
	if assistant.UserType != 2 {
		logger.Error("not assistant")
		RespJson(c, status.InternalServerError, nil)
		return
	}

	if req.CheckType == 1 {
		err := model.NewRecycleCardOrderQuerySet(model.DB).IDEq(req.OrderId).GetUpdater().
			SetState(3).SetCheckTime(time.Now()).SetAssistantName(assistant.ShopAssistantName).
			Update()
		if err != nil {
			logger.Error("update recycle card order err:", err)
			return
		}
	}

	RespOK(c, nil)
	return
}

func ConsoleRecycleCardOrderList(c *gin.Context) {
	req := model.ConsoleRecycleCardOrderListReq{}
	if c.ShouldBindJSON(&req) != nil {
		logger.Error("ShouldBindJSON 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
	}
	//uc = &auth.UserClaims{Uid: 8588420}

	user := model.GetUserByUid(uc.Uid)
	if user != nil {
		req.StoreId = uint32(user.StoreId)
	}

	orders, totalPage, err := req.List()
	if err != nil {
		logger.Error("game cassette err", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	ret := map[string]interface{}{
		"list":       orders,
		"cur_page":   req.PageIdx,
		"total_page": totalPage,
	}

	RespOK(c, ret)
	return
}