package cron

import (
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"recook/configs"
	order3 "recook/internal/api/mobile/order"
	"recook/internal/dbc"
	order4 "recook/internal/model/order"
	"recook/internal/model/user"
	"recook/internal/mq"
	"recook/internal/mq/model"
	"recook/internal/v2/hook"
	"recook/internal/v2/lib/jcook"
	"recook/internal/v2/lib/shama"
	after2 "recook/internal/v2/logic/manage/after"
	order2 "recook/internal/v2/logic/manage/order"
	"recook/internal/v2/model/recook/after"
	goods2 "recook/internal/v2/model/recook/goods"
	manage2 "recook/internal/v2/model/recook/manage"
	manage "recook/internal/v2/model/recook/order"
	"regexp"
	"strconv"
	"strings"
	"time"

	"git.oa00.com/go/mysql"
	"github.com/golangkit/formatime"
	"github.com/robfig/cron/v3"
	"github.com/shopspring/decimal"
	gorm2 "gorm.io/gorm"
)

// Task 定时任务
func Task(c *cron.Cron) {
	c.AddFunc("0 */1 * * * ?", func() {
		fmt.Println("task live")
	})
	c.AddFunc("0 */10 * * * ?", func() {
		NoticeDelete()
	})
	//_ = c.AddFunc("0 */1 * * * ?", func() {
	//	message.DeliveryTimeOut()
	//})
	c.AddFunc("0 */1 * * * ?", func() {
		order3.PlanMonitorTradeSucOrderTask()
	})
	c.AddFunc("0 */1 * * * ?", func() {
		order3.PlanMonitorExpireOrderTask()
	})
	c.AddFunc("0 */1 * * * ?", func() {
		AfterNotToDoTwo()
	})
	c.AddFunc("*/10 * * * * ?", func() {
		VipExpired()
	})

	if configs.IsProductionEnv() {
		go TaskMq()
	}
	// 启动供应链任务
	if configs.IsProductionEnv() {
		SupplyTask.run()
	}

	if configs.IsProductionEnv() {
		//go ShaMaMq()
	}
}

func VipExpired() {
	var u1 []user.Information
	mysql.Db.Find(&u1, "vip_upgrade_end < ?", time.Now())
	for _, v := range u1 {
		mysql.Db.Table((&user.Information{}).TableName()).Where("id = ?", v.ID).Updates(map[string]interface{}{
			"level":             v.OldLevel,
			"parent_id":         v.OldParentID,
			"old_level":         0,
			"old_root_id":       0,
			"old_parent_id":     0,
			"is_offline":        false,
			"vip_upgrade_start": sql.NullTime{},
			"vip_upgrade_end":   sql.NullTime{},
		})
	}
}

func ShaMaMq() {
	go OrderShaMaPay()
	go OrderShaMaCancel()
	go OrderShaMaStockOut()
	go ShaMaSkuPrice()
}

func TaskMq() {
	go skuChange()
	go skuPrice()
	go orderCreate()
	go OrderPay()
	go OrderStockOut()
	go OrderFinished()
	go OrderCancel()
}

const maxRetryNum = 1

func ShaMaSkuPrice() {
	q := fmt.Sprintf("sku.price.queue.%s", configs.ConfigShaMaAppKey)
	mq.Conn1.ListenRetry(q, maxRetryNum, func(data []byte) error {
		client := shama.GetClient()
		var m model.SkuChange
		err := json.Unmarshal(data, &m)
		if err != nil {
			log.Println(err.Error())
			return err
		}
		rq := shama.SkuDetailReq{
			SkuIDSet: []uint{m.SkuID},
		}
		var res []shama.SkuDetailResp
		if err := client.Exec(rq, &res); err != nil {
			log.Println(err.Error())
			return err
		}
		if len(res) == 0 {
			return nil
		}
		t := res[0]

		var sku goods2.RecookGoodsSkuModel
		if err := mysql.Db.Table(sku.TableName()).Where("third_party_sku_id = ? and third_party_type=4", t.SkuDetailBase.SkuID).Updates(map[string]interface{}{
			"sale_purchase_price": t.SkuDetailBase.SupplyPrice,
		}).Error; err != nil {
			log.Println(err.Error())
			return err
		}
		return nil
	})
}

