exchange_go/services/binanceservice/spotreset.go

package binanceservice

import (
	"context"
	"fmt"
	"go-admin/app/admin/models"
	DbModels "go-admin/app/admin/models"
	"go-admin/common/const/rediskey"
	"go-admin/common/helper"
	"go-admin/pkg/utility"
	"strconv"
	"strings"
	"time"

	"github.com/bytedance/sonic"
	"github.com/go-admin-team/go-admin-core/logger"
	"github.com/shopspring/decimal"
	"gorm.io/gorm"
)

/*
订单回调
*/
func ChangeSpotOrder(mapData map[string]interface{}) {
	// 检查订单号是否存在
	orderSn, ok := mapData["c"]
	if !ok {
		logger.Error("订单回调失败, 没有订单号", mapData)
		return
	}

	// 获取数据库连接
	db := GetDBConnection()
	if db == nil {
		logger.Error("订单回调失败, 无法获取数据库连接")
		return
	}

	// 获取 Redis 锁
	lockKey := fmt.Sprintf(rediskey.SpotCallBack, orderSn)
	lock := helper.NewRedisLock(lockKey, 200, 5, 100*time.Millisecond)
	if err := acquireLock(lock, orderSn); err != nil {
		return
	}
	defer lock.Release()

	// 查询订单
	preOrder, err := getPreOrder(db, orderSn)
	if err != nil {
		logger.Error("订单回调失败, 查询订单失败:", orderSn, " err:", err)
		return
	}

	// 解析订单状态
	status, ok := mapData["X"]
	if !ok {
		logMapData(mapData)
		return
	}

	// 更新订单状态
	orderStatus, reason := parseOrderStatus(preOrder, status, mapData)

	if orderStatus == 0 {
		logger.Error("订单回调失败,状态错误:", orderSn, " status:", status, " reason:", reason)
		return
	}

	if err := updateOrderStatus(db, preOrder, orderStatus, reason, true, mapData); err != nil {
		logger.Error("修改订单状态失败:", orderSn, " err:", err)
		return
	}

	// 根据订单类型和状态处理逻辑
	handleOrderByType(db, preOrder, orderStatus)
}

// 获取 Redis 锁
func acquireLock(lock *helper.RedisLock, orderSn interface{}) error {
	acquired, err := lock.AcquireWait(context.Background())
	if err != nil {
		logger.Error("订单回调失败, 获取锁失败:", orderSn, " err:", err)
		return err
	}
	if !acquired {
		logger.Error("订单回调失败, 获取锁失败:", orderSn)
		return fmt.Errorf("failed to acquire lock")
	}
	return nil
}

// 记录 mapData 数据
func logMapData(mapData map[string]interface{}) {
	mapStr, _ := sonic.Marshal(&mapData)
	logger.Error("订单回调失败, 没有状态:", string(mapStr))
}

// 根据订单类型和状态处理逻辑
func handleOrderByType(db *gorm.DB, preOrder *DbModels.LinePreOrder, orderStatus int) {
	switch {
	// 主单成交
	case preOrder.OrderType == 0 && (orderStatus == 9 || orderStatus == 6):
		handleMainOrderFilled(db, preOrder)

	//主单取消
	case preOrder.OrderType == 0 && preOrder.Pid == 0 && orderStatus == 4:
		coin := utility.ReplaceSuffix(preOrder.Symbol, preOrder.QuoteSymbol, "")
		removeHoldingCache(preOrder.ApiId, coin, preOrder.Id)

	// 止盈成交
	case preOrder.OrderType == 1 && (orderStatus == 9 || orderStatus == 6):
		handleSpotTakeProfitFilled(db, preOrder)

	//主单平仓
	case preOrder.OrderType == 3 && orderStatus == 9:
		handleMainOrderClosePosition(db, preOrder)
	}
}

func handleMainOrderClosePosition(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
	panic("unimplemented")
}

func handleSpotTakeProfitFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
	panic("unimplemented")
}

func removeHoldingCache(i1 int, coin string, i2 int) {
	panic("unimplemented")
}

func handleMainOrderFilled(db *gorm.DB, preOrder *DbModels.LinePreOrder) {
	panic("unimplemented")
}

// 解析订单状态
// 5:委托中 9:完全成交 4:取消
func parseOrderStatus(preOrder *DbModels.LinePreOrder, status interface{}, mapData map[string]interface{}) (int, string) {
	reason, _ := mapData["r"].(string)

	if strings.ToLower(reason) == "none" {
		reason = ""
	}

	switch status {
	case "NEW": // 未成交
		return 5, reason
	case "FILLED": // 完全成交
		if preOrder.OrderType < 3 {
			return 6, reason
		}

		return 9, reason
	case "CANCELED", "EXPIRED": // 取消
		return 4, reason
	default:
		return 0, reason
	}
}

