package liquidation

import (
"context"
"time"

"github.com/shopspring/decimal" // go get github.com/shopspring/decimal
)

// Side 表示仓位方向.
type Side int

const (
Long  Side = iota // 多头
Short             // 空头
)

func (s Side) String() string {
if s == Long {
return "Long"
}
return "Short"
}

// MarginMode 保证金模式.
type MarginMode int

const (
Isolated MarginMode = iota // 逐仓: 每个仓位独立保证金, 亏损不影响其他仓位
Cross                      // 全仓: 账户所有仓位共享保证金池, 盈利仓位可以 "救" 亏损仓位
)

// Account 表示一个交易账户.
// 全仓模式下, 清算判断在账户级别进行: 账户总保证金率 <= MMR 时触发清算.
type Account struct {
ID        string                     // 账户地址或 ID
Balance   decimal.Decimal            // 可用余额 (未分配给逐仓仓位的部分)
Positions map[string]*Position       // positionID → Position (该账户下所有仓位)
}

// TotalEquity 计算账户总权益 = 余额 + 所有全仓仓位的未实现盈亏.
// 逐仓仓位不参与, 因为它们的保证金已经从 Balance 中扣除.
func (a *Account) TotalEquity(markPrices map[string]decimal.Decimal) decimal.Decimal {
equity := a.Balance
for _, pos := range a.Positions {
if pos.MarginMode != Cross {
continue
}
mp, ok := markPrices[pos.Symbol]
if !ok {
continue
}
equity = equity.Add(UnrealizedPnL(pos, mp))
}
return equity
}

// TotalMaintenanceMargin 计算账户下所有全仓仓位的维持保证金之和.
func (a *Account) TotalMaintenanceMargin(markPrices map[string]decimal.Decimal) decimal.Decimal {
total := decimal.Zero
for _, pos := range a.Positions {
if pos.MarginMode != Cross {
continue
}
mp, ok := markPrices[pos.Symbol]
if !ok {
continue
}
// MM = markPrice × size × maintenanceRate
total = total.Add(mp.Mul(pos.Size).Mul(pos.MaintenanceRate))
}
return total
}

// Position 表示一个未平仓仓位.
type Position struct {
ID               string          // 仓位唯一标识
Account          string          // 账户地址或 ID
Symbol           string          // 交易对, 如 "ETH-USD"
Side             Side            // Long 或 Short
Size             decimal.Decimal // 仓位数量, 如 1.5 (ETH)
EntryPrice       decimal.Decimal // 开仓均价, 如 3000 (USD)
Margin           decimal.Decimal // 当前保证金 (逐仓: 独立保证金, 全仓: 初始保证金仅做记录)
MaintenanceRate  decimal.Decimal // 维持保证金率, 如 0.005 (0.5%)
MarginMode       MarginMode      // 逐仓 or 全仓
LiquidationPrice decimal.Decimal // 预计算的清算价格 (仅逐仓有效)
UpdatedAt        time.Time
}

// UnrealizedPnL 计算仓位的未实现盈亏.
func UnrealizedPnL(pos *Position, markPrice decimal.Decimal) decimal.Decimal {
if pos.Side == Long {
return markPrice.Sub(pos.EntryPrice).Mul(pos.Size)
}
return pos.EntryPrice.Sub(markPrice).Mul(pos.Size)
}

// LiquidationOrder 清算引擎生成的清算指令.
type LiquidationOrder struct {
PositionID      string          // 被清算的仓位 ID
Account         string          // 被清算账户
Symbol          string          // 交易对
Side            Side            // 清算方向 (与仓位方向相反)
Size            decimal.Decimal // 清算数量
BankruptcyPrice decimal.Decimal // 破产价格 (保证金归零的价格)
MarkPrice       decimal.Decimal // 触发清算时的标记价格
Timestamp       time.Time
}

// LiquidationResult 清算执行结果.
type LiquidationResult struct {
PositionID string
Executed   bool            // 是否成功执行
FillPrice  decimal.Decimal // 实际成交价格
FillSize   decimal.Decimal // 实际成交数量
Surplus    decimal.Decimal // 盈余 (> 0 归保险基金) 或亏损 (< 0 保险基金垫付)
}