func OrderShaMaStockOut() {
	q := fmt.Sprintf("order.stock.out.queue.%s", configs.ConfigShaMaAppKey)
	mq.Conn1.ListenRetry(q, maxRetryNum, func(data []byte) error {
		var m model.OrderStockOutMessage
		err := json.Unmarshal(data, &m)
		if err != nil {
			log.Println(err.Error())
			return err
		}
		var od manage.RecookOrderInfoModel
		if err = mysql.Db.First(&od, "shama_order_id = ?", m.OrderID).Error; err != nil {
			log.Println(err.Error())
			return err
		}

		if od.OrderType == 2 {
			return nil
		}

		var orderSku []manage.RecookOrderGoodsDetailModel
		if err = mysql.Db.Find(&orderSku, "order_id =? ", od.Id).Error; err != nil {
			log.Println(err.Error())
			return err
		}

		ep := make([]order2.ExpressInfo, 0)
		for _, v := range m.Packages {
			ep = append(ep, order2.ExpressInfo{
				ExpressCompName: v.LogisticsName,
				ExpressNo:       v.WaybillCode,
			})
		}

		for index, j := range orderSku {
			order2.Expresslogic.Express(j.VendorId, "jcook", orderSku[index], ep)
		}
		return nil
	})
}

func OrderShaMaPay() {
	q := fmt.Sprintf("order.pay.queue.%s", configs.ConfigShaMaAppKey)
	mq.Conn1.ListenRetry(q, maxRetryNum, func(data []byte) error {
		time.Sleep(time.Second)
		var m model.OrderPayMessage
		err := json.Unmarshal(data, &m)
		if err != nil {
			log.Println(err.Error())
			return err
		}
		var od manage.RecookOrderInfoModel
		if err = mysql.Db.First(&od, "shama_order_id = ?", m.OrderID).Error; err != nil {
			log.Println(err.Error())
			return nil
		}
		if od.Status == 0 {
			return errors.New("订单未支付")
		}
		if od.Status == 1 {
			client := shama.GetClient()
			req := shama.OrderPushReq{
				OrderID: uint(m.OrderID),
			}
			var resp jcook.OrderPushResp
			if err = client.Exec(req, &resp); err != nil {
				return err
			}
		}

		return nil
	})
}

func OrderShaMaCancel() {
	q := fmt.Sprintf("order.cancel.queue.%s", configs.ConfigShaMaAppKey)
	mq.Conn1.ListenRetry(q, maxRetryNum, func(data []byte) error {
		var m model.OrderCancelMessage
		err := json.Unmarshal(data, &m)
		var od manage.RecookOrderInfoModel
		if err = mysql.Db.First(&od, "shama_order_id = ?", m.OrderID).Error; err != nil {
			if err != gorm2.ErrRecordNotFound {
				log.Println(err.Error())
				return err
			} else {
				return nil
			}
		}

		switch m.Status {
		case 1:
			if od.Status == 0 {
				// 未支付订单直接取消
				return nil
			} else {
				tx := dbc.DB.Begin()
				{
					var asGoods []after.RecookAfterSalesGoodsModel
					tx.Find(&asGoods, "order_id = ?", od.Id)
					for _, v := range asGoods {
						if v.RefundStatus == 1 {
							continue
						}
						t := &after2.UpdateOrderCheckStatusReq{
							AsID: v.Id,
						}
						if err = after2.Refund(tx, v, od, t, manage2.RecookManageUserInfoModel{}); err != nil {
							tx.Rollback()
							return err
						}
					}

				}
				if err = tx.Model(od).Update("deal_status", 11).Error; err != nil {
					return err
				}
				tx.Commit()
			}
		case 2:
			tx := dbc.DB.Begin()
			{
				od.DealStatus = 12
				if err = tx.Save(&od).Error; err != nil {
					return err
				}

				var asGoods []after.RecookAfterSalesGoodsModel
				if err = tx.Find(&asGoods, "order_id = ?", od.Id).Error; err != nil {
					return err
				}

				for _, v := range asGoods {
					if err = tx.Model(v).Updates(after.RecookAfterSalesGoodsModel{
						ReturnStatus: 2,
						RejectReason: "系统自动拒绝",
						FinishTime:   formatime.NewSecondNow(),
					}).Error; err != nil {
						tx.Rollback()
						return err
					}

					if err := tx.Model(&manage.RecookOrderGoodsDetailModel{Id: v.OrderGoodsId}).Updates(map[string]interface{}{
						"ass_type": 0,
					}).Error; err != nil {
						tx.Rollback()
						return err
					}

					//这里插入日志
					Log1 := after.RecookAfterSalesLogsModel{
						AsID:    v.Id,
						Title:   "平台拒绝退款",
						Content: "拒绝买家退款申请，如有疑问，请联系客服",
						CTime:   formatime.NewSecondNow(),
						User:    "系统",
						UserId:  0,
					}
					tx.Create(&Log1)
					Log2 := after.RecookAfterSalesLogsModel{
						AsID:    v.Id,
						Title:   "退款关闭",
						Content: "系统自动关闭",
						CTime:   formatime.NewSecondNow(),
						User:    "系统",
						UserId:  0,
					}
					tx.Create(&Log2)
				}
			}
			tx.Commit()
		}

		return nil
	})
}