// 更新订单状态
func updateOrderStatus(db *gorm.DB, preOrder *models.LinePreOrder, status int, reason string, isSpot bool, mapData map[string]interface{}) error {
	params := map[string]interface{}{"status": strconv.Itoa(status), "desc": reason}

	switch isSpot {
	case true:
		total := decimal.Zero
		totalAmount := decimal.Zero
		if totalStr, ok := mapData["Z"].(string); ok {
			total, _ = decimal.NewFromString(totalStr)
		}
		if totalAmountStr, ok := mapData["z"].(string); ok {
			totalAmount, _ = decimal.NewFromString(totalAmountStr)
		}

		//主单 修改单价 和成交数量
		if total.Cmp(decimal.Zero) > 0 && totalAmount.Cmp(decimal.Zero) > 0 {
			num := totalAmount.Div(decimal.NewFromFloat(100)).Mul(decimal.NewFromFloat(99.8))
			params["num"] = num
			params["price"] = total.Div(totalAmount)
			preOrder.Num = num.String()
		}
	case false:
		status, _ := mapData["X"].(string)

		if status == "FILLED" {
			num, _ := decimal.NewFromString(mapData["z"].(string))
			params["num"] = num.Mul(decimal.NewFromFloat(0.998)).String()
			params["price"], _ = mapData["ap"].(string)

			preOrder.Num = num.String()
		}
	}

	return db.Model(&DbModels.LinePreOrder{}).Where("order_sn = ? AND status < 6", preOrder.OrderSn).
		Updates(params).Error
}

// 主单成交 处理止盈止损订单
func processTakeProfitAndStopLossOrders(db *gorm.DB, preOrder *models.LinePreOrder) {
	orders := []models.LinePreOrder{}
	if err := db.Model(&DbModels.LinePreOrder{}).Where("pid = ? AND order_type >0 AND status = '0' ", preOrder.Id).Find(&orders).Error; err != nil {
		logger.Error("订单回调查询止盈止损单失败:", err)
		return
	}

	spotApi := SpotRestApi{}
	num, _ := decimal.NewFromString(preOrder.Num)

	for i, order := range orders {
		if i >= 2 { // 最多处理 2 个订单
			break
		}

		switch order.OrderType {
		case 1: // 止盈
			processTakeProfitOrder(db, spotApi, order, num)
		case 2: // 止损
			processStopLossOrder(db, order)
		}
	}
}

// 处理止盈订单
func processTakeProfitOrder(db *gorm.DB, spotApi SpotRestApi, order models.LinePreOrder, num decimal.Decimal) {
	tradeSet, _ := GetTradeSet(order.Symbol, 0)

	if tradeSet.Coin == "" {
		logger.Error("获取交易对失败")
		return
	}

	price, _ := decimal.NewFromString(order.Price)
	// num, _ := decimal.NewFromString(order.Num)

	params := OrderPlacementService{
		ApiId:            order.ApiId,
		Symbol:           order.Symbol,
		Side:             order.Site,
		Price:            price.Truncate(int32(tradeSet.PriceDigit)),
		Quantity:         num.Truncate(int32(tradeSet.AmountDigit)),
		Type:             "TAKE_PROFIT_LIMIT",
		TimeInForce:      "GTC",
		StopPrice:        price.Truncate(int32(tradeSet.PriceDigit)),
		NewClientOrderId: order.OrderSn,
	}

	err := spotApi.OrderPlace(db, params)

	if err != nil {
		for x := 0; x < 5; x++ {
			if strings.Contains(err.Error(), "LOT_SIZE") {
				break
			}

			err = spotApi.OrderPlace(db, params)

			if err == nil {
				break
			}
		}
	}

	if err != nil {
		logger.Error("现货止盈下单失败:", order.OrderSn, " err:", err)
		if err := db.Model(&DbModels.LinePreOrder{}).Where("id = ?", order.Id).
			Updates(map[string]interface{}{"status": "2", "desc": err.Error()}).Error; err != nil {
			logger.Error("现货止盈下单失败,更新状态失败:", order.OrderSn, " err:", err)
		}
	} else {
		if err := db.Model(&DbModels.LinePreOrder{}).Where("id = ? and status ='0'", order.Id).
			Updates(map[string]interface{}{"status": "1", "num": num.String()}).Error; err != nil {
			logger.Error("现货止盈下单成功,更新状态失败:", order.OrderSn, " err:", err)
		}
	}
}

