package order

import (
	"fmt"
	"git.oa00.com/go/mysql"
	"recook/internal/api/mobile/pay/alipay"
	"recook/internal/api/mobile/pay/public"
	"recook/internal/api/mobile/pay/recookpay"
	"recook/internal/api/mobile/pay/unionpay"
	"recook/internal/api/mobile/pay/wxh5innerpay"
	"recook/internal/api/mobile/pay/wxh5pay"
	"recook/internal/api/mobile/pay/wxminipay"
	"recook/internal/api/mobile/pay/wxpay"
	"recook/internal/back"
	"recook/internal/dbc"
	"recook/internal/model/aftersales"
	"recook/internal/model/goods"
	"recook/internal/model/official"
	"recook/internal/model/order"
	"recook/internal/model/user"
	"recook/internal/service/comFunc"
	"recook/internal/v2/hook"
	"recook/internal/v2/lib/common"
	"recook/internal/v2/model/recook/after"
	"recook/tools"
	"strconv"
	"time"

	"github.com/astaxie/beego"

	"github.com/gin-gonic/gin"
	"github.com/golangkit/formatime"
	"github.com/jinzhu/gorm"
	"github.com/shopspring/decimal"
)

// 0正常，1等待商家审核 2审核被拒绝 3审核成功 4买家已填写退货物流信息 5收到退货，确认退款完成 6退货被拒绝
func QueryAfterSalesGoodsCount(c *gin.Context) {
	var allCount uint
	dbc.DB.Table((&aftersales.Goods{}).TableName()).Count(&allCount)

	var needCheckCount uint
	dbc.DB.Table((&aftersales.Goods{}).TableName()).Where("return_status = 1 and is_closed <>1").Count(&needCheckCount)

	var buyerShipCount uint
	dbc.DB.Table((&aftersales.Goods{}).TableName()).Where("return_status = 3 and is_closed <>1").Count(&buyerShipCount)

	var needShipCount uint
	dbc.DB.Table((&aftersales.Goods{}).TableName()).Where("return_status = 4 and is_closed <>1").Count(&needShipCount)

	var finishCount uint
	dbc.DB.Table((&aftersales.Goods{}).TableName()).Where("return_status = 5 and is_closed <>1").Count(&finishCount)

	var rejectCount uint
	dbc.DB.Table((&aftersales.Goods{}).TableName()).Where("(return_status = 2) OR (return_status = 6) and is_closed <>1").Count(&rejectCount)

	var colosedCount uint
	dbc.DB.Table((&aftersales.Goods{}).TableName()).Where("is_closed = 1").Count(&colosedCount)

	back.Suc(c, "操作成功", gin.H{
		"allCount":       allCount,
		"needCheckCount": needCheckCount,
		"buyerShipCount": buyerShipCount,
		"needShipCount":  needShipCount,
		"finishCount":    finishCount,
		"rejectCount":    rejectCount,
		"colosedCount":   colosedCount,
	})
}

type queryAfterGoodsParam struct {
	Page      uint   `json:"page"` // 分页
	Limit     uint   `json:"limit"`
	Status    uint   `json:"status"`
	AsID      uint   `json:"asId"`
	AssType   uint   `json:"assType"`
	ExpressSn string `json:"expressSn"`
	OrderSn   string `json:"orderSn"`
	StartDate string `json:"startDate"`
	EndDate   string `json:"endDate"`
	SkuCode   string `json:"skuCode"`
}

type queryAfterGoodsResp struct {
	aftersales.Goods
	PurchasePrice decimal.Decimal `json:"purchasePrice"`
	UnitPrice     decimal.Decimal `json:"unitPrice"`
	Address       order.Addr      `json:"address"`
	AfterType     string          `json:"afterType"` //未发货仅退款、部分退款、退货退款
}