func OrderCancel() {
	q := fmt.Sprintf("order.cancel.queue.%s", configs.ConfigJCookAppKey)
	mq.Conn.ListenRetry(q, maxRetryNum, func(data []byte) error {
		var m model.OrderCancelMessage
		err := json.Unmarshal(data, &m)
		var od manage.RecookOrderInfoModel
		if err = mysql.Db.First(&od, "jcook_order_id = ?", m.OrderID).Error; err != nil {
			if err != gorm2.ErrRecordNotFound {
				log.Println(err.Error())
				return err
			} else {
				return nil
			}
		}

		switch m.Status {
		case 1:
			if od.Status == 0 {
				// 未支付订单直接取消
				return nil
			} else {
				tx := dbc.DB.Begin()
				{
					var asGoods []after.RecookAfterSalesGoodsModel
					tx.Find(&asGoods, "order_id = ?", od.Id)
					for _, v := range asGoods {
						if v.RefundStatus == 1 {
							continue
						}
						t := &after2.UpdateOrderCheckStatusReq{
							AsID: v.Id,
						}
						if err = after2.Refund(tx, v, od, t, manage2.RecookManageUserInfoModel{}); err != nil {
							tx.Rollback()
							return err
						}
					}

				}
				if err = tx.Model(od).Update("deal_status", 11).Error; err != nil {
					return err
				}
				tx.Commit()
			}
		case 2:
			tx := dbc.DB.Begin()
			{
				od.DealStatus = 12
				if err = tx.Save(&od).Error; err != nil {
					return err
				}

				var asGoods []after.RecookAfterSalesGoodsModel
				if err = tx.Find(&asGoods, "order_id = ?", od.Id).Error; err != nil {
					return err
				}

				for _, v := range asGoods {
					if err = tx.Model(v).Updates(after.RecookAfterSalesGoodsModel{
						ReturnStatus: 2,
						RejectReason: "系统自动拒绝",
						FinishTime:   formatime.NewSecondNow(),
					}).Error; err != nil {
						tx.Rollback()
						return err
					}

					if err := tx.Model(&manage.RecookOrderGoodsDetailModel{Id: v.OrderGoodsId}).Updates(map[string]interface{}{
						"ass_type": 0,
					}).Error; err != nil {
						tx.Rollback()
						return err
					}

					//这里插入日志
					Log1 := after.RecookAfterSalesLogsModel{
						AsID:    v.Id,
						Title:   "平台拒绝退款",
						Content: "拒绝买家退款申请，如有疑问，请联系客服",
						CTime:   formatime.NewSecondNow(),
						User:    "系统",
						UserId:  0,
					}
					tx.Create(&Log1)
					Log2 := after.RecookAfterSalesLogsModel{
						AsID:    v.Id,
						Title:   "退款关闭",
						Content: "系统自动关闭",
						CTime:   formatime.NewSecondNow(),
						User:    "系统",
						UserId:  0,
					}
					tx.Create(&Log2)
				}

			}

			tx.Commit()
		}

		return nil
	})
}

func OrderFinished() {
	q := fmt.Sprintf("order.finished.queue.%s", configs.ConfigJCookAppKey)
	mq.Conn.ListenRetry(q, maxRetryNum, func(data []byte) error {
		var m model.OrderFinishMessage
		err := json.Unmarshal(data, &m)
		if err != nil {
			log.Println(err.Error())
			return err
		}
		var od order4.Information
		if err = mysql.Db.First(&od, "jcook_order_id = ?", m.OrderID).Error; err != nil {
			log.Println(err.Error())
			return err
		}
		od.JCookStatus = 1
		if err = mysql.Db.Save(od).Error; err != nil {
			log.Println(err.Error())
			return err
		}
		return nil
	})
}