// Executor 抽象清算指令的执行方式.
// 清算引擎只负责 "谁该被清算", Executor 负责 "怎么清算".
type Executor interface {
// Liquidate 执行单个清算指令, 返回执行结果.
Liquidate(ctx context.Context, order LiquidationOrder) (*LiquidationResult, error)
}

// CalcLiquidationPrice 计算清算价格.
//
//Long:  (entryPrice * size - margin) / (size * (1 - maintenanceRate))
//Short: (entryPrice * size + margin) / (size * (1 + maintenanceRate))
func CalcLiquidationPrice(pos *Position) decimal.Decimal {
one := decimal.NewFromInt(1)
entryTimesSize := pos.EntryPrice.Mul(pos.Size)

if pos.Side == Long {
numerator := entryTimesSize.Sub(pos.Margin)
denominator := pos.Size.Mul(one.Sub(pos.MaintenanceRate))
return numerator.Div(denominator)
}

// Short
numerator := entryTimesSize.Add(pos.Margin)
denominator := pos.Size.Mul(one.Add(pos.MaintenanceRate))
return numerator.Div(denominator)
}

// CalcBankruptcyPrice 计算破产价格 (保证金归零).
//
//Long:  entryPrice - margin / size
//Short: entryPrice + margin / size
func CalcBankruptcyPrice(pos *Position) decimal.Decimal {
marginPerUnit := pos.Margin.Div(pos.Size)
if pos.Side == Long {
return pos.EntryPrice.Sub(marginPerUnit)
}
return pos.EntryPrice.Add(marginPerUnit)
}

// IsPositionLiquidatable 判断逐仓仓位是否应被清算.
// 用 margin <= MM (乘法) 而非 marginRatio <= MMR (除法), 避免精度损失.
func IsPositionLiquidatable(pos *Position, markPrice decimal.Decimal) bool {
currentMargin := pos.Margin.Add(UnrealizedPnL(pos, markPrice))
mm := markPrice.Mul(pos.Size).Mul(pos.MaintenanceRate) // MM = notional × MMR
return !currentMargin.IsPositive() || currentMargin.LessThanOrEqual(mm)
}

// IsAccountLiquidatable 判断全仓账户是否应被清算.
// 用 equity <= totalMM (乘法) 而非 ratio <= 1 (除法).
//
// 全仓模式下, 所有仓位的盈亏共享同一个保证金池:
//   - 一个仓位亏 $500, 另一个赚 $300 → 净亏 $200, 从账户余额扣
//   - 只要账户总权益 > 总维持保证金, 就不会被清算
//   - 触发清算时, 引擎选择该账户下风险最高的仓位优先清算
func IsAccountLiquidatable(account *Account, markPrices map[string]decimal.Decimal) bool {
totalMM := account.TotalMaintenanceMargin(markPrices)
if totalMM.IsZero() {
return false // 无仓位
}
equity := account.TotalEquity(markPrices)
return !equity.IsPositive() || equity.LessThanOrEqual(totalMM)
}

// CalcMarginRatio 计算单仓位保证金率 (用于展示/日志, 非清算判断).
// 清算判断请用 IsPositionLiquidatable (纯乘法, 无精度损失).
func CalcMarginRatio(pos *Position, markPrice decimal.Decimal) decimal.Decimal {
effectiveMargin := pos.Margin.Add(UnrealizedPnL(pos, markPrice))
if !effectiveMargin.IsPositive() {
return decimal.Zero
}
notional := markPrice.Mul(pos.Size)
return effectiveMargin.Div(notional)
}

import "github.com/tidwall/btree"

// positionItem 是优先队列中的元素, 按清算价排序.
type positionItem struct {
LiquidationPrice decimal.Decimal
PositionID       string
}

// PositionQueue 维护按清算价排序的仓位优先队列.
// 使用 btree.BTreeG 泛型版本, 自定义 less 函数 (decimal.Decimal 不是 cmp.Ordered).
type PositionQueue struct {
tree *btree.BTreeG[positionItem]
}

func NewPositionQueue() *PositionQueue {
return &PositionQueue{
tree: btree.NewBTreeG[positionItem](func(a, b positionItem) bool {
return a.LiquidationPrice.LessThan(b.LiquidationPrice)
}),
}
}