func QueryAfterSalesGoodsList(c *gin.Context) {
	var p queryAfterGoodsParam
	if err := tools.Params(&p, c); err != nil {
		back.Fail(c, err.Error())
		return
	}

	var limit uint = 10
	if p.Limit > 0 {
		limit = p.Limit
	}

	where := fmt.Sprintf("return_status = %d", p.Status)
	if p.Status == 2 || p.Status == 6 {
		where = "(return_status = 2) OR (return_status = 6)"
	} else if p.Status == 0 {
		where = "1=1"
	}

	//搜索条件的where情况
	whereSearch := " 1=1 "
	if p.Status == 7 {
		where = ""
		whereSearch = " is_closed = 1 "
	}
	if p.AssType != 0 {
		whereSearch += " and ass_type = " + string(strconv.Itoa(int(p.AssType)))
	}
	if p.OrderSn != "" {
		whereSearch += " and order_id = '" + p.OrderSn + "'"
	}
	if p.ExpressSn != "" {
		whereSearch += " and express_no = '" + p.ExpressSn + "'"
	}
	if p.StartDate != "" && p.EndDate != "" {
		whereSearch += " and created_at > '" + p.StartDate + " 00:00:00' and created_at < '" + p.EndDate + " 23:59:59'"
	}
	if p.SkuCode != "" {
		whereSearch += " and sku_code = '" + p.SkuCode + "'"
	}
	var total uint
	asGoodsList := make([]aftersales.Goods, 0, 0)
	dbc.DB.Limit(limit).Offset(limit*p.Page).Where(where).Where(whereSearch).Find(&asGoodsList, aftersales.Goods{
		ID: p.AsID,
	})
	dbc.DB.Table((&aftersales.Goods{}).TableName()).Where(where).Where(whereSearch).Where(aftersales.Goods{
		ID: p.AsID,
	}).Count(&total)

	list := make([]queryAfterGoodsResp, 0, 0)
	var sku goods.Sku
	var det order.GoodsDetail
	for i, v := range asGoodsList {

		var address order.Addr
		dbc.DB.First(&address, "order_id = ?", v.OrderID)
		dbc.DB.Select("purchase_price").Where("code = ?", v.SkuCode).First(&sku)
		dbc.DB.Select("unit_price").Where("id = ?", v.OrderGoodsID).First(&det)

		//获取售后类型
		var afterType = ""
		if v.IsShip == 0 && v.AssType == 1 {
			afterType = "未发货仅退款"
		}
		if v.IsShip == 1 && v.AssType == 1 {
			afterType = "部分退款"
		}
		if v.AssType == 2 {
			afterType = "退货退款"
		}

		list = append(list, queryAfterGoodsResp{
			Goods:         asGoodsList[i],
			PurchasePrice: sku.PurchasePrice,
			UnitPrice:     det.UnitPrice,
			Address:       address,
			AfterType:     afterType,
		})
		det = order.GoodsDetail{}
		sku = goods.Sku{}
	}
	back.Suc(c, "", gin.H{
		"total": total,
		"list":  list,
	})
}

// ******************* ******************* ******************* ******************* *******************
// ******************* ******************* ******************* ******************* *******************
// ******************* ******************* *****更新操作******* ******************* *******************
// ******************* ******************* ******************* ******************* *******************
// ******************* ******************* ******************* ******************* *******************

type updateOrderCheckStatusParam struct {
	AsID         uint   `json:"asId" binding:"required"`
	Opinion      uint   `json:"opinion" binding:"required"`      // 审核意见 1：可以退货 2 拒绝退货
	RejectReason string `json:"rejectReason" binding:"required"` // 拒绝理由
}