func OrderStockOut() {
	q := fmt.Sprintf("order.stock.out.queue.%s", configs.ConfigJCookAppKey)
	mq.Conn.ListenRetry(q, maxRetryNum, func(data []byte) error {
		var m model.OrderStockOutMessage
		err := json.Unmarshal(data, &m)
		if err != nil {
			log.Println(err.Error())
			return err
		}
		var od manage.RecookOrderInfoModel
		if err = mysql.Db.First(&od, "jcook_order_id = ?", m.OrderID).Error; err != nil {
			log.Println(err.Error())
			return err
		}

		var orderSku []manage.RecookOrderGoodsDetailModel
		if err = mysql.Db.Find(&orderSku, "order_id =? ", od.Id).Error; err != nil {
			log.Println(err.Error())
			return err
		}

		ep := make([]order2.ExpressInfo, 0)
		for _, v := range m.Packages {
			ep = append(ep, order2.ExpressInfo{
				ExpressCompName: v.LogisticsName,
				ExpressNo:       v.WaybillCode,
			})
		}

		for index, j := range orderSku {
			if j.ExpressStatus == manage.RecookOrderGoodsDetailExpressStatusTrue {
				continue
			}
			if err := order2.Expresslogic.Express(j.VendorId, "jcook", orderSku[index], ep); err != nil {
				return err
			}
		}
		return nil
	})
}

func OrderPay() {
	q := fmt.Sprintf("order.pay.queue.%s", configs.ConfigJCookAppKey)
	mq.Conn.ListenRetry(q, maxRetryNum, func(data []byte) error {
		time.Sleep(time.Second)
		var m model.OrderPayMessage
		err := json.Unmarshal(data, &m)
		if err != nil {
			log.Println(err.Error())
			return err
		}
		var od manage.RecookOrderInfoModel
		if err = mysql.Db.First(&od, "jcook_order_id = ?", m.OrderID).Error; err != nil {
			log.Println(err.Error())
			return nil
		}
		if od.Status == 0 {
			return errors.New("订单未支付")
		}
		if od.Status == 1 {
			client := jcook.GetClient()
			req := jcook.OrderPushReq{
				OrderID: uint(m.OrderID),
			}
			var resp jcook.OrderPushResp
			if err = client.Exec(req, &resp); err != nil {
				return err
			}
		}

		return nil
	})
}