// Insert 插入仓位到优先队列.
func (pq *PositionQueue) Insert(posID string, liqPrice decimal.Decimal) {
pq.tree.Set(positionItem{
LiquidationPrice: liqPrice,
PositionID:       posID,
})
}

// Remove 从优先队列移除仓位 (平仓或保证金变更后需要重新插入).
func (pq *PositionQueue) Remove(posID string, liqPrice decimal.Decimal) {
pq.tree.Delete(positionItem{
LiquidationPrice: liqPrice,
PositionID:       posID,
})
}

// ScanLongsAt 从最高清算价开始, 返回所有清算价 >= markPrice 的多头仓位 ID.
// 即: 这些仓位在当前 markPrice 下应该被清算.
// Reverse: 从树的最大值开始降序遍历, 无需构造 fake pivot.
func (pq *PositionQueue) ScanLongsAt(markPrice decimal.Decimal) []string {
var result []string
pq.tree.Reverse(func(item positionItem) bool {
if item.LiquidationPrice.GreaterThanOrEqual(markPrice) {
result = append(result, item.PositionID)
return true // 继续
}
return false // 安全了, 停止
})
return result
}

// ScanShortsAt 从最低清算价开始, 返回所有清算价 <= markPrice 的空头仓位 ID.
// Scan: 从树的最小值开始升序遍历.
func (pq *PositionQueue) ScanShortsAt(markPrice decimal.Decimal) []string {
var result []string
pq.tree.Scan(func(item positionItem) bool {
if item.LiquidationPrice.LessThanOrEqual(markPrice) {
result = append(result, item.PositionID)
return true
}
return false
})
return result
}

// LiquidationConfig 清算引擎配置.
type LiquidationConfig struct {
// PartialRatio 部分清算比例, 范围 (0, 1].
// 每次清算平掉仓位的这个比例. 例如 0.25 表示每次清算 25%.
// 部分清算后仓位仍不健康会在下一轮继续清算.
// 设为 1.0 则退化为全部清算.
PartialRatio decimal.Decimal // 建议 0.25 ~ 0.50

// MinPositionSize 最小仓位名义价值 (USD).
// 仓位名义价值低于此阈值时直接全部清算, 不做部分清算.
// 原因: 小仓位拆分清算不划算 (gas 成本 / 撮合开销 > 收益).
MinPositionSize decimal.Decimal // 建议 $500 ~ $1,000
}

// Engine 是清算引擎核心.
// 同时支持逐仓和全仓模式:
//   - 逐仓: 通过优先队列按单仓位清算价扫描 (O(log n))
//   - 全仓: 遍历有风险的账户, 计算账户级别保证金率
type Engine struct {
config     LiquidationConfig
positions  map[string]*Position  // positionID → Position
accounts   map[string]*Account   // accountID → Account
longQueue  *PositionQueue        // 逐仓多头优先队列 (按清算价 DESC)
shortQueue *PositionQueue        // 逐仓空头优先队列 (按清算价 ASC)
executor   Executor              // 清算执行器 (可替换)
insurance  *InsuranceFund        // 保险基金
adl        *ADLEngine            // 自动减仓引擎
}

// NewEngine 创建清算引擎.
func NewEngine(config LiquidationConfig, executor Executor, insuranceFund *InsuranceFund) *Engine {
return &Engine{
config:     config,
positions:  make(map[string]*Position),
accounts:   make(map[string]*Account),
longQueue:  NewPositionQueue(),
shortQueue: NewPositionQueue(),
executor:   executor,
insurance:  insuranceFund,
adl:        NewADLEngine(),
}
}

// GetOrCreateAccount 获取或创建账户.
func (e *Engine) GetOrCreateAccount(accountID string) *Account {
if acc, ok := e.accounts[accountID]; ok {
return acc
}
acc := &Account{
ID:        accountID,
Balance:   decimal.Zero,
Positions: make(map[string]*Position),
}
e.accounts[accountID] = acc
return acc
}

