nautilus_model/

position.rs

// -------------------------------------------------------------------------------------------------
//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
//  https://nautechsystems.io
//
//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
//  You may not use this file except in compliance with the License.
//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
// -------------------------------------------------------------------------------------------------

//! A `Position` for the trading domain model.
//!
//! Represents an open or closed position a the market, tracking quantity, side, average
//! prices, realized P&L, and the fill events that created and changed the position.

use std::{
    fmt::Display,
    hash::{Hash, Hasher},
};

use ahash::{AHashMap, AHashSet};
use indexmap::IndexMap;
use nautilus_core::{
    DurationNanos, UUID4, UnixNanos,
    correctness::{
        CorrectnessError, CorrectnessResult, CorrectnessResultExt, FAILED, check_equal,
        check_predicate_true,
    },
};
use rust_decimal::{Decimal, prelude::ToPrimitive};
use serde::{Deserialize, Serialize};

use crate::{
    enums::{InstrumentClass, OrderSide, PositionAdjustmentType, PositionSide},
    events::{OrderFillVoided, OrderFilled, PositionAdjusted},
    identifiers::{
        AccountId, ClientOrderId, InstrumentId, PositionId, StrategyId, Symbol, TradeId, TraderId,
        Venue, VenueOrderId,
    },
    instruments::{Instrument, InstrumentAny},
    types::{Currency, Money, Price, Quantity},
};

/// Represents a position in a market.
///
/// The position ID may be assigned at the trading venue, or can be system
/// generated depending on a strategies OMS (Order Management System) settings.
/// Replay events and cumulative fill corrections preserve derived state across close and reopen
/// cycles.
#[repr(C)]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[cfg_attr(
    feature = "python",
    pyo3::pyclass(module = "nautilus_trader.model", from_py_object)
)]
#[cfg_attr(
    feature = "python",
    pyo3_stub_gen::derive::gen_stub_pyclass(module = "nautilus_trader.model")
)]
pub struct Position {
    pub events: Vec<OrderFilled>,
    pub adjustments: Vec<PositionAdjusted>,
    #[serde(default)]
    pub replay_events: Vec<PositionReplayEvent>,
    #[serde(default)]
    pub fill_voids: Vec<PositionFillVoid>,
    pub trader_id: TraderId,
    pub strategy_id: StrategyId,
    pub instrument_id: InstrumentId,
    pub id: PositionId,
    pub account_id: AccountId,
    pub opening_order_id: ClientOrderId,
    pub closing_order_id: Option<ClientOrderId>,
    pub entry: OrderSide,
    pub side: PositionSide,
    pub signed_qty: f64,
    pub quantity: Quantity,
    pub peak_qty: Quantity,
    pub price_precision: u8,
    pub size_precision: u8,
    pub multiplier: Quantity,
    pub is_inverse: bool,
    pub is_currency_pair: bool,
    pub instrument_class: InstrumentClass,
    pub base_currency: Option<Currency>,
    pub quote_currency: Currency,
    pub settlement_currency: Currency,
    pub ts_init: UnixNanos,
    pub ts_opened: UnixNanos,
    pub ts_last: UnixNanos,
    pub ts_closed: Option<UnixNanos>,
    pub duration_ns: DurationNanos,
    pub avg_px_open: f64,
    pub avg_px_close: Option<f64>,
    pub realized_return: f64,
    pub realized_pnl: Option<Money>,
    #[serde(with = "nautilus_core::serialization::sorted_hashset")]
    pub trade_ids: AHashSet<TradeId>,
    /// Total buy quantity in the current position episode.
    pub buy_qty: Quantity,
    /// Total sell quantity in the current position episode.
    pub sell_qty: Quantity,
    pub commissions: IndexMap<Currency, Money>,
}

#[expect(clippy::large_enum_variant)]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PositionReplayEvent {
    Filled(OrderFilled),
    Adjusted(PositionAdjusted),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PositionFillVoid {
    pub event: OrderFillVoided,
    pub voided_qty: Quantity,
    pub commission_voided: Option<Money>,
}