// @Summary 同意或拒绝商品退货/退款
// @Description
// @Tags    订单
// @Version 1.0
// @Accept  json
// @Produce json
// @Param 	params body order.updateOrderCheckStatusParam true "参数"
// @Router  /manage/order/return/goods/status/update [POST]
// @Success 200 {object}
func UpdateAfterSalesGoodsCheckStatus(c *gin.Context) {
	var p updateOrderCheckStatusParam
	if err := tools.Params(&p, c); err != nil {
		back.Fail(c, err.Error())
		return
	}

	if p.Opinion == 2 && len(p.RejectReason) == 0 {
		back.Fail(c, "必须填写拒绝理由")
		return
	}

	var asGoods aftersales.Goods
	if err := dbc.DB.First(&asGoods, p.AsID).Error; err != nil {
		back.Err(c, err.Error())
		return
	}

	var orderInfo order.Information
	if err := dbc.DB.First(&orderInfo, asGoods.OrderID).Error; err != nil {
		back.Err(c, err.Error())
		return
	}
	userLog, _ := common.GetManageUser(c)

	// 0正常，1等待商家审核 2审核被拒绝 3审核成功 4买家已填写退货物流信息 5收到退货，确认退款完成 6退货被拒绝

	if asGoods.AssType == 2 { // 退货 退款
		if p.Opinion == 1 {
			tx := dbc.DB.Begin()
			if err := tx.Model(&asGoods).Updates(aftersales.Goods{
				ReturnStatus: 3,
				CheckTime:    formatime.NewSecondNow(),
			}).Error; err != nil {
				tx.Rollback()
				back.Err(c, err.Error())
				return
			}

			if !refundRecord(tx, orderInfo, asGoods) {
				tx.Rollback()
				back.Err(c, "流水保存错误1")
				return
			}

			//这边增加一个让买家填写单号的通知
			var userNotice = &user.Notice{
				Type:      4,
				UserID:    asGoods.UserID,
				Content:   "您的售后已通过，尽快填写退回的快递单号",
				CreatTime: formatime.NewSecondNow(),
			}
			tx.Create(userNotice)

			//这里插入日志
			var addr official.ReturnAddress
			dbc.DB.Last(&addr)
			aftersalesLog := aftersales.AftersalesLog{
				AsId:    asGoods.ID,
				Title:   "平台同意退货",
				Content: "平台同意买家退货，买家须在48小时内上传物流信息，否则系统将自动关闭退货请求。|<address>寄回地址：" + addr.Address + " " + " " + addr.Name + addr.Mobile + "</address>",
				Ctime:   formatime.NewSecondNow(),
				User:    userLog.Name,
				UserId:  userLog.Id,
			}
			tx.Create(&aftersalesLog)
			tx.Commit()
		} else { // 拒绝的话，将原来的订单商品ass_type标记下
			tx := dbc.DB.Begin()
			{
				if err := tx.Model(&asGoods).Updates(aftersales.Goods{
					ReturnStatus: 2,
					RejectReason: p.RejectReason,
					FinishTime:   formatime.NewSecondNow(),
				}).Error; err != nil {
					back.Err(c, err.Error())
					tx.Rollback()
					return
				}

				if err := tx.Model(&order.GoodsDetail{ID: asGoods.OrderGoodsID}).Updates(map[string]interface{}{
					"ass_type": 0,
				}).Error; err != nil {
					back.Err(c, err.Error())
					tx.Rollback()
					return
				}
			}

			//这里插入日志
			aftersalesLog := aftersales.AftersalesLog{
				AsId:    asGoods.ID,
				Title:   "平台拒绝退货",
				Content: "拒绝买家退货申请，如有疑问，请联系客服",
				Ctime:   formatime.NewSecondNow(),
				User:    userLog.Name,
				UserId:  userLog.Id,
			}
			tx.Create(&aftersalesLog)
			tx.Commit()
		}
	} else { // 只是退款
		tx := dbc.DB.Begin()
		{
			if p.Opinion == 1 {
				if asGoods.IsShip == 1 && asGoods.RefundAmount.IsZero() {
					if err := tx.Model(&asGoods).Updates(aftersales.Goods{
						ReturnStatus: 5,
						RefundStatus: 1,
						CheckTime:    formatime.NewSecondNow(),
					}).Error; err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
					salesGoodsModel := after.RecookAfterSalesGoodsModel{Id: asGoods.ID}
					mysql.Db.First(&salesGoodsModel)
					if err := hook.AfterHook.Finish(&salesGoodsModel); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
					//这里插入日志

					aftersalesLog := aftersales.AftersalesLog{
						AsId:    asGoods.ID,
						Title:   "平台同意退款",
						Content: "同意买家退款，平台将在24小时内处理退款。",
						Ctime:   formatime.NewSecondNow(),
						User:    userLog.Name,
						UserId:  userLog.Id,
					}
					tx.Create(&aftersalesLog)

					aftersalesLog1 := aftersales.AftersalesLog{
						AsId:    asGoods.ID,
						Title:   "退款成功",
						Content: "退款金额<black>￥" + asGoods.RefundAmount.String() + "</black>将原路退回至您的<black>付款账户</black>，请及时关注到账情况。|退回瑞币<black>" + asGoods.RefundCoin.Add(asGoods.ExpressFree).String() + "</black>已返回至您的<black>瑞币账户</black>，请及时合适。|<gray>若3天内未收到退款/瑞币，请联系客服咨询。</gray>",
						Ctime:   formatime.NewSecondNow(),
						User:    userLog.Name,
						UserId:  userLog.Id,
					}
					tx.Create(&aftersalesLog1)

					if err := public.SyncRefundSuccessCallback(tx, &asGoods); err != nil {
						tx.Rollback()
						back.Err(c, "退款失败")
						return
					}
					tx.Commit()
				} else {
					if err := tx.Model(&asGoods).Updates(aftersales.Goods{
						ReturnStatus: 5,
						RefundStatus: 1,
						CheckTime:    formatime.NewSecondNow(),
					}).Error; err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}

					salesGoodsModel := after.RecookAfterSalesGoodsModel{Id: asGoods.ID}
					mysql.Db.First(&salesGoodsModel)
					if err := hook.AfterHook.Finish(&salesGoodsModel); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
					if orderInfo.PayMethod == 0 {
						if err := recookpay.Refund(tx, &asGoods); err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}
					} else if orderInfo.PayMethod == 1 {
						if err := wxpay.Refund(&asGoods); err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}
					} else if orderInfo.PayMethod == 2 {
						if err := alipay.Refund(tx, &asGoods); err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}
					} else if orderInfo.PayMethod == 4 {
						if err := wxminipay.Refund(&asGoods); err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}
					} else if orderInfo.PayMethod == order.AlipayH5ForOrderInfo {
						if err := alipay.Refund(tx, &asGoods); err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}
					} else if orderInfo.PayMethod == order.WechatH5PayForOrderInfo {
						if err := wxh5pay.Refund(&asGoods); err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}
					} else if orderInfo.PayMethod == order.WechatH5InnerForOrderInfo {
						if err := wxh5innerpay.Refund(&asGoods); err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}
					} else if orderInfo.PayMethod == order.UnionPay {
						if err := unionpay.Refund(&asGoods); err != nil {
							back.Err(c, err.Error())
							tx.Rollback()
							return
						}
					}

					//这里插入日志
					aftersalesLog := aftersales.AftersalesLog{
						AsId:    asGoods.ID,
						Title:   "平台同意退款",
						Content: "同意买家退款，平台将在24小时内处理退款。",
						Ctime:   formatime.NewSecondNow(),
						User:    userLog.Name,
						UserId:  userLog.Id,
					}
					tx.Create(&aftersalesLog)

					aftersalesLog1 := aftersales.AftersalesLog{
						AsId:    asGoods.ID,
						Title:   "退款成功",
						Content: "退款金额<black>￥" + asGoods.RefundAmount.String() + "</black>将原路退回至您的<black>付款账户</black>，请及时关注到账情况。|退回瑞币<black>" + asGoods.RefundCoin.Add(asGoods.ExpressFree).String() + "</black>已返回至您的<black>瑞币账户</black>，请及时合适。|<gray>若3天内未收到退款/瑞币，请联系客服咨询。</gray>",
						Ctime:   formatime.NewSecondNow(),
						User:    userLog.Name,
						UserId:  userLog.Id,
					}
					tx.Create(&aftersalesLog1)
					// 瑞比退款
					if !refundRecord(tx, orderInfo, asGoods) {
						tx.Rollback()
						back.Err(c, "流水保存错误2")
						return
					}
					tx.Commit()
					if orderInfo.PayMethod == order.UnionPay {
						if err := unionpay.RefundSucc(&asGoods); err != nil {
						}
					}
				}
			} else { // 拒绝的话，将原来的订单商品ass_type标记下
				if err := tx.Model(&asGoods).Updates(aftersales.Goods{
					ReturnStatus: 2,
					RejectReason: p.RejectReason,
					FinishTime:   formatime.NewSecondNow(),
				}).Error; err != nil {
					back.Err(c, err.Error())
					tx.Rollback()
					return
				}

				if err := tx.Model(&order.GoodsDetail{ID: asGoods.OrderGoodsID}).Updates(map[string]interface{}{
					"ass_type": 0,
				}).Error; err != nil {
					back.Err(c, err.Error())
					tx.Rollback()
					return
				}

				//这里插入日志
				aftersalesLog := aftersales.AftersalesLog{
					AsId:    asGoods.ID,
					Title:   "平台拒绝退款",
					Content: "拒绝买家退款申请，如有疑问，请联系客服",
					Ctime:   formatime.NewSecondNow(),
					User:    userLog.Name,
					UserId:  userLog.Id,
				}
				tx.Create(&aftersalesLog)
				aftersalesLog1 := aftersales.AftersalesLog{
					AsId:    asGoods.ID,
					Title:   "退款关闭",
					Content: "系统自动关闭",
					Ctime:   formatime.NewSecondNow(),
					User:    userLog.Name,
					UserId:  userLog.Id,
				}
				tx.Create(&aftersalesLog1)
				tx.Commit()
			}
		}
	}

	back.Suc(c, "", &asGoods)
}