// RegisterPosition 注册新仓位到清算引擎.
// 逐仓仓位进入优先队列, 全仓仓位只注册到账户.
func (e *Engine) RegisterPosition(pos *Position) {
e.positions[pos.ID] = pos

// 注册到账户
acc := e.GetOrCreateAccount(pos.Account)
acc.Positions[pos.ID] = pos

if pos.MarginMode == Isolated {
// 逐仓: 预计算清算价, 插入优先队列
pos.LiquidationPrice = CalcLiquidationPrice(pos)
if pos.Side == Long {
e.longQueue.Insert(pos.ID, pos.LiquidationPrice)
} else {
e.shortQueue.Insert(pos.ID, pos.LiquidationPrice)
}
}
// 全仓: 不进队列, 在 OnPriceUpdate 时按账户扫描
}

// RemovePosition 从清算引擎移除仓位 (平仓时调用).
func (e *Engine) RemovePosition(posID string) {
pos, ok := e.positions[posID]
if !ok {
return
}

if pos.MarginMode == Isolated {
if pos.Side == Long {
e.longQueue.Remove(posID, pos.LiquidationPrice)
} else {
e.shortQueue.Remove(posID, pos.LiquidationPrice)
}
}

// 从账户中移除
if acc, ok := e.accounts[pos.Account]; ok {
delete(acc.Positions, posID)
}

delete(e.positions, posID)
}

// OnPriceUpdate 是清算引擎的核心入口.
// 每次 mark price 更新时调用, 分别扫描逐仓和全仓仓位.
func (e *Engine) OnPriceUpdate(ctx context.Context, symbol string, markPrice decimal.Decimal) error {
markPrices := map[string]decimal.Decimal{symbol: markPrice}

// ── 逐仓模式: 优先队列扫描 ──

// 1. 扫描需要清算的多头 (价格下跌, 清算价 >= 当前价)
for _, posID := range e.longQueue.ScanLongsAt(markPrice) {
if err := e.liquidatePosition(ctx, posID, markPrice); err != nil {
return fmt.Errorf("liquidate long %s: %w", posID, err)
}
}

// 2. 扫描需要清算的空头 (价格上涨, 清算价 <= 当前价)
for _, posID := range e.shortQueue.ScanShortsAt(markPrice) {
if err := e.liquidatePosition(ctx, posID, markPrice); err != nil {
return fmt.Errorf("liquidate short %s: %w", posID, err)
}
}

// ── 全仓模式: 账户级别扫描 ──

for _, acc := range e.accounts {
if !e.accountHasCrossPositions(acc, symbol) {
continue
}
if IsAccountLiquidatable(acc, markPrices) {
if err := e.liquidateCrossAccount(ctx, acc, markPrices); err != nil {
return fmt.Errorf("liquidate cross account %s: %w", acc.ID, err)
}
}
}

return nil
}

// accountHasCrossPositions 检查账户是否有指定 symbol 的全仓仓位.
func (e *Engine) accountHasCrossPositions(acc *Account, symbol string) bool {
for _, pos := range acc.Positions {
if pos.MarginMode == Cross && pos.Symbol == symbol {
return true
}
}
return false
}

// liquidateCrossAccount 清算全仓账户: 选择亏损最大的仓位优先清算.
// 每次清算一个仓位后重新检查账户保证金率, 直到恢复健康或无仓位可清算.
func (e *Engine) liquidateCrossAccount(ctx context.Context, acc *Account, markPrices map[string]decimal.Decimal) error {
for {
// 账户恢复健康则停止
if !IsAccountLiquidatable(acc, markPrices) {
return nil
}

// 找亏损最大的全仓仓位
var worst *Position
worstPnL := decimal.Zero
for _, pos := range acc.Positions {
if pos.MarginMode != Cross {
continue
}
mp, ok := markPrices[pos.Symbol]
if !ok {
continue
}
pnl := UnrealizedPnL(pos, mp)
if worst == nil || pnl.LessThan(worstPnL) {
worst = pos
worstPnL = pnl
}
}

if worst == nil {
return nil // 无全仓仓位
}

mp := markPrices[worst.Symbol]
if err := e.liquidatePosition(ctx, worst.ID, mp); err != nil {
return err
}
}
}