impl Position {
    /// Creates a new [`Position`] instance.
    ///
    /// # Panics
    ///
    /// Panics if [`Position::new_checked`] returns an error.
    #[must_use]
    #[allow(
        clippy::needless_pass_by_value,
        reason = "constructor takes the opening fill by value as the position's seed event"
    )]
    pub fn new(instrument: &InstrumentAny, fill: OrderFilled) -> Self {
        Self::new_checked(instrument, fill).expect_display(FAILED)
    }

    /// Creates a new [`Position`] instance with correctness checking.
    ///
    /// # Errors
    ///
    /// Returns an error if the instrument ID does not match the fill or the fill has no position
    /// ID.
    #[allow(
        clippy::needless_pass_by_value,
        reason = "constructor takes the opening fill by value as the position's seed event"
    )]
    pub fn new_checked(instrument: &InstrumentAny, fill: OrderFilled) -> CorrectnessResult<Self> {
        Self::check_fill_instrument(instrument.id(), "instrument.id()", &fill)?;
        let position_id = Self::fill_position_id(&fill)?;

        let mut item = Self {
            events: Vec::<OrderFilled>::new(),
            adjustments: Vec::<PositionAdjusted>::new(),
            replay_events: Vec::new(),
            fill_voids: Vec::new(),
            trade_ids: AHashSet::<TradeId>::new(),
            buy_qty: Quantity::zero(instrument.size_precision()),
            sell_qty: Quantity::zero(instrument.size_precision()),
            commissions: IndexMap::<Currency, Money>::new(),
            trader_id: fill.trader_id,
            strategy_id: fill.strategy_id,
            instrument_id: fill.instrument_id,
            id: position_id,
            account_id: fill.account_id,
            opening_order_id: fill.client_order_id,
            closing_order_id: None,
            entry: fill.order_side,
            side: PositionSide::Flat,
            signed_qty: 0.0,
            quantity: fill.last_qty,
            peak_qty: fill.last_qty,
            price_precision: instrument.price_precision(),
            size_precision: instrument.size_precision(),
            multiplier: instrument.multiplier(),
            is_inverse: instrument.is_inverse(),
            is_currency_pair: matches!(instrument, InstrumentAny::CurrencyPair(_)),
            instrument_class: instrument.instrument_class(),
            base_currency: instrument.base_currency(),
            quote_currency: instrument.quote_currency(),
            settlement_currency: instrument.cost_currency(),
            ts_init: fill.ts_init,
            ts_opened: fill.ts_event,
            ts_last: fill.ts_event,
            ts_closed: None,
            duration_ns: DurationNanos::default(),
            avg_px_open: fill.last_px.as_f64(),
            avg_px_close: None,
            realized_return: 0.0,
            realized_pnl: None,
        };
        item.apply_fill(&fill, true)?;
        Ok(item)
    }

    /// Returns a copy without stored events, adjustments, replay events, fill voids, or trade IDs.
    ///
    /// # Warning
    ///
    /// Use this copy only as transient read state. Applying events or caching this copy can bypass
    /// replay and duplicate-fill checks and discard position history.
    #[must_use]
    pub fn clone_without_events(&self) -> Self {
        Self {
            events: Vec::new(),
            adjustments: Vec::new(),
            replay_events: Vec::new(),
            fill_voids: Vec::new(),
            trader_id: self.trader_id,
            strategy_id: self.strategy_id,
            instrument_id: self.instrument_id,
            id: self.id,
            account_id: self.account_id,
            opening_order_id: self.opening_order_id,
            closing_order_id: self.closing_order_id,
            entry: self.entry,
            side: self.side,
            signed_qty: self.signed_qty,
            quantity: self.quantity,
            peak_qty: self.peak_qty,
            price_precision: self.price_precision,
            size_precision: self.size_precision,
            multiplier: self.multiplier,
            is_inverse: self.is_inverse,
            is_currency_pair: self.is_currency_pair,
            instrument_class: self.instrument_class,
            base_currency: self.base_currency,
            quote_currency: self.quote_currency,
            settlement_currency: self.settlement_currency,
            ts_init: self.ts_init,
            ts_opened: self.ts_opened,
            ts_last: self.ts_last,
            ts_closed: self.ts_closed,
            duration_ns: self.duration_ns,
            avg_px_open: self.avg_px_open,
            avg_px_close: self.avg_px_close,
            realized_return: self.realized_return,
            realized_pnl: self.realized_pnl,
            trade_ids: AHashSet::new(),
            buy_qty: self.buy_qty,
            sell_qty: self.sell_qty,
            commissions: self.commissions.clone(),
        }
    }

    /// Returns a snapshot copy without durable replay or fill-void history.
    #[must_use]
    pub fn clone_for_snapshot(&self) -> Self {
        let mut snapshot = self.clone_without_events();
        snapshot.events.clone_from(&self.events);
        snapshot.adjustments.clone_from(&self.adjustments);
        snapshot.trade_ids.clone_from(&self.trade_ids);
        snapshot
    }

    /// Moves durable replay state from `prior` and keeps this position's current replay events.
    pub fn transfer_replay_state_from(&mut self, prior: &mut Self) {
        let current_replay = std::mem::take(&mut self.replay_events);
        self.replay_events = std::mem::take(&mut prior.replay_events);
        self.fill_voids = std::mem::take(&mut prior.fill_voids);
        self.replay_events.extend(current_replay);
    }

    /// Purges all order fill events for the given client order ID and recalculates derived state.
    ///
    /// # Warning
    ///
    /// This operation recalculates the entire position from scratch after removing the specified
    /// order's fills. This is an expensive operation and should be used sparingly.
    ///
    /// # Panics
    ///
    /// Panics if after purging, no fills remain and the position cannot be reconstructed.
    pub fn purge_events_for_order(&mut self, client_order_id: ClientOrderId) {
        self.replay_events.retain(|event| {
            !matches!(event, PositionReplayEvent::Filled(fill) if fill.client_order_id == client_order_id)
        });
        self.fill_voids
            .retain(|record| record.event.client_order_id != client_order_id);

        let filtered_events: Vec<OrderFilled> = self
            .events
            .iter()
            .filter(|e| e.client_order_id != client_order_id)
            .cloned()
            .collect();

        // Preserve non-commission adjustments (funding, manual adjustments, etc.)
        // Commission adjustments will be automatically re-created when fills are replayed
        let preserved_adjustments: Vec<PositionAdjusted> = self
            .adjustments
            .iter()
            .filter(|adj| {
                // Keep all non-commission adjustments (funding, manual, etc.)
                // Commission adjustments will be re-created during fill replay
                adj.adjustment_type != PositionAdjustmentType::Commission
            })
            .copied()
            .collect();

        // If no events remain, log warning - position should be closed/removed instead
        if filtered_events.is_empty() {
            log::warn!(
                "Position {} has no fills remaining after purging order {}; consider closing the position instead",
                self.id,
                client_order_id
            );
            self.events.clear();
            self.trade_ids.clear();
            self.adjustments.clear();
            self.buy_qty = Quantity::zero(self.size_precision);
            self.sell_qty = Quantity::zero(self.size_precision);
            self.commissions.clear();
            self.signed_qty = 0.0;
            self.quantity = Quantity::zero(self.size_precision);
            self.side = PositionSide::Flat;
            self.avg_px_close = None;
            self.realized_pnl = None;
            self.realized_return = 0.0;
            self.ts_opened = UnixNanos::default();
            self.ts_last = UnixNanos::default();
            self.ts_closed = Some(UnixNanos::default());
            self.duration_ns = DurationNanos::default();
            return;
        }

        // Recalculate position from scratch
        let position_id = self.id;
        self.reset_derived_state();

        // Use the first remaining event to set opening state
        let first_event = &filtered_events[0];
        self.entry = first_event.order_side;
        self.opening_order_id = first_event.client_order_id;
        self.ts_opened = first_event.ts_event;
        self.ts_init = first_event.ts_init;
        self.closing_order_id = None;
        self.ts_closed = None;
        self.duration_ns = DurationNanos::default();

        // Reapply all remaining fills to reconstruct state
        for event in filtered_events {
            self.apply_fill(&event, false).expect_display(FAILED);
        }

        // Reapply preserved adjustments to maintain full state
        for adjustment in preserved_adjustments {
            self.apply_adjustment_state(adjustment, false);
        }

        log::info!(
            "Purged fills for order {} from position {}; recalculated state: qty={}, signed_qty={}, side={:?}",
            client_order_id,
            position_id,
            self.quantity,
            self.signed_qty,
            self.side
        );
    }

    /// Applies an `OrderFilled` event to this position.
    ///
    /// # Panics
    ///
    /// Panics if the `fill.trade_id` is already present in the position's `trade_ids`.
    pub fn apply(&mut self, fill: &OrderFilled) {
        self.apply_fill(fill, true).expect_display(FAILED);
    }

    /// Applies an `OrderFilled` event to this position with correctness checking.
    ///
    /// # Errors
    ///
    /// Returns an error if the fill instrument or position identity does not match this position,
    /// the fill has no position ID, or an ordinary duplicate trade ID is applied. An error leaves
    /// the position unchanged.
    pub fn try_apply(&mut self, fill: &OrderFilled) -> CorrectnessResult<()> {
        Self::check_fill_instrument(self.instrument_id, "self.instrument_id", fill)?;
        let position_id = Self::fill_position_id(fill)?;
        check_equal(&self.id, &position_id, "self.id", "fill.position_id")?;
        self.apply_fill(fill, true)
    }

    fn check_fill_instrument(
        instrument_id: InstrumentId,
        instrument_param: &str,
        fill: &OrderFilled,
    ) -> CorrectnessResult<()> {
        check_equal(
            &instrument_id,
            &fill.instrument_id,
            instrument_param,
            "fill.instrument_id",
        )
    }

    fn fill_position_id(fill: &OrderFilled) -> CorrectnessResult<PositionId> {
        fill.position_id
            .ok_or_else(|| CorrectnessError::PredicateViolation {
                message: "`fill.position_id` was None".to_string(),
            })
    }

    fn apply_fill(&mut self, fill: &OrderFilled, record_replay: bool) -> CorrectnessResult<()> {
        if record_replay
            && (self.side == PositionSide::Flat || !self.trade_ids.contains(&fill.trade_id))
            && self.is_duplicate_replay_fill(fill)
        {
            log::warn!(
                "Ignoring historical duplicate fill {} for position {}; durable replay already contains this trade",
                fill.trade_id,
                self.id,
            );
            return Ok(());
        }

        if fill.ts_event < self.ts_opened {
            log::warn!(
                "Fill ts_event {} for {} is before position ts_opened {}",
                fill.ts_event,
                self.id,
                self.ts_opened,
            );
        }

        if self.side == PositionSide::Flat {
            self.reset_cycle(fill);
        }

        if record_replay {
            check_predicate_true(
                !self.trade_ids.contains(&fill.trade_id),
                "`fill.trade_id` already contained in `trade_ids`",
            )?;
            self.replay_events
                .push(PositionReplayEvent::Filled(fill.clone()));
        }

        self.events.push(fill.clone());
        self.trade_ids.insert(fill.trade_id);

        // Calculate cumulative commissions
        if let Some(commission) = fill.commission {
            self.commissions
                .entry(commission.currency)
                .and_modify(|total| *total = *total + commission)
                .or_insert(commission);
        }

        // Calculate avg prices, points, return, PnL
        match fill.order_side {
            OrderSide::Buy => {
                self.handle_buy_order_fill(fill);
            }
            OrderSide::Sell => {
                self.handle_sell_order_fill(fill);
            }
        }

        // For CurrencyPair instruments, create adjustment event when commission is in base currency
        if self.is_currency_pair
            && let Some(commission) = fill.commission
            && let Some(base_currency) = self.base_currency
            && commission.currency == base_currency
        {
            self.apply_base_commission_adjustment(fill, commission);
        }

        // size_precision is valid from instrument
        self.quantity = Quantity::new(self.signed_qty.abs(), self.size_precision);
        if self.quantity > self.peak_qty {
            self.peak_qty = self.quantity;
        }

        if self.quantity.is_zero() {
            self.side = PositionSide::Flat;
            self.signed_qty = 0.0; // Normalize
            self.closing_order_id = Some(fill.client_order_id);
            self.ts_closed = Some(fill.ts_event);
            self.duration_ns = fill.ts_event.saturating_duration_since(self.ts_opened);
        } else if self.signed_qty > 0.0 {
            self.entry = OrderSide::Buy;
            self.side = PositionSide::Long;
        } else {
            self.entry = OrderSide::Sell;
            self.side = PositionSide::Short;
        }

        self.ts_last = fill.ts_event;

        self.debug_assert_invariants();

        Ok(())
    }

    fn reset_cycle(&mut self, fill: &OrderFilled) {
        self.events.clear();
        self.trade_ids.clear();
        self.adjustments.clear();
        self.buy_qty = Quantity::zero(self.size_precision);
        self.sell_qty = Quantity::zero(self.size_precision);
        self.commissions.clear();
        self.opening_order_id = fill.client_order_id;
        self.closing_order_id = None;
        self.peak_qty = Quantity::zero(self.size_precision);
        self.ts_init = fill.ts_init;
        self.ts_opened = fill.ts_event;
        self.ts_closed = None;
        self.duration_ns = DurationNanos::default();
        self.avg_px_open = fill.last_px.as_f64();
        self.avg_px_close = None;
        self.realized_return = 0.0;
        self.realized_pnl = None;
    }

    /// Returns whether durable replay history contains `trade_id`.
    #[must_use]
    pub fn has_replay_trade_id(&self, trade_id: TradeId) -> bool {
        self.replay_events.iter().any(
            |event| matches!(event, PositionReplayEvent::Filled(fill) if fill.trade_id == trade_id),
        )
    }

    fn is_duplicate_replay_fill(&self, fill: &OrderFilled) -> bool {
        let continues_latest_fill = fill.causation_id.is_some_and(|source_id| {
            self.events.last().is_some_and(|latest| {
                latest.trade_id == fill.trade_id && latest.event_id == source_id
            })
        });

        if self.trade_ids.contains(&fill.trade_id) {
            return !continues_latest_fill
                || self.replay_events.iter().any(|event| {
                    matches!(
                        event,
                        PositionReplayEvent::Filled(replayed)
                            if replayed.trade_id == fill.trade_id
                                && replayed.causation_id == fill.causation_id
                    )
                });
        }

        let replay_starts_current_cycle = self.replay_events.is_empty()
            || matches!(
                (self.replay_events.first(), self.events.first()),
                (
                    Some(PositionReplayEvent::Filled(replayed)),
                    Some(current),
                ) if replayed.event_id == current.event_id
            );
        let corrected_trade = self
            .fill_voids
            .iter()
            .any(|record| record.event.trade_id == fill.trade_id);
        let current_cycle_only = replay_starts_current_cycle && !corrected_trade;
        if current_cycle_only {
            return false;
        }

        self.has_replay_trade_id(fill.trade_id)
    }

    fn handle_buy_order_fill(&mut self, fill: &OrderFilled) {
        // Handle case where commission could be None or not settlement currency
        let mut realized_pnl = if let Some(commission) = fill.commission {
            if commission.currency == self.settlement_currency {
                -commission.as_f64()
            } else {
                0.0
            }
        } else {
            0.0
        };

        let last_px = fill.last_px.as_f64();
        let last_qty = fill.last_qty.as_f64();
        let last_qty_object = fill.last_qty;
        let was_short = self.signed_qty < 0.0;
        let is_reversal = was_short && last_qty_object > self.quantity;
        let closing_qty_object = if is_reversal {
            self.quantity
        } else {
            last_qty_object
        };
        let opening_qty_object = last_qty_object - closing_qty_object;
        let closing_qty = closing_qty_object.as_f64();

        if self.signed_qty > 0.0 {
            self.avg_px_open = self.calculate_avg_px_open_px(last_px, last_qty);
        } else if was_short {
            // Closing short position
            let avg_px_close = self.calculate_avg_px_close_px(last_px, closing_qty);
            self.avg_px_close = Some(avg_px_close);
            self.realized_return = self
                .calculate_return(self.avg_px_open, avg_px_close)
                .unwrap_or_else(|e| {
                    log::error!("Error calculating return: {e}");
                    0.0
                });
            realized_pnl += self
                .calculate_pnl_raw(self.avg_px_open, last_px, closing_qty)
                .unwrap_or_else(|e| {
                    log::error!("Error calculating PnL: {e}");
                    0.0
                });
        }

        let current_pnl = self.realized_pnl.map_or(0.0, |p| p.as_f64());
        self.realized_pnl = Some(Money::new(
            current_pnl + realized_pnl,
            self.settlement_currency,
        ));

        self.signed_qty += last_qty;
        self.buy_qty = self.buy_qty + last_qty_object;

        // Start a new accounting episode after a short-to-long reversal
        if is_reversal {
            self.avg_px_open = last_px;
            self.avg_px_close = None;
            self.realized_return = 0.0;
            self.buy_qty = opening_qty_object;
            self.sell_qty = Quantity::zero(self.size_precision);
        }
    }

    fn handle_sell_order_fill(&mut self, fill: &OrderFilled) {
        // Handle case where commission could be None or not settlement currency
        let mut realized_pnl = if let Some(commission) = fill.commission {
            if commission.currency == self.settlement_currency {
                -commission.as_f64()
            } else {
                0.0
            }
        } else {
            0.0
        };

        let last_px = fill.last_px.as_f64();
        let last_qty = fill.last_qty.as_f64();
        let last_qty_object = fill.last_qty;
        let was_long = self.signed_qty > 0.0;
        let is_reversal = was_long && last_qty_object > self.quantity;
        let closing_qty_object = if is_reversal {
            self.quantity
        } else {
            last_qty_object
        };
        let opening_qty_object = last_qty_object - closing_qty_object;
        let closing_qty = closing_qty_object.as_f64();

        if self.signed_qty < 0.0 {
            self.avg_px_open = self.calculate_avg_px_open_px(last_px, last_qty);
        } else if was_long {
            // Closing long position
            let avg_px_close = self.calculate_avg_px_close_px(last_px, closing_qty);
            self.avg_px_close = Some(avg_px_close);
            self.realized_return = self
                .calculate_return(self.avg_px_open, avg_px_close)
                .unwrap_or_else(|e| {
                    log::error!("Error calculating return: {e}");
                    0.0
                });
            realized_pnl += self
                .calculate_pnl_raw(self.avg_px_open, last_px, closing_qty)
                .unwrap_or_else(|e| {
                    log::error!("Error calculating PnL: {e}");
                    0.0
                });
        }

        let current_pnl = self.realized_pnl.map_or(0.0, |p| p.as_f64());
        self.realized_pnl = Some(Money::new(
            current_pnl + realized_pnl,
            self.settlement_currency,
        ));

        self.signed_qty -= last_qty;
        self.sell_qty = self.sell_qty + last_qty_object;

        // Start a new accounting episode after a long-to-short reversal
        if is_reversal {
            self.avg_px_open = last_px;
            self.avg_px_close = None;
            self.realized_return = 0.0;
            self.buy_qty = Quantity::zero(self.size_precision);
            self.sell_qty = opening_qty_object;
        }
    }

    /// Applies a position adjustment event.
    ///
    /// This method handles adjustments to position quantity or realized PnL that occur
    /// outside of normal order fills, such as:
    /// - Commission adjustments in base currency (crypto spot markets).
    /// - Funding payments (perpetual futures).
    ///
    /// The adjustment event is stored in the position's adjustment history for full audit trail.
    ///
    /// # Panics
    ///
    /// Panics if the adjustment's `quantity_change` cannot be converted to f64.
    pub fn apply_adjustment(&mut self, adjustment: PositionAdjusted) {
        self.apply_adjustment_state(adjustment, true);
    }

    fn apply_adjustment_state(&mut self, adjustment: PositionAdjusted, record_replay: bool) {
        if record_replay {
            self.replay_events
                .push(PositionReplayEvent::Adjusted(adjustment));
        }

        // Apply quantity change if present
        if let Some(quantity_change) = adjustment.quantity_change {
            self.signed_qty += quantity_change
                .to_f64()
                .expect("Failed to convert Decimal to f64");

            self.quantity = Quantity::new(self.signed_qty.abs(), self.size_precision);

            if self.quantity > self.peak_qty {
                self.peak_qty = self.quantity;
            }
        }

        // Apply PnL change if present
        if let Some(pnl_change) = adjustment.pnl_change {
            self.realized_pnl = Some(match self.realized_pnl {
                Some(current) => current + pnl_change,
                None => pnl_change,
            });
        }

        // Update position state based on quantity (source of truth for zero check)
        // This handles floating-point precision edge cases
        if self.quantity.is_zero() {
            self.side = PositionSide::Flat;
            self.signed_qty = 0.0; // Normalize
        } else if self.signed_qty > 0.0 {
            self.side = PositionSide::Long;
        } else {
            self.side = PositionSide::Short;
        }

        self.adjustments.push(adjustment);
        self.ts_last = adjustment.ts_event;

        self.debug_assert_invariants();
    }

    fn debug_assert_invariants(&self) {
        debug_assert!(
            match self.side {
                PositionSide::Long => self.signed_qty > 0.0,
                PositionSide::Short => self.signed_qty < 0.0,
                PositionSide::Flat => self.signed_qty == 0.0,
            },
            "Invariant: position side must match signed_qty sign (side={:?}, signed_qty={})",
            self.side,
            self.signed_qty,
        );
        debug_assert!(
            self.peak_qty >= self.quantity,
            "Invariant: peak_qty must not be less than current quantity (peak={}, quantity={})",
            self.peak_qty,
            self.quantity,
        );
    }

    /// Applies a cumulative fill correction allocated to this position and rebuilds derived state.
    ///
    /// Returns the realized PnL of the cycles the rebuild closed before the current one, which
    /// [`Self::realized_pnl`] no longer holds because reopening from flat resets it. A caller
    /// archiving closed cycles needs this to keep their PnL once the correction has moved the
    /// cycle boundaries its existing archive describes. `None` when the corrected history never
    /// goes flat, so the current cycle covers all of it.
    ///
    /// # Errors
    ///
    /// Returns an error when the allocation is stale, duplicated, exceeds known fragments,
    /// or has a commission currency that differs from those fragments.
    pub fn apply_fill_void(
        &mut self,
        event: OrderFillVoided,
        voided_qty: Quantity,
        commission_voided: Option<Money>,
    ) -> anyhow::Result<Option<Money>> {
        let fragments = self.fill_fragments(event.client_order_id, event.trade_id);

        let fragment_qty = fragments
            .iter()
            .fold(Quantity::zero(self.size_precision), |total, fill| {
                total + fill.last_qty
            });
        anyhow::ensure!(
            !voided_qty.is_zero() && voided_qty <= fragment_qty,
            "position fill void exceeds known fragments for {}",
            event.trade_id,
        );

        if let Some(commission_voided) = commission_voided {
            for commission in fragments.iter().filter_map(|fill| fill.commission) {
                anyhow::ensure!(
                    commission.currency == commission_voided.currency,
                    "position commission currency differs for fill {}",
                    event.trade_id,
                );
            }
        }

        if let Some(previous) = self.fill_voids.iter().rev().find(|record| {
            record.event.client_order_id == event.client_order_id
                && record.event.trade_id == event.trade_id
        }) {
            anyhow::ensure!(
                voided_qty >= previous.voided_qty,
                "stale position fill void for {}",
                event.trade_id,
            );
            anyhow::ensure!(
                voided_qty != previous.voided_qty
                    || commission_voided != previous.commission_voided,
                "duplicate position fill void for {}",
                event.trade_id,
            );
        }

        self.fill_voids.push(PositionFillVoid {
            event,
            voided_qty,
            commission_voided,
        });

        Ok(self.rebuild_from_replay())
    }

    /// Returns durable fill fragments matching an order trade in local application order.
    #[must_use]
    pub fn fill_fragments(
        &self,
        client_order_id: ClientOrderId,
        trade_id: TradeId,
    ) -> Vec<&OrderFilled> {
        self.replay_events
            .iter()
            .filter_map(|event| match event {
                PositionReplayEvent::Filled(fill)
                    if fill.client_order_id == client_order_id && fill.trade_id == trade_id =>
                {
                    Some(fill)
                }
                _ => None,
            })
            .collect()
    }

    // The banked total assumes `replay_events` spans every cycle this position archived, since
    // settling replaces all of its frames with one worth that total. Bounding the log has to
    // preserve it at trim time; `Cache::settle_position_snapshots` documents the two ways.
    fn rebuild_from_replay(&mut self) -> Option<Money> {
        let replay_events = self.replay_events.clone();
        let mut quantity_removed = AHashMap::<usize, Quantity>::new();
        let mut commission_removed = AHashMap::<usize, Money>::new();

        for correction in self.latest_fill_voids() {
            let mut remaining_qty = correction.voided_qty;
            let mut remaining_commission = correction.commission_voided;

            for (index, replay_event) in replay_events.iter().enumerate().rev() {
                let PositionReplayEvent::Filled(fill) = replay_event else {
                    continue;
                };

                if fill.client_order_id != correction.event.client_order_id
                    || fill.trade_id != correction.event.trade_id
                {
                    continue;
                }

                if !remaining_qty.is_zero() {
                    let removed = remaining_qty.min(fill.last_qty);
                    quantity_removed.insert(index, removed);
                    remaining_qty = remaining_qty - removed;
                }

                if let (Some(remaining), Some(commission)) = (remaining_commission, fill.commission)
                {
                    let magnitude = remaining.abs().min(commission.abs());

                    let removed = if remaining.is_negative() {
                        -magnitude
                    } else {
                        magnitude
                    };

                    commission_removed.insert(index, removed);
                    let next = remaining - removed;
                    remaining_commission = (!next.is_zero()).then_some(next);
                }
            }
        }

        self.reset_derived_state();

        let mut closed_cycles_pnl: Option<Money> = None;

        for (index, replay_event) in replay_events.iter().enumerate() {
            match replay_event {
                PositionReplayEvent::Filled(fill) => {
                    let removed = quantity_removed
                        .get(&index)
                        .copied()
                        .unwrap_or_else(|| Quantity::zero(fill.last_qty.precision));
                    let effective_qty = fill.last_qty - removed;
                    let effective_commission =
                        match (fill.commission, commission_removed.get(&index).copied()) {
                            (Some(commission), Some(removed)) => Some(commission - removed),
                            (commission, None) => commission,
                            (None, Some(_)) => None,
                        };

                    if effective_qty.is_zero() {
                        if let Some(commission) =
                            effective_commission.filter(|commission| !commission.is_zero())
                            && let Some(realized_pnl) =
                                self.apply_surviving_fill_commission(fill, commission)
                        {
                            closed_cycles_pnl = Some(
                                closed_cycles_pnl
                                    .map_or(realized_pnl, |total| total + realized_pnl),
                            );
                        }
                        continue;
                    }

                    // `apply_fill` clears realized PnL when it reopens from flat, so bank the
                    // closing cycle's total before it goes
                    if self.side == PositionSide::Flat
                        && let Some(realized_pnl) = self.realized_pnl
                    {
                        closed_cycles_pnl = Some(
                            closed_cycles_pnl.map_or(realized_pnl, |total| total + realized_pnl),
                        );
                    }

                    let mut effective = fill.clone();
                    effective.last_qty = effective_qty;
                    effective.commission = effective_commission;
                    self.apply_fill(&effective, false).expect_display(FAILED);
                }
                PositionReplayEvent::Adjusted(adjustment) => {
                    self.apply_adjustment_state(*adjustment, false);
                }
            }
        }

        closed_cycles_pnl
    }

    fn apply_surviving_fill_commission(
        &mut self,
        fill: &OrderFilled,
        commission: Money,
    ) -> Option<Money> {
        let is_base_commission =
            self.is_currency_pair && self.base_currency == Some(commission.currency);
        let reopens = self.side == PositionSide::Flat
            && is_base_commission
            && !Quantity::new(commission.as_f64().abs(), self.size_precision).is_zero();
        let closed_cycles_pnl_previous = reopens.then_some(self.realized_pnl).flatten();

        if reopens {
            self.reset_cycle(fill);
        }

        self.commissions
            .entry(commission.currency)
            .and_modify(|total| *total = *total + commission)
            .or_insert(commission);

        if commission.currency == self.settlement_currency {
            let pnl_change = Money::zero(self.settlement_currency) - commission;
            self.realized_pnl = Some(match self.realized_pnl {
                Some(current) => current + pnl_change,
                None => pnl_change,
            });
        }

        if is_base_commission {
            let previous_side = self.side;
            self.apply_base_commission_adjustment(fill, commission);
            self.finalize_surviving_base_commission(fill, previous_side);
        } else {
            self.ts_last = fill.ts_event;
        }

        closed_cycles_pnl_previous
    }

    fn finalize_surviving_base_commission(
        &mut self,
        fill: &OrderFilled,
        previous_side: PositionSide,
    ) {
        if self.side == PositionSide::Flat {
            if previous_side != PositionSide::Flat {
                self.closing_order_id = Some(fill.client_order_id);
                self.ts_closed = Some(fill.ts_event);
                self.duration_ns = fill.ts_event.saturating_duration_since(self.ts_opened);
            }
        } else {
            self.entry = match self.side {
                PositionSide::Long => OrderSide::Buy,
                PositionSide::Short => OrderSide::Sell,
                PositionSide::Flat => unreachable!(),
            };

            if previous_side != PositionSide::Flat && previous_side != self.side {
                self.avg_px_open = fill.last_px.as_f64();
            }
        }
    }

    fn apply_base_commission_adjustment(&mut self, fill: &OrderFilled, commission: Money) {
        let mut adjustment_id = fill.event_id.as_bytes();
        adjustment_id[15] ^= 0x01;
        self.apply_adjustment_state(
            PositionAdjusted::new(
                self.trader_id,
                self.strategy_id,
                self.instrument_id,
                self.id,
                self.account_id,
                PositionAdjustmentType::Commission,
                Some(-commission.as_decimal()),
                None,
                Some(fill.client_order_id.inner()),
                UUID4::from_bytes(adjustment_id),
                fill.ts_event,
                fill.ts_init,
            ),
            false,
        );
    }

    fn latest_fill_voids(&self) -> Vec<&PositionFillVoid> {
        let mut latest = IndexMap::<(ClientOrderId, TradeId), &PositionFillVoid>::new();
        for correction in &self.fill_voids {
            latest.insert(
                (correction.event.client_order_id, correction.event.trade_id),
                correction,
            );
        }
        latest.into_values().collect()
    }

    fn reset_derived_state(&mut self) {
        self.events.clear();
        self.adjustments.clear();
        self.trade_ids.clear();
        self.buy_qty = Quantity::zero(self.size_precision);
        self.sell_qty = Quantity::zero(self.size_precision);
        self.commissions.clear();
        self.signed_qty = 0.0;
        self.quantity = Quantity::zero(self.size_precision);
        self.peak_qty = Quantity::zero(self.size_precision);
        self.side = PositionSide::Flat;
        self.closing_order_id = None;
        self.ts_opened = UnixNanos::default();
        self.ts_last = UnixNanos::default();
        self.ts_closed = Some(UnixNanos::default());
        self.duration_ns = DurationNanos::default();
        self.avg_px_open = 0.0;
        self.avg_px_close = None;
        self.realized_pnl = None;
        self.realized_return = 0.0;
    }

    /// Calculates the average price using f64 arithmetic.
    ///
    /// # Design Decision: f64 vs Fixed-Point Arithmetic
    ///
    /// This function uses f64 arithmetic which provides sufficient precision for financial
    /// calculations in this context. While f64 can introduce precision errors, the risk
    /// is minimal here because:
    ///
    /// 1. **No cumulative error**: Each calculation starts fresh from precise Price and
    ///    Quantity objects (derived from fixed-point raw values via `as_f64()`), rather
    ///    than carrying f64 intermediate results between calculations.
    ///
    /// 2. **Single operation**: This is a single weighted average calculation, not a
    ///    chain of operations where errors would compound.
    ///
    /// 3. **Overflow safety**: Raw integer arithmetic (`price_raw` * `qty_raw`) would risk
    ///    overflow even with i128 intermediates, since max values can exceed integer limits.
    ///
    /// 4. **f64 precision**: ~15 decimal digits is sufficient for typical financial
    ///    calculations at this level.
    ///
    /// For scenarios requiring higher precision (regulatory compliance, high-frequency
    /// micro-calculations), consider using Decimal arithmetic libraries.
    ///
    /// # Empirical Precision Validation
    ///
    /// Testing confirms f64 arithmetic maintains accuracy for typical trading scenarios:
    /// - **Typical amounts**: No precision loss for amounts ≥ 0.01 in standard currencies.
    /// - **High-precision instruments**: 9-decimal crypto prices preserved within 1e-6 tolerance.
    /// - **Many fills**: 100 sequential fills show no drift (commission accuracy to 1e-10).
    /// - **Extreme prices**: Handles range from 0.00001 to 99999.99999 without overflow/underflow.
    /// - **Round-trip**: Open/close at same price produces exact PnL (commissions only).
    ///
    /// See precision validation tests: `test_position_pnl_precision_*`
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - Both `qty` and `last_qty` are zero.
    /// - `last_qty` is zero (prevents division by zero).
    /// - `total_qty` is zero or negative (arithmetic error).
    fn calculate_avg_px(
        &self,
        qty: f64,
        avg_pg: f64,
        last_px: f64,
        last_qty: f64,
    ) -> anyhow::Result<f64> {
        // Prices can be negative for options and spreads, so only quantities
        // are checked for non-negativity here.
        debug_assert!(
            qty >= 0.0 && last_qty >= 0.0,
            "Invariant: average price calc requires non-negative quantities \
             (qty={qty}, last_qty={last_qty})"
        );

        if qty == 0.0 && last_qty == 0.0 {
            anyhow::bail!("Cannot calculate average price: both quantities are zero");
        }

        if last_qty == 0.0 {
            anyhow::bail!("Cannot calculate average price: fill quantity is zero");
        }

        if qty == 0.0 {
            return Ok(last_px);
        }

        let start_cost = avg_pg * qty;
        let event_cost = last_px * last_qty;
        let total_qty = qty + last_qty;

        // Runtime check to prevent division by zero even in release builds
        if total_qty <= 0.0 {
            anyhow::bail!(
                "Total quantity unexpectedly zero or negative in average price calculation: qty={qty}, last_qty={last_qty}, total_qty={total_qty}"
            );
        }

        Ok((start_cost + event_cost) / total_qty)
    }

    fn calculate_avg_px_open_px(&self, last_px: f64, last_qty: f64) -> f64 {
        self.calculate_avg_px(self.quantity.as_f64(), self.avg_px_open, last_px, last_qty)
            .unwrap_or_else(|e| {
                log::error!("Error calculating average open price: {e}");
                last_px
            })
    }

    fn calculate_avg_px_close_px(&self, last_px: f64, last_qty: f64) -> f64 {
        let Some(avg_px_close) = self.avg_px_close else {
            return last_px;
        };
        let closing_qty = if self.side == PositionSide::Long {
            self.sell_qty
        } else {
            self.buy_qty
        };
        self.calculate_avg_px(closing_qty.as_f64(), avg_px_close, last_px, last_qty)
            .unwrap_or_else(|e| {
                log::error!("Error calculating average close price: {e}");
                last_px
            })
    }

    fn calculate_points(&self, avg_px_open: f64, avg_px_close: f64) -> f64 {
        match self.side {
            PositionSide::Long => avg_px_close - avg_px_open,
            PositionSide::Short => avg_px_open - avg_px_close,
            PositionSide::Flat => 0.0,
        }
    }

    fn calculate_points_inverse(&self, avg_px_open: f64, avg_px_close: f64) -> anyhow::Result<f64> {
        // Epsilon at the limit of IEEE f64 precision before rounding errors (f64::EPSILON ≈ 2.22e-16)
        const EPSILON: f64 = 1e-15;

        if avg_px_open <= 0.0 || avg_px_open.abs() < EPSILON {
            anyhow::bail!(
                "Cannot calculate inverse points: open price is not positive or is too small ({avg_px_open})"
            );
        }

        if avg_px_close <= 0.0 || avg_px_close.abs() < EPSILON {
            anyhow::bail!(
                "Cannot calculate inverse points: close price is not positive or is too small ({avg_px_close})"
            );
        }

        let inverse_open = 1.0 / avg_px_open;
        let inverse_close = 1.0 / avg_px_close;
        let result = match self.side {
            PositionSide::Long => inverse_open - inverse_close,
            PositionSide::Short => inverse_close - inverse_open,
            PositionSide::Flat => 0.0,
        };
        Ok(result)
    }

    fn calculate_return(&self, avg_px_open: f64, avg_px_close: f64) -> anyhow::Result<f64> {
        // Prevent division by zero in return calculation
        if avg_px_open == 0.0 {
            anyhow::bail!(
                "Cannot calculate return: open price is zero (close price: {avg_px_close})"
            );
        }
        Ok(self.calculate_points(avg_px_open, avg_px_close) / avg_px_open)
    }

    fn calculate_pnl_raw(
        &self,
        avg_px_open: f64,
        avg_px_close: f64,
        quantity: f64,
    ) -> anyhow::Result<f64> {
        let quantity = quantity.min(self.signed_qty.abs());
        let result = if self.is_inverse {
            anyhow::ensure!(
                self.base_currency.is_some(),
                "inverse position {} has no base currency",
                self.instrument_id
            );
            let points = self.calculate_points_inverse(avg_px_open, avg_px_close)?;
            quantity * self.multiplier.as_f64() * points
        } else {
            quantity * self.multiplier.as_f64() * self.calculate_points(avg_px_open, avg_px_close)
        };
        Ok(result)
    }

    /// Calculates profit and loss from the given prices and quantity.
    ///
    /// # Errors
    ///
    /// Returns an error if inverse P&L cannot be calculated or the result cannot be represented as
    /// [`Money`].
    pub fn try_calculate_pnl(
        &self,
        avg_px_open: f64,
        avg_px_close: f64,
        quantity: Quantity,
    ) -> anyhow::Result<Money> {
        let pnl_raw = self.calculate_pnl_raw(avg_px_open, avg_px_close, quantity.as_f64())?;
        Money::new_checked(pnl_raw, self.settlement_currency).map_err(Into::into)
    }

    /// Calculates profit and loss from the given prices and quantity.
    #[must_use]
    pub fn calculate_pnl(&self, avg_px_open: f64, avg_px_close: f64, quantity: Quantity) -> Money {
        self.try_calculate_pnl(avg_px_open, avg_px_close, quantity)
            .unwrap_or_else(|e| {
                log::error!("Error calculating PnL: {e}");
                Money::zero(self.settlement_currency)
            })
    }

    /// Returns total P&L (realized + unrealized) based on the last price.
    ///
    /// # Errors
    ///
    /// Returns an error if unrealized P&L cannot be calculated, the realized and unrealized
    /// currencies differ, or the total cannot be represented as [`Money`].
    pub fn try_total_pnl(&self, last: Price) -> anyhow::Result<Money> {
        let unrealized = self.try_unrealized_pnl(last)?;

        match self.realized_pnl {
            Some(realized) => {
                anyhow::ensure!(
                    realized.currency == unrealized.currency,
                    "realized and unrealized PnL currencies differ"
                );
                realized
                    .checked_add(unrealized)
                    .ok_or_else(|| anyhow::anyhow!("total PnL overflow"))
            }
            None => Ok(unrealized),
        }
    }

    /// Returns total P&L (realized + unrealized) based on the last price.
    #[must_use]
    pub fn total_pnl(&self, last: Price) -> Money {
        self.try_total_pnl(last).unwrap_or_else(|e| {
            log::error!("Error calculating total PnL: {e}");
            Money::zero(self.settlement_currency)
        })
    }

    /// Returns unrealized P&L based on the last price.
    ///
    /// # Errors
    ///
    /// Returns an error if inverse P&L cannot be calculated or the result cannot be represented as
    /// [`Money`].
    pub fn try_unrealized_pnl(&self, last: Price) -> anyhow::Result<Money> {
        if self.side == PositionSide::Flat {
            Ok(Money::zero(self.settlement_currency))
        } else {
            let pnl =
                self.calculate_pnl_raw(self.avg_px_open, last.as_f64(), self.quantity.as_f64())?;
            Money::new_checked(pnl, self.settlement_currency).map_err(Into::into)
        }
    }

    /// Returns unrealized P&L based on the last price.
    #[must_use]
    pub fn unrealized_pnl(&self, last: Price) -> Money {
        self.try_unrealized_pnl(last).unwrap_or_else(|e| {
            log::error!("Error calculating unrealized PnL: {e}");
            Money::zero(self.settlement_currency)
        })
    }

    /// Returns the order side required to close this position.
    #[must_use]
    pub fn closing_order_side(&self) -> Option<OrderSide> {
        match self.side {
            PositionSide::Long => Some(OrderSide::Sell),
            PositionSide::Short => Some(OrderSide::Buy),
            PositionSide::Flat => None,
        }
    }

    /// Returns whether the given order side is opposite to the position entry side.
    #[must_use]
    pub fn is_opposite_side(&self, side: OrderSide) -> bool {
        self.entry != side
    }

    /// Returns the instrument symbol.
    #[must_use]
    pub fn symbol(&self) -> Symbol {
        self.instrument_id.symbol
    }

    /// Returns the trading venue.
    #[must_use]
    pub fn venue(&self) -> Venue {
        self.instrument_id.venue
    }

    /// Returns the count of order fill events applied to this position.
    #[must_use]
    pub fn event_count(&self) -> usize {
        self.events.len()
    }

    /// Returns unique client order IDs from all fill events, sorted.
    #[must_use]
    pub fn client_order_ids(&self) -> Vec<ClientOrderId> {
        // First to hash set to remove duplicate, then again iter to vector
        let mut result = self
            .events
            .iter()
            .map(|event| event.client_order_id)
            .collect::<AHashSet<ClientOrderId>>()
            .into_iter()
            .collect::<Vec<ClientOrderId>>();
        result.sort_unstable();
        result
    }

    /// Returns unique venue order IDs from all fill events, sorted.
    #[must_use]
    pub fn venue_order_ids(&self) -> Vec<VenueOrderId> {
        // First to hash set to remove duplicate, then again iter to vector
        let mut result = self
            .events
            .iter()
            .map(|event| event.venue_order_id)
            .collect::<AHashSet<VenueOrderId>>()
            .into_iter()
            .collect::<Vec<VenueOrderId>>();
        result.sort_unstable();
        result
    }

    /// Returns unique trade IDs from all fill events, sorted.
    #[must_use]
    pub fn trade_ids(&self) -> Vec<TradeId> {
        let mut result = self
            .events
            .iter()
            .map(|event| event.trade_id)
            .collect::<AHashSet<TradeId>>()
            .into_iter()
            .collect::<Vec<TradeId>>();
        result.sort_unstable();
        result
    }

    /// Calculates the notional value based on the last price.
    ///
    /// # Errors
    ///
    /// Returns an error if this is an inverse position without a base currency, the price is not
    /// positive for inverse valuation, or the result cannot be represented as [`Money`].
    pub fn try_notional_value(&self, last: Price) -> anyhow::Result<Money> {
        let currency = if self.is_inverse {
            self.base_currency.ok_or_else(|| {
                anyhow::anyhow!(
                    "inverse position {} has no base currency",
                    self.instrument_id
                )
            })?
        } else {
            self.settlement_currency
        };

        crate::instruments::try_notional_value(
            self.quantity,
            last,
            self.multiplier,
            self.is_inverse,
            false,
            currency,
        )
    }

    /// Calculates the notional value based on the last price.
    ///
    /// # Panics
    ///
    /// Panics if [`Position::try_notional_value`] returns an error.
    #[must_use]
    pub fn notional_value(&self, last: Price) -> Money {
        self.try_notional_value(last)
            .expect("invalid notional value")
    }

    /// Returns the last `OrderFilled` event for the position (if any after purging).
    #[must_use]
    pub fn last_event(&self) -> Option<OrderFilled> {
        self.events.last().cloned()
    }

    /// Returns the last `TradeId` for the position (if any after purging).
    #[must_use]
    pub fn last_trade_id(&self) -> Option<TradeId> {
        self.events.last().map(|e| e.trade_id)
    }

    /// Returns whether the position is long (positive quantity).
    #[must_use]
    pub fn is_long(&self) -> bool {
        self.side == PositionSide::Long
    }

    /// Returns whether the position is short (negative quantity).
    #[must_use]
    pub fn is_short(&self) -> bool {
        self.side == PositionSide::Short
    }

    /// Returns whether the position is currently open (has quantity and no close timestamp).
    #[must_use]
    pub fn is_open(&self) -> bool {
        self.side != PositionSide::Flat && self.ts_closed.is_none()
    }

    /// Returns whether the position is closed (flat with a close timestamp).
    #[must_use]
    pub fn is_closed(&self) -> bool {
        self.side == PositionSide::Flat && self.ts_closed.is_some()
    }

    /// Returns the signed quantity as a `Decimal`.
    ///
    /// Uses the raw `signed_qty` field to preserve full precision, as the `quantity`
    /// field may have reduced precision based on the instrument's `size_precision`.
    #[must_use]
    pub fn signed_decimal_qty(&self) -> Decimal {
        Decimal::try_from(self.signed_qty).unwrap_or(Decimal::ZERO)
    }

    /// Returns the cumulative commissions for the position as a vector.
    #[must_use]
    pub fn commissions(&self) -> Vec<Money> {
        self.commissions.values().copied().collect()
    }
}

impl PartialEq<Self> for Position {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl Eq for Position {}

impl Hash for Position {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

impl Display for Position {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let quantity_str = if self.quantity == Quantity::zero(self.size_precision) {
            String::new()
        } else {
            self.quantity.to_formatted_string() + " "
        };
        write!(
            f,
            "Position({} {}{}, id={})",
            self.side, quantity_str, self.instrument_id, self.id
        )
    }
}

/// Replays position legs onto a hypothetical NETTING position in `ts_opened`
/// order, returning `(net_signed_qty, net_avg_px_open)`.
///
/// Each leg is `(signed_qty, avg_px_open, ts_opened_ns)`. Rules follow
/// [`Position::apply`]:
/// - Same-side legs produce a quantity-weighted average open price.
/// - Opposite-side legs partial-close at the existing average.
/// - A leg that crosses zero makes the residual take that leg's price.
///
/// Zero-quantity legs are skipped. Sort is stable on `ts_opened`; the caller
/// orders ties (e.g. by `position_id`).
#[must_use]
pub fn fold_net_position(legs: &[(Decimal, Decimal, u64)]) -> (Decimal, Decimal) {
    let mut sorted: Vec<&(Decimal, Decimal, u64)> =
        legs.iter().filter(|(qty, _, _)| !qty.is_zero()).collect();
    sorted.sort_by_key(|(_, _, ts_opened)| *ts_opened);

    let mut net_signed_qty = Decimal::ZERO;
    let mut net_avg_px = Decimal::ZERO;

    for &(p_qty, p_px, _) in sorted {
        if net_signed_qty.is_zero() {
            net_signed_qty = p_qty;
            net_avg_px = p_px;
            continue;
        }

        let same_side = net_signed_qty.is_sign_negative() == p_qty.is_sign_negative();
        let new_net = net_signed_qty + p_qty;

        if same_side {
            let total_abs = net_signed_qty.abs() + p_qty.abs();
            net_avg_px = (net_signed_qty.abs() * net_avg_px + p_qty.abs() * p_px) / total_abs;
            net_signed_qty = new_net;
        } else if new_net.is_zero()
            || new_net.is_sign_negative() == net_signed_qty.is_sign_negative()
        {
            net_signed_qty = new_net;
            if new_net.is_zero() {
                net_avg_px = Decimal::ZERO;
            }
        } else {
            net_signed_qty = new_net;
            net_avg_px = p_px;
        }
    }

    (net_signed_qty, net_avg_px)
}

#[cfg(test)]
mod tests {
    use std::str::FromStr;

    use ahash::AHashSet;
    use nautilus_core::{DurationNanos, UUID4, UnixNanos, correctness::CorrectnessError};
    use proptest::prelude::*;
    use rstest::rstest;
    use rust_decimal::{Decimal, prelude::ToPrimitive};
    use rust_decimal_macros::dec;