func orderCreate() {
	q := fmt.Sprintf("order.create.queue.%s", configs.ConfigJCookAppKey)
	mq.Conn.ListenRetry(q, maxRetryNum, func(data []byte) error {
		var m model.OrderCreateMessage
		err := json.Unmarshal(data, &m)
		if err != nil {
			log.Println(err.Error())
			return err
		}

		if m.RootOrderID != 0 {
			// 发生拆单.
			var rod manage.RecookOrderInfoModel
			if err := mysql.Db.Preload("OrderSku").First(&rod, "jcook_order_id = ?", m.RootOrderID).Error; err != nil {
				return err

			}

			var pod manage.RecookOrderInfoModel
			if err := mysql.Db.Preload("OrderSku").First(&pod, "jcook_order_id = ?", m.ParentOrderID).Error; err != nil {
				return err
			}

			if err := mysql.Db.Transaction(func(tx *gorm2.DB) error {
				rod.IsSplit = true
				rod.Status = 3
				tx.Save(&rod)

				pod.IsSplit = true
				pod.Status = 3
				tx.Save(&pod)

				if err := tx.Table((&order4.Profit{}).TableName()).Where("order_id = ?", rod.Id).Update("status", 1).Error; err != nil {
					return err
				}

				if err := tx.Table((&order4.Profit{}).TableName()).Where("order_id = ?", pod.Id).Update("status", 1).Error; err != nil {
					return err
				}

				var ids []uint64
				for _, v := range m.SkuList {
					ids = append(ids, v.SkuID)
				}
				var orderSku []manage.RecookOrderGoodsDetailModel
				var sku []goods2.RecookGoodsSkuModel
				sub := tx.Select("id").Find(&sku, "third_party_sku_id in (?)", ids)
				if err := tx.Find(&orderSku, "sku_id in (?) AND order_id = ?", sub, rod.Id).Error; err != nil {
					log.Println(err.Error())
					return err
				}
				// 拆分拆单运费
				unit := m.FreightFee.Div(decimal.NewFromInt(int64(len(orderSku)))).Round(2)
				fee := m.FreightFee
				unitMap := make(map[uint]decimal.Decimal)
				var orderSkuNew []manage.RecookOrderGoodsDetailModel
				for i := 0; i < len(orderSku); i++ {
					if i == len(orderSku)-1 {
						unitMap[orderSku[i].SkuId] = fee
						break
					}
					fee = fee.Sub(unit)
					unitMap[orderSku[i].SkuId] = unit
				}

				coinTotal := decimal.Zero
				goodsTotalAmount := decimal.Zero
				goodsTotalCommission := decimal.Zero
				actualAmount := decimal.Zero
				for _, v := range orderSku {
					actualAmount = actualAmount.Add(v.GoodsAmount).Add(unitMap[v.SkuId]).Sub(v.CoinAmount)
					coinTotal = coinTotal.Add(v.CoinAmount)
					goodsTotalAmount = goodsTotalAmount.Add(v.GoodsAmount)
				}

				orderNew := manage.RecookOrderInfoModel{
					AncestorId:           rod.AncestorId,
					ParentId:             rod.ParentId,
					SharerId:             rod.SharerId,
					LiveId:               rod.LiveId,
					UserId:               rod.UserId,
					UserRole:             rod.UserRole,
					Title:                "",
					CoinTotalAmount:      coinTotal,
					ExpressTotalFee:      m.FreightFee,
					GoodsTotalAmount:     goodsTotalAmount,
					GoodsTotalCommission: goodsTotalCommission,
					ActualTotalAmount:    actualAmount,
					Channel:              rod.Channel,
					ShippingMethod:       rod.ShippingMethod,
					StoreId:              rod.StoreId,
					BuyerMessage:         rod.BuyerMessage,
					Status:               1,
					ExpressStatus:        rod.ExpressStatus,
					InvoiceStatus:        rod.InvoiceStatus,
					CreatedAt:            rod.CreatedAt,
					ExpireTime:           rod.ExpireTime,
					PayIP:                rod.PayIP,
					TradeNo:              rod.TradeNo,
					PayTime:              rod.PayTime,
					PayMethod:            rod.PayMethod,
					RbacId:               rod.RbacId,
					IsFirst:              rod.IsFirst,
					VirtualID:            rod.VirtualID,
					PayType:              rod.PayType,
					Kind:                 rod.Kind,
					JCookOrderID:         uint(m.OrderID),
					JCookRootID:          uint(m.RootOrderID),
					JCookParentID:        uint(m.ParentOrderID),
					OrderType:            rod.OrderType,
				}
				var orderAddr manage.RecookOrderAddrModel
				tx.First(&orderAddr, "order_id = ?", rod.Id)

				if err := tx.Create(&orderNew).Error; err != nil {
					log.Println(err.Error())
					return err
				}
				orderAddr.Id = 0
				orderAddr.OrderId = orderNew.Id
				if err := tx.Create(&orderAddr).Error; err != nil {
					log.Println(err.Error())
					return err
				}
				cost := decimal.Zero
				total := decimal.Zero
				for _, v := range orderSku {
					cost = cost.Add(v.PurchasePrice).Mul(decimal.NewFromInt(int64(v.Quantity)))
					total = total.Add(v.GoodsAmount)
					v.Id = 0
					v.OrderId = orderNew.Id
					v.ExpressFee = unitMap[v.SkuId]
					//v.CoinAmount = decimal.Zero
					v.ActualAmount = v.GoodsAmount.Add(v.ExpressFee).Sub(v.CoinAmount)
					//coinTotal = decimal.Zero
					orderSkuNew = append(orderSkuNew, v)
				}
				//orderNew.CoinTotalAmount = coinTotal
				if err = tx.Save(orderNew).Error; err != nil {
					log.Println(err.Error())
					return err
				}
				if err = tx.Create(orderSkuNew).Error; err != nil {
					log.Println(err.Error())
					return err
				}
				var rp []order4.Profit
				if err := tx.Table((&order4.Profit{}).TableName()).Find(&rp, "order_id = ?", rod.Id).Error; err != nil {
					return err
				}

				profitNew := make([]*order4.Profit, 0)
				b2 := decimal.Zero
				for _, k := range orderSkuNew {
					b2 = b2.Add(k.GetBase().Mul(decimal.NewFromInt(int64(k.Quantity))))
				}
				for _, v := range rp {
					temp := order4.CreateProfit(v.UserID, v.Type, b2, orderNew.Id)
					profitNew = append(profitNew, temp)
				}

				if len(profitNew) != 0 {
					if err = tx.Create(profitNew).Error; err != nil {
						log.Println(err.Error())
						return err
					}
				}

				return nil
			}); err != nil {
				return err
			}
		}
		return nil
	})
}