// liquidatePosition 执行单个仓位的清算 (逐仓和全仓共用).
// 根据 config 决定部分清算还是全部清算:
//   - 仓位名义价值 < MinPositionSize → 全部清算 (小仓位不值得拆分)
//   - 否则 → 部分清算 (按 PartialRatio 比例平仓)
//   - 部分清算后仍不健康 → 下一轮 OnPriceUpdate 继续清算
func (e *Engine) liquidatePosition(ctx context.Context, posID string, markPrice decimal.Decimal) error {
pos, ok := e.positions[posID]
if !ok {
return nil // 已被清算或平仓
}

// 决定清算数量: 部分 or 全部
liqSize := e.calcLiquidationSize(pos, markPrice)

// 构建清算订单
order := LiquidationOrder{
PositionID:      pos.ID,
Account:         pos.Account,
Symbol:          pos.Symbol,
Side:            1 - pos.Side, // 反向: Long 仓位 → 卖出清算
Size:            liqSize,
BankruptcyPrice: CalcBankruptcyPrice(pos),
MarkPrice:       markPrice,
Timestamp:       time.Now(),
}

// 通过 Executor 执行清算
result, err := e.executor.Liquidate(ctx, order)
if err != nil {
return fmt.Errorf("executor.Liquidate: %w", err)
}

if !result.Executed {
return e.adl.Execute(ctx, pos, e.positions, e.executor)
}

// 处理清算盈余/亏损
e.insurance.Settle(result.Surplus)

// 保险基金为负 → 触发 ADL
if e.insurance.Balance().IsNegative() {
deficit := e.insurance.Balance().Neg()
if err := e.adl.CoverDeficit(ctx, pos.Symbol, pos.Side, deficit, e.positions, e.executor); err != nil {
return fmt.Errorf("ADL cover deficit: %w", err)
}
e.insurance.Reset()
}

isFullLiquidation := liqSize.Equal(pos.Size)

if isFullLiquidation {
e.RemovePosition(posID)
} else {
// 部分清算: 按比例缩减仓位和保证金
e.applyPartialLiquidation(pos, result, markPrice)
}

return nil
}

// calcLiquidationSize 计算本次清算的数量.
func (e *Engine) calcLiquidationSize(pos *Position, markPrice decimal.Decimal) decimal.Decimal {
notional := markPrice.Mul(pos.Size)

// 小仓位 → 全部清算
if notional.LessThanOrEqual(e.config.MinPositionSize) {
return pos.Size
}

// 部分清算: size × partialRatio
liqSize := pos.Size.Mul(e.config.PartialRatio)

// 如果剩余仓位名义价值 < MinPositionSize, 也全部清算
remaining := pos.Size.Sub(liqSize)
if markPrice.Mul(remaining).LessThan(e.config.MinPositionSize) {
return pos.Size
}

return liqSize
}

// applyPartialLiquidation 部分清算后更新仓位状态.
// 按清算比例缩减 size 和 margin, 重新计算清算价格.
func (e *Engine) applyPartialLiquidation(pos *Position, result *LiquidationResult, markPrice decimal.Decimal) {
liqRatio := result.FillSize.Div(pos.Size) // 实际清算比例
remainRatio := decimal.NewFromInt(1).Sub(liqRatio)

// 缩减保证金: 按比例扣除, 并扣除清算亏损 (如有)
// 清算盈余归保险基金 (已在 insurance.Settle 处理), 这里只扣 margin
pos.Margin = pos.Margin.Mul(remainRatio)
pos.Size = pos.Size.Sub(result.FillSize)
pos.UpdatedAt = time.Now()

// 逐仓模式: 重新计算清算价格并更新优先队列
if pos.MarginMode == Isolated {
oldLiqPrice := pos.LiquidationPrice
pos.LiquidationPrice = CalcLiquidationPrice(pos)

if pos.Side == Long {
e.longQueue.Remove(pos.ID, oldLiqPrice)
e.longQueue.Insert(pos.ID, pos.LiquidationPrice)
} else {
e.shortQueue.Remove(pos.ID, oldLiqPrice)
e.shortQueue.Insert(pos.ID, pos.LiquidationPrice)
}
}
}

// MatchingEngine 是撮合引擎的接口.
// 如果已有撮合引擎原理与 Go 实现的实现, 直接对接即可.
type MatchingEngine interface {
SubmitOrder(symbol string, side Side, price, size decimal.Decimal) ([]Trade, error)
}

type Trade struct {
Price decimal.Decimal
Size  decimal.Decimal
}