    use crate::{
        enums::{OrderSide, OrderType, PositionAdjustmentType, PositionSide},
        events::{
            OrderEventAny, OrderFillVoided, OrderFilled, PositionAdjusted,
            order::spec::{OrderFillVoidedSpec, OrderFilledSpec},
        },
        identifiers::{
            AccountId, ClientOrderId, InstrumentId, PositionId, StrategyId, TradeId, VenueOrderId,
            stubs::uuid4,
        },
        instruments::{
            CryptoFuture, CryptoPerpetual, CurrencyPair, Instrument, InstrumentAny, stubs::*,
        },
        orders::{Order, builder::OrderTestBuilder, stubs::TestOrderEventStubs},
        position::{Position, PositionFillVoid, fold_net_position},
        stubs::*,
        types::{Currency, Money, Price, Quantity},
    };

    #[rstest]
    fn test_position_long_display(stub_position_long: Position) {
        let display = format!("{stub_position_long}");
        assert_eq!(display, "Position(LONG 1 AUD/USD.SIM, id=1)");
    }

    #[rstest]
    fn test_position_short_display(stub_position_short: Position) {
        let display = format!("{stub_position_short}");
        assert_eq!(display, "Position(SHORT 1 AUD/USD.SIM, id=1)");
    }

    #[rstest]
    #[case::open(false)]
    #[case::closed(true)]
    fn test_clone_without_events_preserves_current_state(
        mut stub_position_long: Position,
        #[case] close: bool,
    ) {
        let adjustment = PositionAdjusted::new(
            stub_position_long.trader_id,
            stub_position_long.strategy_id,
            stub_position_long.instrument_id,
            stub_position_long.id,
            stub_position_long.account_id,
            PositionAdjustmentType::Funding,
            None,
            Some(Money::from_decimal(dec!(1.25), stub_position_long.settlement_currency).unwrap()),
            Some("clone-test".into()),
            uuid4(),
            UnixNanos::from(2),
            UnixNanos::from(2),
        );
        stub_position_long.apply_adjustment(adjustment);

        if close {
            let closing_fill = OrderFilledSpec::builder()
                .trader_id(stub_position_long.trader_id)
                .strategy_id(stub_position_long.strategy_id)
                .instrument_id(stub_position_long.instrument_id)
                .client_order_id(ClientOrderId::from("CLONE-CLOSE"))
                .venue_order_id(VenueOrderId::from("CLONE-CLOSE"))
                .account_id(stub_position_long.account_id)
                .trade_id(TradeId::from("CLONE-CLOSE"))
                .order_side(OrderSide::Sell)
                .order_type(OrderType::Market)
                .last_qty(stub_position_long.quantity)
                .last_px(Price::from("1.0012"))
                .currency(stub_position_long.settlement_currency)
                .position_id(stub_position_long.id)
                .ts_event(UnixNanos::from(3))
                .ts_init(UnixNanos::from(3))
                .build();
            stub_position_long.apply(&closing_fill);
        }

        let source_fill = stub_position_long.events[0].clone();
        let fill_voided = matching_fill_void(&source_fill, source_fill.last_qty, None);
        stub_position_long.fill_voids.push(PositionFillVoid {
            event: fill_voided,
            voided_qty: source_fill.last_qty,
            commission_voided: source_fill.commission,
        });

        let cloned = stub_position_long.clone_without_events();
        let mut expected = stub_position_long.clone();
        expected.events.clear();
        expected.adjustments.clear();
        expected.replay_events.clear();
        expected.fill_voids.clear();
        expected.trade_ids.clear();

        assert!(!stub_position_long.events.is_empty());
        assert!(!stub_position_long.adjustments.is_empty());
        assert!(!stub_position_long.replay_events.is_empty());
        assert!(!stub_position_long.fill_voids.is_empty());
        assert!(!stub_position_long.trade_ids.is_empty());
        assert!(cloned.events.is_empty());
        assert!(cloned.adjustments.is_empty());
        assert!(cloned.replay_events.is_empty());
        assert!(cloned.fill_voids.is_empty());
        assert!(cloned.trade_ids.is_empty());
        assert_eq!(
            serde_json::to_value(cloned).unwrap(),
            serde_json::to_value(expected).unwrap()
        );
    }

    #[rstest]
    fn test_clone_for_snapshot_matches_clone_then_clear(mut stub_position_long: Position) {
        let source_fill = stub_position_long.events[0].clone();
        stub_position_long.fill_voids.push(PositionFillVoid {
            event: matching_fill_void(&source_fill, source_fill.last_qty, None),
            voided_qty: source_fill.last_qty,
            commission_voided: source_fill.commission,
        });
        let mut expected = stub_position_long.clone();
        expected.replay_events.clear();
        expected.fill_voids.clear();

        let snapshot = stub_position_long.clone_for_snapshot();

        assert!(snapshot.replay_events.is_empty());
        assert!(snapshot.fill_voids.is_empty());
        assert_eq!(
            serde_json::to_vec(&snapshot).unwrap(),
            serde_json::to_vec(&expected).unwrap(),
        );
    }

    #[rstest]
    fn test_new_checked_rejects_missing_position_id(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .build();

        let error = Position::new_checked(&instrument, fill).unwrap_err();

        assert_eq!(
            error,
            CorrectnessError::PredicateViolation {
                message: "`fill.position_id` was None".to_string(),
            }
        );
    }

    #[rstest]
    fn test_new_checked_rejects_instrument_mismatch(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let fill = OrderFilledSpec::builder()
            .instrument_id(InstrumentId::from("GBP/USD.SIM"))
            .position_id(PositionId::from("P-1"))
            .build();

        let error = Position::new_checked(&instrument, fill).unwrap_err();

        assert_eq!(
            error,
            CorrectnessError::EqualityMismatch {
                lhs_param: "instrument.id()".to_string(),
                rhs_param: "fill.instrument_id".to_string(),
                lhs: "AUD/USD.SIM".to_string(),
                rhs: "GBP/USD.SIM".to_string(),
                type_name: "value",
            }
        );
    }

