aiaa-notification-server/internal/subscriber/tradesignal/position.go

package tradesignal

import (
	"strings"
	"sync"
)

type mode int

const (
	modeNone mode = iota
	modeQty
	modeWeight
)

type Snapshot struct {
	AvgPrice float64 `json:"avgPrice"`
	Size     float64 `json:"size"`
	HasAvg   bool    `json:"hasAvg"`
}

type state struct {
	avg  float64
	size float64
	mode mode
}

type Tracker struct {
	mu    sync.Mutex
	store positionStore
}

func NewTracker() *Tracker {
	return NewTrackerWithStore(newMemoryStore())
}

func NewTrackerWithStore(store positionStore) *Tracker {
	if store == nil {
		store = newMemoryStore()
	}
	return &Tracker{store: store}
}

func (t *Tracker) Apply(signal *Signal) (Snapshot, error) {
	if signal == nil {
		return Snapshot{}, nil
	}

	t.mu.Lock()
	defer t.mu.Unlock()

	if signal.SignalID != "" {
		if snap, ok, err := t.store.loadApplied(signal.SignalID); err != nil {
			return Snapshot{}, err
		} else if ok {
			return snap, nil
		}
	}

	key := positionKey(signal.StrategyCode, signal.Symbol, signal.Side)
	action := strings.ToUpper(signal.Action)
	st, err := t.store.load(key)
	if err != nil {
		return Snapshot{}, err
	}

	var snap Snapshot
	del := false
	switch action {
	case "OPEN":
		st = openPosition(signal)
		snap = snapshotFrom(st)
		if st == nil {
			del = true
		}
	case "ADD":
		st = addPosition(st, signal)
		snap = snapshotFrom(st)
	case "REDUCE":
		snap = snapshotFrom(st)
		st = reducePosition(st, signal)
		if st == nil || st.size <= 0 {
			del = true
			st = nil
		}
	case "CLOSE":
		snap = snapshotFrom(st)
		del = true
		st = nil
	default:
		snap = snapshotFrom(st)
	}

	if err := t.store.commit(key, st, del, signal.SignalID, snap); err != nil {
		return Snapshot{}, err
	}
	return snap, nil
}

func openPosition(signal *Signal) *state {
	if qty, ok := positiveQty(signal.Quantity); ok {
		return &state{avg: signal.Price, size: qty, mode: modeQty}
	}
	if w, ok := positiveRatio(signal.AmountMarginRatio); ok {
		return &state{avg: signal.Price, size: w, mode: modeWeight}
	}
	if signal.Price > 0 {
		return &state{avg: signal.Price, size: 0, mode: modeNone}
	}
	return nil
}

func addPosition(st *state, signal *Signal) *state {
	if st == nil || st.size <= 0 {
		return openPosition(signal)
	}

	if qty, ok := positiveQty(signal.Quantity); ok {
		if st.mode == modeWeight {
			return st
		}
		if st.mode == modeNone || st.size == 0 {
			st.mode = modeQty
			st.size = qty
			st.avg = signal.Price
			return st
		}
		st.avg = (st.size*st.avg + qty*signal.Price) / (st.size + qty)
		st.size += qty
		st.mode = modeQty
		return st
	}

	if w, ok := positiveRatio(signal.AmountMarginRatio); ok {
		if st.mode == modeQty {
			return st
		}
		if st.mode == modeNone || st.size == 0 {
			st.mode = modeWeight
			st.size = w
			st.avg = signal.Price
			return st
		}
		st.avg = (st.size*st.avg + w*signal.Price) / (st.size + w)
		st.size += w
		st.mode = modeWeight
		return st
	}

	return st
}

func reducePosition(st *state, signal *Signal) *state {
	if st == nil {
		return nil
	}

	if qty, ok := positiveQty(signal.Quantity); ok && st.mode == modeQty {
		st.size -= qty
		if st.size < 0 {
			st.size = 0
		}
		return st
	}

	ratio := 0.0
	if r, ok := positiveRatio(signal.PosMarginRatio); ok {
		ratio = r
	} else if signal.Quantity == nil && signal.PosMarginRatio == nil {
		return st
	}
	if ratio > 1 {
		ratio = 1
	}
	if ratio > 0 {
		st.size *= (1 - ratio)
	}
	return st
}

func snapshotFrom(st *state) Snapshot {
	if st == nil || st.avg <= 0 {
		return Snapshot{}
	}
	return Snapshot{
		AvgPrice: st.avg,
		Size:     st.size,
		HasAvg:   true,
	}
}

func positiveQty(q *float64) (float64, bool) {
	if q == nil || *q <= 0 {
		return 0, false
	}
	return *q, true
}

func positiveRatio(r *float64) (float64, bool) {
	if r == nil || *r <= 0 {
		return 0, false
	}
	return *r, true
}

func positionKey(strategyCode, symbol, side string) string {
	return strings.ToUpper(strategyCode) + "|" + strings.ToUpper(symbol) + "|" + strings.ToUpper(side)
}