func skuPrice() {
	q := fmt.Sprintf("sku.price.queue.%s", configs.ConfigJCookAppKey)
	mq.Conn.ListenRetry(q, maxRetryNum, func(data []byte) error {
		client := jcook.GetClient()
		var m model.SkuChange
		err := json.Unmarshal(data, &m)
		if err != nil {
			log.Println(err.Error())
			return err
		}
		rq := jcook.SkuPriceReq{
			SkuIDSet: []uint{m.SkuID},
		}
		var res []jcook.SkuPriceResp
		if err := client.Exec(rq, &res); err != nil {
			log.Println(err.Error())
			return err
		}
		if len(res) == 0 {
			return nil
		}
		t := res[0]

		var sku goods2.RecookGoodsSkuModel
		if err := mysql.Db.Table(sku.TableName()).Where("third_party_sku_id = ? and third_party_type=3", t.SkuID).Updates(map[string]interface{}{
			"purchase_price": t.SupplyPrice,
		}).Error; err != nil {
			log.Println(err.Error())
			return err
		}
		return nil
	})
}

func skuChange() {
	q := fmt.Sprintf("sku.change.queue.%s", configs.ConfigJCookAppKey)
	mq.Conn.ListenRetry(q, maxRetryNum, func(data []byte) error {
		client := jcook.GetClient()
		var m model.SkuChange
		_ = json.Unmarshal(data, &m)
		rq := jcook.SkuDetailReq{
			SkuIDSet: []uint{m.SkuID},
		}

		var gsk goods2.RecookGoodsSkuModel
		if err := mysql.Db.First(&gsk, "third_party_sku_id = ? AND third_party_type = 3 ", strconv.Itoa(int(m.SkuID))).Error; err != nil {
			if err == gorm2.ErrRecordNotFound {
				return nil
			}
			log.Println(err.Error())
			return err
		}

		var res []jcook.SkuDetailResp
		if err := client.Exec(rq, &res); err != nil {
			return err
		}
		if len(res) == 0 {
			return nil
		}
		if err := mysql.Db.Transaction(func(tx *gorm2.DB) error {
			patch := res[0]
			var pu uint
			if patch.SkuDetailBase.Yn && patch.SkuDetailBase.Status {
				pu = 1
			} else {
				pu = 0
			}

			p1 := map[string]interface{}{}
			p1["inventory"] = 500
			if pu == 0 {
				p1["inventory"] = 0
			}
			name := strings.Trim(strings.Join([]string{patch.SkuDetailBase.Color, patch.SkuDetailBase.Size}, "+"), "+")
			if name == "" {
				name = "标准"
			}
			if name != gsk.Name {
				p1["name"] = name
				combineID := strings.Split(gsk.CombineId, ",")
				for index, s1 := range combineID {
					sid, _ := strconv.Atoi(s1)
					if index == 0 {
						tx.Model(&goods2.RecookGoodsAttributeModel{Id: uint(sid)}).Update("value", patch.SkuDetailBase.Color)
					} else {
						tx.Model(&goods2.RecookGoodsAttributeModel{Id: uint(sid)}).Update("value", patch.SkuDetailBase.Size)
					}
				}
			}

			if err := tx.Model(&gsk).Updates(p1).Error; err != nil {
				return err
			}
			if p1["inventory"] == 0 {
				var other []goods2.RecookGoodsSkuModel
				tx.Find(&other, "goods_id = ?", gsk.GoodsId)
				flag := 1
				for _, v := range other {
					if v.Inventory != 0 {
						flag = 0
						break
					}
				}
				if flag == 1 {
					tx.Table((&goods2.RecookGoodsInfoModel{}).TableName()).
						Where("id = ?", gsk.GoodsId).
						Update("publish_status", 0)
				}
			} else {
				// tx.Table((&goods2.RecookGoodsInfoModel{}).TableName()).Where("id = ?", gsk.GoodsId).Update("publish_status", 1)
			}
			if err := tx.Table((&goods2.RecookGoodsSkuModel{}).TableName()).Where("id = ?", gsk.Id).
				Update("pic_url", patch.SkuDetailBase.MainPhoto).Error; err != nil {
				return err
			}
			if err := tx.Delete(&goods2.RecookGoodsMainPhotoModel{}, "goods_id = ?", gsk.GoodsId).Error; err != nil {
				return err
			}
			if err := tx.Delete(&goods2.RecookGoodsDetailPhotoModel{}, "goods_id = ?", gsk.GoodsId).Error; err != nil {
				return err
			}
			mp := make([]goods2.RecookGoodsMainPhotoModel, 0)
			dp := make([]goods2.RecookGoodsDetailPhotoModel, 0)
			if len(patch.Images) == 1 {
				mp = append(mp, goods2.RecookGoodsMainPhotoModel{
					GoodsId:  gsk.GoodsId,
					Url:      patch.Images[0].Url,
					IsMaster: 0,
					Name:     "api",
					OrderNo:  1,
					Width:    0,
					Height:   0,
				})
			}
			for ki, k := range patch.Images {
				master := 0
				if k.IsPrimer {
					master = 1
				}
				mp = append(mp, goods2.RecookGoodsMainPhotoModel{
					GoodsId:  gsk.GoodsId,
					Url:      k.Url,
					IsMaster: master,
					Name:     "api",
					OrderNo:  ki,
					Width:    0,
					Height:   0,
				})
			}

			reg := regexp.MustCompile("background-image:url\\((?s:(.*?))\\)|src=\"(?s:(.*?))\"")
			result := reg.FindAllStringSubmatch(patch.BigInfo.PcWDis, -1)
			for ki, k := range result {
				kt := k[1]
				if len(strings.TrimSpace(kt)) == 0 {
					if len(k) > 2 {
						kt = k[2]
					}
				}
				if len(strings.TrimSpace(kt)) == 0 || len(strings.TrimSpace(kt)) > 255 || len(strings.TrimSpace(kt)) < 25 {
					continue
				}

				kt = strings.Trim(kt, "\\")
				if !strings.HasPrefix(kt, "http") && !strings.HasPrefix(kt, "https") {
					kt = "http:" + kt
				}
				dp = append(dp, goods2.RecookGoodsDetailPhotoModel{
					GoodsID: gsk.GoodsId,
					Url:     kt,
					Name:    "api",
					OrderNo: ki,
					Width:   0,
					Height:  0,
				})
			}
			if len(mp) > 0 {
				if err := tx.Create(&mp).Error; err != nil {
					log.Println(err.Error())
					return err
				}
			}
			if len(dp) > 0 {
				if err := tx.Create(&dp).Error; err != nil {
					log.Println(err.Error())
					return err
				}
			}

			return nil
		}); err != nil {
			log.Println(err.Error())
			return err
		}
		return nil
	})
}

func NoticeDelete() {
	log.Println("清理商详")
	var data []goods2.RecookGoodsNoticeModel
	if err := dbc.DB.Table((&goods2.RecookGoodsNoticeModel{}).TableName()).Find(&data).Error; err != nil {
		log.Println("task error: ", err.Error())
		return
	}
	for _, v := range data {
		if v.EndTime.Time.Before(time.Now()) {
			var temp goods2.RecookGoodsNoticeGoodsModel
			if err := dbc.DB.Delete(&temp, "notice_id = ?", v.Id).Error; err != nil {
				log.Println("task error: ", err.Error())
				continue
			}
			if err := dbc.DB.Delete(&v).Error; err != nil {
				log.Println("task error: ", err.Error())
				continue
			}
		}
	}
}

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

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

// AfterNotToDoTwo 买家没有填写单号
func AfterNotToDoTwo() {
	t := time.Now().Add(time.Hour * 72 * -days1)
	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)
	}
}

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

	var orderInfo manage.RecookOrderInfoModel
	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(&manage.RecookOrderGoodsDetailModel{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()
	}

}