    #[rstest]
    #[case::instrument_mismatch(
        "GBP/USD.SIM",
        Some("P-1"),
        "'self.instrument_id' value of AUD/USD.SIM was not equal to 'fill.instrument_id' value of GBP/USD.SIM"
    )]
    #[case::missing_position_id("AUD/USD.SIM", None, "`fill.position_id` was None")]
    #[case::position_mismatch(
        "AUD/USD.SIM",
        Some("P-2"),
        "'self.id' value of P-1 was not equal to 'fill.position_id' value of P-2"
    )]
    fn test_try_apply_rejects_invalid_fill_identity_without_mutation(
        #[case] fill_instrument_id: &str,
        #[case] fill_position_id: Option<&str>,
        #[case] expected_error: &str,
        audusd_sim: CurrencyPair,
    ) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-1");
        let fill_open = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .trade_id(TradeId::from("T-1"))
            .position_id(position_id)
            .build();
        let mut fill_invalid = OrderFilledSpec::builder()
            .instrument_id(InstrumentId::from(fill_instrument_id))
            .trade_id(TradeId::from("T-2"))
            .build();
        fill_invalid.position_id = fill_position_id.map(PositionId::from);
        let mut position = Position::new(&instrument, fill_open);
        let state_before = serde_json::to_value(&position).unwrap();

        let error = position.try_apply(&fill_invalid).unwrap_err();

        assert_eq!(error.to_string(), expected_error);
        assert_eq!(serde_json::to_value(&position).unwrap(), state_before);
    }

    #[rstest]
    fn test_try_apply_rejects_duplicate_trade_without_mutation(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-1");
        let fill_open = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .trade_id(TradeId::from("T-1"))
            .position_id(position_id)
            .build();
        let fill_duplicate = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-2"))
            .trade_id(TradeId::from("T-1"))
            .position_id(position_id)
            .build();
        let mut position = Position::new(&instrument, fill_open);
        let state_before = serde_json::to_value(&position).unwrap();

        let error = position.try_apply(&fill_duplicate).unwrap_err();

        assert_eq!(
            error,
            CorrectnessError::PredicateViolation {
                message: "`fill.trade_id` already contained in `trade_ids`".to_string(),
            }
        );
        assert_eq!(serde_json::to_value(&position).unwrap(), state_before);
    }

    #[rstest]
    #[should_panic(expected = "`fill.trade_id` already contained in `trade_ids`")]
    fn test_two_trades_with_same_trade_id_error(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &audusd_sim,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            None,
            None,
            None,
        );
        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &audusd_sim,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("1.00002")),
            None,
            None,
            None,
            None,
            None,
        );
        let mut position = Position::new(&audusd_sim, fill1.into());
        position.apply(&fill2.into());
    }

    #[rstest]
    #[case(false)]
    #[case(true)]
    fn test_historical_duplicate_trade_id_does_not_poison_fill_void_replay(
        #[case] causal_duplicate: bool,
        audusd_sim: CurrencyPair,
    ) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-DUP");
        let fill_open = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill_close = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-2"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Sell)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00010"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let mut fill_duplicate = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00020"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(3))
            .build();

        if causal_duplicate {
            fill_duplicate.causation_id = Some(fill_open.event_id);
        }
        let fill_reopen = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-3"))
            .trade_id(TradeId::from("T-3"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(5))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(4))
            .build();
        let mut fill_duplicate_open = fill_duplicate.clone();
        fill_duplicate_open.event_id = uuid4();
        fill_duplicate_open.client_order_id = ClientOrderId::from("O-4");
        fill_duplicate_open.ts_event = UnixNanos::from(5);
        let fill_voided = matching_fill_void(&fill_close, Quantity::from(10), None);
        let mut position = Position::new(&instrument, fill_open.clone());
        position.try_apply(&fill_close).unwrap();

        position.try_apply(&fill_duplicate).unwrap();

        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.quantity, Quantity::from(0));
        assert_eq!(position.events, vec![fill_open.clone(), fill_close.clone()]);
        assert_eq!(position.replay_events.len(), 2);
        assert_eq!(position.trade_ids.len(), 2);
        assert!(position.trade_ids.contains(&TradeId::from("T-1")));
        assert!(position.trade_ids.contains(&TradeId::from("T-2")));

        position.try_apply(&fill_reopen).unwrap();
        position.try_apply(&fill_duplicate_open).unwrap();

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(5));
        assert_eq!(position.opening_order_id, ClientOrderId::from("O-3"));
        assert_eq!(position.events, vec![fill_reopen.clone()]);
        assert_eq!(position.replay_events.len(), 3);
        assert_eq!(position.trade_ids.len(), 1);
        assert!(position.trade_ids.contains(&TradeId::from("T-3")));

        position
            .apply_fill_void(fill_voided, Quantity::from(10), None)
            .unwrap();

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(15));
        assert_eq!(position.opening_order_id, ClientOrderId::from("O-1"));
        assert_eq!(position.closing_order_id, None);
        assert_eq!(position.avg_px_open, 1.0);
        assert_eq!(position.buy_qty, Quantity::from(15));
        assert_eq!(position.sell_qty, Quantity::from(0));
        assert_eq!(
            position.events,
            vec![fill_open.clone(), fill_reopen.clone()]
        );
        assert_eq!(position.replay_events.len(), 3);
        assert_eq!(position.fill_voids.len(), 1);
        assert_eq!(position.trade_ids.len(), 2);
        assert!(position.trade_ids.contains(&TradeId::from("T-1")));
        assert!(position.trade_ids.contains(&TradeId::from("T-3")));

        let mut fill_close_duplicate = fill_close;
        fill_close_duplicate.event_id = uuid4();
        fill_close_duplicate.ts_event = UnixNanos::from(6);
        position.try_apply(&fill_close_duplicate).unwrap();

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(15));
        assert_eq!(position.events, vec![fill_open, fill_reopen]);
        assert_eq!(position.replay_events.len(), 3);
    }

    #[rstest]
    fn test_replay_fill_with_foreign_causation_stays_duplicate(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-CAUSATION");
        let fill_open = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill_close = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-2"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Sell)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let mut position = Position::new(&instrument, fill_open.clone());
        position.apply(&fill_close);

        let mut replayed = fill_open.clone();
        replayed.event_id = uuid4();
        replayed.ts_event = UnixNanos::from(3);
        replayed.causation_id = Some(fill_close.event_id);

        position.apply(&replayed);

        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.quantity, Quantity::from(0));
        assert_eq!(position.events, vec![fill_open, fill_close.clone()]);
    }

    #[rstest]
    fn test_position_applies_fills_with_negative_prices(audusd_sim: CurrencyPair) {
        // Options and spreads can trade at negative prices; position average
        // price updates must not panic when the stored average or incoming
        // fill price is below zero.
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let fill1 = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("-5.00000")),
            Some(Quantity::from(50_000)),
            None,
            None,
            None,
            None,
        );
        let fill2 = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("-7.00000")),
            Some(Quantity::from(50_000)),
            None,
            None,
            None,
            None,
        );
        let mut position = Position::new(&audusd_sim, fill1.into());
        position.apply(&fill2.into());

        assert_eq!(position.quantity, Quantity::from(100_000));
        assert_eq!(position.signed_qty, 100_000.0);
        assert_eq!(position.side, PositionSide::Long);
        // Weighted avg_px_open: (50_000 * -5 + 50_000 * -7) / 100_000 = -6.0
        assert_eq!(position.avg_px_open, -6.0);
    }

    #[rstest]
    fn test_position_filled_with_buy_order(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            None,
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            None,
            None,
            None,
        );
        let last_price = Price::from_str("1.0005").unwrap();
        let position = Position::new(&audusd_sim, fill.into());
        assert_eq!(position.symbol(), audusd_sim.id().symbol);
        assert_eq!(position.venue(), audusd_sim.id().venue);
        assert_eq!(position.closing_order_side(), Some(OrderSide::Sell));
        assert!(!position.is_opposite_side(OrderSide::Buy));
        assert_eq!(position, position); // equality operator test
        assert!(position.closing_order_id.is_none());
        assert_eq!(position.quantity, Quantity::from(100_000));
        assert_eq!(position.peak_qty, Quantity::from(100_000));
        assert_eq!(position.size_precision, 0);
        assert_eq!(position.signed_qty, 100_000.0);
        assert_eq!(position.entry, OrderSide::Buy);
        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.ts_opened.as_u64(), 0);
        assert_eq!(position.duration_ns, DurationNanos::default());
        assert_eq!(position.avg_px_open, 1.00001);
        assert_eq!(position.event_count(), 1);
        assert_eq!(position.id, PositionId::new("1"));
        assert_eq!(position.events.len(), 1);
        assert!(position.is_long());
        assert!(!position.is_short());
        assert!(position.is_open());
        assert!(!position.is_closed());
        assert_eq!(position.realized_return, 0.0);
        assert_eq!(position.realized_pnl, Some(Money::from("-2.0 USD")));
        assert_eq!(position.unrealized_pnl(last_price), Money::from("49.0 USD"));
        assert_eq!(position.total_pnl(last_price), Money::from("47.0 USD"));
        assert_eq!(position.commissions(), vec![Money::from("2.0 USD")]);
        assert_eq!(
            format!("{position}"),
            "Position(LONG 100_000 AUD/USD.SIM, id=1)"
        );
    }

    #[rstest]
    fn test_position_filled_with_sell_order(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(100_000))
            .build();
        let fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            None,
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            None,
            None,
            None,
        );
        let last_price = Price::from_str("1.00050").unwrap();
        let position = Position::new(&audusd_sim, fill.into());
        assert_eq!(position.symbol(), audusd_sim.id().symbol);
        assert_eq!(position.venue(), audusd_sim.id().venue);
        assert_eq!(position.closing_order_side(), Some(OrderSide::Buy));
        assert!(!position.is_opposite_side(OrderSide::Sell));
        assert_eq!(position, position); // Equality operator test
        assert!(position.closing_order_id.is_none());
        assert_eq!(position.quantity, Quantity::from(100_000));
        assert_eq!(position.peak_qty, Quantity::from(100_000));
        assert_eq!(position.signed_qty, -100_000.0);
        assert_eq!(position.entry, OrderSide::Sell);
        assert_eq!(position.side, PositionSide::Short);
        assert_eq!(position.ts_opened.as_u64(), 0);
        assert_eq!(position.avg_px_open, 1.00001);
        assert_eq!(position.event_count(), 1);
        assert_eq!(position.id, PositionId::new("1"));
        assert_eq!(position.events.len(), 1);
        assert!(!position.is_long());
        assert!(position.is_short());
        assert!(position.is_open());
        assert!(!position.is_closed());
        assert_eq!(position.realized_return, 0.0);
        assert_eq!(position.realized_pnl, Some(Money::from("-2.0 USD")));
        assert_eq!(
            position.unrealized_pnl(last_price),
            Money::from("-49.0 USD")
        );
        assert_eq!(position.total_pnl(last_price), Money::from("-51.0 USD"));
        assert_eq!(position.commissions(), vec![Money::from("2.0 USD")]);
        assert_eq!(
            format!("{position}"),
            "Position(SHORT 100_000 AUD/USD.SIM, id=1)"
        );
    }

    #[rstest]
    fn test_position_partial_fills_with_buy_order(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            None,
            None,
            Some(Price::from("1.00001")),
            Some(Quantity::from(50_000)),
            None,
            None,
            None,
            None,
        );
        let last_price = Price::from_str("1.00048").unwrap();
        let position = Position::new(&audusd_sim, fill.into());
        assert_eq!(position.quantity, Quantity::from(50_000));
        assert_eq!(position.peak_qty, Quantity::from(50_000));
        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.signed_qty, 50000.0);
        assert_eq!(position.avg_px_open, 1.00001);
        assert_eq!(position.event_count(), 1);
        assert_eq!(position.ts_opened.as_u64(), 0);
        assert!(position.is_long());
        assert!(!position.is_short());
        assert!(position.is_open());
        assert!(!position.is_closed());
        assert_eq!(position.realized_return, 0.0);
        assert_eq!(position.realized_pnl, Some(Money::from("-2.0 USD")));
        assert_eq!(position.unrealized_pnl(last_price), Money::from("23.5 USD"));
        assert_eq!(position.total_pnl(last_price), Money::from("21.5 USD"));
        assert_eq!(position.commissions(), vec![Money::from("2.0 USD")]);
        assert_eq!(
            format!("{position}"),
            "Position(LONG 50_000 AUD/USD.SIM, id=1)"
        );
    }

    #[rstest]
    fn test_position_partial_fills_with_two_sell_orders(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(100_000))
            .build();
        let fill1 = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("1.00001")),
            Some(Quantity::from(50_000)),
            None,
            None,
            None,
            None,
        );
        let fill2 = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("1.00002")),
            Some(Quantity::from(50_000)),
            None,
            None,
            None,
            None,
        );
        let last_price = Price::from_str("1.0005").unwrap();
        let mut position = Position::new(&audusd_sim, fill1.into());
        position.apply(&fill2.into());

        assert_eq!(position.quantity, Quantity::from(100_000));
        assert_eq!(position.peak_qty, Quantity::from(100_000));
        assert_eq!(position.side, PositionSide::Short);
        assert_eq!(position.signed_qty, -100_000.0);
        assert_eq!(position.avg_px_open, 1.000_015);
        assert_eq!(position.event_count(), 2);
        assert_eq!(position.ts_opened, 0);
        assert!(position.is_short());
        assert!(!position.is_long());
        assert!(position.is_open());
        assert!(!position.is_closed());
        assert_eq!(position.realized_return, 0.0);
        assert_eq!(position.realized_pnl, Some(Money::from("-4.0 USD")));
        assert_eq!(
            position.unrealized_pnl(last_price),
            Money::from("-48.5 USD")
        );
        assert_eq!(position.total_pnl(last_price), Money::from("-52.5 USD"));
        assert_eq!(position.commissions(), vec![Money::from("4.0 USD")]);
    }

    #[rstest]
    pub fn test_position_filled_with_buy_order_then_sell_order(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(150_000))
            .build();
        let fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            Some(TradeId::new("1")),
            Some(PositionId::new("P-1")),
            Some(Price::from("1.00001")),
            None,
            None,
            None,
            Some(UnixNanos::from(1_000_000_000)),
            None,
        );
        let mut position = Position::new(&audusd_sim, fill.into());

        let fill2 = OrderFilledSpec::builder()
            .trader_id(order.trader_id())
            .strategy_id(StrategyId::new("S-001"))
            .instrument_id(order.instrument_id())
            .client_order_id(order.client_order_id())
            .venue_order_id(VenueOrderId::from("2"))
            .account_id(order.account_id().unwrap_or(AccountId::new("SIM-001")))
            .trade_id(TradeId::new("2"))
            .order_side(OrderSide::Sell)
            .last_qty(order.quantity())
            .last_px(Price::from("1.00011"))
            .currency(audusd_sim.quote_currency())
            .ts_event(2_000_000_000.into())
            .position_id(PositionId::new("T1"))
            .commission(Money::from("0.0 USD"))
            .build();
        position.apply(&fill2);
        let last = Price::from_str("1.0005").unwrap();

        assert!(position.is_opposite_side(fill2.order_side));
        assert_eq!(
            position.quantity,
            Quantity::zero(audusd_sim.price_precision())
        );
        assert_eq!(position.size_precision, 0);
        assert_eq!(position.signed_qty, 0.0);
        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.ts_opened, 1_000_000_000);
        assert_eq!(position.ts_closed, Some(UnixNanos::from(2_000_000_000)));
        assert_eq!(position.duration_ns, DurationNanos::from_secs(1));
        assert_eq!(position.avg_px_open, 1.00001);
        assert_eq!(position.avg_px_close, Some(1.00011));
        assert!(!position.is_long());
        assert!(!position.is_short());
        assert!(!position.is_open());
        assert!(position.is_closed());
        assert_eq!(position.realized_return, 9.999_900_000_998_888e-5);
        assert_eq!(position.realized_pnl, Some(Money::from("13.0 USD")));
        assert_eq!(position.unrealized_pnl(last), Money::from("0 USD"));
        assert_eq!(position.commissions(), vec![Money::from("2 USD")]);
        assert_eq!(position.total_pnl(last), Money::from("13 USD"));
        assert_eq!(format!("{position}"), "Position(FLAT AUD/USD.SIM, id=P-1)");
    }

    #[rstest]
    pub fn test_position_filled_with_sell_order_then_buy_order(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(100_000))
            .build();
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &audusd_sim,
            None,
            Some(PositionId::new("P-19700101-000000-001-001-1")),
            Some(Price::from("1.0")),
            None,
            None,
            None,
            None,
            None,
        );
        let mut position = Position::new(&audusd_sim, fill1.into());
        // create closing from order from different venue but same strategy
        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &audusd_sim,
            Some(TradeId::new("1")),
            Some(PositionId::new("P-19700101-000000-001-001-1")),
            Some(Price::from("1.00001")),
            Some(Quantity::from(50_000)),
            None,
            None,
            None,
            None,
        );
        let fill3 = TestOrderEventStubs::filled(
            &order2,
            &audusd_sim,
            Some(TradeId::new("2")),
            Some(PositionId::new("P-19700101-000000-001-001-1")),
            Some(Price::from("1.00003")),
            Some(Quantity::from(50_000)),
            None,
            None,
            None,
            None,
        );
        let last = Price::from("1.0005");
        position.apply(&fill2.into());
        position.apply(&fill3.into());

        assert_eq!(
            position.quantity,
            Quantity::zero(audusd_sim.price_precision())
        );
        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.ts_opened, 0);
        assert_eq!(position.avg_px_open, 1.0);
        assert_eq!(position.events.len(), 3);
        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
        assert_eq!(position.avg_px_close, Some(1.00002));
        assert!(!position.is_long());
        assert!(!position.is_short());
        assert!(!position.is_open());
        assert!(position.is_closed());
        assert_eq!(position.commissions(), vec![Money::from("6.0 USD")]);
        assert_eq!(position.unrealized_pnl(last), Money::from("0 USD"));
        assert_eq!(position.realized_pnl, Some(Money::from("-8.0 USD")));
        assert_eq!(position.total_pnl(last), Money::from("-8.0 USD"));
        assert_eq!(
            format!("{position}"),
            "Position(FLAT AUD/USD.SIM, id=P-19700101-000000-001-001-1)"
        );
    }

    #[rstest]
    fn test_position_filled_with_no_change(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(100_000))
            .build();
        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &audusd_sim,
            Some(TradeId::new("1")),
            Some(PositionId::new("P-19700101-000000-001-001-1")),
            Some(Price::from("1.0")),
            None,
            None,
            None,
            None,
            None,
        );
        let mut position = Position::new(&audusd_sim, fill1.into());
        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &audusd_sim,
            Some(TradeId::new("2")),
            Some(PositionId::new("P-19700101-000000-001-001-1")),
            Some(Price::from("1.0")),
            None,
            None,
            None,
            None,
            None,
        );
        let last = Price::from("1.0005");
        position.apply(&fill2.into());

        assert_eq!(
            position.quantity,
            Quantity::zero(audusd_sim.price_precision())
        );
        assert_eq!(position.closing_order_side(), None);
        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.ts_opened, 0);
        assert_eq!(position.avg_px_open, 1.0);
        assert_eq!(position.events.len(), 2);
        // assert_eq!(position.trade_ids, vec![fill1.trade_id, fill2.trade_id]);  // TODO
        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
        assert_eq!(position.avg_px_close, Some(1.0));
        assert!(!position.is_long());
        assert!(!position.is_short());
        assert!(!position.is_open());
        assert!(position.is_closed());
        assert_eq!(position.commissions(), vec![Money::from("4.0 USD")]);
        assert_eq!(position.unrealized_pnl(last), Money::from("0 USD"));
        assert_eq!(position.realized_pnl, Some(Money::from("-4.0 USD")));
        assert_eq!(position.total_pnl(last), Money::from("-4.0 USD"));
        assert_eq!(
            format!("{position}"),
            "Position(FLAT AUD/USD.SIM, id=P-19700101-000000-001-001-1)"
        );
    }

    #[rstest]
    fn test_position_long_with_multiple_filled_orders(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let order3 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(200_000))
            .build();
        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &audusd_sim,
            Some(TradeId::new("1")),
            Some(PositionId::new("P-123456")),
            Some(Price::from("1.0")),
            None,
            None,
            None,
            None,
            None,
        );
        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &audusd_sim,
            Some(TradeId::new("2")),
            Some(PositionId::new("P-123456")),
            Some(Price::from("1.00001")),
            None,
            None,
            None,
            None,
            None,
        );
        let fill3 = TestOrderEventStubs::filled(
            &order3,
            &audusd_sim,
            Some(TradeId::new("3")),
            Some(PositionId::new("P-123456")),
            Some(Price::from("1.0001")),
            None,
            None,
            None,
            None,
            None,
        );
        let mut position = Position::new(&audusd_sim, fill1.into());
        let last = Price::from("1.0005");
        position.apply(&fill2.into());
        position.apply(&fill3.into());

        assert_eq!(
            position.quantity,
            Quantity::zero(audusd_sim.price_precision())
        );
        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.ts_opened, 0);
        assert_eq!(position.avg_px_open, 1.000_005);
        assert_eq!(position.events.len(), 3);
        // assert_eq!(
        //     position.trade_ids,
        //     vec![fill1.trade_id, fill2.trade_id, fill3.trade_id]
        // );
        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
        assert_eq!(position.avg_px_close, Some(1.0001));
        assert!(position.is_closed());
        assert!(!position.is_open());
        assert!(!position.is_long());
        assert!(!position.is_short());
        assert_eq!(position.commissions(), vec![Money::from("6.0 USD")]);
        assert_eq!(position.realized_pnl, Some(Money::from("13.0 USD")));
        assert_eq!(position.unrealized_pnl(last), Money::from("0 USD"));
        assert_eq!(position.total_pnl(last), Money::from("13 USD"));
        assert_eq!(
            format!("{position}"),
            "Position(FLAT AUD/USD.SIM, id=P-123456)"
        );
    }

    #[rstest]
    fn test_pnl_calculation_from_trading_technologies_example(currency_pair_ethusdt: CurrencyPair) {
        let ethusdt = InstrumentAny::CurrencyPair(currency_pair_ethusdt);
        let quantity1 = Quantity::from(12);
        let price1 = Price::from("100.0");
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(ethusdt.id())
            .side(OrderSide::Buy)
            .quantity(quantity1)
            .build();
        let commission1 = calculate_commission(&ethusdt, order1.quantity(), price1, None);
        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &ethusdt,
            Some(TradeId::new("1")),
            Some(PositionId::new("P-123456")),
            Some(price1),
            None,
            None,
            Some(commission1),
            None,
            None,
        );
        let mut position = Position::new(&ethusdt, fill1.into());
        let quantity2 = Quantity::from(17);
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(ethusdt.id())
            .side(OrderSide::Buy)
            .quantity(quantity2)
            .build();
        let price2 = Price::from("99.0");
        let commission2 = calculate_commission(&ethusdt, order2.quantity(), price2, None);
        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &ethusdt,
            Some(TradeId::new("2")),
            Some(PositionId::new("P-123456")),
            Some(price2),
            None,
            None,
            Some(commission2),
            None,
            None,
        );
        position.apply(&fill2.into());
        assert_eq!(position.quantity, Quantity::from(29));
        assert_eq!(position.realized_pnl, Some(Money::from("-0.28830000 USDT")));
        assert_eq!(position.avg_px_open, 99.413_793_103_448_27);
        let quantity3 = Quantity::from(9);
        let order3 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(ethusdt.id())
            .side(OrderSide::Sell)
            .quantity(quantity3)
            .build();
        let price3 = Price::from("101.0");
        let commission3 = calculate_commission(&ethusdt, order3.quantity(), price3, None);
        let fill3 = TestOrderEventStubs::filled(
            &order3,
            &ethusdt,
            Some(TradeId::new("3")),
            Some(PositionId::new("P-123456")),
            Some(price3),
            None,
            None,
            Some(commission3),
            None,
            None,
        );
        position.apply(&fill3.into());
        assert_eq!(position.quantity, Quantity::from(20));
        assert_eq!(position.realized_pnl, Some(Money::from("13.89666207 USDT")));
        assert_eq!(position.avg_px_open, 99.413_793_103_448_27);
        let quantity4 = Quantity::from("4");
        let price4 = Price::from("105.0");
        let order4 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(ethusdt.id())
            .side(OrderSide::Sell)
            .quantity(quantity4)
            .build();
        let commission4 = calculate_commission(&ethusdt, order4.quantity(), price4, None);
        let fill4 = TestOrderEventStubs::filled(
            &order4,
            &ethusdt,
            Some(TradeId::new("4")),
            Some(PositionId::new("P-123456")),
            Some(price4),
            None,
            None,
            Some(commission4),
            None,
            None,
        );
        position.apply(&fill4.into());
        assert_eq!(position.quantity, Quantity::from("16"));
        assert_eq!(position.realized_pnl, Some(Money::from("36.19948966 USDT")));
        assert_eq!(position.avg_px_open, 99.413_793_103_448_27);
        let quantity5 = Quantity::from("3");
        let price5 = Price::from("103.0");
        let order5 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(ethusdt.id())
            .side(OrderSide::Buy)
            .quantity(quantity5)
            .build();
        let commission5 = calculate_commission(&ethusdt, order5.quantity(), price5, None);
        let fill5 = TestOrderEventStubs::filled(
            &order5,
            &ethusdt,
            Some(TradeId::new("5")),
            Some(PositionId::new("P-123456")),
            Some(price5),
            None,
            None,
            Some(commission5),
            None,
            None,
        );
        position.apply(&fill5.into());
        assert_eq!(position.quantity, Quantity::from("19"));
        assert_eq!(position.realized_pnl, Some(Money::from("36.16858966 USDT")));
        assert_eq!(position.avg_px_open, 99.980_036_297_640_65);
        assert_eq!(
            format!("{position}"),
            "Position(LONG 19.00000 ETHUSDT.BINANCE, id=P-123456)"
        );
    }

    #[rstest]
    fn test_position_closed_and_reopened(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let quantity1 = Quantity::from(150_000);
        let price1 = Price::from("1.00001");
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(quantity1)
            .build();
        let commission1 = calculate_commission(&audusd_sim, quantity1, price1, None);
        let fill1 = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            Some(TradeId::new("5")),
            Some(PositionId::new("P-123456")),
            Some(Price::from("1.00001")),
            None,
            None,
            Some(commission1),
            Some(UnixNanos::from(1_000_000_000)),
            None,
        );
        let mut position = Position::new(&audusd_sim, fill1.into());

        let fill2 = OrderFilledSpec::builder()
            .trader_id(order.trader_id())
            .strategy_id(order.strategy_id())
            .instrument_id(order.instrument_id())
            .client_order_id(order.client_order_id())
            .venue_order_id(VenueOrderId::from("2"))
            .account_id(order.account_id().unwrap_or(AccountId::new("SIM-001")))
            .trade_id(TradeId::from("2"))
            .order_side(OrderSide::Sell)
            .last_qty(order.quantity())
            .last_px(Price::from("1.00011"))
            .currency(audusd_sim.quote_currency())
            .ts_event(UnixNanos::from(2_000_000_000))
            .position_id(PositionId::from("P-123456"))
            .commission(Money::from("0 USD"))
            .build();

        position.apply(&fill2);

        let fill3 = OrderFilledSpec::builder()
            .trader_id(order.trader_id())
            .strategy_id(order.strategy_id())
            .instrument_id(order.instrument_id())
            .client_order_id(order.client_order_id())
            .venue_order_id(VenueOrderId::from("2"))
            .account_id(order.account_id().unwrap_or(AccountId::new("SIM-001")))
            .trade_id(TradeId::from("3"))
            .last_qty(order.quantity())
            .last_px(Price::from("1.00012"))
            .currency(audusd_sim.quote_currency())
            .ts_event(UnixNanos::from(3_000_000_000))
            .position_id(PositionId::from("P-123456"))
            .commission(Money::from("0 USD"))
            .build();

        position.apply(&fill3);

        let last = Price::from("1.0003");
        assert!(position.is_opposite_side(fill2.order_side));
        assert_eq!(position.quantity, Quantity::from(150_000));
        assert_eq!(position.peak_qty, Quantity::from(150_000));
        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.opening_order_id, fill3.client_order_id);
        assert_eq!(position.closing_order_id, None);
        assert_eq!(position.ts_opened, 3_000_000_000);
        assert_eq!(position.duration_ns, DurationNanos::default());
        assert_eq!(position.avg_px_open, 1.00012);
        assert_eq!(position.event_count(), 1);
        assert_eq!(position.ts_closed, None);
        assert_eq!(position.avg_px_close, None);
        assert!(position.is_long());
        assert!(!position.is_short());
        assert!(position.is_open());
        assert!(!position.is_closed());
        assert_eq!(position.realized_return, 0.0);
        assert_eq!(position.realized_pnl, Some(Money::from("0 USD")));
        assert_eq!(position.unrealized_pnl(last), Money::from("27 USD"));
        assert_eq!(position.total_pnl(last), Money::from("27 USD"));
        assert_eq!(position.commissions(), vec![Money::from("0 USD")]);
        assert_eq!(
            format!("{position}"),
            "Position(LONG 150_000 AUD/USD.SIM, id=P-123456)"
        );
    }

    #[rstest]
    #[case::zero(Quantity::from(0))]
    #[case::exceeds_fragments(Quantity::from(11))]
    fn test_apply_fill_void_rejects_invalid_allocation_without_mutation(
        #[case] voided_qty: Quantity,
        audusd_sim: CurrencyPair,
    ) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-VOID-INVALID");
        let fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-VOID-INVALID"))
            .trade_id(TradeId::from("T-VOID-INVALID"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .build();
        let fill_voided = matching_fill_void(&fill, voided_qty, None);
        let mut position = Position::new(&instrument, fill);
        let state_before = serde_json::to_value(&position).unwrap();

        let error = position
            .apply_fill_void(fill_voided, voided_qty, None)
            .unwrap_err();

        assert_eq!(
            error.to_string(),
            "position fill void exceeds known fragments for T-VOID-INVALID"
        );
        assert_eq!(serde_json::to_value(&position).unwrap(), state_before);
    }

    #[rstest]
    #[case::stale(
        Quantity::from(4),
        Money::from("0.40 USD"),
        "stale position fill void for T-VOID-CUMULATIVE"
    )]
    #[case::duplicate(
        Quantity::from(5),
        Money::from("0.50 USD"),
        "duplicate position fill void for T-VOID-CUMULATIVE"
    )]
    fn test_apply_fill_void_rejects_invalid_cumulative_update_without_mutation(
        #[case] voided_qty: Quantity,
        #[case] commission_voided: Money,
        #[case] expected_error: &str,
        audusd_sim: CurrencyPair,
    ) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-VOID-CUMULATIVE");
        let fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-VOID-CUMULATIVE"))
            .trade_id(TradeId::from("T-VOID-CUMULATIVE"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .commission(Money::from("1.00 USD"))
            .build();
        let fill_voided =
            matching_fill_void(&fill, Quantity::from(5), Some(Money::from("0.50 USD")));
        let mut position = Position::new(&instrument, fill);
        position
            .apply_fill_void(
                fill_voided.clone(),
                Quantity::from(5),
                Some(Money::from("0.50 USD")),
            )
            .unwrap();
        let state_before = serde_json::to_value(&position).unwrap();

        let error = position
            .apply_fill_void(fill_voided, voided_qty, Some(commission_voided))
            .unwrap_err();

        assert_eq!(error.to_string(), expected_error);
        assert_eq!(serde_json::to_value(&position).unwrap(), state_before);
    }

    #[rstest]
    fn test_apply_fill_void_rejects_currency_mismatch_without_mutation(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-VOID-CURRENCY"))
            .trade_id(TradeId::from("T-VOID-CURRENCY"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(PositionId::from("P-VOID-CURRENCY"))
            .commission(Money::from("1.00 USD"))
            .build();
        let commission_voided = Some(Money::from("0.50 EUR"));
        let voided_qty = Quantity::from(5);
        let fill_voided = matching_fill_void(&fill, voided_qty, commission_voided);

        let mut position = Position::new(&instrument, fill);
        let before = serde_json::to_value(&position).unwrap();
        let error = position
            .apply_fill_void(fill_voided, voided_qty, commission_voided)
            .unwrap_err();
        assert_eq!(
            error.to_string(),
            "position commission currency differs for fill T-VOID-CURRENCY"
        );
        assert_eq!(serde_json::to_value(&position).unwrap(), before);
    }

    #[rstest]
    fn test_apply_fill_void_uses_latest_cumulative_commission(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-VOID-LATEST");
        let fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-VOID-LATEST"))
            .trade_id(TradeId::from("T-VOID-LATEST"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .commission(Money::from("1.00 USD"))
            .build();
        let fill_voided =
            matching_fill_void(&fill, Quantity::from(4), Some(Money::from("0.40 USD")));
        let mut position = Position::new(&instrument, fill);
        position
            .apply_fill_void(
                fill_voided.clone(),
                Quantity::from(4),
                Some(Money::from("0.40 USD")),
            )
            .unwrap();

        position
            .apply_fill_void(fill_voided, Quantity::from(7), None)
            .unwrap();

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(3));
        assert_eq!(position.commissions(), vec![Money::from("1.00 USD")]);
        assert_eq!(position.realized_pnl, Some(Money::from("-1.00 USD")));
        assert_eq!(position.fill_voids.len(), 2);
    }

    #[rstest]
    fn test_fill_void_replays_across_position_close_and_reopen(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-VOID-REPLAY");
        let fill1 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-OPEN"))
            .trade_id(TradeId::from("T-OPEN"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .commission(Money::from("1.00 USD"))
            .ts_event(UnixNanos::from(1))
            .build();
        let fill2 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-CLOSE"))
            .trade_id(TradeId::from("T-CLOSE"))
            .order_side(OrderSide::Sell)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.10000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .commission(Money::from("1.00 USD"))
            .ts_event(UnixNanos::from(2))
            .build();
        let fill3 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-REOPEN"))
            .trade_id(TradeId::from("T-REOPEN"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(5))
            .last_px(Price::from("1.20000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .commission(Money::from("1.00 USD"))
            .ts_event(UnixNanos::from(3))
            .build();
        let fill_voided =
            matching_fill_void(&fill2, Quantity::from(5), Some(Money::from("0.50 USD")));
        let mut position = Position::new(&instrument, fill1);
        position.apply(&fill2);
        position.apply(&fill3);

        position
            .apply_fill_void(
                fill_voided,
                Quantity::from(5),
                Some(Money::from("0.50 USD")),
            )
            .unwrap();
        let encoded = serde_json::to_string(&position).unwrap();
        let restored: Position = serde_json::from_str(&encoded).unwrap();

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(10));
        assert_eq!(position.opening_order_id, ClientOrderId::from("O-OPEN"));
        assert_eq!(position.buy_qty, Quantity::from(15));
        assert_eq!(position.sell_qty, Quantity::from(5));
        assert_eq!(position.commissions(), vec![Money::from("2.50 USD")]);
        assert_eq!(position.replay_events.len(), 3);
        assert_eq!(position.fill_voids.len(), 1);
        assert_eq!(restored.quantity, position.quantity);
        assert_eq!(restored.opening_order_id, position.opening_order_id);
        assert_eq!(restored.commissions(), position.commissions());
        assert_eq!(restored.replay_events.len(), position.replay_events.len());
        assert_eq!(restored.fill_voids.len(), position.fill_voids.len());
    }

    #[rstest]
    fn test_fill_void_replays_manual_adjustment(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-VOID-ADJUSTMENT");
        let fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-VOID-ADJUSTMENT"))
            .trade_id(TradeId::from("T-VOID-ADJUSTMENT"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill_voided = matching_fill_void(&fill, Quantity::from(2), None);
        let adjustment = PositionAdjusted::new(
            fill.trader_id,
            fill.strategy_id,
            fill.instrument_id,
            position_id,
            fill.account_id,
            PositionAdjustmentType::Funding,
            None,
            Some(Money::from("5.00 USD")),
            Some("funding".into()),
            uuid4(),
            UnixNanos::from(2),
            UnixNanos::from(2),
        );
        let mut position = Position::new(&instrument, fill);
        position.apply_adjustment(adjustment);

        position
            .apply_fill_void(fill_voided, Quantity::from(2), None)
            .unwrap();

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(8));
        assert_eq!(position.realized_pnl, Some(Money::from("5.00 USD")));
        assert_eq!(position.adjustments, vec![adjustment]);
        assert_eq!(position.replay_events.len(), 2);
        assert_eq!(position.fill_voids.len(), 1);
        assert_eq!(position.ts_last, UnixNanos::from(2));
    }

    #[rstest]
    fn test_fill_void_returns_all_closed_cycle_pnl(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-VOID-CYCLES");
        let fill = |client_order_id: &str,
                    trade_id: &str,
                    order_side: OrderSide,
                    quantity: u32,
                    price: &str,
                    ts_event: u64| {
            OrderFilledSpec::builder()
                .instrument_id(instrument.id())
                .client_order_id(ClientOrderId::from(client_order_id))
                .trade_id(TradeId::from(trade_id))
                .order_side(order_side)
                .last_qty(Quantity::from(quantity))
                .last_px(Price::from(price))
                .currency(Currency::USD())
                .position_id(position_id)
                .ts_event(UnixNanos::from(ts_event))
                .build()
        };
        let fills = [
            fill("O-OPEN-1", "T-OPEN-1", OrderSide::Buy, 10, "1.0", 1),
            fill("O-CLOSE-1", "T-CLOSE-1", OrderSide::Sell, 10, "2.0", 2),
            fill("O-OPEN-2", "T-OPEN-2", OrderSide::Buy, 10, "3.0", 3),
            fill("O-CLOSE-2", "T-CLOSE-2", OrderSide::Sell, 10, "5.0", 4),
            fill("O-CURRENT", "T-CURRENT", OrderSide::Buy, 5, "6.0", 5),
        ];
        let current = fills.last().unwrap();
        let fill_voided = matching_fill_void(current, Quantity::from(1), None);
        let mut position = Position::new(&instrument, fills[0].clone());
        for fill in &fills[1..] {
            position.apply(fill);
        }

        let closed_cycles_pnl = position
            .apply_fill_void(fill_voided, Quantity::from(1), None)
            .unwrap();

        assert_eq!(closed_cycles_pnl, Some(Money::from("30.00 USD")));
        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(4));
        assert_eq!(position.avg_px_open, 6.0);
        assert_eq!(position.realized_pnl, Some(Money::from("0.00 USD")));
        assert_eq!(position.events.len(), 1);
        assert_eq!(position.replay_events.len(), 5);
        assert_eq!(position.fill_voids.len(), 1);
    }

    #[rstest]
    fn test_full_fill_void_preserves_unvoided_commission(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-FEE-VOID");
        let fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-FEE"))
            .trade_id(TradeId::from("T-FEE"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .commission(Money::from("1.00 USD"))
            .build();
        let fill_voided = OrderFillVoidedSpec::builder()
            .instrument_id(fill.instrument_id)
            .client_order_id(fill.client_order_id)
            .venue_order_id(fill.venue_order_id)
            .account_id(fill.account_id)
            .trade_id(fill.trade_id)
            .voided_qty(fill.last_qty)
            .order_side(fill.order_side)
            .order_type(fill.order_type)
            .last_px(fill.last_px)
            .currency(fill.currency)
            .liquidity_side(fill.liquidity_side)
            .build();
        let mut position = Position::new(&instrument, fill);

        position
            .apply_fill_void(fill_voided, Quantity::from(10), None)
            .unwrap();

        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.quantity, Quantity::from(0));
        assert_eq!(position.commissions(), vec![Money::from("1.00 USD")]);
        assert_eq!(position.realized_pnl, Some(Money::from("-1.00 USD")));
        assert!(position.events.is_empty());
    }

    #[rstest]
    fn test_full_fill_void_preserves_unvoided_base_commission() {
        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
        let position_id = PositionId::from("P-BASE-FEE-VOID");
        let fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-BASE-FEE"))
            .trade_id(TradeId::from("T-BASE-FEE"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from("1.000000"))
            .last_px(Price::from("50000.00"))
            .currency(Currency::USDT())
            .position_id(position_id)
            .commission(Money::from("0.00100000 BTC"))
            .ts_event(UnixNanos::from(2_000))
            .ts_init(UnixNanos::from(1_900))
            .build();
        let fill_voided = matching_fill_void(&fill, fill.last_qty, None);
        let mut position = Position::new(&instrument, fill);

        let closed_cycles_pnl = position
            .apply_fill_void(fill_voided, Quantity::from("1.000000"), None)
            .unwrap();

        assert_eq!(closed_cycles_pnl, None);
        assert_eq!(position.entry, OrderSide::Sell);
        assert_eq!(position.side, PositionSide::Short);
        assert_eq!(position.signed_decimal_qty(), dec!(-0.001));
        assert_eq!(position.quantity.as_decimal(), dec!(0.001));
        assert_eq!(position.buy_qty.as_decimal(), Decimal::ZERO);
        assert_eq!(position.sell_qty.as_decimal(), Decimal::ZERO);
        assert_eq!(position.commissions(), vec![Money::from("0.00100000 BTC")]);
        assert_eq!(position.adjustments.len(), 1);
        assert_eq!(
            position.adjustments[0].adjustment_type,
            PositionAdjustmentType::Commission
        );
        assert_eq!(position.adjustments[0].quantity_change, Some(dec!(-0.001)));
        assert_eq!(position.opening_order_id, ClientOrderId::from("O-BASE-FEE"));
        assert_eq!(position.closing_order_id, None);
        assert_eq!(position.ts_init, UnixNanos::from(1_900));
        assert_eq!(position.ts_opened, UnixNanos::from(2_000));
        assert_eq!(position.ts_last, UnixNanos::from(2_000));
        assert_eq!(position.ts_closed, None);
        assert_eq!(position.duration_ns, DurationNanos::default());
        assert_eq!(position.avg_px_open, 50_000.0);
        assert_eq!(position.avg_px_close, None);
        assert_eq!(position.realized_pnl, None);
        assert!(position.events.is_empty());
        assert!(position.is_open());
        assert!(!position.is_closed());
    }

    #[rstest]
    fn test_surviving_base_commission_can_close_position() {
        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
        let position_id = PositionId::from("P-BASE-FEE-CLOSE");
        let opening = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-BASE-OPEN"))
            .trade_id(TradeId::from("T-BASE-OPEN"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from("0.001000"))
            .last_px(Price::from("50000.00"))
            .currency(Currency::USDT())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1_000))
            .ts_init(UnixNanos::from(900))
            .build();
        let fee_fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-BASE-FEE"))
            .trade_id(TradeId::from("T-BASE-FEE"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from("1.000000"))
            .last_px(Price::from("51000.00"))
            .currency(Currency::USDT())
            .position_id(position_id)
            .commission(Money::from("0.00100000 BTC"))
            .ts_event(UnixNanos::from(2_000))
            .ts_init(UnixNanos::from(1_900))
            .build();
        let fill_voided = matching_fill_void(&fee_fill, fee_fill.last_qty, None);
        let mut position = Position::new(&instrument, opening);
        position.apply(&fee_fill);

        let closed_cycles_pnl = position
            .apply_fill_void(fill_voided, Quantity::from("1.000000"), None)
            .unwrap();

        assert_eq!(closed_cycles_pnl, None);
        assert_eq!(position.entry, OrderSide::Buy);
        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.signed_decimal_qty(), Decimal::ZERO);
        assert_eq!(position.quantity.as_decimal(), Decimal::ZERO);
        assert_eq!(position.buy_qty.as_decimal(), dec!(0.001));
        assert_eq!(position.sell_qty.as_decimal(), Decimal::ZERO);
        assert_eq!(position.commissions(), vec![Money::from("0.00100000 BTC")]);
        assert_eq!(position.events.len(), 1);
        assert_eq!(position.adjustments.len(), 1);
        assert_eq!(
            position.opening_order_id,
            ClientOrderId::from("O-BASE-OPEN")
        );
        assert_eq!(
            position.closing_order_id,
            Some(ClientOrderId::from("O-BASE-FEE"))
        );
        assert_eq!(position.ts_init, UnixNanos::from(900));
        assert_eq!(position.ts_opened, UnixNanos::from(1_000));
        assert_eq!(position.ts_last, UnixNanos::from(2_000));
        assert_eq!(position.ts_closed, Some(UnixNanos::from(2_000)));
        assert_eq!(position.duration_ns, DurationNanos::new(1_000));
        assert_eq!(position.avg_px_open, 50_000.0);
        assert_eq!(position.avg_px_close, None);
        assert_eq!(position.realized_pnl, Some(Money::from("0.00 USDT")));
        assert!(!position.is_open());
        assert!(position.is_closed());
    }

    #[rstest]
    fn test_surviving_base_commission_reopen_returns_previous_cycle_pnl() {
        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
        let position_id = PositionId::from("P-BASE-FEE-REOPEN");
        let opening = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-OPEN"))
            .trade_id(TradeId::from("T-OPEN"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from("1.000000"))
            .last_px(Price::from("50000.00"))
            .currency(Currency::USDT())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1_000))
            .build();
        let closing = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-CLOSE"))
            .trade_id(TradeId::from("T-CLOSE"))
            .order_side(OrderSide::Sell)
            .last_qty(Quantity::from("1.000000"))
            .last_px(Price::from("51000.00"))
            .currency(Currency::USDT())
            .position_id(position_id)
            .ts_event(UnixNanos::from(2_000))
            .build();
        let reopening = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-REOPEN"))
            .trade_id(TradeId::from("T-REOPEN"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from("1.000000"))
            .last_px(Price::from("52000.00"))
            .currency(Currency::USDT())
            .position_id(position_id)
            .commission(Money::from("0.00100000 BTC"))
            .ts_event(UnixNanos::from(3_000))
            .ts_init(UnixNanos::from(2_900))
            .build();
        let fill_voided = matching_fill_void(&reopening, reopening.last_qty, None);
        let mut position = Position::new(&instrument, opening);
        position.apply(&closing);
        position.apply(&reopening);

        let closed_cycles_pnl = position
            .apply_fill_void(fill_voided, Quantity::from("1.000000"), None)
            .unwrap();

        assert_eq!(closed_cycles_pnl, Some(Money::from("1000.00 USDT")));
        assert_eq!(position.entry, OrderSide::Sell);
        assert_eq!(position.side, PositionSide::Short);
        assert_eq!(position.signed_decimal_qty(), dec!(-0.001));
        assert_eq!(position.quantity.as_decimal(), dec!(0.001));
        assert_eq!(position.buy_qty.as_decimal(), Decimal::ZERO);
        assert_eq!(position.sell_qty.as_decimal(), Decimal::ZERO);
        assert_eq!(position.commissions(), vec![Money::from("0.00100000 BTC")]);
        assert!(position.events.is_empty());
        assert_eq!(position.adjustments.len(), 1);
        assert_eq!(position.opening_order_id, ClientOrderId::from("O-REOPEN"));
        assert_eq!(position.closing_order_id, None);
        assert_eq!(position.ts_init, UnixNanos::from(2_900));
        assert_eq!(position.ts_opened, UnixNanos::from(3_000));
        assert_eq!(position.ts_last, UnixNanos::from(3_000));
        assert_eq!(position.ts_closed, None);
        assert_eq!(position.duration_ns, DurationNanos::default());
        assert_eq!(position.avg_px_open, 52_000.0);
        assert_eq!(position.avg_px_close, None);
        assert_eq!(position.realized_pnl, None);
        assert!(position.is_open());
        assert!(!position.is_closed());
    }

    #[rstest]
    fn test_surviving_base_commission_can_flip_position() {
        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
        let position_id = PositionId::from("P-BASE-FEE-FLIP");
        let opening = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-BASE-OPEN"))
            .trade_id(TradeId::from("T-BASE-OPEN"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from("0.000500"))
            .last_px(Price::from("50000.00"))
            .currency(Currency::USDT())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1_000))
            .ts_init(UnixNanos::from(900))
            .build();
        let fee_fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-BASE-FEE"))
            .trade_id(TradeId::from("T-BASE-FEE"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from("1.000000"))
            .last_px(Price::from("52000.00"))
            .currency(Currency::USDT())
            .position_id(position_id)
            .commission(Money::from("0.00100000 BTC"))
            .ts_event(UnixNanos::from(2_000))
            .ts_init(UnixNanos::from(1_900))
            .build();
        let fill_voided = matching_fill_void(&fee_fill, fee_fill.last_qty, None);
        let mut position = Position::new(&instrument, opening);
        position.apply(&fee_fill);

        let closed_cycles_pnl = position
            .apply_fill_void(fill_voided, Quantity::from("1.000000"), None)
            .unwrap();

        assert_eq!(closed_cycles_pnl, None);
        assert_eq!(position.entry, OrderSide::Sell);
        assert_eq!(position.side, PositionSide::Short);
        assert_eq!(position.signed_decimal_qty(), dec!(-0.0005));
        assert_eq!(position.quantity.as_decimal(), dec!(0.0005));
        assert_eq!(position.buy_qty.as_decimal(), dec!(0.0005));
        assert_eq!(position.sell_qty.as_decimal(), Decimal::ZERO);
        assert_eq!(position.commissions(), vec![Money::from("0.00100000 BTC")]);
        assert_eq!(position.events.len(), 1);
        assert_eq!(position.adjustments.len(), 1);
        assert_eq!(
            position.opening_order_id,
            ClientOrderId::from("O-BASE-OPEN")
        );
        assert_eq!(position.closing_order_id, None);
        assert_eq!(position.ts_init, UnixNanos::from(900));
        assert_eq!(position.ts_opened, UnixNanos::from(1_000));
        assert_eq!(position.ts_last, UnixNanos::from(2_000));
        assert_eq!(position.ts_closed, None);
        assert_eq!(position.duration_ns, DurationNanos::default());
        assert_eq!(position.avg_px_open, 52_000.0);
        assert_eq!(position.avg_px_close, None);
        assert_eq!(position.realized_pnl, Some(Money::from("0.00 USDT")));
        assert!(position.is_open());
        assert!(!position.is_closed());
    }

    #[rstest]
    fn test_fill_void_replays_netting_flip_fragments_with_one_trade_id(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-FLIP-VOID");
        let opening = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-OPEN"))
            .trade_id(TradeId::from("T-OPEN"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .build();
        let closing = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-FLIP"))
            .trade_id(TradeId::from("T-FLIP"))
            .order_side(OrderSide::Sell)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.10000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .build();
        let mut reopening = closing.clone();
        reopening.last_qty = Quantity::from(5);
        reopening.event_id = uuid4();
        reopening.causation_id = Some(closing.event_id);
        let fill_voided = matching_fill_void(&closing, Quantity::from(12), None);
        let mut position = Position::new(&instrument, opening);
        position.apply(&closing);
        assert!(!position.is_duplicate_replay_fill(&reopening));
        position.apply(&reopening);

        position
            .apply_fill_void(fill_voided, Quantity::from(12), None)
            .unwrap();

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(7));
        assert_eq!(position.buy_qty, Quantity::from(10));
        assert_eq!(position.sell_qty, Quantity::from(3));
        assert_eq!(position.replay_events.len(), 3);
        assert!(position.is_duplicate_replay_fill(&reopening));
    }

    #[rstest]
    fn test_fill_void_replays_split_fragments_in_one_corrected_cycle(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-FLIP-CYCLE-VOID");
        let opening = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-SELL-1"))
            .trade_id(TradeId::from("T-SELL-1"))
            .order_side(OrderSide::Sell)
            .last_qty(Quantity::from(17))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .build();
        let second_sell = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-SELL-2"))
            .trade_id(TradeId::from("T-SELL-2"))
            .order_side(OrderSide::Sell)
            .last_qty(Quantity::from(17))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .build();
        let closing = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-FLIP"))
            .trade_id(TradeId::from("T-FLIP"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(34))
            .last_px(Price::from("1.10000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .build();
        let mut reopening = closing.clone();
        reopening.last_qty = Quantity::from(591);
        reopening.event_id = uuid4();
        reopening.causation_id = Some(closing.event_id);
        let fill_voided = matching_fill_void(&second_sell, Quantity::from(2), None);
        let mut position = Position::new(&instrument, opening);
        position.apply(&second_sell);
        position.apply(&closing);
        position.apply(&reopening);

        position
            .apply_fill_void(fill_voided, Quantity::from(2), None)
            .unwrap();

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(593));
        // The reversal starts a new episode with only the opening residual
        assert_eq!(position.buy_qty, Quantity::from(593));
        assert_eq!(position.sell_qty, Quantity::from(0));
        assert_eq!(position.events.len(), 4);
        assert_eq!(position.replay_events.len(), 4);
        assert_eq!(position.fill_voids.len(), 1);
        assert_eq!(position.trade_ids.len(), 3);
        assert!(position.trade_ids.contains(&TradeId::from("T-FLIP")));
    }

    #[rstest]
    fn test_fill_void_replays_partially_voided_reversal(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-REVERSAL-PARTIAL-VOID");
        let opening = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-OPEN"))
            .trade_id(TradeId::from("T-OPEN"))
            .order_side(OrderSide::Sell)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .build();
        let partial_close = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-CLOSE"))
            .trade_id(TradeId::from("T-CLOSE"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(4))
            .last_px(Price::from("0.90000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .build();
        let reversal = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-REVERSE"))
            .trade_id(TradeId::from("T-REVERSE"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(11))
            .last_px(Price::from("1.10000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .build();
        let fill_voided = matching_fill_void(&reversal, Quantity::from(2), None);
        let mut position = Position::new(&instrument, opening);
        position.apply(&partial_close);
        position.apply(&reversal);

        position
            .apply_fill_void(fill_voided, Quantity::from(2), None)
            .unwrap();

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.quantity, Quantity::from(3));
        assert_eq!(position.avg_px_open, 1.1);
        assert_eq!(position.avg_px_close, None);
        assert_eq!(position.realized_return, 0.0);
        assert_eq!(position.buy_qty, Quantity::from(3));
        assert_eq!(position.sell_qty, Quantity::from(0));
        assert_eq!(position.realized_pnl, Some(Money::from("-0.20 USD")));
        assert_eq!(position.fill_voids.len(), 1);
    }

    #[rstest]
    fn test_position_realized_pnl_with_interleaved_order_sides(
        currency_pair_btcusdt: CurrencyPair,
    ) {
        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(12))
            .build();
        let commission1 =
            calculate_commission(&btcusdt, order1.quantity(), Price::from("10000.0"), None);
        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &btcusdt,
            Some(TradeId::from("1")),
            Some(PositionId::from("P-19700101-000000-001-001-1")),
            Some(Price::from("10000.0")),
            None,
            None,
            Some(commission1),
            None,
            None,
        );
        let mut position = Position::new(&btcusdt, fill1.into());
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(17))
            .build();
        let commission2 =
            calculate_commission(&btcusdt, order2.quantity(), Price::from("9999.0"), None);
        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &btcusdt,
            Some(TradeId::from("2")),
            Some(PositionId::from("P-19700101-000000-001-001-1")),
            Some(Price::from("9999.0")),
            None,
            None,
            Some(commission2),
            None,
            None,
        );
        position.apply(&fill2.into());
        assert_eq!(position.quantity, Quantity::from(29));
        assert_eq!(
            position.realized_pnl,
            Some(Money::from("-289.98300000 USDT"))
        );
        assert_eq!(position.avg_px_open, 9_999.413_793_103_447);
        let order3 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(9))
            .build();
        let commission3 =
            calculate_commission(&btcusdt, order3.quantity(), Price::from("10001.0"), None);
        let fill3 = TestOrderEventStubs::filled(
            &order3,
            &btcusdt,
            Some(TradeId::from("3")),
            Some(PositionId::from("P-19700101-000000-001-001-1")),
            Some(Price::from("10001.0")),
            None,
            None,
            Some(commission3),
            None,
            None,
        );
        position.apply(&fill3.into());
        assert_eq!(position.quantity, Quantity::from(20));
        assert_eq!(
            position.realized_pnl,
            Some(Money::from("-365.71613793 USDT"))
        );
        assert_eq!(position.avg_px_open, 9_999.413_793_103_447);
        let order4 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(3))
            .build();
        let commission4 =
            calculate_commission(&btcusdt, order4.quantity(), Price::from("10003.0"), None);
        let fill4 = TestOrderEventStubs::filled(
            &order4,
            &btcusdt,
            Some(TradeId::from("4")),
            Some(PositionId::from("P-19700101-000000-001-001-1")),
            Some(Price::from("10003.0")),
            None,
            None,
            Some(commission4),
            None,
            None,
        );
        position.apply(&fill4.into());
        assert_eq!(position.quantity, Quantity::from(23));
        assert_eq!(
            position.realized_pnl,
            Some(Money::from("-395.72513793 USDT"))
        );
        assert_eq!(position.avg_px_open, 9_999.881_559_220_39);
        let order5 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(4))
            .build();
        let commission5 =
            calculate_commission(&btcusdt, order5.quantity(), Price::from("10005.0"), None);
        let fill5 = TestOrderEventStubs::filled(
            &order5,
            &btcusdt,
            Some(TradeId::from("5")),
            Some(PositionId::from("P-19700101-000000-001-001-1")),
            Some(Price::from("10005.0")),
            None,
            None,
            Some(commission5),
            None,
            None,
        );
        position.apply(&fill5.into());
        assert_eq!(position.quantity, Quantity::from(19));
        assert_eq!(
            position.realized_pnl,
            Some(Money::from("-415.27137481 USDT"))
        );
        assert_eq!(position.avg_px_open, 9_999.881_559_220_39);
        assert_eq!(
            format!("{position}"),
            "Position(LONG 19.000000 BTCUSDT.BINANCE, id=P-19700101-000000-001-001-1)"
        );
    }

    #[rstest]
    fn test_calculate_pnl_when_given_position_side_flat_returns_zero(
        currency_pair_btcusdt: CurrencyPair,
    ) {
        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(12))
            .build();
        let fill = TestOrderEventStubs::filled(
            &order,
            &btcusdt,
            None,
            Some(PositionId::from("P-123456")),
            Some(Price::from("10500.0")),
            None,
            None,
            None,
            None,
            None,
        );
        let position = Position::new(&btcusdt, fill.into());
        let result = position.calculate_pnl(10500.0, 10500.0, Quantity::from("100000.0"));
        assert_eq!(result, Money::from("0 USDT"));
    }

    #[rstest]
    fn test_calculate_pnl_for_long_position_win(currency_pair_btcusdt: CurrencyPair) {
        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(12))
            .build();
        let commission =
            calculate_commission(&btcusdt, order.quantity(), Price::from("10500.0"), None);
        let fill = TestOrderEventStubs::filled(
            &order,
            &btcusdt,
            None,
            Some(PositionId::from("P-123456")),
            Some(Price::from("10500.0")),
            None,
            None,
            Some(commission),
            None,
            None,
        );
        let position = Position::new(&btcusdt, fill.into());
        let pnl = position.calculate_pnl(10500.0, 10510.0, Quantity::from("12.0"));
        assert_eq!(pnl, Money::from("120 USDT"));
        assert_eq!(position.realized_pnl, Some(Money::from("-126 USDT")));
        assert_eq!(
            position.unrealized_pnl(Price::from("10510.0")),
            Money::from("120.0 USDT")
        );
        assert_eq!(
            position.total_pnl(Price::from("10510.0")),
            Money::from("-6 USDT")
        );
        assert_eq!(position.commissions(), vec![Money::from("126.0 USDT")]);
    }

    #[rstest]
    fn test_calculate_pnl_for_long_position_loss(currency_pair_btcusdt: CurrencyPair) {
        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(12))
            .build();
        let commission =
            calculate_commission(&btcusdt, order.quantity(), Price::from("10500.0"), None);
        let fill = TestOrderEventStubs::filled(
            &order,
            &btcusdt,
            None,
            Some(PositionId::from("P-123456")),
            Some(Price::from("10500.0")),
            None,
            None,
            Some(commission),
            None,
            None,
        );
        let position = Position::new(&btcusdt, fill.into());
        let pnl = position.calculate_pnl(10500.0, 10480.5, Quantity::from("10.0"));
        assert_eq!(pnl, Money::from("-195 USDT"));
        assert_eq!(position.realized_pnl, Some(Money::from("-126 USDT")));
        assert_eq!(
            position.unrealized_pnl(Price::from("10480.50")),
            Money::from("-234.0 USDT")
        );
        assert_eq!(
            position.total_pnl(Price::from("10480.50")),
            Money::from("-360 USDT")
        );
        assert_eq!(position.commissions(), vec![Money::from("126.0 USDT")]);
    }

    #[rstest]
    fn test_calculate_pnl_for_short_position_winning(currency_pair_btcusdt: CurrencyPair) {
        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("10.15"))
            .build();
        let commission =
            calculate_commission(&btcusdt, order.quantity(), Price::from("10500.0"), None);
        let fill = TestOrderEventStubs::filled(
            &order,
            &btcusdt,
            None,
            Some(PositionId::from("P-123456")),
            Some(Price::from("10500.0")),
            None,
            None,
            Some(commission),
            None,
            None,
        );
        let position = Position::new(&btcusdt, fill.into());
        let pnl = position.calculate_pnl(10500.0, 10390.0, Quantity::from("10.15"));
        assert_eq!(pnl, Money::from("1116.5 USDT"));
        assert_eq!(
            position.unrealized_pnl(Price::from("10390.0")),
            Money::from("1116.5 USDT")
        );
        assert_eq!(position.realized_pnl, Some(Money::from("-106.575 USDT")));
        assert_eq!(position.commissions(), vec![Money::from("106.575 USDT")]);
        assert_eq!(
            position.notional_value(Price::from("10390.0")),
            Money::from("105458.5 USDT")
        );
    }

    #[rstest]
    fn test_calculate_pnl_for_short_position_loss(currency_pair_btcusdt: CurrencyPair) {
        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("10.0"))
            .build();
        let commission =
            calculate_commission(&btcusdt, order.quantity(), Price::from("10500.0"), None);
        let fill = TestOrderEventStubs::filled(
            &order,
            &btcusdt,
            None,
            Some(PositionId::from("P-123456")),
            Some(Price::from("10500.0")),
            None,
            None,
            Some(commission),
            None,
            None,
        );
        let position = Position::new(&btcusdt, fill.into());
        let pnl = position.calculate_pnl(10500.0, 10670.5, Quantity::from("10.0"));
        assert_eq!(pnl, Money::from("-1705 USDT"));
        assert_eq!(
            position.unrealized_pnl(Price::from("10670.5")),
            Money::from("-1705 USDT")
        );
        assert_eq!(position.realized_pnl, Some(Money::from("-105 USDT")));
        assert_eq!(position.commissions(), vec![Money::from("105 USDT")]);
        assert_eq!(
            position.notional_value(Price::from("10670.5")),
            Money::from("106705 USDT")
        );
    }

    #[rstest]
    fn test_calculate_pnl_for_inverse1(xbtusd_bitmex: CryptoPerpetual) {
        let xbtusd_bitmex = InstrumentAny::CryptoPerpetual(xbtusd_bitmex);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(xbtusd_bitmex.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("100000"))
            .build();
        let commission = calculate_commission(
            &xbtusd_bitmex,
            order.quantity(),
            Price::from("10000.0"),
            None,
        );
        let fill = TestOrderEventStubs::filled(
            &order,
            &xbtusd_bitmex,
            None,
            Some(PositionId::from("P-123456")),
            Some(Price::from("10000.0")),
            None,
            None,
            Some(commission),
            None,
            None,
        );
        let position = Position::new(&xbtusd_bitmex, fill.into());
        let pnl = position.calculate_pnl(10000.0, 11000.0, Quantity::from("100000.0"));
        assert_eq!(pnl, Money::from("-0.90909091 BTC"));
        assert_eq!(
            position.unrealized_pnl(Price::from("11000.0")),
            Money::from("-0.90909091 BTC")
        );
        assert_eq!(position.realized_pnl, Some(Money::from("-0.00750000 BTC")));
        assert_eq!(
            position.notional_value(Price::from("11000.0")),
            Money::from("9.09090909 BTC")
        );
    }

    #[rstest]
    fn test_calculate_pnl_scales_by_contract_multiplier(
        mut xbtusd_bitmex: CryptoPerpetual,
        mut crypto_perpetual_ethusdt: CryptoPerpetual,
    ) {
        xbtusd_bitmex.multiplier = Quantity::from(10);
        let xbtusd_bitmex = InstrumentAny::CryptoPerpetual(xbtusd_bitmex);
        let inverse_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(xbtusd_bitmex.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("100000"))
            .build();
        let inverse_fill = TestOrderEventStubs::filled(
            &inverse_order,
            &xbtusd_bitmex,
            None,
            Some(PositionId::from("P-MULTIPLIER-INVERSE")),
            Some(Price::from("10000.0")),
            None,
            None,
            None,
            None,
            None,
        );
        let inverse_position = Position::new(&xbtusd_bitmex, inverse_fill.into());

        assert_eq!(
            inverse_position.calculate_pnl(10000.0, 11000.0, Quantity::from("100000.0")),
            Money::from("-9.09090909 BTC")
        );

        crypto_perpetual_ethusdt.multiplier = Quantity::from(10);
        let ethusdt = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt);
        let linear_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(ethusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("2.000"))
            .build();
        let linear_fill = TestOrderEventStubs::filled(
            &linear_order,
            &ethusdt,
            None,
            Some(PositionId::from("P-MULTIPLIER-LINEAR")),
            Some(Price::from("1000.00")),
            None,
            None,
            None,
            None,
            None,
        );
        let linear_position = Position::new(&ethusdt, linear_fill.into());

        assert_eq!(
            linear_position.calculate_pnl(1000.0, 1100.0, Quantity::from("2.000")),
            Money::new(2000.0, linear_position.settlement_currency)
        );
    }

    #[rstest]
    fn test_try_notional_value_for_inverse_zero_price_returns_error(
        xbtusd_bitmex: CryptoPerpetual,
    ) {
        let xbtusd_bitmex = InstrumentAny::CryptoPerpetual(xbtusd_bitmex);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(xbtusd_bitmex.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("100000"))
            .build();
        let fill = TestOrderEventStubs::filled(
            &order,
            &xbtusd_bitmex,
            None,
            Some(PositionId::from("P-ZERO-PRICE")),
            Some(Price::from("10000.0")),
            None,
            None,
            None,
            None,
            None,
        );
        let mut position = Position::new(&xbtusd_bitmex, fill.into());

        let result = position.try_notional_value(Price::new(0.0, 1));

        assert_eq!(
            result.unwrap_err().to_string(),
            "price must be positive for inverse notional valuation"
        );
        assert!(
            position
                .try_calculate_pnl(10_000.0, 0.0, position.quantity)
                .is_err()
        );
        assert!(position.try_unrealized_pnl(Price::new(0.0, 1)).is_err());
        assert!(position.try_total_pnl(Price::new(0.0, 1)).is_err());
        assert!(position.try_unrealized_pnl(Price::new(-1.0, 1)).is_err());
        assert_eq!(
            position.calculate_pnl(10_000.0, 0.0, position.quantity),
            Money::zero(position.settlement_currency)
        );
        assert_eq!(
            position.unrealized_pnl(Price::new(0.0, 1)),
            Money::zero(position.settlement_currency)
        );
        assert_eq!(
            position.total_pnl(Price::new(0.0, 1)),
            Money::zero(position.settlement_currency)
        );

        position.base_currency = None;
        let result = position.try_notional_value(Price::from("10000.0"));

        assert_eq!(
            result.unwrap_err().to_string(),
            "inverse position BTCUSDT.BITMEX has no base currency"
        );
        assert!(position.try_unrealized_pnl(Price::from("10000.0")).is_err());
    }

    #[rstest]
    fn test_calculate_avg_px_zero_quantity_paths(stub_position_long: Position) {
        assert_eq!(
            stub_position_long
                .calculate_avg_px(0.0, 1.0, 2.0, 5.0)
                .unwrap(),
            2.0
        );
        assert_eq!(
            stub_position_long
                .calculate_avg_px(0.0, 1.0, 2.0, 0.0)
                .unwrap_err()
                .to_string(),
            "Cannot calculate average price: both quantities are zero"
        );
        assert_eq!(
            stub_position_long
                .calculate_avg_px(5.0, 1.0, 2.0, 0.0)
                .unwrap_err()
                .to_string(),
            "Cannot calculate average price: fill quantity is zero"
        );
    }

    #[rstest]
    fn test_calculate_return_rejects_zero_open_price(stub_position_long: Position) {
        assert_eq!(
            stub_position_long
                .calculate_return(0.0, 1.5)
                .unwrap_err()
                .to_string(),
            "Cannot calculate return: open price is zero (close price: 1.5)"
        );
        assert_eq!(stub_position_long.calculate_return(2.0, 3.0).unwrap(), 0.5);
    }

    #[rstest]
    fn test_calculate_points_inverse_rejects_non_positive_prices(xbtusd_bitmex: CryptoPerpetual) {
        let xbtusd_bitmex = InstrumentAny::CryptoPerpetual(xbtusd_bitmex);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(xbtusd_bitmex.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("100000"))
            .build();
        let fill = TestOrderEventStubs::filled(
            &order,
            &xbtusd_bitmex,
            None,
            Some(PositionId::from("P-INVERSE-GUARD")),
            Some(Price::from("10000.0")),
            None,
            None,
            None,
            None,
            None,
        );
        let position = Position::new(&xbtusd_bitmex, fill.into());

        assert_eq!(
            position
                .calculate_points_inverse(-1.0, 10_000.0)
                .unwrap_err()
                .to_string(),
            "Cannot calculate inverse points: open price is not positive or is too small (-1)"
        );
        assert_eq!(
            position
                .calculate_points_inverse(10_000.0, -1.0)
                .unwrap_err()
                .to_string(),
            "Cannot calculate inverse points: close price is not positive or is too small (-1)"
        );
        assert!(position.calculate_points_inverse(1e-16, 10_000.0).is_err());
        assert!(position.calculate_points_inverse(10_000.0, 1e-16).is_err());
        assert!(position.calculate_points_inverse(1e-15, 10_000.0).is_ok());
        assert!(position.calculate_points_inverse(10_000.0, 1e-15).is_ok());
    }

    #[rstest]
    fn test_calculate_pnl_for_inverse2(ethusdt_bitmex: CryptoPerpetual) {
        let ethusdt_bitmex = InstrumentAny::CryptoPerpetual(ethusdt_bitmex);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(ethusdt_bitmex.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("100000"))
            .build();
        let commission = calculate_commission(
            &ethusdt_bitmex,
            order.quantity(),
            Price::from("375.95"),
            None,
        );
        let fill = TestOrderEventStubs::filled(
            &order,
            &ethusdt_bitmex,
            None,
            Some(PositionId::from("P-123456")),
            Some(Price::from("375.95")),
            None,
            None,
            Some(commission),
            None,
            None,
        );
        let position = Position::new(&ethusdt_bitmex, fill.into());

        assert_eq!(
            position.unrealized_pnl(Price::from("370.00")),
            Money::from("4.27745208 ETH")
        );
        assert_eq!(
            position.notional_value(Price::from("370.00")),
            Money::from("270.27027027 ETH")
        );
    }

    #[rstest]
    fn test_notional_value_for_quanto_uses_settlement_currency(ethbtc_quanto: CryptoFuture) {
        let instrument = InstrumentAny::CryptoFuture(ethbtc_quanto);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(instrument.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("5"))
            .build();
        let price = Price::from("0.03600");
        let fill = TestOrderEventStubs::filled(
            &order,
            &instrument,
            None,
            Some(PositionId::from("P-QUANTO-NOTIONAL")),
            Some(price),
            None,
            None,
            None,
            None,
            None,
        );
        let position = Position::new(&instrument, fill.into());
        let position_notional = position.notional_value(price);
        let instrument_notional =
            instrument.calculate_notional_value(position.quantity, price, None);

        assert_eq!(position_notional, instrument_notional);
        assert_eq!(position_notional, Money::from("0.18 USDT"));
    }

    #[rstest]
    fn test_calculate_unrealized_pnl_for_long(currency_pair_btcusdt: CurrencyPair) {
        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("2.000000"))
            .build();
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("2.000000"))
            .build();
        let commission1 =
            calculate_commission(&btcusdt, order1.quantity(), Price::from("10500.0"), None);
        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &btcusdt,
            Some(TradeId::new("1")),
            Some(PositionId::new("P-123456")),
            Some(Price::from("10500.00")),
            None,
            None,
            Some(commission1),
            None,
            None,
        );
        let commission2 =
            calculate_commission(&btcusdt, order2.quantity(), Price::from("10500.0"), None);
        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &btcusdt,
            Some(TradeId::new("2")),
            Some(PositionId::new("P-123456")),
            Some(Price::from("10500.00")),
            None,
            None,
            Some(commission2),
            None,
            None,
        );
        let mut position = Position::new(&btcusdt, fill1.into());
        position.apply(&fill2.into());
        let pnl = position.unrealized_pnl(Price::from("11505.60"));
        assert_eq!(pnl, Money::from("4022.40000000 USDT"));
        assert_eq!(
            position.realized_pnl,
            Some(Money::from("-42.00000000 USDT"))
        );
        assert_eq!(
            position.commissions(),
            vec![Money::from("42.00000000 USDT")]
        );
    }

    #[rstest]
    fn test_calculate_unrealized_pnl_for_short(currency_pair_btcusdt: CurrencyPair) {
        let btcusdt = InstrumentAny::CurrencyPair(currency_pair_btcusdt);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btcusdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("5.912000"))
            .build();
        let commission =
            calculate_commission(&btcusdt, order.quantity(), Price::from("10505.60"), None);
        let fill = TestOrderEventStubs::filled(
            &order,
            &btcusdt,
            Some(TradeId::new("1")),
            Some(PositionId::new("P-123456")),
            Some(Price::from("10505.60")),
            None,
            None,
            Some(commission),
            None,
            None,
        );
        let position = Position::new(&btcusdt, fill.into());
        let pnl = position.unrealized_pnl(Price::from("10407.15"));
        assert_eq!(pnl, Money::from("582.03640000 USDT"));
        assert_eq!(
            position.realized_pnl,
            Some(Money::from("-62.10910720 USDT"))
        );
        assert_eq!(
            position.commissions(),
            vec![Money::from("62.10910720 USDT")]
        );
    }

    #[rstest]
    fn test_calculate_unrealized_pnl_for_long_inverse(xbtusd_bitmex: CryptoPerpetual) {
        let xbtusd_bitmex = InstrumentAny::CryptoPerpetual(xbtusd_bitmex);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(xbtusd_bitmex.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("100000"))
            .build();
        let commission = calculate_commission(
            &xbtusd_bitmex,
            order.quantity(),
            Price::from("10500.0"),
            None,
        );
        let fill = TestOrderEventStubs::filled(
            &order,
            &xbtusd_bitmex,
            Some(TradeId::new("1")),
            Some(PositionId::new("P-123456")),
            Some(Price::from("10500.00")),
            None,
            None,
            Some(commission),
            None,
            None,
        );

        let position = Position::new(&xbtusd_bitmex, fill.into());
        let pnl = position.unrealized_pnl(Price::from("11505.60"));
        assert_eq!(pnl, Money::from("0.83238969 BTC"));
        assert_eq!(position.realized_pnl, Some(Money::from("-0.00714286 BTC")));
        assert_eq!(position.commissions(), vec![Money::from("0.00714286 BTC")]);
    }

    #[rstest]
    fn test_calculate_unrealized_pnl_for_short_inverse(xbtusd_bitmex: CryptoPerpetual) {
        let xbtusd_bitmex = InstrumentAny::CryptoPerpetual(xbtusd_bitmex);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(xbtusd_bitmex.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("1250000"))
            .build();
        let commission = calculate_commission(
            &xbtusd_bitmex,
            order.quantity(),
            Price::from("15500.00"),
            None,
        );
        let fill = TestOrderEventStubs::filled(
            &order,
            &xbtusd_bitmex,
            Some(TradeId::new("1")),
            Some(PositionId::new("P-123456")),
            Some(Price::from("15500.00")),
            None,
            None,
            Some(commission),
            None,
            None,
        );
        let position = Position::new(&xbtusd_bitmex, fill.into());
        let pnl = position.unrealized_pnl(Price::from("12506.65"));

        assert_eq!(pnl, Money::from("19.30166700 BTC"));
        assert_eq!(position.realized_pnl, Some(Money::from("-0.06048387 BTC")));
        assert_eq!(position.commissions(), vec![Money::from("0.06048387 BTC")]);
    }

    #[rstest]
    #[case(OrderSide::Buy, 25, 25.0)]
    #[case(OrderSide::Sell,25,-25.0)]
    fn test_signed_qty_decimal_qty_for_equity(
        #[case] order_side: OrderSide,
        #[case] quantity: i64,
        #[case] expected: f64,
        audusd_sim: CurrencyPair,
    ) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(order_side)
            .quantity(Quantity::from(quantity))
            .build();

        let commission =
            calculate_commission(&audusd_sim, order.quantity(), Price::from("1.0"), None);
        let fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            None,
            Some(PositionId::from("P-123456")),
            None,
            None,
            None,
            Some(commission),
            None,
            None,
        );
        let position = Position::new(&audusd_sim, fill.into());
        assert_eq!(position.signed_qty, expected);
    }

    #[rstest]
    fn test_position_with_commission_none(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let fill = OrderFilledSpec::builder()
            .position_id(PositionId::from("1"))
            .build();

        let position = Position::new(&audusd_sim, fill);
        assert_eq!(position.realized_pnl, Some(Money::from("0 USD")));
    }

    #[rstest]
    fn test_position_with_commission_zero(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let fill = OrderFilledSpec::builder()
            .position_id(PositionId::from("1"))
            .commission(Money::from("0 USD"))
            .build();

        let position = Position::new(&audusd_sim, fill);
        assert_eq!(position.realized_pnl, Some(Money::from("0 USD")));
    }

    #[rstest]
    fn test_cache_purge_order_events() {
        let audusd_sim = audusd_sim();
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);

        let order1 = OrderTestBuilder::new(OrderType::Market)
            .client_order_id(ClientOrderId::new("O-1"))
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(50_000))
            .build();

        let order2 = OrderTestBuilder::new(OrderType::Market)
            .client_order_id(ClientOrderId::new("O-2"))
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(50_000))
            .build();

        let position_id = PositionId::new("P-123456");

        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &audusd_sim,
            Some(TradeId::new("1")),
            Some(position_id),
            Some(Price::from("1.00001")),
            None,
            None,
            None,
            None,
            None,
        );

        let mut position = Position::new(&audusd_sim, fill1.into());

        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &audusd_sim,
            Some(TradeId::new("2")),
            Some(position_id),
            Some(Price::from("1.00002")),
            None,
            None,
            None,
            None,
            None,
        );

        position.apply(&fill2.into());
        position.purge_events_for_order(order1.client_order_id());

        assert_eq!(position.events.len(), 1);
        assert_eq!(position.trade_ids.len(), 1);
        assert_eq!(position.events[0].client_order_id, order2.client_order_id());
        assert!(position.trade_ids.contains(&TradeId::new("2")));
    }

    #[rstest]
    fn test_purge_all_events_returns_none_for_last_event_and_trade_id() {
        let audusd_sim = audusd_sim();
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);

        let order = OrderTestBuilder::new(OrderType::Market)
            .client_order_id(ClientOrderId::new("O-1"))
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();

        let position_id = PositionId::new("P-123456");
        let fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            Some(TradeId::new("1")),
            Some(position_id),
            Some(Price::from("1.00050")),
            None,
            None,
            None,
            Some(UnixNanos::from(1_000_000_000)), // Explicit non-zero timestamp
            None,
        );

        let mut position = Position::new(&audusd_sim, fill.into());

        assert_eq!(position.events.len(), 1);
        assert!(position.last_event().is_some());
        assert!(position.last_trade_id().is_some());

        // Store original timestamps (should be non-zero)
        let original_ts_opened = position.ts_opened;
        let original_ts_last = position.ts_last;
        assert_ne!(original_ts_opened, UnixNanos::default());
        assert_ne!(original_ts_last, UnixNanos::default());

        position.purge_events_for_order(order.client_order_id());

        assert_eq!(position.events.len(), 0);
        assert_eq!(position.trade_ids.len(), 0);
        assert!(position.last_event().is_none());
        assert!(position.last_trade_id().is_none());

        // Verify timestamps are zeroed - empty shell has no meaningful history
        // ts_closed is set to Some(0) so position reports as closed and is eligible for purge
        assert_eq!(position.ts_opened, UnixNanos::default());
        assert_eq!(position.ts_last, UnixNanos::default());
        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
        assert_eq!(position.duration_ns, DurationNanos::default());

        // Verify empty shell reports as closed (this was the bug we fixed!)
        // is_closed() must return true so cache purge logic recognizes empty shells
        assert!(position.is_closed());
        assert!(!position.is_open());
        assert_eq!(position.side, PositionSide::Flat);
    }

    #[rstest]
    fn test_revive_from_empty_shell(audusd_sim: CurrencyPair) {
        // Test adding a fill to an empty shell position
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);

        // Create and then purge position to get empty shell
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();

        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &audusd_sim,
            None,
            Some(PositionId::new("P-1")),
            Some(Price::from("1.00000")),
            None,
            None,
            None,
            Some(UnixNanos::from(1_000_000_000)),
            None,
        );

        let mut position = Position::new(&audusd_sim, fill1.into());
        position.purge_events_for_order(order1.client_order_id());

        // Verify it's an empty shell
        assert!(position.is_closed());
        assert_eq!(position.ts_closed, Some(UnixNanos::default()));
        assert_eq!(position.event_count(), 0);

        // Add new fill to revive the position
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(50_000))
            .build();

        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &audusd_sim,
            None,
            Some(PositionId::new("P-1")),
            Some(Price::from("1.00020")),
            None,
            None,
            None,
            Some(UnixNanos::from(3_000_000_000)),
            None,
        );

        let fill2_typed: OrderFilled = fill2.clone().into();
        position.apply(&fill2_typed);

        // Position should be alive with new timestamps
        assert!(position.is_long());
        assert!(!position.is_closed());
        assert!(position.ts_closed.is_none());
        assert_eq!(position.ts_opened, fill2.ts_event());
        assert_eq!(position.ts_last, fill2.ts_event());
        assert_eq!(position.event_count(), 1);
        assert_eq!(position.quantity, Quantity::from(50_000));
    }

    #[rstest]
    fn test_empty_shell_position_invariants(audusd_sim: CurrencyPair) {
        // Property-based test: Any position with event_count == 0 must satisfy invariants
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);

        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();

        let fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            None,
            Some(PositionId::new("P-1")),
            Some(Price::from("1.00000")),
            None,
            None,
            None,
            Some(UnixNanos::from(1_000_000_000)),
            None,
        );

        let mut position = Position::new(&audusd_sim, fill.into());
        position.purge_events_for_order(order.client_order_id());

        // INVARIANTS: When event_count == 0, the following MUST be true
        assert_eq!(
            position.event_count(),
            0,
            "Precondition: event_count must be 0"
        );

        // Invariant 1: Position must report as closed
        assert!(
            position.is_closed(),
            "INV1: Empty shell must report is_closed() == true"
        );
        assert!(
            !position.is_open(),
            "INV1: Empty shell must report is_open() == false"
        );

        // Invariant 2: Position must be FLAT
        assert_eq!(
            position.side,
            PositionSide::Flat,
            "INV2: Empty shell must be FLAT"
        );

        // Invariant 3: ts_closed must be Some (not None)
        assert!(
            position.ts_closed.is_some(),
            "INV3: Empty shell must have ts_closed.is_some()"
        );
        assert_eq!(
            position.ts_closed,
            Some(UnixNanos::default()),
            "INV3: Empty shell ts_closed must be 0"
        );

        // Invariant 4: All lifecycle timestamps must be zeroed
        assert_eq!(
            position.ts_opened,
            UnixNanos::default(),
            "INV4: Empty shell ts_opened must be 0"
        );
        assert_eq!(
            position.ts_last,
            UnixNanos::default(),
            "INV4: Empty shell ts_last must be 0"
        );
        assert_eq!(
            position.duration_ns,
            DurationNanos::default(),
            "INV4: Empty shell duration_ns must be 0"
        );

        // Invariant 5: Quantity must be zero
        assert_eq!(
            position.quantity,
            Quantity::zero(audusd_sim.size_precision()),
            "INV5: Empty shell quantity must be 0"
        );

        // Invariant 6: No events or trade IDs
        assert!(
            position.events.is_empty(),
            "INV6: Empty shell must have no events"
        );
        assert!(
            position.trade_ids.is_empty(),
            "INV6: Empty shell must have no trade IDs"
        );
        assert!(
            position.last_event().is_none(),
            "INV6: Empty shell must have no last event"
        );
        assert!(
            position.last_trade_id().is_none(),
            "INV6: Empty shell must have no last trade ID"
        );
    }

    #[rstest]
    fn test_position_pnl_precision_with_very_small_amounts(audusd_sim: CurrencyPair) {
        // Tests behavior with very small commission amounts
        // NOTE: Amounts below f64 epsilon (~1e-15) may be lost to precision
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100))
            .build();

        // Test with a commission that won't be lost to Money precision (0.01 USD)
        let small_commission = Money::new(0.01, Currency::USD());
        let fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            None,
            None,
            Some(Price::from("1.00001")),
            Some(Quantity::from(100)),
            None,
            Some(small_commission),
            None,
            None,
        );

        let position = Position::new(&audusd_sim, fill.into());

        // Commission is recorded and preserved in f64 arithmetic
        assert_eq!(position.commissions().len(), 1);
        let recorded_commission = position.commissions()[0];
        assert!(
            recorded_commission.as_f64() > 0.0,
            "Commission of 0.01 should be preserved"
        );

        // Realized PnL should include commission (negative)
        let realized = position.realized_pnl.unwrap().as_f64();
        assert!(
            realized < 0.0,
            "Realized PnL should be negative due to commission"
        );
    }

    #[rstest]
    fn test_position_pnl_precision_with_high_precision_instrument() {
        // Tests precision with high-precision crypto instrument
        use crate::instruments::stubs::crypto_perpetual_ethusdt;
        let ethusdt = crypto_perpetual_ethusdt();
        let ethusdt = InstrumentAny::CryptoPerpetual(ethusdt);

        // Check instrument precision
        let size_precision = ethusdt.size_precision();

        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(ethusdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.123456789"))
            .build();

        let fill = TestOrderEventStubs::filled(
            &order,
            &ethusdt,
            None,
            None,
            Some(Price::from("2345.123456789")),
            Some(Quantity::from("1.123456789")),
            None,
            Some(Money::from("0.1 USDT")),
            None,
            None,
        );

        let position = Position::new(&ethusdt, fill.into());

        // Verify high-precision price is preserved in f64 (within tolerance)
        let avg_px = position.avg_px_open;
        assert!(
            (avg_px - 2_345.123_456_789).abs() < 1e-6,
            "High precision price should be preserved within f64 tolerance"
        );

        // Quantity will be rounded to instrument's size_precision
        // Verify it matches the instrument's precision
        assert_eq!(
            position.quantity.precision, size_precision,
            "Quantity precision should match instrument"
        );

        // f64 representation will be close but may have rounding based on precision
        let qty_f64 = position.quantity.as_f64();
        assert!(
            qty_f64 > 1.0 && qty_f64 < 2.0,
            "Quantity should be in expected range"
        );
    }

    #[rstest]
    fn test_position_pnl_accumulation_across_many_fills(audusd_sim: CurrencyPair) {
        // Tests precision drift across 100 fills
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(1000))
            .build();

        let initial_fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("1.00000")),
            Some(Quantity::from(10)),
            None,
            Some(Money::from("0.01 USD")),
            None,
            None,
        );

        let mut position = Position::new(&audusd_sim, initial_fill.into());

        // Apply 99 more fills with varying prices
        for i in 2..=100 {
            let price_offset = f64::from(i) * 0.00001;
            let fill = TestOrderEventStubs::filled(
                &order,
                &audusd_sim,
                Some(TradeId::new(i.to_string())),
                None,
                Some(Price::from(&format!("{:.5}", 1.0 + price_offset))),
                Some(Quantity::from(10)),
                None,
                Some(Money::from("0.01 USD")),
                None,
                None,
            );
            position.apply(&fill.into());
        }

        // Verify we accumulated 100 fills
        assert_eq!(position.events.len(), 100);
        assert_eq!(position.quantity, Quantity::from(1000));

        // Verify commissions accumulated (should be 100 * 0.01 = 1.0 USD)
        let total_commission: f64 = position.commissions().iter().map(Money::as_f64).sum();
        assert!(
            (total_commission - 1.0).abs() < 1e-10,
            "Commission accumulation should be accurate: expected 1.0, was {total_commission}"
        );

        // Verify average price is reasonable (should be around 1.0005)
        let avg_px = position.avg_px_open;
        assert!(
            avg_px > 1.0 && avg_px < 1.001,
            "Average price should be reasonable: got {avg_px}"
        );
    }

    #[rstest]
    fn test_position_pnl_with_extreme_price_values(audusd_sim: CurrencyPair) {
        // Tests position handling with very large and very small prices
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);

        // Test with very small price
        let order_small = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();

        let fill_small = TestOrderEventStubs::filled(
            &order_small,
            &audusd_sim,
            None,
            None,
            Some(Price::from("0.00001")),
            Some(Quantity::from(100_000)),
            None,
            None,
            None,
            None,
        );

        let position_small = Position::new(&audusd_sim, fill_small.into());
        assert_eq!(position_small.avg_px_open, 0.00001);

        // Verify notional calculation doesn't underflow
        let last_price_small = Price::from("0.00002");
        let unrealized = position_small.unrealized_pnl(last_price_small);
        assert!(
            unrealized.as_f64() > 0.0,
            "Unrealized PnL should be positive when price doubles"
        );

        // Test with very large price
        let order_large = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100))
            .build();

        let fill_large = TestOrderEventStubs::filled(
            &order_large,
            &audusd_sim,
            None,
            None,
            Some(Price::from("99999.99999")),
            Some(Quantity::from(100)),
            None,
            None,
            None,
            None,
        );

        let position_large = Position::new(&audusd_sim, fill_large.into());
        assert!(
            (position_large.avg_px_open - 99999.99999).abs() < 1e-6,
            "Large price should be preserved within f64 tolerance"
        );
    }

    #[rstest]
    fn test_position_pnl_roundtrip_precision(audusd_sim: CurrencyPair) {
        // Tests that opening and closing a position preserves precision
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let buy_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();

        let sell_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(100_000))
            .build();

        // Open at precise price
        let open_fill = TestOrderEventStubs::filled(
            &buy_order,
            &audusd_sim,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("1.123456")),
            None,
            None,
            Some(Money::from("0.50 USD")),
            None,
            None,
        );

        let mut position = Position::new(&audusd_sim, open_fill.into());

        // Close at same price (no profit/loss except commission)
        let close_fill = TestOrderEventStubs::filled(
            &sell_order,
            &audusd_sim,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("1.123456")),
            None,
            None,
            Some(Money::from("0.50 USD")),
            None,
            None,
        );

        position.apply(&close_fill.into());

        // Position should be flat
        assert!(position.is_closed());

        // Realized PnL should be exactly -1.0 USD (two commissions of 0.50)
        let realized = position.realized_pnl.unwrap().as_f64();
        assert!(
            (realized - (-1.0)).abs() < 1e-10,
            "Realized PnL should be exactly -1.0 USD (commissions), was {realized}"
        );
    }

    #[rstest]
    fn test_position_commission_in_base_currency_buy() {
        // Test that commission in base currency reduces position quantity on buy (SPOT only)
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.0"))
            .build();

        // Buy 1.0 BTC with 0.001 BTC commission
        let fill = match TestOrderEventStubs::filled(
            &order,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("1.0")),
            None,
            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
            None,
            None,
        ) {
            OrderEventAny::Filled(fill) => fill,
            _ => unreachable!(),
        };

        let position = Position::new(&btc_usdt, fill.clone());
        let replayed_position = Position::new(&btc_usdt, fill);

        // Position quantity should be 1.0 - 0.001 = 0.999 BTC
        assert!(
            (position.quantity.as_f64() - 0.999).abs() < 1e-9,
            "Position quantity should be 0.999 BTC (1.0 - 0.001 commission), was {}",
            position.quantity.as_f64()
        );

        // Signed qty should also be 0.999
        assert!(
            (position.signed_qty - 0.999).abs() < 1e-9,
            "Signed qty should be 0.999, was {}",
            position.signed_qty
        );

        // Verify PositionAdjusted event was created
        assert_eq!(
            position.adjustments.len(),
            1,
            "Should have 1 adjustment event"
        );
        let adjustment = &position.adjustments[0];
        assert_eq!(
            adjustment.adjustment_type,
            PositionAdjustmentType::Commission
        );
        assert_eq!(
            adjustment.quantity_change,
            Some(rust_decimal_macros::dec!(-0.001))
        );
        assert_eq!(adjustment.pnl_change, None);
        assert_eq!(
            adjustment.event_id,
            replayed_position.adjustments[0].event_id
        );
    }

    #[rstest]
    fn test_base_commission_adjustment_id_flips_low_bit_of_fill_id(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let base_currency = instrument.base_currency().unwrap();
        let fill = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .commission(Money::new(2.0, base_currency))
            .position_id(PositionId::from("P-COMMISSION"))
            .event_id(UUID4::from_str("a1b2c3d4-e5f6-4789-8abc-def012345679").unwrap())
            .ts_event(UnixNanos::from(1))
            .build();

        let position = Position::new(&instrument, fill);

        assert_eq!(position.adjustments.len(), 1);
        assert_eq!(
            position.adjustments[0].event_id,
            UUID4::from_str("a1b2c3d4-e5f6-4789-8abc-def012345678").unwrap()
        );
    }

    #[rstest]
    fn test_position_commission_in_base_currency_sell() {
        // Test that commission in base currency increases short position on sell
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("1.0"))
            .build();

        // Sell 1.0 BTC with 0.001 BTC commission
        let fill = TestOrderEventStubs::filled(
            &order,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("1.0")),
            None,
            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let position = Position::new(&btc_usdt, fill.into());

        // Position quantity should be 1.0 + 0.001 = 1.001 BTC
        // (you sold 1.0 and paid 0.001 commission, so total short exposure is 1.001)
        assert!(
            (position.quantity.as_f64() - 1.001).abs() < 1e-9,
            "Position quantity should be 1.001 BTC (1.0 + 0.001 commission), was {}",
            position.quantity.as_f64()
        );

        // Signed qty should be -1.001 (short position)
        assert!(
            (position.signed_qty - (-1.001)).abs() < 1e-9,
            "Signed qty should be -1.001, was {}",
            position.signed_qty
        );

        // Verify PositionAdjusted event was created
        assert_eq!(
            position.adjustments.len(),
            1,
            "Should have 1 adjustment event"
        );
        let adjustment = &position.adjustments[0];
        assert_eq!(
            adjustment.adjustment_type,
            PositionAdjustmentType::Commission
        );
        // For sell, commission increases the short (negative adjustment)
        assert_eq!(
            adjustment.quantity_change,
            Some(rust_decimal_macros::dec!(-0.001))
        );
        assert_eq!(adjustment.pnl_change, None);
    }

    #[rstest]
    fn test_position_commission_in_quote_currency_no_adjustment() {
        // Test that commission in quote currency does NOT reduce position quantity
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.0"))
            .build();

        // Buy 1.0 BTC with 50 USDT commission (in quote currency)
        let fill = TestOrderEventStubs::filled(
            &order,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("1.0")),
            None,
            Some(Money::new(50.0, Currency::USD())),
            None,
            None,
        );

        let position = Position::new(&btc_usdt, fill.into());

        // Position quantity should be exactly 1.0 BTC (no adjustment)
        assert!(
            (position.quantity.as_f64() - 1.0).abs() < 1e-9,
            "Position quantity should be 1.0 BTC (no adjustment for quote currency commission), was {}",
            position.quantity.as_f64()
        );

        // Verify NO PositionAdjusted event was created (commission in quote currency)
        assert_eq!(
            position.adjustments.len(),
            0,
            "Should have no adjustment events for quote currency commission"
        );
    }

    #[rstest]
    fn test_position_reset_clears_adjustments() {
        // Test that closing and reopening a position clears adjustment history
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        // Open long position with commission adjustment
        let buy_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.0"))
            .build();

        let buy_fill = TestOrderEventStubs::filled(
            &buy_order,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("1.0")),
            None,
            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let mut position = Position::new(&btc_usdt, buy_fill.into());
        assert_eq!(position.adjustments.len(), 1, "Should have 1 adjustment");

        // Close the position (sell the actual quantity, use quote currency commission to avoid complexity)
        let sell_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("0.999"))
            .build();

        let sell_fill = TestOrderEventStubs::filled(
            &sell_order,
            &btc_usdt,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("51000.0")),
            Some(Quantity::from("0.999")),
            None,
            Some(Money::new(50.0, Currency::USD())), // Quote currency commission - no adjustment
            None,
            None,
        );

        position.apply(&sell_fill.into());
        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(
            position.adjustments.len(),
            1,
            "Should still have 1 adjustment (no new one from quote commission)"
        );

        // Reopen the position - adjustments should be cleared
        let buy_order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("2.0"))
            .build();

        let buy_fill2 = TestOrderEventStubs::filled(
            &buy_order2,
            &btc_usdt,
            Some(TradeId::new("3")),
            None,
            Some(Price::from("52000.0")),
            Some(Quantity::from("2.0")),
            None,
            Some(Money::new(0.002, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        position.apply(&buy_fill2.into());

        // Verify adjustments were cleared and only new adjustment exists
        assert_eq!(
            position.adjustments.len(),
            1,
            "Adjustments should be cleared on position reset, only new adjustment"
        );
        assert_eq!(
            position.adjustments[0].quantity_change,
            Some(rust_decimal_macros::dec!(-0.002)),
            "New adjustment should be for the new fill"
        );
        assert_eq!(position.events.len(), 1, "Events should also be reset");
    }

    #[rstest]
    fn test_id_accessors_deduplicate_and_sort(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-IDS");
        let fill1 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-2"))
            .venue_order_id(VenueOrderId::from("V-2"))
            .trade_id(TradeId::from("T-3"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill2 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .venue_order_id(VenueOrderId::from("V-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let fill3 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .venue_order_id(VenueOrderId::from("V-1"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(3))
            .build();
        let mut position = Position::new(&instrument, fill1);
        position.apply(&fill2);
        position.apply(&fill3);

        assert_eq!(
            position.client_order_ids(),
            vec![ClientOrderId::from("O-1"), ClientOrderId::from("O-2")]
        );
        assert_eq!(
            position.venue_order_ids(),
            vec![VenueOrderId::from("V-1"), VenueOrderId::from("V-2")]
        );
        assert_eq!(
            position.trade_ids(),
            vec![
                TradeId::from("T-1"),
                TradeId::from("T-2"),
                TradeId::from("T-3")
            ]
        );
    }

    #[rstest]
    fn test_is_open_and_is_closed_require_both_conditions(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-PREDICATES");
        let fill_open = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill_close = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-2"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Sell)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let mut position = Position::new(&instrument, fill_open);
        position.apply(&fill_close);

        assert!(position.is_closed());
        assert!(!position.is_open());

        position.apply_adjustment(PositionAdjusted::new(
            position.trader_id,
            position.strategy_id,
            position.instrument_id,
            position.id,
            position.account_id,
            PositionAdjustmentType::Funding,
            Some(dec!(5)),
            None,
            None,
            uuid4(),
            UnixNanos::from(3),
            UnixNanos::from(3),
        ));

        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.ts_closed, Some(UnixNanos::from(2)));
        assert!(!position.is_open());
        assert!(!position.is_closed());
    }

    #[rstest]
    fn test_voided_fill_rebate_leaves_no_residual_commission(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-VOID-REBATE");
        let fill1 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let rebate = Money::from("-2.00 USD");
        let fill2 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-2"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .commission(rebate)
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let void2 = matching_fill_void(&fill2, Quantity::from(10), Some(rebate));
        let mut position = Position::new(&instrument, fill1);
        position.apply(&fill2);

        position
            .apply_fill_void(void2, Quantity::from(10), Some(rebate))
            .unwrap();

        assert_eq!(position.quantity, Quantity::from(10));
        assert!(position.commissions().is_empty());
        assert_eq!(position.realized_pnl, Some(Money::from("0.00 USD")));
    }

    #[rstest]
    fn test_voided_fill_commission_accumulates_into_realized_pnl(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-SURVIVING-QUOTE");
        let fill1 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .commission(Money::from("2.00 USD"))
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill2 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-2"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("2.00000"))
            .currency(Currency::USD())
            .commission(Money::from("1.00 USD"))
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let void2 = matching_fill_void(&fill2, Quantity::from(10), None);
        let mut position = Position::new(&instrument, fill1);
        position.apply(&fill2);

        position
            .apply_fill_void(void2, Quantity::from(10), None)
            .unwrap();

        assert_eq!(position.quantity, Quantity::from(10));
        assert_eq!(position.commissions(), vec![Money::from("3.00 USD")]);
        assert_eq!(position.realized_pnl, Some(Money::from("-3.00 USD")));
    }

    #[rstest]
    fn test_voided_fill_base_commission_preserves_avg_px_open(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let base_currency = instrument.base_currency().unwrap();
        let position_id = PositionId::from("P-SURVIVING-BASE");
        let fill1 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .commission(Money::new(2.0, base_currency))
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill2 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-2"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("2.00000"))
            .currency(Currency::USD())
            .commission(Money::new(1.0, base_currency))
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let void2 = matching_fill_void(&fill2, Quantity::from(10), None);
        let mut position = Position::new(&instrument, fill1);
        position.apply(&fill2);

        position
            .apply_fill_void(void2, Quantity::from(10), None)
            .unwrap();

        assert_eq!(position.quantity, Quantity::from(7));
        assert_eq!(position.avg_px_open, 1.0);
        assert_eq!(position.commissions(), vec![Money::new(3.0, base_currency)]);
    }

    #[rstest]
    fn test_fill_fragments_requires_matching_order_and_trade(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-FRAGMENTS");
        let fill1 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill2 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let mut position = Position::new(&instrument, fill1);
        position.apply(&fill2);

        let fragments = position.fill_fragments(ClientOrderId::from("O-1"), TradeId::from("T-1"));

        assert_eq!(fragments.len(), 1);
        assert_eq!(fragments[0].trade_id, TradeId::from("T-1"));
        assert!(
            position
                .fill_fragments(ClientOrderId::from("O-2"), TradeId::from("T-1"))
                .is_empty()
        );
    }

    #[rstest]
    fn test_apply_fill_void_scopes_staleness_check_to_same_trade(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-VOID-TRADES");
        let fill1 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill2 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let void1 = matching_fill_void(&fill1, Quantity::from(6), None);
        let void2 = matching_fill_void(&fill2, Quantity::from(2), None);
        let mut position = Position::new(&instrument, fill1);
        position.apply(&fill2);
        position
            .apply_fill_void(void1, Quantity::from(6), None)
            .unwrap();

        position
            .apply_fill_void(void2, Quantity::from(2), None)
            .unwrap();

        assert_eq!(position.quantity, Quantity::from(12));
        assert_eq!(position.fill_voids.len(), 2);
    }

    #[rstest]
    fn test_apply_fill_void_removes_quantity_from_voided_trade_only(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-VOID-ATTRIBUTION");
        let fill1 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill2 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("2.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let void1 = matching_fill_void(&fill1, Quantity::from(4), None);
        let mut position = Position::new(&instrument, fill1);
        position.apply(&fill2);

        position
            .apply_fill_void(void1, Quantity::from(4), None)
            .unwrap();

        assert_eq!(position.quantity, Quantity::from(16));
        assert_eq!(position.avg_px_open, 1.625);
    }

    #[rstest]
    fn test_purge_events_for_order_retains_other_order_fill_voids(audusd_sim: CurrencyPair) {
        let instrument = InstrumentAny::CurrencyPair(audusd_sim);
        let position_id = PositionId::from("P-PURGE-VOID");
        let fill1 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-1"))
            .trade_id(TradeId::from("T-1"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(1))
            .build();
        let fill2 = OrderFilledSpec::builder()
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::from("O-2"))
            .trade_id(TradeId::from("T-2"))
            .order_side(OrderSide::Buy)
            .last_qty(Quantity::from(10))
            .last_px(Price::from("1.00000"))
            .currency(Currency::USD())
            .position_id(position_id)
            .ts_event(UnixNanos::from(2))
            .build();
        let void1 = matching_fill_void(&fill1, Quantity::from(2), None);
        let void2 = matching_fill_void(&fill2, Quantity::from(3), None);
        let mut position = Position::new(&instrument, fill1);
        position.apply(&fill2);
        position
            .apply_fill_void(void1, Quantity::from(2), None)
            .unwrap();
        position
            .apply_fill_void(void2, Quantity::from(3), None)
            .unwrap();

        assert_eq!(position.fill_voids.len(), 2);

        position.purge_events_for_order(ClientOrderId::from("O-1"));

        assert_eq!(position.fill_voids.len(), 1);
        assert_eq!(
            position.fill_voids[0].event.client_order_id,
            ClientOrderId::from("O-2")
        );
        assert_eq!(position.fill_voids[0].voided_qty, Quantity::from(3));
    }

    #[rstest]
    fn test_purge_events_for_order_clears_adjustments_when_flat() {
        // Test that purging all fills clears adjustment history
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.0"))
            .build();

        let fill = TestOrderEventStubs::filled(
            &order,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("1.0")),
            None,
            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let mut position = Position::new(&btc_usdt, fill.into());
        assert_eq!(position.adjustments.len(), 1, "Should have 1 adjustment");
        assert_eq!(position.events.len(), 1);

        // Purge the only fill - should go to flat and clear everything
        position.purge_events_for_order(order.client_order_id());

        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.events.len(), 0, "Events should be cleared");
        assert_eq!(
            position.adjustments.len(),
            0,
            "Adjustments should be cleared when position goes flat"
        );
        assert_eq!(position.quantity, Quantity::zero(btc_usdt.size_precision()));
    }

    #[rstest]
    fn test_purge_events_for_order_clears_adjustments_on_rebuild() {
        // Test that rebuilding position from remaining fills clears and recreates adjustments
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        // First fill with adjustment
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.0"))
            .client_order_id(ClientOrderId::new("O-001"))
            .build();

        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("1.0")),
            None,
            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let mut position = Position::new(&btc_usdt, fill1.into());
        assert_eq!(position.adjustments.len(), 1);

        // Second fill with different order and adjustment
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("2.0"))
            .client_order_id(ClientOrderId::new("O-002"))
            .build();

        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &btc_usdt,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("51000.0")),
            Some(Quantity::from("2.0")),
            None,
            Some(Money::new(0.002, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        position.apply(&fill2.into());
        assert_eq!(position.adjustments.len(), 2, "Should have 2 adjustments");
        assert_eq!(position.events.len(), 2);

        // Purge first order - should rebuild from remaining fill
        position.purge_events_for_order(order1.client_order_id());

        assert_eq!(position.events.len(), 1, "Should have 1 remaining event");
        assert_eq!(
            position.adjustments.len(),
            1,
            "Should have only the adjustment from remaining fill"
        );
        assert_eq!(
            position.adjustments[0].quantity_change,
            Some(rust_decimal_macros::dec!(-0.002)),
            "Should be the adjustment from order2"
        );
        assert!(
            (position.quantity.as_f64() - 1.998).abs() < 1e-9,
            "Quantity should be 2.0 - 0.002 commission"
        );
    }

    #[rstest]
    fn test_purge_events_preserves_manual_adjustments() {
        // Test that manual adjustments (e.g., funding payments) are preserved when purging unrelated fills
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        // First fill
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.0"))
            .client_order_id(ClientOrderId::new("O-001"))
            .build();

        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("1.0")),
            None,
            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let mut position = Position::new(&btc_usdt, fill1.into());
        assert_eq!(position.adjustments.len(), 1);

        // Apply a manual funding payment adjustment (no reason field)
        let funding_adjustment = PositionAdjusted::new(
            position.trader_id,
            position.strategy_id,
            position.instrument_id,
            position.id,
            position.account_id,
            PositionAdjustmentType::Funding,
            None,
            Some(Money::new(10.0, btc_usdt.quote_currency())),
            None, // No reason - this is a manual adjustment
            uuid4(),
            UnixNanos::default(),
            UnixNanos::default(),
        );
        position.apply_adjustment(funding_adjustment);
        assert_eq!(position.adjustments.len(), 2);

        // Second fill with different order
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("2.0"))
            .client_order_id(ClientOrderId::new("O-002"))
            .build();

        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &btc_usdt,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("51000.0")),
            Some(Quantity::from("2.0")),
            None,
            Some(Money::new(0.002, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        position.apply(&fill2.into());
        assert_eq!(
            position.adjustments.len(),
            3,
            "Should have 3 adjustments: 2 commissions + 1 funding"
        );

        // Purge first order - manual funding adjustment should be preserved
        position.purge_events_for_order(order1.client_order_id());

        assert_eq!(position.events.len(), 1, "Should have 1 remaining event");
        assert_eq!(
            position.adjustments.len(),
            2,
            "Should have funding adjustment + commission from remaining fill"
        );

        // Verify funding adjustment is preserved
        let has_funding = position.adjustments.iter().any(|adj| {
            adj.adjustment_type == PositionAdjustmentType::Funding
                && adj.pnl_change == Some(Money::new(10.0, btc_usdt.quote_currency()))
        });
        assert!(has_funding, "Funding adjustment should be preserved");

        // Verify realized_pnl includes the funding payment
        // Note: Commission is in BTC (base currency), so it doesn't directly affect USDT realized_pnl
        assert_eq!(
            position.realized_pnl,
            Some(Money::new(10.0, btc_usdt.quote_currency())),
            "Realized PnL should be the funding payment only (commission is in BTC, not USDT)"
        );
    }

    #[rstest]
    fn test_position_commission_affects_buy_and_sell_qty() {
        // Test that commission in base currency affects both buy_qty and sell_qty tracking
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        let buy_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.0"))
            .build();

        // Buy 1.0 BTC with 0.001 BTC commission
        let fill = TestOrderEventStubs::filled(
            &buy_order,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("1.0")),
            None,
            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let position = Position::new(&btc_usdt, fill.into());

        // buy_qty tracks order fills (1.0 BTC), adjustments tracked separately
        assert!(
            (position.buy_qty.as_f64() - 1.0).abs() < 1e-9,
            "buy_qty should be 1.0 (order fill amount), was {}",
            position.buy_qty.as_f64()
        );

        // Position quantity reflects both order fill and commission adjustment
        assert!(
            (position.quantity.as_f64() - 0.999).abs() < 1e-9,
            "position.quantity should be 0.999 (1.0 - 0.001 commission), was {}",
            position.quantity.as_f64()
        );

        // Adjustment event tracks the commission
        assert_eq!(position.adjustments.len(), 1);
        assert_eq!(
            position.adjustments[0].quantity_change,
            Some(rust_decimal_macros::dec!(-0.001))
        );
    }

    #[rstest]
    fn test_position_perpetual_commission_no_adjustment() {
        // Test that perpetuals/futures do NOT adjust quantity for base currency commission
        let eth_perp = crypto_perpetual_ethusdt();
        let eth_perp = InstrumentAny::CryptoPerpetual(eth_perp);

        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(eth_perp.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.0"))
            .build();

        // Buy 1.0 ETH-PERP contracts with 0.001 ETH commission
        let fill = TestOrderEventStubs::filled(
            &order,
            &eth_perp,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("3000.0")),
            Some(Quantity::from("1.0")),
            None,
            Some(Money::new(0.001, eth_perp.base_currency().unwrap())),
            None,
            None,
        );

        let position = Position::new(&eth_perp, fill.into());

        // Position quantity should be exactly 1.0 (NO adjustment for derivatives)
        assert!(
            (position.quantity.as_f64() - 1.0).abs() < 1e-9,
            "Perpetual position should be 1.0 contracts (no adjustment), was {}",
            position.quantity.as_f64()
        );

        // Signed qty should also be 1.0
        assert!(
            (position.signed_qty - 1.0).abs() < 1e-9,
            "Signed qty should be 1.0, was {}",
            position.signed_qty
        );
    }

    #[rstest]
    fn test_signed_decimal_qty_long(stub_position_long: Position) {
        let signed_qty = stub_position_long.signed_decimal_qty();
        assert!(signed_qty > Decimal::ZERO);
        assert_eq!(
            signed_qty,
            Decimal::try_from(stub_position_long.signed_qty).unwrap()
        );
    }

    #[rstest]
    fn test_signed_decimal_qty_short(stub_position_short: Position) {
        let signed_qty = stub_position_short.signed_decimal_qty();
        assert!(signed_qty < Decimal::ZERO);
        assert_eq!(
            signed_qty,
            Decimal::try_from(stub_position_short.signed_qty).unwrap()
        );
    }

    #[rstest]
    fn test_signed_decimal_qty_flat(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let fill = TestOrderEventStubs::filled(
            &order,
            &audusd_sim,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            None,
            None,
            None,
        );
        let mut position = Position::new(&audusd_sim, fill.into());

        let close_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(100_000))
            .build();
        let close_fill = TestOrderEventStubs::filled(
            &close_order,
            &audusd_sim,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("1.00002")),
            None,
            None,
            None,
            None,
            None,
        );
        position.apply(&close_fill.into());

        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.signed_decimal_qty(), Decimal::ZERO);
    }

    #[rstest]
    fn test_position_flat_with_floating_point_precision_edge_case() {
        // This test verifies that when signed_qty has accumulated floating-point
        // errors (tiny non-zero value) but quantity rounds to zero, the position
        // correctly becomes FLAT with signed_qty normalized to 0.0
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("0.123456789"))
            .build();
        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.00")),
            None,
            None,
            None,
            None,
            None,
        );
        let mut position = Position::new(&btc_usdt, fill1.into());

        assert_eq!(position.side, PositionSide::Long);
        assert!(position.quantity.is_positive());

        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("0.123456789"))
            .build();
        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &btc_usdt,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("50000.00")),
            None,
            None,
            None,
            None,
            None,
        );
        position.apply(&fill2.into());

        assert_eq!(
            position.side,
            PositionSide::Flat,
            "Position should be FLAT, not {:?}",
            position.side
        );
        assert!(
            position.quantity.is_zero(),
            "Quantity should be zero, was {}",
            position.quantity
        );
        assert_eq!(
            position.signed_qty, 0.0,
            "signed_qty should be normalized to 0.0, was {}",
            position.signed_qty
        );
        assert!(position.is_closed());
    }

    #[rstest]
    #[case(OrderSide::Buy, OrderSide::Sell, "162.50", "176.50", 171.5)]
    #[case(OrderSide::Sell, OrderSide::Buy, "140.00", "126.00", 131.0)]
    fn test_position_exact_close_after_partial_fills_preserves_open_average(
        #[case] entry: OrderSide,
        #[case] exit: OrderSide,
        #[case] first_close_px: &str,
        #[case] final_close_px: &str,
        #[case] expected_avg_close: f64,
    ) {
        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
        let position_id = PositionId::new("P-PARTIAL-CLOSE");
        let open_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::new("O-OPEN"))
            .side(entry)
            .quantity(Quantity::from("0.7"))
            .build();
        let open_fill = TestOrderEventStubs::filled(
            &open_order,
            &instrument,
            Some(TradeId::new("T-OPEN")),
            Some(position_id),
            Some(Price::from("151.25")),
            None,
            None,
            Some(Money::from("0 USDT")),
            Some(UnixNanos::from(1_000)),
            None,
        );
        let mut position = Position::new(&instrument, open_fill.into());

        for (client_order_id, trade_id, quantity, price, ts_event) in [
            ("O-CLOSE-1", "T-CLOSE-1", "0.25", first_close_px, 1_100),
            ("O-CLOSE-2", "T-CLOSE-2", "0.45", final_close_px, 1_250),
        ] {
            let close_order = OrderTestBuilder::new(OrderType::Market)
                .instrument_id(instrument.id())
                .client_order_id(ClientOrderId::new(client_order_id))
                .side(exit)
                .quantity(Quantity::from(quantity))
                .build();
            let close_fill = TestOrderEventStubs::filled(
                &close_order,
                &instrument,
                Some(TradeId::new(trade_id)),
                Some(position_id),
                Some(Price::from(price)),
                None,
                None,
                Some(Money::from("0 USDT")),
                Some(UnixNanos::from(ts_event)),
                None,
            );
            position.apply(&close_fill.into());
        }

        assert_eq!(position.entry, entry);
        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.signed_qty, 0.0);
        assert_eq!(position.quantity, Quantity::zero(6));
        assert_eq!(position.peak_qty, Quantity::from("0.7"));
        assert_eq!(position.buy_qty, Quantity::from("0.7"));
        assert_eq!(position.sell_qty, Quantity::from("0.7"));
        assert_eq!(position.avg_px_open, 151.25);
        assert_eq!(position.avg_px_close, Some(expected_avg_close));
        assert_eq!(position.realized_return, 0.133_884_297_520_661_17);
        assert_eq!(position.realized_pnl, Some(Money::from("14.17500000 USDT")));
        assert_eq!(position.commissions(), vec![Money::from("0 USDT")]);
        assert_eq!(position.opening_order_id, ClientOrderId::new("O-OPEN"));
        assert_eq!(
            position.closing_order_id,
            Some(ClientOrderId::new("O-CLOSE-2"))
        );
        assert_eq!(position.ts_opened, UnixNanos::from(1_000));
        assert_eq!(position.ts_last, UnixNanos::from(1_250));
        assert_eq!(position.ts_closed, Some(UnixNanos::from(1_250)));
        assert_eq!(position.duration_ns, DurationNanos::new(250));
        assert_eq!(position.event_count(), 3);
        assert!(position.is_closed());
    }

    #[rstest]
    #[case(
        OrderSide::Buy,
        OrderSide::Sell,
        "140.00",
        "126.00",
        PositionSide::Short,
        -0.000_001
    )]
    #[case(
        OrderSide::Sell,
        OrderSide::Buy,
        "162.50",
        "176.50",
        PositionSide::Long,
        0.000_001
    )]
    fn test_position_true_reversal_uses_fill_price(
        #[case] entry: OrderSide,
        #[case] exit: OrderSide,
        #[case] first_close_px: &str,
        #[case] reversal_px: &str,
        #[case] expected_side: PositionSide,
        #[case] expected_signed_qty: f64,
    ) {
        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
        let position_id = PositionId::new("P-REVERSAL");
        let open_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::new("O-REVERSAL-OPEN"))
            .side(entry)
            .quantity(Quantity::from("0.7"))
            .build();
        let open_fill = TestOrderEventStubs::filled(
            &open_order,
            &instrument,
            Some(TradeId::new("T-REVERSAL-OPEN")),
            Some(position_id),
            Some(Price::from("151.25")),
            None,
            None,
            Some(Money::from("0 USDT")),
            Some(UnixNanos::from(2_000)),
            None,
        );
        let mut position = Position::new(&instrument, open_fill.into());

        let close_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::new("O-REVERSAL-CLOSE"))
            .side(exit)
            .quantity(Quantity::from("0.25"))
            .build();
        let close_fill = TestOrderEventStubs::filled(
            &close_order,
            &instrument,
            Some(TradeId::new("T-REVERSAL-CLOSE")),
            Some(position_id),
            Some(Price::from(first_close_px)),
            None,
            None,
            Some(Money::from("0 USDT")),
            Some(UnixNanos::from(2_050)),
            None,
        );
        position.apply(&close_fill.into());

        let reversal_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::new("O-REVERSAL"))
            .side(exit)
            .quantity(Quantity::from("0.450001"))
            .build();
        let reversal_fill = TestOrderEventStubs::filled(
            &reversal_order,
            &instrument,
            Some(TradeId::new("T-REVERSAL")),
            Some(position_id),
            Some(Price::from(reversal_px)),
            None,
            None,
            Some(Money::from("0 USDT")),
            Some(UnixNanos::from(2_100)),
            None,
        );
        position.apply(&reversal_fill.into());

        assert_eq!(position.entry, exit);
        assert_eq!(position.side, expected_side);
        assert!((position.signed_qty - expected_signed_qty).abs() < 1e-12);
        assert_eq!(position.quantity, Quantity::from("0.000001"));
        assert_eq!(position.peak_qty, Quantity::from("0.7"));
        assert_eq!(position.avg_px_open, Price::from(reversal_px).as_f64());
        assert_eq!(
            position.realized_pnl,
            Some(Money::from("-14.17500000 USDT"))
        );
        assert_eq!(position.commissions(), vec![Money::from("0 USDT")]);
        assert_eq!(
            position.opening_order_id,
            ClientOrderId::new("O-REVERSAL-OPEN")
        );
        assert_eq!(position.closing_order_id, None);
        assert_eq!(position.ts_opened, UnixNanos::from(2_000));
        assert_eq!(position.ts_last, UnixNanos::from(2_100));
        assert_eq!(position.ts_closed, None);
        assert_eq!(position.duration_ns, DurationNanos::default());
        assert_eq!(position.event_count(), 3);
        assert!(position.is_open());
    }

    #[rstest]
    #[case(OrderSide::Buy, OrderSide::Sell)]
    #[case(OrderSide::Sell, OrderSide::Buy)]
    fn test_position_reversal_starts_new_close_episode(
        #[case] entry: OrderSide,
        #[case] exit: OrderSide,
    ) {
        let (
            open_px,
            first_close_px,
            reversal_px,
            expected_side,
            new_first_close_px,
            new_final_close_px,
            expected_avg_close,
            expected_return,
        ) = if entry == OrderSide::Buy {
            (
                "100.00",
                "110.00",
                "120.00",
                PositionSide::Short,
                "110.00",
                "90.00",
                95.0,
                0.208_333_333_333_333_34,
            )
        } else {
            (
                "120.00",
                "110.00",
                "100.00",
                PositionSide::Long,
                "110.00",
                "130.00",
                125.0,
                0.25,
            )
        };
        let instrument = InstrumentAny::CurrencyPair(currency_pair_btcusdt());
        let position_id = PositionId::new("P-REVERSAL-EPISODE");
        let open_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(instrument.id())
            .client_order_id(ClientOrderId::new("O-OPEN"))
            .side(entry)
            .quantity(Quantity::from("10"))
            .build();
        let open_fill = TestOrderEventStubs::filled(
            &open_order,
            &instrument,
            Some(TradeId::new("T-OPEN")),
            Some(position_id),
            Some(Price::from(open_px)),
            None,
            None,
            Some(Money::from("1 USDT")),
            Some(UnixNanos::from(3_000)),
            None,
        );
        let mut position = Position::new(&instrument, open_fill.into());

        for (client_order_id, trade_id, quantity, price, ts_event) in [
            ("O-CLOSE", "T-CLOSE", "4", first_close_px, 3_100),
            ("O-REVERSE", "T-REVERSE", "8", reversal_px, 3_200),
        ] {
            let order = OrderTestBuilder::new(OrderType::Market)
                .instrument_id(instrument.id())
                .client_order_id(ClientOrderId::new(client_order_id))
                .side(exit)
                .quantity(Quantity::from(quantity))
                .build();
            let fill = TestOrderEventStubs::filled(
                &order,
                &instrument,
                Some(TradeId::new(trade_id)),
                Some(position_id),
                Some(Price::from(price)),
                None,
                None,
                Some(Money::from("1 USDT")),
                Some(UnixNanos::from(ts_event)),
                None,
            );
            position.apply(&fill.into());
        }

        assert_eq!(position.side, expected_side);
        assert_eq!(position.quantity, Quantity::from("2"));
        assert_eq!(position.avg_px_open, Price::from(reversal_px).as_f64());
        assert_eq!(position.avg_px_close, None);
        assert_eq!(position.realized_return, 0.0);
        if expected_side == PositionSide::Long {
            assert_eq!(position.buy_qty, Quantity::from("2"));
            assert_eq!(position.sell_qty, Quantity::from("0"));
        } else {
            assert_eq!(position.buy_qty, Quantity::from("0"));
            assert_eq!(position.sell_qty, Quantity::from("2"));
        }
        assert_eq!(position.realized_pnl, Some(Money::from("157 USDT")));

        for (client_order_id, trade_id, quantity, price, ts_event) in [
            (
                "O-NEW-CLOSE-1",
                "T-NEW-CLOSE-1",
                "0.5",
                new_first_close_px,
                3_300,
            ),
            (
                "O-NEW-CLOSE-2",
                "T-NEW-CLOSE-2",
                "1.5",
                new_final_close_px,
                3_400,
            ),
        ] {
            let order = OrderTestBuilder::new(OrderType::Market)
                .instrument_id(instrument.id())
                .client_order_id(ClientOrderId::new(client_order_id))
                .side(entry)
                .quantity(Quantity::from(quantity))
                .build();
            let fill = TestOrderEventStubs::filled(
                &order,
                &instrument,
                Some(TradeId::new(trade_id)),
                Some(position_id),
                Some(Price::from(price)),
                None,
                None,
                Some(Money::from("1 USDT")),
                Some(UnixNanos::from(ts_event)),
                None,
            );
            position.apply(&fill.into());
        }

        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.quantity, Quantity::zero(6));
        assert_eq!(position.buy_qty, Quantity::from("2"));
        assert_eq!(position.sell_qty, Quantity::from("2"));
        assert_eq!(position.avg_px_close, Some(expected_avg_close));
        assert_eq!(position.realized_return, expected_return);
        assert_eq!(position.realized_pnl, Some(Money::from("205 USDT")));
        assert_eq!(position.commissions(), vec![Money::from("5 USDT")]);
    }

    #[rstest]
    fn test_position_adjustment_floating_point_precision_edge_case() {
        // Test that apply_adjustment handles precision edge cases correctly
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        let order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.0"))
            .build();
        let fill = TestOrderEventStubs::filled(
            &order,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.00")),
            None,
            None,
            None,
            None,
            None,
        );
        let mut position = Position::new(&btc_usdt, fill.into());

        let adjustment = PositionAdjusted::new(
            position.trader_id,
            position.strategy_id,
            position.instrument_id,
            position.id,
            position.account_id,
            PositionAdjustmentType::Commission,
            Some(Decimal::from_str("-1.0").unwrap()),
            None,
            None,
            uuid4(),
            UnixNanos::default(),
            UnixNanos::default(),
        );
        position.apply_adjustment(adjustment);

        assert_eq!(
            position.side,
            PositionSide::Flat,
            "Position should be FLAT after zeroing adjustment"
        );
        assert!(
            position.quantity.is_zero(),
            "Quantity should be zero after adjustment"
        );
        assert_eq!(
            position.signed_qty, 0.0,
            "signed_qty should be normalized to 0.0"
        );
    }

    #[rstest]
    fn test_position_spot_buy_partial_fills_with_base_commission() {
        // Reproduce GitHub issue #3546: partial fills with base currency commission
        // should reduce position quantity, not increase it
        let eth_usdt = currency_pair_ethusdt();
        let eth_usdt = InstrumentAny::CurrencyPair(eth_usdt);

        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(eth_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("0.00350"))
            .build();

        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &eth_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("2042.69")),
            Some(Quantity::from("0.00350")),
            None,
            Some(Money::new(0.00001, eth_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let mut position = Position::new(&eth_usdt, fill1.into());

        assert_eq!(position.quantity, Quantity::from("0.00349"));
        assert!((position.signed_qty - 0.00349).abs() < 1e-9);
        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.adjustments.len(), 1);
        assert_eq!(
            position.adjustments[0].quantity_change,
            Some(rust_decimal_macros::dec!(-0.00001))
        );

        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(eth_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("0.00350"))
            .build();

        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &eth_usdt,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("2042.69")),
            Some(Quantity::from("0.00350")),
            None,
            Some(Money::new(0.00001, eth_usdt.base_currency().unwrap())),
            None,
            None,
        );

        position.apply(&fill2.into());

        assert_eq!(position.quantity, Quantity::from("0.00698"));
        assert!((position.signed_qty - 0.00698).abs() < 1e-9);
        assert_eq!(position.adjustments.len(), 2);

        let order3 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(eth_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("0.00300"))
            .build();

        let fill3 = TestOrderEventStubs::filled(
            &order3,
            &eth_usdt,
            Some(TradeId::new("3")),
            None,
            Some(Price::from("2042.69")),
            Some(Quantity::from("0.00300")),
            None,
            Some(Money::new(0.00001, eth_usdt.base_currency().unwrap())),
            None,
            None,
        );

        position.apply(&fill3.into());

        // Total filled: 0.01000, total commission: 0.00003
        // Position should be 0.01000 - 0.00003 = 0.00997
        assert_eq!(position.quantity, Quantity::from("0.00997"));
        assert!((position.signed_qty - 0.00997).abs() < 1e-9);
        assert_eq!(position.side, PositionSide::Long);
        assert_eq!(position.adjustments.len(), 3);

        // buy_qty tracks order fill amounts, not commission-adjusted
        assert_eq!(position.buy_qty, Quantity::from("0.01000"));
    }

    #[rstest]
    fn test_position_spot_sell_partial_fills_with_base_commission() {
        let btc_usdt = currency_pair_btcusdt();
        let btc_usdt = InstrumentAny::CurrencyPair(btc_usdt);

        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("0.5"))
            .build();

        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &btc_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("0.5")),
            None,
            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let mut position = Position::new(&btc_usdt, fill1.into());

        // Short: sold 0.5 + paid 0.001 commission = -0.501 exposure
        assert!((position.signed_qty - (-0.501)).abs() < 1e-9);
        assert_eq!(position.side, PositionSide::Short);
        assert_eq!(position.adjustments.len(), 1);

        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(btc_usdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("0.5"))
            .build();

        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &btc_usdt,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("50000.0")),
            Some(Quantity::from("0.5")),
            None,
            Some(Money::new(0.001, btc_usdt.base_currency().unwrap())),
            None,
            None,
        );

        position.apply(&fill2.into());

        // Total short: 1.0 sold + 0.002 commission = -1.002
        assert!((position.signed_qty - (-1.002)).abs() < 1e-9);
        assert!((position.quantity.as_f64() - 1.002).abs() < 1e-9);
        assert_eq!(position.adjustments.len(), 2);
        assert_eq!(position.sell_qty, Quantity::from("1.0"));
    }

    #[rstest]
    fn test_position_spot_round_trip_close_flat_with_quote_commission() {
        let eth_usdt = currency_pair_ethusdt();
        let eth_usdt = InstrumentAny::CurrencyPair(eth_usdt);

        let buy_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(eth_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("1.00000"))
            .build();

        let buy_fill = TestOrderEventStubs::filled(
            &buy_order,
            &eth_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("2000.00")),
            Some(Quantity::from("1.00000")),
            None,
            Some(Money::new(0.001, eth_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let mut position = Position::new(&eth_usdt, buy_fill.into());

        // Position = 1.0 - 0.001 = 0.999
        assert_eq!(position.quantity, Quantity::from("0.99900"));
        assert_eq!(position.side, PositionSide::Long);

        let sell_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(eth_usdt.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from("0.99900"))
            .build();

        let sell_fill = TestOrderEventStubs::filled(
            &sell_order,
            &eth_usdt,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("2100.00")),
            Some(Quantity::from("0.99900")),
            None,
            Some(Money::new(2.0, Currency::USDT())),
            None,
            None,
        );

        position.apply(&sell_fill.into());

        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.signed_qty, 0.0);
        assert!(position.is_closed());
        // Only 1 adjustment from the buy (quote commission doesn't create adjustment)
        assert_eq!(position.adjustments.len(), 1);

        // PnL: 0.999 ETH * $100 price move = $99.90, minus $2 commission
        let realized = position.realized_pnl.unwrap().as_f64();
        assert!(
            (realized - 97.9).abs() < 0.01,
            "Realized PnL should be ~97.90 USDT, was {realized}"
        );
    }

    #[rstest]
    fn test_position_spot_commission_accumulation_multiple_partial_fills() {
        let eth_usdt = currency_pair_ethusdt();
        let eth_usdt = InstrumentAny::CurrencyPair(eth_usdt);

        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(eth_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("0.50000"))
            .build();

        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &eth_usdt,
            Some(TradeId::new("1")),
            None,
            Some(Price::from("2000.00")),
            Some(Quantity::from("0.50000")),
            None,
            Some(Money::new(0.0005, eth_usdt.base_currency().unwrap())),
            None,
            None,
        );

        let mut position = Position::new(&eth_usdt, fill1.into());

        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(eth_usdt.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from("0.50000"))
            .build();

        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &eth_usdt,
            Some(TradeId::new("2")),
            None,
            Some(Price::from("2010.00")),
            Some(Quantity::from("0.50000")),
            None,
            Some(Money::new(0.0005, eth_usdt.base_currency().unwrap())),
            None,
            None,
        );

        position.apply(&fill2.into());

        // Total: 1.0 filled, 0.001 total commission
        assert_eq!(position.quantity, Quantity::from("0.99900"));
        assert_eq!(position.buy_qty, Quantity::from("1.00000"));

        assert_eq!(position.adjustments.len(), 2);
        for adj in &position.adjustments {
            assert_eq!(adj.adjustment_type, PositionAdjustmentType::Commission);
            assert_eq!(
                adj.quantity_change,
                Some(rust_decimal_macros::dec!(-0.0005))
            );
        }

        let commissions = position.commissions();
        assert_eq!(commissions.len(), 1);
        let eth_commission = commissions[0];
        assert!(
            (eth_commission.as_f64() - 0.001).abs() < 1e-9,
            "Total ETH commission should be 0.001, was {}",
            eth_commission.as_f64()
        );
    }

    #[rstest]
    fn test_position_apply_fill_with_earlier_timestamp_adjusts_ts_opened(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order1 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let order2 = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();

        // First fill at ts=2000
        let fill1 = TestOrderEventStubs::filled(
            &order1,
            &audusd_sim,
            Some(TradeId::new("t1")),
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            None,
            Some(UnixNanos::from(2_000u64)),
            None,
        );
        let mut position = Position::new(&audusd_sim, fill1.into());
        assert_eq!(position.ts_opened, UnixNanos::from(2_000u64));

        // Second fill at ts=1000 (earlier than position open)
        let fill2 = TestOrderEventStubs::filled(
            &order2,
            &audusd_sim,
            Some(TradeId::new("t2")),
            None,
            Some(Price::from("1.00002")),
            None,
            None,
            None,
            Some(UnixNanos::from(1_000u64)),
            None,
        );

        // Should not panic; ts_opened and opening_order_id stay unchanged
        position.apply(&fill2.into());
        assert_eq!(position.ts_opened, UnixNanos::from(2_000u64));
        assert_eq!(position.opening_order_id, order1.client_order_id());
        assert_eq!(position.events.len(), 2);
    }

    #[rstest]
    fn test_position_close_before_open_clamps_duration(audusd_sim: CurrencyPair) {
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let opening_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();
        let closing_order = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Sell)
            .quantity(Quantity::from(100_000))
            .build();
        let opening_fill = TestOrderEventStubs::filled(
            &opening_order,
            &audusd_sim,
            Some(TradeId::new("OPEN")),
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            None,
            Some(UnixNanos::from(2_000u64)),
            None,
        );
        let closing_fill = TestOrderEventStubs::filled(
            &closing_order,
            &audusd_sim,
            Some(TradeId::new("CLOSE")),
            None,
            Some(Price::from("1.00002")),
            None,
            None,
            None,
            Some(UnixNanos::from(1_000u64)),
            None,
        );
        let mut position = Position::new(&audusd_sim, opening_fill.into());

        position.apply(&closing_fill.into());

        assert_eq!(position.side, PositionSide::Flat);
        assert_eq!(position.ts_opened, UnixNanos::from(2_000u64));
        assert_eq!(position.ts_closed, Some(UnixNanos::from(1_000u64)));
        assert_eq!(position.duration_ns, DurationNanos::default());
        assert_eq!(
            position.closing_order_id,
            Some(closing_order.client_order_id())
        );
    }

    #[rstest]
    fn test_position_commissions_multi_currency_insertion_order(audusd_sim: CurrencyPair) {
        // Locks in IndexMap iteration order for Position::commissions:
        // new currencies append to the end, existing currencies accumulate
        // in place. PositionSnapshot.commissions builds its Vec from this
        // iteration; the order must be deterministic across runs.
        let audusd_sim = InstrumentAny::CurrencyPair(audusd_sim);
        let order_template = OrderTestBuilder::new(OrderType::Market)
            .instrument_id(audusd_sim.id())
            .side(OrderSide::Buy)
            .quantity(Quantity::from(100_000))
            .build();

        let fill_usd = TestOrderEventStubs::filled(
            &order_template,
            &audusd_sim,
            Some(TradeId::new("t1")),
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            Some(Money::from("1.0 USD")),
            None,
            None,
        );
        let mut position = Position::new(&audusd_sim, fill_usd.into());

        let fill_usdt = TestOrderEventStubs::filled(
            &order_template,
            &audusd_sim,
            Some(TradeId::new("t2")),
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            Some(Money::from("2.0 USDT")),
            None,
            None,
        );
        position.apply(&fill_usdt.into());

        let fill_usd_again = TestOrderEventStubs::filled(
            &order_template,
            &audusd_sim,
            Some(TradeId::new("t3")),
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            Some(Money::from("0.5 USD")),
            None,
            None,
        );
        position.apply(&fill_usd_again.into());

        let fill_btc = TestOrderEventStubs::filled(
            &order_template,
            &audusd_sim,
            Some(TradeId::new("t4")),
            None,
            Some(Price::from("1.00001")),
            None,
            None,
            Some(Money::from("0.0001 BTC")),
            None,
            None,
        );
        position.apply(&fill_btc.into());

        // USD entered first and accumulates in place, USDT appends second,
        // BTC appends third
        assert_eq!(
            position.commissions(),
            vec![
                Money::from("1.5 USD"),
                Money::from("2.0 USDT"),
                Money::from("0.0001 BTC"),
            ]
        );
    }

    #[rstest]
    fn test_fold_net_position_empty() {
        let (net_qty, net_px) = fold_net_position(&[]);
        assert_eq!(net_qty, Decimal::ZERO);
        assert_eq!(net_px, Decimal::ZERO);
    }

    #[rstest]
    fn test_fold_net_position_single_long() {
        let legs = [(dec!(100), dec!(1.5), 1u64)];
        let (net_qty, net_px) = fold_net_position(&legs);
        assert_eq!(net_qty, dec!(100));
        assert_eq!(net_px, dec!(1.5));
    }

    #[rstest]
    fn test_fold_net_position_single_short() {
        let legs = [(dec!(-100), dec!(1.5), 1u64)];
        let (net_qty, net_px) = fold_net_position(&legs);
        assert_eq!(net_qty, dec!(-100));
        assert_eq!(net_px, dec!(1.5));
    }

    #[rstest]
    fn test_fold_net_position_same_side_weighted_average() {
        // Long 100 @ 1.00, long 200 @ 0.50 -> net 300 @ 0.6667 (rounded weighted avg).
        let legs = [(dec!(100), dec!(1.0), 1u64), (dec!(200), dec!(0.5), 2u64)];
        let (net_qty, net_px) = fold_net_position(&legs);
        assert_eq!(net_qty, dec!(300));
        // (100 * 1.0 + 200 * 0.5) / 300 = 200/300 = 0.6666...
        assert_eq!(net_px, dec!(200) / dec!(300));
    }

    #[rstest]
    fn test_fold_net_position_partial_close_preserves_avg() {
        // Long 300 @ 0.80, short 100 @ 1.00 -> net long 200 @ 0.80 (short closes part of long).
        let legs = [
            (dec!(300), dec!(0.80), 1u64),
            (dec!(-100), dec!(1.00), 2u64),
        ];
        let (net_qty, net_px) = fold_net_position(&legs);
        assert_eq!(net_qty, dec!(200));
        assert_eq!(net_px, dec!(0.80));
    }

    #[rstest]
    fn test_fold_net_position_full_close() {
        let legs = [(dec!(100), dec!(1.0), 1u64), (dec!(-100), dec!(2.0), 2u64)];
        let (net_qty, net_px) = fold_net_position(&legs);
        assert_eq!(net_qty, Decimal::ZERO);
        assert_eq!(net_px, Decimal::ZERO);
    }

    #[rstest]
    fn test_fold_net_position_single_flip_uses_flipping_price() {
        // L100@1, S50@2 partial-closes to L50@1, S100@3 flips to S50 @ 3
        let legs = [
            (dec!(100), dec!(1.00), 1u64),
            (dec!(-50), dec!(2.00), 2u64),
            (dec!(-100), dec!(3.00), 3u64),
        ];
        let (net_qty, net_px) = fold_net_position(&legs);
        assert_eq!(net_qty, dec!(-50));
        assert_eq!(net_px, dec!(3.00));
    }

    #[rstest]
    fn test_fold_net_position_double_flip() {
        // L50, S100 flips to S50@2, B100 flips to L50@3
        let legs = [
            (dec!(50), dec!(1.00), 1u64),
            (dec!(-100), dec!(2.00), 2u64),
            (dec!(100), dec!(3.00), 3u64),
        ];
        let (net_qty, net_px) = fold_net_position(&legs);
        assert_eq!(net_qty, dec!(50));
        assert_eq!(net_px, dec!(3.00));
    }

    #[rstest]
    fn test_fold_net_position_zero_quantity_legs_skipped() {
        // Zero-qty legs are filtered out (closed positions have signed_qty == 0)
        let legs = [
            (dec!(100), dec!(1.0), 1u64),
            (Decimal::ZERO, dec!(99.0), 2u64),
            (dec!(50), dec!(2.0), 3u64),
        ];
        let (net_qty, net_px) = fold_net_position(&legs);
        assert_eq!(net_qty, dec!(150));
        // (100 * 1.0 + 50 * 2.0) / 150 = 200/150 = 1.333
        assert_eq!(net_px, dec!(200) / dec!(150));
    }

    #[rstest]
    fn test_fold_net_position_stable_sort_preserves_input_order_for_equal_ts() {
        // Caller owns tie-breaking; this pins the input-order contract for equal-ts legs
        let leg_a = (dec!(100), dec!(1.00), 1u64);
        let leg_b = (dec!(-100), dec!(2.00), 1u64);

        let ab = [leg_a, leg_b];
        let ba = [leg_b, leg_a];

        // a-then-b: L100@1, S100@2 -> net zero
        assert_eq!(fold_net_position(&ab), (Decimal::ZERO, Decimal::ZERO));
        // b-then-a: S100@2, B100@1 -> net zero
        assert_eq!(fold_net_position(&ba), (Decimal::ZERO, Decimal::ZERO));

        // Same-ts legs that do NOT fully cancel: input order picks the surviving avg
        let leg_c = (dec!(150), dec!(1.00), 1u64);
        let leg_d = (dec!(-100), dec!(2.00), 1u64);
        let cd = [leg_c, leg_d];
        let dc = [leg_d, leg_c];
        // c-then-d: L150@1, S100@2 -> long 50 @ 1
        assert_eq!(fold_net_position(&cd), (dec!(50), dec!(1.00)));
        // d-then-c: S100@2, B150@1 -> flip to long, residual @ 1
        assert_eq!(fold_net_position(&dc), (dec!(50), dec!(1.00)));
    }

    #[rstest]
    fn test_fold_net_position_close_then_reopen() {
        // A leg after a full close opens fresh (new net, new avg)
        let legs = [
            (dec!(100), dec!(1.00), 1u64),
            (dec!(-100), dec!(1.50), 2u64),
            (dec!(50), dec!(3.00), 3u64),
        ];
        let (net_qty, net_px) = fold_net_position(&legs);
        assert_eq!(net_qty, dec!(50));
        assert_eq!(net_px, dec!(3.00));
    }

    #[rstest]
    fn test_fold_net_position_orders_by_ts_opened() {
        // Sorted vs shuffled input must fold to the same result.
        let in_order = [
            (dec!(100), dec!(1.00), 1u64),
            (dec!(-50), dec!(2.00), 2u64),
            (dec!(-100), dec!(3.00), 3u64),
        ];
        let shuffled = [
            (dec!(-100), dec!(3.00), 3u64),
            (dec!(100), dec!(1.00), 1u64),
            (dec!(-50), dec!(2.00), 2u64),
        ];
        assert_eq!(fold_net_position(&in_order), fold_net_position(&shuffled));
    }

    // Build a NETTING-mode reference Position by applying fills sorted by ts_opened
    // (the same order fold_net_position uses). Returns (signed_qty, avg_px_open) as Decimals.
    fn netting_reference(
        instrument: &InstrumentAny,
        fills: &[(OrderSide, u32, u32, u64)],
    ) -> (Decimal, Decimal) {
        let mut sorted_fills = fills.to_vec();
        sorted_fills.sort_by_key(|(_, _, _, ts)| *ts);

        let mut position: Option<Position> = None;

        for (idx, &(side, qty, px, ts)) in sorted_fills.iter().enumerate() {
            let order = OrderTestBuilder::new(OrderType::Market)
                .instrument_id(instrument.id())
                .side(side)
                .quantity(Quantity::from(qty))
                .build();
            let fill = TestOrderEventStubs::filled(
                &order,
                instrument,
                Some(TradeId::new(format!("T{idx}").as_str())),
                Some(PositionId::new("P-NET")),
                Some(Price::from(px.to_string().as_str())),
                None,
                None,
                Some(Money::new(0.0, instrument.quote_currency())),
                Some(UnixNanos::from(ts)),
                None,
            );
            let event: OrderFilled = fill.into();
            if let Some(p) = position.as_mut() {
                p.apply(&event);
            } else {
                position = Some(Position::new(instrument, event));
            }
        }
        let p = position.expect("at least one fill");
        let signed = Decimal::try_from(p.signed_qty).unwrap_or(Decimal::ZERO);
        let px = Decimal::try_from(p.avg_px_open).unwrap_or(Decimal::ZERO);
        (signed, px)
    }

    // Build the HEDGING leg list (one leg per fill) as Decimal tuples.
    fn hedging_legs(fills: &[(OrderSide, u32, u32, u64)]) -> Vec<(Decimal, Decimal, u64)> {
        fills
            .iter()
            .map(|&(side, qty, px, ts)| {
                let signed = if side == OrderSide::Buy {
                    Decimal::from(qty)
                } else {
                    -Decimal::from(qty)
                };
                (signed, Decimal::from(px), ts)
            })
            .collect()
    }

    proptest! {
        // For any fill sequence that does not fully close mid-stream, fold_net_position
        // produces the same (signed_qty, avg_px_open) as applying the same fills in order
        // to a single NETTING-mode Position. Sequences that pass through zero mid-stream are
        // filtered out because Position::apply does not reset avg_px_open on the next fill
        // after a close (production fills are pre-split before reaching that path).
        #[rstest]
        fn prop_fold_matches_netting_replay(
            fills in proptest::collection::vec(
                (
                    prop_oneof![Just(OrderSide::Buy), Just(OrderSide::Sell)],
                    1u32..1_000u32,
                    1u32..100u32,
                    0u64..1_000_000u64,
                ),
                1..6,
            )
        ) {
            // Filter sequences with duplicate ts_opened: equal-ts ties resolve to stable
            // input order, but the proptest generator does not preserve ties meaningfully.
            let mut seen_ts: AHashSet<u64> = AHashSet::new();
            for &(_, _, _, ts) in &fills {
                if !seen_ts.insert(ts) {
                    prop_assume!(false);
                }
            }

            // Filter sequences that fully close mid-stream on the sorted (ts_opened) order.
            // Position::apply on a closed position does not reset avg_px_open on the next
            // re-open fill (production fills are pre-split, so the path is not exercised).
            let mut sorted_fills = fills.clone();
            sorted_fills.sort_by_key(|(_, _, _, ts)| *ts);
            let mut running: i64 = 0;
            let mut zero_mid = false;

            for (idx, &(side, qty, _, _)) in sorted_fills.iter().enumerate() {
                let qty_i64 = i64::from(qty);
                let signed: i64 = if side == OrderSide::Buy {
                    qty_i64
                } else {
                    -qty_i64
                };
                running += signed;
                if idx + 1 < sorted_fills.len() && running == 0 {
                    zero_mid = true;
                    break;
                }
            }
            prop_assume!(!zero_mid);

            let instrument = InstrumentAny::CurrencyPair(audusd_sim());
            let (ref_qty, ref_px) = netting_reference(&instrument, &fills);
            let legs = hedging_legs(&fills);
            let (fold_qty, fold_px) = fold_net_position(&legs);

            prop_assert_eq!(fold_qty, ref_qty);

            // avg_px_open is only meaningful when the position is non-flat. Compare via
            // f64 round-trip since the reference goes through Position::apply f64 arithmetic;
            // fold's full-precision Decimal is more accurate but not exactly equal.
            if !ref_qty.is_zero() {
                let fold_px_f64 = fold_px.to_f64().unwrap_or(0.0);
                let ref_px_f64 = ref_px.to_f64().unwrap_or(0.0);
                let max_mag = fold_px_f64.abs().max(ref_px_f64.abs()).max(1.0);
                prop_assert!(
                    (fold_px_f64 - ref_px_f64).abs() < 1e-9 * max_mag,
                    "fold_px {fold_px_f64} vs ref_px {ref_px_f64}",
                );
            }
        }
    }

    fn matching_fill_void(
        fill: &OrderFilled,
        voided_qty: Quantity,
        commission_voided: Option<Money>,
    ) -> OrderFillVoided {
        OrderFillVoidedSpec::builder()
            .trader_id(fill.trader_id)
            .strategy_id(fill.strategy_id)
            .instrument_id(fill.instrument_id)
            .client_order_id(fill.client_order_id)
            .venue_order_id(fill.venue_order_id)
            .account_id(fill.account_id)
            .trade_id(fill.trade_id)
            .voided_qty(voided_qty)
            .order_side(fill.order_side)
            .order_type(fill.order_type)
            .last_px(fill.last_px)
            .currency(fill.currency)
            .liquidity_side(fill.liquidity_side)
            .maybe_position_id(fill.position_id)
            .maybe_commission_voided(commission_voided)
            .build()
    }
}