type updateReturnSuccessParam struct {
	AsID         uint   `json:"asId" binding:"required"`
	Opinion      uint   `json:"opinion"` // 1同意退款退货 2拒绝
	RejectReason string `json:"rejectReason"`
}

func UpdateAfterSalesGoodsExpressStatus(c *gin.Context) {
	var p updateReturnSuccessParam
	if err := tools.Params(&p, c); err != nil {
		back.Fail(c, err.Error())
		return
	}

	var asGoods aftersales.Goods
	if err := dbc.DB.First(&asGoods, p.AsID).Error; err != nil {
		back.Err(c, err.Error())
		return
	}

	if asGoods.AssType == 1 {
		back.Fail(c, "该订单仅退款")
		return
	}

	if asGoods.ReturnStatus != 4 {
		back.Fail(c, "订单状态不可更新")
		return
	}

	var orderInfo order.Information
	if err := dbc.DB.First(&orderInfo, asGoods.OrderID).Error; err != nil {
		back.Err(c, err.Error())
		return
	}

	userLog, _ := common.GetManageUser(c)

	if p.Opinion == 2 {
		if len(p.RejectReason) == 0 {
			back.Fail(c, "没有填写拒绝原因")
			return
		}
		tx := dbc.DB.Begin()
		{
			if err := tx.Model(&asGoods).Updates(aftersales.Goods{
				ReturnStatus: 3, //让买家继续填写单号
				RejectReason: p.RejectReason,
				FinishTime:   formatime.NewSecondNow(),
			}).Error; err != nil {
				back.Err(c, err.Error())
				tx.Rollback()
				return
			}

			//这边增加一个让买家填写单号的通知
			var userNotice = &user.Notice{
				Type:      4,
				UserID:    asGoods.UserID,
				Content:   "您的售后已通过，尽快填写退回的快递单号",
				CreatTime: formatime.NewSecondNow(),
			}
			tx.Create(userNotice)

			//这里插入日志
			var addr official.ReturnAddress
			dbc.DB.Last(&addr)
			aftersalesLog := aftersales.AftersalesLog{
				AsId:    asGoods.ID,
				Title:   "平台拒绝收货",
				Content: "已收到买家退回商品，不符合退货条件，拒绝退款。理由：" + p.RejectReason + "|买家须在48小时内上传物流信息，否则系统将自动关闭退货请求。|<address>寄回地址：" + addr.Address + " " + addr.Name + " " + addr.Mobile + "</address>",
				Ctime:   formatime.NewSecondNow(),
				User:    userLog.Name,
				UserId:  userLog.Id,
			}
			tx.Create(&aftersalesLog)

			aftersalesLog1 := aftersales.AftersalesLog{
				AsId:    asGoods.ID,
				Title:   "等待买家重新上传物流信息",
				Content: "",
				Ctime:   formatime.NewSecondNow(),
				User:    userLog.Name,
				UserId:  userLog.Id,
			}
			tx.Create(&aftersalesLog1)

			//不改变商品的售后状态
			//if err := tx.Model(&order.GoodsDetail{ID: asGoods.OrderGoodsID}).Updates(map[string]interface{}{
			//	"ass_type": 0,
			//}).Error; err != nil {
			//	http.Err(c, err.Error())
			//	tx.Rollback()
			//	return
			//}
		}
		tx.Commit()
	} else {
		tx := dbc.DB.Begin()
		{
			if err := tx.Model(&asGoods).Updates(aftersales.Goods{
				ReturnStatus: 5,
				RefundStatus: 1,
			}).Error; err != nil {
				back.Err(c, err.Error())
				tx.Rollback()
				return
			}
			salesGoodsModel := after.RecookAfterSalesGoodsModel{Id: asGoods.ID}
			mysql.Db.First(&salesGoodsModel)
			if err := hook.AfterHook.Finish(&salesGoodsModel); err != nil {
				back.Err(c, err.Error())
				tx.Rollback()
				return
			}
			if asGoods.IsShip == 1 && asGoods.RefundAmount.IsZero() {
				var coinHistory user.CoinHistory
				coinHistory.UserID = orderInfo.UserID
				coinHistory.CoinType = user.RefundTypeForCoinHistory1
				coinHistory.CoinNum = asGoods.RefundCoin
				coinHistory.OrderId = orderInfo.ID
				if err := tx.Save(&coinHistory).Error; err != nil {
					tx.Rollback()
					back.Err(c, "退款失败")
					return
				}
				if err := coinHistory.UpdateWalletAfterCreate(tx, orderInfo.UserID); err != nil {
					tx.Rollback()
					back.Err(c, "退款失败")
					return
				}
			} else {
				if orderInfo.PayMethod == 0 {
					if err := recookpay.Refund(tx, &asGoods); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == 1 {
					if err := wxpay.Refund(&asGoods); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == 2 {
					if err := alipay.Refund(tx, &asGoods); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == 4 {
					if err := wxminipay.Refund(&asGoods); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == order.AlipayH5ForOrderInfo {
					if err := alipay.Refund(tx, &asGoods); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == order.WechatH5PayForOrderInfo {
					if err := wxh5pay.Refund(&asGoods); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == order.WechatH5InnerForOrderInfo {
					if err := wxh5innerpay.Refund(&asGoods); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == order.UnionPay {
					if err := unionpay.Refund(&asGoods); err != nil {
						back.Err(c, err.Error())
						tx.Rollback()
						return
					}
				}
				// 瑞比退款
				if !refundRecord(tx, orderInfo, asGoods) {
					tx.Rollback()
					back.Err(c, "流水保存错误2")
					return
				}
			}
		}

		aftersalesLog := aftersales.AftersalesLog{
			AsId:    asGoods.ID,
			Title:   "平台确认收货",
			Content: "已收到买家退回商品，符合退货条件，同意退款。|平台将在24小时内处理退款。",
			Ctime:   formatime.NewSecondNow(),
			User:    userLog.Name,
			UserId:  userLog.Id,
		}
		tx.Create(&aftersalesLog)

		aftersalesLog1 := aftersales.AftersalesLog{
			AsId:    asGoods.ID,
			Title:   "退款成功",
			Content: "退款金额<black>￥" + asGoods.RefundAmount.String() + "</black>将原路退回至您的<black>付款账户</black>，请及时关注到账情况。|退回瑞币<black>" + asGoods.RefundCoin.Add(asGoods.ExpressFree).String() + "</black>已返回至您的<black>瑞币账户</black>，请及时合适。|<gray>若3天内未收到退款/瑞币，请联系客服咨询。</gray>",
			Ctime:   formatime.NewSecondNow(),
			User:    userLog.Name,
			UserId:  userLog.Id,
		}
		tx.Create(&aftersalesLog1)

		tx.Commit()
		if orderInfo.PayMethod == order.UnionPay {
			if err := unionpay.RefundSucc(&asGoods); err != nil {
			}
		}
	}

	back.Suc(c, "", nil)
}
func RefundRecord(tx *gorm.DB, orderInfo order.Information, afterSalesGood aftersales.Goods) bool {
	return refundRecord(tx, orderInfo, afterSalesGood)
}

func refundRecord(tx *gorm.DB, orderInfo order.Information, afterSalesGood aftersales.Goods) bool {
	// pay success 里面已经调用 这边不需要更新
	if orderInfo.PayMethod != 0 {
		if orderInfo.CoinTotalAmount.GreaterThan(decimal.NewFromInt(0)) {
			var orderGoods order.GoodsDetail
			if err := dbc.DB.First(&orderGoods, afterSalesGood.OrderGoodsID).Error; err != nil {
				beego.Error(err)
				return false
			}

			var coinHistory user.CoinHistory
			coinHistory.UserID = orderInfo.UserID
			coinHistory.CoinType = user.RefundTypeForCoinHistory1
			// coinHistory.CoinNum = orderInfo.CoinTotalAmount
			coinHistory.CoinNum = orderGoods.CoinAmount
			coinHistory.OrderAmount = orderInfo.GoodsTotalAmount
			coinHistory.OrderId = orderInfo.ID
			coinHistory.Remark = "商品退款-退回"
			// beego.Info(coinHistory.CoinNum, orderInfo.CoinTotalAmount)
			if err := tx.Save(&coinHistory).Error; err != nil {
				comFunc.PrintErr("refundRecord save coinHistory error:", err)
				return false
			}
			if err := coinHistory.UpdateWalletAfterCreate(tx, orderInfo.UserID); err != nil {
				comFunc.PrintErr("refundRecord UpdateWalletAfterCreate error:", err)
				return false
			}
		}
	}
	return true
}

//24小时自动通过售后，现在这个只针对已发货的退货退款和仅退款
var days time.Duration = 1

func AfterNotToDoOne() {
	for {
		select {
		case <-time.After(2 * time.Minute):
			t := time.Now().Add(time.Hour * 24 * -days)
			//为了测试，将24小时改成2分钟
			//t := time.Now().Add(time.Minute * -2)

			var afterSales []aftersales.Goods
			dbc.DB.Find(&afterSales, "is_ship=1 and return_status = 1 AND apply_time <= ?", t.Format("2006-01-02 15:04:05"))
			for _, v := range afterSales {

				var p updateOrderCheckStatusParam
				p = updateOrderCheckStatusParam{
					v.ID,
					1,
					"自动退货",
				}
				UpdateAfterSalesGoods(p, v)

			}

		}
	}
}

//自动通过未发货仅退款的
func AfterAssTpyeOne() {
	for {
		select {
		case <-time.After(1 * time.Minute):
			var afterSales []aftersales.Goods
			dbc.DB.Find(&afterSales, "ass_type=1 and return_status = 1 and is_ship=0 and third_party_type = 0 and pay_method != ?", order.UnionPay)
			for _, v := range afterSales {

				var p updateOrderCheckStatusParam
				p = updateOrderCheckStatusParam{
					v.ID,
					1,
					"自动退货",
				}
				UpdateAfterSalesGoods(p, v)

			}

		}
	}
}

//退款退货或者仅退款都通过
func UpdateAfterSalesGoods(p updateOrderCheckStatusParam, asGoods aftersales.Goods) {

	var orderInfo order.Information
	if err := dbc.DB.First(&orderInfo, asGoods.OrderID).Error; err != nil {
		return
	}

	// 0正常，1等待商家审核 2审核被拒绝 3审核成功 4买家已填写退货物流信息 5收到退货，确认退款完成 6退货被拒绝

	if asGoods.AssType == 2 { // 退货 退款
		tx := dbc.DB.Begin()
		if err := tx.Model(&asGoods).Updates(aftersales.Goods{
			ReturnStatus: 3,
			CheckTime:    formatime.NewSecondNow(),
		}).Error; err != nil {
			tx.Rollback()
			return
		}

		if !refundRecord(tx, orderInfo, asGoods) {
			tx.Rollback()
			return
		}
		//这边增加一个让买家填写单号的通知
		var userNotice = &user.Notice{
			Type:      4,
			UserID:    asGoods.UserID,
			Content:   "您的售后已通过，尽快填写退回的快递单号",
			CreatTime: formatime.NewSecondNow(),
		}
		tx.Create(userNotice)

		//这里插入日志
		var addr official.ReturnAddress
		dbc.DB.Last(&addr)
		aftersalesLog := aftersales.AftersalesLog{
			AsId:    asGoods.ID,
			Title:   "平台同意退货",
			Content: "平台同意买家退货，买家须在48小时内上传物流信息，否则系统将自动关闭退货请求。|<address>寄回地址：" + addr.Address + " " + " " + addr.Name + addr.Mobile + "</address>",
			Ctime:   formatime.NewSecondNow(),
			UserId:  0,
			User:    "系统",
		}
		tx.Create(&aftersalesLog)

		tx.Commit()

	} else { // 只是退款
		tx := dbc.DB.Begin()
		{
			if p.Opinion == 1 {
				if err := tx.Model(&asGoods).Updates(aftersales.Goods{
					ReturnStatus: 5,
					RefundStatus: 1,
					CheckTime:    formatime.NewSecondNow(),
				}).Error; err != nil {
					tx.Rollback()
					return
				}

				if orderInfo.PayMethod == 0 {
					if err := recookpay.Refund(tx, &asGoods); err != nil {
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == 1 {
					if err := wxpay.Refund(&asGoods); err != nil {
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == 2 {
					if err := alipay.Refund(tx, &asGoods); err != nil {
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == 4 {
					if err := wxminipay.Refund(&asGoods); err != nil {
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == order.AlipayH5ForOrderInfo {
					if err := alipay.Refund(tx, &asGoods); err != nil {
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == order.WechatH5PayForOrderInfo {
					if err := wxh5pay.Refund(&asGoods); err != nil {
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == order.WechatH5InnerForOrderInfo {
					if err := wxh5innerpay.Refund(&asGoods); err != nil {
						tx.Rollback()
						return
					}
				} else if orderInfo.PayMethod == order.UnionPay {
					if err := unionpay.Refund(&asGoods); err != nil {
						tx.Rollback()
						return
					}
				}
			}
		}
		if !refundRecord(tx, orderInfo, asGoods) {
			tx.Rollback()
			return
		}
		//这里插入日志
		aftersalesLog := aftersales.AftersalesLog{
			AsId:    asGoods.ID,
			Title:   "平台同意退款",
			Content: "同意买家退款，平台将在24小时内处理退款。",
			Ctime:   formatime.NewSecondNow(),
			UserId:  0,
			User:    "系统",
		}
		tx.Create(&aftersalesLog)

		aftersalesLog1 := aftersales.AftersalesLog{
			AsId:    asGoods.ID,
			Title:   "退款成功",
			Content: "退款金额<black>￥" + asGoods.RefundAmount.String() + "</black>将原路退回至您的<black>付款账户</black>，请及时关注到账情况。|退回瑞币<black>" + asGoods.RefundCoin.Add(asGoods.ExpressFree).String() + "</black>已返回至您的<black>瑞币账户</black>，请及时合适。|<gray>若3天内未收到退款/瑞币，请联系客服咨询。</gray>",
			Ctime:   formatime.NewSecondNow(),
			UserId:  0,
			User:    "系统",
		}
		tx.Create(&aftersalesLog1)

		tx.Commit()
		if orderInfo.PayMethod == order.UnionPay {
			if err := unionpay.RefundSucc(&asGoods); err != nil {
			}
		}

	}
}

//48小时自动关闭未填写单号的售后
var days1 time.Duration = 2

// AfterNotToDoTwo 买家没有填写单号
func AfterNotToDoTwo() {
	for {
		select {
		case <-time.After(2 * time.Minute):
			t := time.Now().Add(time.Hour * 72 * -days1)
			//为了测试，将24小时改成2分钟
			//t := time.Now().Add(time.Minute * -2)

			var afterSales []after.RecookAfterSalesGoodsModel
			dbc.DB.Find(&afterSales, "return_status = 3 AND ass_type=2 AND check_time <= ?", t.Format("2006-01-02 15:04:05"))
			for _, v := range afterSales {

				var p updateReturnSuccessParam
				p = updateReturnSuccessParam{
					v.Id,
					2,
					"72小时未填写单号，系统自动关闭",
				}
				UpdateNotExp(p, v)
			}
		}
	}
}

//没有填写单号，退货被拒绝
func UpdateNotExp(p updateReturnSuccessParam, asGoods after.RecookAfterSalesGoodsModel) {

	var orderInfo order.Information
	if err := dbc.DB.First(&orderInfo, asGoods.OrderId).Error; err != nil {
		return
	}

	if p.Opinion == 2 {
		tx := mysql.Db.Begin()
		{
			if err := tx.Model(&asGoods).Updates(&after.RecookAfterSalesGoodsModel{
				ReturnStatus: 6,
				RejectReason: p.RejectReason,
				FinishTime:   formatime.NewSecondNow(),
				IsClosed:     1,
			}).Error; err != nil {
				tx.Rollback()
				return
			}

			if err := tx.Model(&order.GoodsDetail{ID: asGoods.OrderGoodsId}).Updates(map[string]interface{}{
				"ass_type":  0,
				"is_closed": 1,
			}).Error; err != nil {
				tx.Rollback()
				return
			}
			if err := hook.AfterHook.Close(&asGoods); err != nil {
				tx.Rollback()
				return
			}

		}
		tx.Commit()
	}

}