// 处理止损订单
// order 止损单
func processStopLossOrder(db *gorm.DB, order models.LinePreOrder) error {
	// var stopOrder models.LinePreOrder
	// orderTypes := []string{"4", "6", "9", "12"}
	// parentId := order.Id

	// if order.Pid > 0 {
	// 	parentId = order.Pid
	// }

	// if utility.ContainsStr(orderTypes, order.OrderType) {
	// 	var err error
	// 	stopOrder, err = GetStopOrder(db, order.Pid)

	// 	if err != nil {
	// 		logger.Error("查询止损单失败:", err)
	// 		return err
	// 	}
	// }

	// price, _ := decimal.NewFromString(stopOrder.Price)
	// stoploss, _ := decimal.NewFromString(order.Rate)

	// if holdeB.Id > 0 {
	// 	_, holdeA := GetHoldeA(stopOrder.Pid)
	// 	var percent decimal.Decimal
	// 	lastPercent, _ := GetStopOrderRate(db, stopOrder.Pid)

	// 	if stopOrder.Site == "BUY" {
	// 		//平仓次数>=最大次数 且余数为0 重新计算触发对冲百分比
	// 		// if holdeA.Id > 0 && holdeB.HedgeCloseCount >= stopOrder.HedgeCloseCount && (holdeB.HedgeCloseCount%stopOrder.HedgeCloseCount == 0) {
	// 		rand := getRand(stopOrder.HedgeTriggerPercent, stopOrder.HedgeTriggerPercentMax, lastPercent, 1)

	// 		percent = decimal.NewFromInt(100).Add(rand).Div(decimal.NewFromInt(100))
	// 		// } else {
	// 		// 	rate, _ := decimal.NewFromString(stopOrder.Rate)
	// 		// 	percent = decimal.NewFromInt(100).Add(rate).Div(decimal.NewFromInt(100))
	// 		// }
	// 	} else {
	// 		// if holdeA.Id > 0 && holdeB.HedgeCloseCount >= stopOrder.HedgeCloseCount {
	// 		rand := getRand(stopOrder.HedgeTriggerPercent, stopOrder.HedgeTriggerPercentMax, lastPercent, 1)

	// 		percent = decimal.NewFromInt(100).Sub(rand).Div(decimal.NewFromInt(100))
	// 		// } else {
	// 		// 	rate, _ := decimal.NewFromString(stopOrder.Rate)
	// 		// 	percent = decimal.NewFromInt(100).Sub(rate).Div(decimal.NewFromInt(100))
	// 		// }
	// 	}
	// 	stoploss = decimal.NewFromInt(100).Sub(percent.Mul(decimal.NewFromInt(100))).Truncate(2)
	// 	price = holdeA.AveragePrice.Mul(percent)
	// }

	// tradeset, _ := GetTradeSet(stopOrder.Symbol, 1)
	// if tradeset.PriceDigit > 0 {
	// 	price = price.Truncate(int32(tradeset.PriceDigit))
	// }

	// cache := dto.StopLossRedisList{
	// 	PId:      stopOrder.Pid,
	// 	ApiId:    stopOrder.ApiId,
	// 	Price:    price,
	// 	OrderTye: stopOrder.OrderType,
	// 	Site:     stopOrder.Site,
	// 	Symbol:   stopOrder.Symbol,
	// 	Stoploss: stoploss,
	// }

	// stoplossKey := fmt.Sprintf(rediskey.SpotStopLossList)
	// cacheVal, _ := sonic.MarshalString(&cache)

	// if stopOrder.OrderType == "4" {
	// 	stoplossKey = rediskey.FuturesStopLossList
	// }

	// stopLossVal, _ := helper.DefaultRedis.GetAllList(stoplossKey)
	// for _, itemVal := range stopLossVal {
	// 	if strings.Contains(itemVal, fmt.Sprintf("\"pid\":%v,", stopOrder.Pid)) {
	// 		helper.DefaultRedis.LRem(stoplossKey, itemVal)
	// 		break
	// 	}
	// }

	// //重新保存待触发对冲单
	// if err := helper.DefaultRedis.RPushList(stoplossKey, cacheVal); err != nil {
	// 	logger.Error("B单平仓回调,redis添加止损单失败", err)
	// }

	return nil
}

// 生成随机数 且不重复
// lastPercent 上一次的百分比
// floatNum 小数点后几位
func getRand(start, end, lastPercent decimal.Decimal, floatNum int) decimal.Decimal {
	var rand decimal.Decimal

	for x := 0; x < 10; x++ {
		rand = utility.DecimalRandom(start, end, floatNum)

		if rand.Cmp(lastPercent) != 0 {
			break
		}
	}

	return rand
}

func GetSystemSetting(db *gorm.DB) (models.LineSystemSetting, error) {
	key := fmt.Sprintf(rediskey.SystemSetting)
	val, _ := helper.DefaultRedis.GetString(key)
	setting := models.LineSystemSetting{}

	if val != "" {
		sonic.UnmarshalString(val, &setting)
	}

	if setting.Id > 0 {
		return setting, nil
	}

	var err error
	setting, err = ResetSystemSetting(db)
	if err != nil {
		return setting, err
	}

	return setting, nil
}

func ResetSystemSetting(db *gorm.DB) (DbModels.LineSystemSetting, error) {
	setting := DbModels.LineSystemSetting{}
	if err := db.Model(&setting).First(&setting).Error; err != nil {
		return setting, err
	}

	settVal, _ := sonic.MarshalString(&setting)

	if settVal != "" {
		if err := helper.DefaultRedis.SetString(rediskey.SystemSetting, settVal); err != nil {
			logger.Error("redis添加系统设置失败", err)
		}
	}
	return DbModels.LineSystemSetting{}, nil
}

// NEW
// PENDING_NEW
// PARTIALLY_FILLED
// FILLED
// CANCELED
// PENDING_CANCEL
// REJECTED
// EXPIRED
// EXPIRED_IN_MATCH