// LocalExecutor 在同一进程内直接调用撮合引擎.
type LocalExecutor struct {
engine MatchingEngine
}

func NewLocalExecutor(engine MatchingEngine) *LocalExecutor {
return &LocalExecutor{engine: engine}
}

func (e *LocalExecutor) Liquidate(ctx context.Context, order LiquidationOrder) (*LiquidationResult, error) {
trades, err := e.engine.SubmitOrder(order.Symbol, order.Side, order.BankruptcyPrice, order.Size)
if err != nil {
return nil, err
}

if len(trades) == 0 {
return &LiquidationResult{PositionID: order.PositionID, Executed: false}, nil
}

// 计算加权平均成交价
totalSize := decimal.Zero
totalValue := decimal.Zero
for _, t := range trades {
totalSize = totalSize.Add(t.Size)
totalValue = totalValue.Add(t.Price.Mul(t.Size))
}
avgPrice := totalValue.Div(totalSize)

// 计算盈余/亏损
// Long 清算 (卖出): surplus = (fillPrice - bankruptcyPrice) * size
// Short 清算 (买入): surplus = (bankruptcyPrice - fillPrice) * size
var surplus decimal.Decimal
if order.Side == Short { // 原仓位是 Long, 清算卖出
surplus = avgPrice.Sub(order.BankruptcyPrice).Mul(totalSize)
} else {
surplus = order.BankruptcyPrice.Sub(avgPrice).Mul(totalSize)
}

return &LiquidationResult{
PositionID: order.PositionID,
Executed:   true,
FillPrice:  avgPrice,
FillSize:   totalSize,
Surplus:    surplus,
}, nil
}

// GRPCExecutor 通过 gRPC 调用远程撮合服务.
type GRPCExecutor struct {
client MatchingServiceClient // protobuf 生成的 client
}

func NewGRPCExecutor(addr string) (*GRPCExecutor, error) {
conn, err := grpc.Dial(addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
return nil, fmt.Errorf("dial matching service: %w", err)
}
return &GRPCExecutor{client: NewMatchingServiceClient(conn)}, nil
}

func (e *GRPCExecutor) Liquidate(ctx context.Context, order LiquidationOrder) (*LiquidationResult, error) {
resp, err := e.client.SubmitLiquidation(ctx, &LiquidationRequest{
PositionId:      order.PositionID,
Symbol:          order.Symbol,
Side:            int32(order.Side),
Size:            order.Size.String(),
BankruptcyPrice: order.BankruptcyPrice.String(),
})
if err != nil {
return nil, fmt.Errorf("grpc SubmitLiquidation: %w", err)
}

fillPrice, _ := decimal.NewFromString(resp.FillPrice)
fillSize, _ := decimal.NewFromString(resp.FillSize)
surplus, _ := decimal.NewFromString(resp.Surplus)

return &LiquidationResult{
PositionID: order.PositionID,
Executed:   resp.Executed,
FillPrice:  fillPrice,
FillSize:   fillSize,
Surplus:    surplus,
}, nil
}

// OnChainExecutor 通过发送链上交易调用清算合约.
// 适用于 DeFi 协议, Keeper 模式.
//
// 注意: 链上交互需要 big.Int (EVM uint256), 在边界处转换:
//   decimal → big.Int: order.Size.Shift(18).BigInt() (乘以 1e18 转定点数)
//   big.Int → decimal: decimal.NewFromBigInt(val, -18)
type OnChainExecutor struct {
client     *ethclient.Client
contract   *LiquidationContract // abigen 生成的合约绑定
privateKey *ecdsa.PrivateKey
chainID    *big.Int
}

func NewOnChainExecutor(rpcURL string, contractAddr common.Address, key *ecdsa.PrivateKey) (*OnChainExecutor, error) {
client, err := ethclient.Dial(rpcURL)
if err != nil {
return nil, fmt.Errorf("dial rpc: %w", err)
}
contract, err := NewLiquidationContract(contractAddr, client)
if err != nil {
return nil, fmt.Errorf("bind contract: %w", err)
}
chainID, err := client.ChainID(context.Background())
if err != nil {
return nil, fmt.Errorf("get chain id: %w", err)
}
return &OnChainExecutor{
client: client, contract: contract,
privateKey: key, chainID: chainID,
}, nil
}

