FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
// src/algo_engine/PositionManager.cpp
#include "algo_engine/PositionManager.h"
#include <QDate>
#include <QDateTime>
#include <QMutexLocker>
#include <QUuid>
#include <cmath>
namespace fincept::algo {
PositionManager::PositionManager(const QString& deployment_id, double stop_loss_pct, double take_profit_pct,
double trailing_stop_pct, double max_order_value, double max_daily_loss)
: deployment_id_(deployment_id),
stop_loss_pct_(stop_loss_pct),
take_profit_pct_(take_profit_pct),
trailing_stop_pct_(trailing_stop_pct),
max_order_value_(max_order_value),
max_daily_loss_(max_daily_loss) {
risk_.day_start_epoch = QDateTime::currentMSecsSinceEpoch();
}
std::optional<AlgoOrderSignal> PositionManager::check_risk(double current_price) {
QMutexLocker lock(&mutex_);
// ── Multi-leg basket branch (P3) ────────────────────────────────────────
// Entered ONLY when legs are active. Single-position logic below is UNCHANGED.
if (multi_leg_) {
if (legs_.isEmpty())
return std::nullopt;
// Compute current basket P&L from cached unrealized_pnl on each leg.
double basket_pnl = 0;
for (const auto& leg : std::as_const(legs_))
basket_pnl += leg.unrealized_pnl;
double basket_pnl_pct = basket_entry_value_ > 1e-10 ? basket_pnl / basket_entry_value_ * 100.0 : 0;
// Daily loss limit
if (max_daily_loss_ > 0 && risk_.daily_pnl <= -std::abs(max_daily_loss_)) {
risk_.paused_by_loss_limit = true;
AlgoOrderSignal sig;
sig.deployment_id = deployment_id_;
sig.reason = "daily_loss_limit";
return sig;
}
// Stop loss
if (stop_loss_pct_ > 0 && basket_pnl_pct <= -std::abs(stop_loss_pct_)) {
AlgoOrderSignal sig;
sig.deployment_id = deployment_id_;
sig.reason = "stop_loss";
return sig;
}
// Take profit
if (take_profit_pct_ > 0 && basket_pnl_pct >= std::abs(take_profit_pct_)) {
AlgoOrderSignal sig;
sig.deployment_id = deployment_id_;
sig.reason = "take_profit";
return sig;
}
// Trailing stop — track peak basket P&L
if (trailing_stop_pct_ > 0) {
if (basket_pnl > basket_peak_pnl_)
basket_peak_pnl_ = basket_pnl;
double peak_pct = basket_entry_value_ > 1e-10 ? basket_peak_pnl_ / basket_entry_value_ * 100.0 : 0;
if (peak_pct - basket_pnl_pct >= trailing_stop_pct_) {
AlgoOrderSignal sig;
sig.deployment_id = deployment_id_;
sig.reason = "trailing_stop";
return sig;
}
}
return std::nullopt;
}
// ── End multi-leg branch ────────────────────────────────────────────────
if (position_.side == PositionSide::None)
return std::nullopt;
// Daily loss limit
if (max_daily_loss_ > 0 && risk_.daily_pnl <= -std::abs(max_daily_loss_)) {
risk_.paused_by_loss_limit = true;
AlgoOrderSignal sig;
sig.deployment_id = deployment_id_;
sig.side = (position_.side == PositionSide::Long) ? "SELL" : "BUY";
sig.quantity = position_.quantity;
sig.reason = "daily_loss_limit";
return sig;
}
double pnl_pct = 0;
if (position_.side == PositionSide::Long && position_.entry_price > 1e-10)
pnl_pct = (current_price - position_.entry_price) / position_.entry_price * 100.0;
else if (position_.side == PositionSide::Short && position_.entry_price > 1e-10)
pnl_pct = (position_.entry_price - current_price) / position_.entry_price * 100.0;
// Stop loss
if (stop_loss_pct_ > 0 && pnl_pct <= -std::abs(stop_loss_pct_)) {
AlgoOrderSignal sig;
sig.deployment_id = deployment_id_;
sig.side = (position_.side == PositionSide::Long) ? "SELL" : "BUY";
sig.quantity = position_.quantity;
sig.reason = "stop_loss";
return sig;
}
// Take profit
if (take_profit_pct_ > 0 && pnl_pct >= std::abs(take_profit_pct_)) {
AlgoOrderSignal sig;
sig.deployment_id = deployment_id_;
sig.side = (position_.side == PositionSide::Long) ? "SELL" : "BUY";
sig.quantity = position_.quantity;
sig.reason = "take_profit";
return sig;
}
// Trailing stop
if (trailing_stop_pct_ > 0) {
if (position_.side == PositionSide::Long) {
if (current_price > position_.highest_since_entry)
position_.highest_since_entry = current_price;
double peak_pnl = (position_.highest_since_entry - position_.entry_price) / position_.entry_price * 100.0;
if (peak_pnl - pnl_pct >= trailing_stop_pct_) {
AlgoOrderSignal sig;
sig.deployment_id = deployment_id_;
sig.side = "SELL";
sig.quantity = position_.quantity;
sig.reason = "trailing_stop";
return sig;
}
} else {
if (current_price < position_.lowest_since_entry || position_.lowest_since_entry < 1e-10)
position_.lowest_since_entry = current_price;
double peak_pnl = (position_.entry_price - position_.lowest_since_entry) / position_.entry_price * 100.0;
if (peak_pnl - pnl_pct >= trailing_stop_pct_) {
AlgoOrderSignal sig;
sig.deployment_id = deployment_id_;
sig.side = "BUY";
sig.quantity = position_.quantity;
sig.reason = "trailing_stop";
return sig;
}
}
}
return std::nullopt;
}
void PositionManager::record_entry(PositionSide side, double qty, double price, int64_t time_ms) {
QMutexLocker lock(&mutex_);
Q_ASSERT(!multi_leg_); // invariant: single-leg path must not be called while a basket is active
position_.side = side;
position_.quantity = qty;
position_.entry_price = price;
position_.entry_time = time_ms;
position_.unrealized_pnl = 0;
position_.highest_since_entry = price;
position_.lowest_since_entry = price;
metrics_.last_trade_time = time_ms;
}
double PositionManager::record_exit(double qty, double price, int64_t time_ms) {
QMutexLocker lock(&mutex_);
double pnl = 0;
if (position_.side == PositionSide::Long)
pnl = (price - position_.entry_price) * qty;
else if (position_.side == PositionSide::Short)
pnl = (position_.entry_price - price) * qty;
metrics_.total_pnl += pnl;
metrics_.total_trades++;
if (pnl > 0)
metrics_.winning_trades++;
else if (pnl < 0)
metrics_.losing_trades++;
metrics_.win_rate =
metrics_.total_trades > 0 ? static_cast<double>(metrics_.winning_trades) / metrics_.total_trades * 100.0 : 0;
metrics_.last_trade_time = time_ms;
risk_.daily_pnl += pnl;
update_drawdown();
latch_daily_loss_if_breached();
position_.side = PositionSide::None;
position_.quantity = 0;
position_.entry_price = 0;
position_.entry_time = 0;
position_.unrealized_pnl = 0;
return pnl;
}
// The daily-loss halt used to be raised only from check_risk() while a position was
// open. A realized loss that breaches the limit closes the position, so check_risk()
// then returns early (no position) and never sees the breach — the runner stayed
// un-latched, took one MORE entry, and only halted when that fresh position's next
// tick tripped the check (an extra round trip beyond the configured loss limit).
// Latching on the realizing exit itself closes that hole. Caller holds mutex_.
void PositionManager::latch_daily_loss_if_breached() {
if (max_daily_loss_ > 0 && risk_.daily_pnl <= -std::abs(max_daily_loss_))
risk_.paused_by_loss_limit = true;
}
void PositionManager::restore_state(PositionSide side, double qty, double entry_price, double total_pnl,
int total_trades, double win_rate, double max_drawdown) {
QMutexLocker lock(&mutex_);
position_.side = side;
position_.quantity = qty;
position_.entry_price = entry_price;
position_.highest_since_entry = entry_price; // trailing-stop baseline resets on resume
position_.lowest_since_entry = entry_price;
metrics_.total_pnl = total_pnl;
metrics_.total_trades = total_trades;
metrics_.win_rate = win_rate;
metrics_.winning_trades = static_cast<int>(std::lround(win_rate * total_trades / 100.0));
metrics_.losing_trades = total_trades - metrics_.winning_trades;
if (metrics_.losing_trades < 0)
metrics_.losing_trades = 0;
metrics_.max_drawdown = max_drawdown;
metrics_.current_position_qty = qty;
metrics_.current_position_side = position_side_to_string(side);
metrics_.current_position_entry = entry_price;
risk_.max_drawdown = max_drawdown;
risk_.peak_equity = total_pnl > 0 ? total_pnl : 0;
}
void PositionManager::update_price(double price) {
QMutexLocker lock(&mutex_);
metrics_.current_price = price;
if (position_.side == PositionSide::Long)
position_.unrealized_pnl = (price - position_.entry_price) * position_.quantity;
else if (position_.side == PositionSide::Short)
position_.unrealized_pnl = (position_.entry_price - price) * position_.quantity;
metrics_.unrealized_pnl = position_.unrealized_pnl;
metrics_.current_position_qty = position_.quantity;
metrics_.current_position_side = position_side_to_string(position_.side);
metrics_.current_position_entry = position_.entry_price;
}
void PositionManager::update_drawdown() {
double equity = metrics_.total_pnl;
if (equity > risk_.peak_equity)
risk_.peak_equity = equity;
double dd = risk_.peak_equity - equity;
if (dd > risk_.max_drawdown)
risk_.max_drawdown = dd;
metrics_.max_drawdown = risk_.max_drawdown;
}
bool PositionManager::has_position() const {
QMutexLocker lock(&mutex_);
return position_.side != PositionSide::None;
}
bool PositionManager::is_paused() const {
QMutexLocker lock(&mutex_);
return risk_.paused_by_loss_limit;
}
bool PositionManager::validate_order_value(double qty, double price) const {
return validate_order_notional(qty * price);
}
bool PositionManager::validate_order_notional(double notional) const {
if (max_order_value_ <= 0)
return true;
return std::abs(notional) <= max_order_value_;
}
AlgoPosition PositionManager::position() const {
QMutexLocker lock(&mutex_);
return position_;
}
AlgoMetrics PositionManager::metrics() const {
QMutexLocker lock(&mutex_);
return metrics_;
}
RiskState PositionManager::risk_state() const {
QMutexLocker lock(&mutex_);
return risk_;
}
void PositionManager::reset_daily_locked() {
risk_.daily_pnl = 0;
risk_.paused_by_loss_limit = false;
risk_.day_start_epoch = QDateTime::currentMSecsSinceEpoch();
}
void PositionManager::reset_daily() {
QMutexLocker lock(&mutex_);
reset_daily_locked();
}
bool PositionManager::reset_daily_if_new_day() {
QMutexLocker lock(&mutex_);
if (risk_.day_start_epoch <= 0) {
// Never stamped (restored state / defensive) — adopt today as day one.
risk_.day_start_epoch = QDateTime::currentMSecsSinceEpoch();
return false;
}
// day_start_epoch is stamped with currentMSecsSinceEpoch(), so the matching
// trading date is the LOCAL date of that instant. Compare dates, not a fixed
// 24h window, so the reset lands on the day boundary regardless of when the
// deployment was started.
const QDate start_day = QDateTime::fromMSecsSinceEpoch(risk_.day_start_epoch).date();
if (start_day >= QDate::currentDate())
return false;
reset_daily_locked();
return true;
}
// ── Multi-leg basket methods (P3) ───────────────────────────────────────────
void PositionManager::record_entry_legs(const QVector<fincept::algo::AlgoLegPosition>& legs, int64_t time_ms) {
QMutexLocker lock(&mutex_);
Q_ASSERT(position_.side ==
PositionSide::None); // invariant: multi-leg path must not be called while a single-leg position is open
legs_ = legs;
multi_leg_ = true;
basket_peak_pnl_ = 0;
// Compute entry value: Σ |entry_price * quantity| (unsigned, used as denominator)
basket_entry_value_ = 0;
double total_qty = 0;
for (const auto& leg : std::as_const(legs_)) {
basket_entry_value_ += std::abs(leg.entry_price * leg.quantity);
total_qty += leg.quantity;
}
metrics_.current_position_side = QStringLiteral("BASKET");
metrics_.current_position_qty = total_qty;
metrics_.last_trade_time = time_ms;
}
double PositionManager::record_exit_legs(int64_t time_ms) {
QMutexLocker lock(&mutex_);
double pnl = 0;
for (const auto& leg : std::as_const(legs_))
pnl += leg.unrealized_pnl;
metrics_.total_pnl += pnl;
metrics_.total_trades++;
if (pnl > 0)
metrics_.winning_trades++;
else if (pnl < 0)
metrics_.losing_trades++;
metrics_.win_rate =
metrics_.total_trades > 0 ? static_cast<double>(metrics_.winning_trades) / metrics_.total_trades * 100.0 : 0;
metrics_.last_trade_time = time_ms;
metrics_.unrealized_pnl = 0;
risk_.daily_pnl += pnl;
update_drawdown();
latch_daily_loss_if_breached();
legs_.clear();
multi_leg_ = false;
basket_entry_value_ = 0;
basket_peak_pnl_ = 0;
metrics_.current_position_side = QString();
metrics_.current_position_qty = 0;
return pnl;
}
void PositionManager::update_leg_price(const QString& symbol, double ltp) {
QMutexLocker lock(&mutex_);
bool found = false;
for (auto& leg : legs_) {
if (leg.symbol == symbol) {
leg.current_price = ltp;
leg.unrealized_pnl = (ltp - leg.entry_price) * leg.quantity * leg.side_sign;
found = true;
break;
}
}
if (!found)
qWarning() << "PositionManager::update_leg_price: symbol not in basket:" << symbol;
// Recompute basket unrealized P&L
double basket_pnl = 0;
for (const auto& leg : std::as_const(legs_))
basket_pnl += leg.unrealized_pnl;
metrics_.unrealized_pnl = basket_pnl;
}
bool PositionManager::has_legs() const {
QMutexLocker lock(&mutex_);
return multi_leg_ && !legs_.isEmpty();
}
QVector<fincept::algo::AlgoLegPosition> PositionManager::legs() const {
QMutexLocker lock(&mutex_);
return legs_;
}
} // namespace fincept::algo