func (e *OnChainExecutor) Liquidate(ctx context.Context, order LiquidationOrder) (*LiquidationResult, error) {
auth, err := bind.NewKeyedTransactorWithChainID(e.privateKey, e.chainID)
if err != nil {
return nil, fmt.Errorf("create transactor: %w", err)
}

tx, err := e.contract.Liquidate(auth, order.Account, order.Symbol)
if err != nil {
return nil, fmt.Errorf("send liquidation tx: %w", err)
}

receipt, err := bind.WaitMined(ctx, e.client, tx)
if err != nil {
return nil, fmt.Errorf("wait tx mined: %w", err)
}

if receipt.Status == 0 {
return &LiquidationResult{PositionID: order.PositionID, Executed: false}, nil
}

result, err := e.parseLiquidationEvent(receipt)
if err != nil {
return nil, fmt.Errorf("parse event: %w", err)
}
return result, nil
}

// InsuranceFund 管理清算盈余和亏损.
type InsuranceFund struct {
balance decimal.Decimal
mu      sync.RWMutex
}

func NewInsuranceFund(initial decimal.Decimal) *InsuranceFund {
return &InsuranceFund{balance: initial}
}

// Settle 结算清算盈余或亏损.
// surplus > 0: 清算盈余, 归入保险基金
// surplus < 0: 清算亏损, 从保险基金扣除
func (f *InsuranceFund) Settle(surplus decimal.Decimal) {
f.mu.Lock()
defer f.mu.Unlock()
f.balance = f.balance.Add(surplus)
}

func (f *InsuranceFund) Balance() decimal.Decimal {
f.mu.RLock()
defer f.mu.RUnlock()
return f.balance
}

func (f *InsuranceFund) Reset() {
f.mu.Lock()
defer f.mu.Unlock()
f.balance = decimal.Zero
}

// ADLEngine 自动减仓引擎.
type ADLEngine struct{}

func NewADLEngine() *ADLEngine { return &ADLEngine{} }

// adlCandidate 是 ADL 候选仓位.
type adlCandidate struct {
Position *Position
Priority decimal.Decimal // 越大越优先被减仓
}

// CoverDeficit 通过 ADL 覆盖保险基金亏损.
// 选择对手方向的盈利仓位, 按优先级从高到低减仓, 直到覆盖 deficit.
func (a *ADLEngine) CoverDeficit(
ctx context.Context,
symbol string,
liquidatedSide Side,
deficit decimal.Decimal,
positions map[string]*Position,
executor Executor,
) error {
targetSide := 1 - liquidatedSide

var candidates []adlCandidate
for _, pos := range positions {
if pos.Symbol != symbol || pos.Side != targetSide {
continue
}
priority := a.calcPriority(pos)
if priority.IsPositive() {
candidates = append(candidates, adlCandidate{Position: pos, Priority: priority})
}
}

sort.Slice(candidates, func(i, j int) bool {
return candidates[i].Priority.GreaterThan(candidates[j].Priority)
})

remaining := deficit
for _, c := range candidates {
if !remaining.IsPositive() {
break
}
order := LiquidationOrder{
PositionID: c.Position.ID,
Account:    c.Position.Account,
Symbol:     symbol,
Side:       1 - c.Position.Side,
Size:       c.Position.Size,
MarkPrice:  c.Position.EntryPrice,
Timestamp:  time.Now(),
}
if _, err := executor.Liquidate(ctx, order); err != nil {
return fmt.Errorf("ADL position %s: %w", c.Position.ID, err)
}
remaining = remaining.Sub(c.Position.Margin)
}
return nil
}

// calcPriority 计算 ADL 优先级.
// priority = profitPercent * effectiveLeverage
func (a *ADLEngine) calcPriority(pos *Position) decimal.Decimal {
// 实际生产中需要传入 markPrice 计算 unrealizedPnL
// 此处为 placeholder
return decimal.Zero
}

// Execute 在清算订单无法成交时触发 ADL.
func (a *ADLEngine) Execute(ctx context.Context, pos *Position, positions map[string]*Position, executor Executor) error {
return a.CoverDeficit(ctx, pos.Symbol, pos.Side, pos.Margin, positions, executor)
}