Skip to main content

nautilus_betfair/stream/
parse.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Parsing utilities that convert Betfair stream messages into Nautilus domain models.
17//!
18//! MCM (Market Change Messages) are parsed into order book deltas, trade ticks,
19//! and instrument status updates. OCM (Order Change Messages) are parsed into
20//! order status reports and fill reports.
21
22use ahash::{AHashMap, AHashSet};
23use nautilus_core::UnixNanos;
24use nautilus_model::{
25    data::{
26        BookOrder, InstrumentClose, InstrumentStatus, OrderBookDelta, OrderBookDeltas, TradeTick,
27    },
28    enums::{
29        AggressorSide, BookAction, InstrumentCloseType, LiquiditySide, MarketStatusAction,
30        OrderSide, OrderStatus, OrderType, RecordFlag, TimeInForce,
31    },
32    identifiers::{AccountId, ClientOrderId, InstrumentId, TradeId, VenueOrderId},
33    reports::{FillReport, OrderStatusReport},
34    types::{Currency, Money, Price, Quantity},
35};
36use rust_decimal::Decimal;
37
38use crate::{
39    common::{
40        enums::{
41            MarketStatus, RunnerStatus, StreamingOrderStatus, StreamingOrderType,
42            resolve_streaming_order_status,
43        },
44        parse::{
45            make_instrument_id, normalize_betfair_price, normalize_betfair_quantity,
46            parse_betfair_price, parse_betfair_quantity, parse_millis_timestamp,
47        },
48    },
49    data_types::{
50        BetfairBspBookDelta, BetfairCricketMatch, BetfairRaceProgress, BetfairRaceRunnerData,
51        BetfairStartingPrice, BetfairTicker,
52    },
53    stream::messages::{
54        CricketChange, MarketDefinition, RaceProgressChange, RaceRunnerChange, RunnerChange,
55        UnmatchedOrder,
56    },
57};
58
59/// Parses a single runner's book data into [`OrderBookDeltas`].
60///
61/// Handles both full image snapshots (`is_snapshot = true`) and delta updates.
62///
63/// Only processes price-keyed fields (`atb`/`atl`). Level-indexed fields
64/// (`batb`/`batl`/`bdatb`/`bdatl`) are ignored because correct delta
65/// processing requires stateful level-to-price tracking. The stream
66/// subscription should use `EX_ALL_OFFERS` which populates `atb`/`atl`.
67///
68/// Book side mapping (Betfair exchange convention):
69/// - `atb` (available to back) -> [`OrderSide::Buy`] (bid side)
70/// - `atl` (available to lay) -> [`OrderSide::Sell`] (ask side)
71///
72/// For snapshots: emits a Clear delta followed by Add deltas for each level.
73/// For updates: emits Update or Delete (when volume is zero) deltas.
74///
75/// Returns `Ok(None)` if the runner change contains no processable book data.
76///
77/// # Errors
78///
79/// Returns an error if price or quantity values cannot be converted.
80pub fn parse_runner_book_deltas(
81    instrument_id: InstrumentId,
82    rc: &RunnerChange,
83    is_snapshot: bool,
84    sequence: u64,
85    ts_event: UnixNanos,
86    ts_init: UnixNanos,
87) -> anyhow::Result<Option<OrderBookDeltas>> {
88    let atb_len = rc.atb.as_ref().map_or(0, Vec::len);
89    let atl_len = rc.atl.as_ref().map_or(0, Vec::len);
90    let total_levels = atb_len + atl_len;
91
92    if total_levels == 0 && !is_snapshot {
93        return Ok(None);
94    }
95
96    let snapshot_flags = if is_snapshot {
97        RecordFlag::F_SNAPSHOT as u8
98    } else {
99        0
100    };
101    let mut deltas = Vec::with_capacity(total_levels + usize::from(is_snapshot));
102
103    if is_snapshot {
104        let mut clear = OrderBookDelta::clear(instrument_id, sequence, ts_event, ts_init);
105
106        if total_levels == 0 {
107            clear.flags |= RecordFlag::F_LAST as u8;
108        }
109        deltas.push(clear);
110    }
111
112    for (levels, side) in [
113        (rc.atb.as_deref().unwrap_or(&[]), OrderSide::Buy),
114        (rc.atl.as_deref().unwrap_or(&[]), OrderSide::Sell),
115    ] {
116        for pv in levels {
117            if is_snapshot && pv.volume == Decimal::ZERO {
118                continue;
119            }
120
121            let action = if is_snapshot {
122                BookAction::Add
123            } else if pv.volume == Decimal::ZERO {
124                BookAction::Delete
125            } else {
126                BookAction::Update
127            };
128
129            deltas.push(OrderBookDelta::new(
130                instrument_id,
131                action,
132                BookOrder::new(
133                    side,
134                    parse_betfair_price(pv.price)?,
135                    parse_betfair_quantity(pv.volume)?,
136                    0,
137                ),
138                snapshot_flags,
139                sequence,
140                ts_event,
141                ts_init,
142            ));
143        }
144    }
145
146    // Set F_LAST on the final delta
147    if let Some(last) = deltas.last_mut() {
148        last.flags |= RecordFlag::F_LAST as u8;
149    }
150
151    Ok(Some(OrderBookDeltas::new(instrument_id, deltas)))
152}
153
154/// Creates a [`TradeTick`] from stream data.
155///
156/// Betfair does not identify the aggressor side in its stream, so
157/// [`AggressorSide::NoAggressor`] is always used.
158#[must_use]
159pub fn make_trade_tick(
160    instrument_id: InstrumentId,
161    price: Price,
162    size: Quantity,
163    trade_id: TradeId,
164    ts_event: UnixNanos,
165    ts_init: UnixNanos,
166) -> TradeTick {
167    TradeTick::new(
168        instrument_id,
169        price,
170        size,
171        AggressorSide::NoAggressor,
172        trade_id,
173        ts_event,
174        ts_init,
175    )
176}
177
178/// Produces per-runner [`InstrumentStatus`] events from a market definition.
179///
180/// Iterates `def.runners` and maps each runner's lifecycle to a Nautilus status.
181/// Scratched runners (`Removed`, `RemovedVacant`) close immediately regardless
182/// of market-level state. The `in_play` flag distinguishes pre-open (Open + not
183/// in play) from active trading (Open + in play).
184///
185/// Returns an empty vector when `def.status` or `def.runners` is missing.
186#[must_use]
187pub fn parse_instrument_statuses(
188    market_id: &str,
189    def: &MarketDefinition,
190    ts_event: UnixNanos,
191    ts_init: UnixNanos,
192) -> Vec<InstrumentStatus> {
193    let Some(status) = def.status else {
194        return Vec::new();
195    };
196    let Some(runners) = &def.runners else {
197        return Vec::new();
198    };
199    let in_play = def.in_play.unwrap_or(false);
200
201    if status == MarketStatus::Unknown {
202        log::warn!("Skipping unmodeled Betfair market status for market {market_id}");
203        return Vec::new();
204    }
205
206    runners
207        .iter()
208        .filter_map(|rd| {
209            let handicap = rd.hc.unwrap_or(Decimal::ZERO);
210            let instrument_id = make_instrument_id(market_id, rd.id, handicap);
211            if rd.status == Some(RunnerStatus::Unknown) {
212                log::warn!("Skipping unmodeled Betfair runner status for {instrument_id}");
213                return None;
214            }
215            let action = match rd.status {
216                Some(RunnerStatus::Removed | RunnerStatus::RemovedVacant) => {
217                    MarketStatusAction::Close
218                }
219                _ => match (status, in_play) {
220                    (MarketStatus::Inactive, _) => MarketStatusAction::Close,
221                    (MarketStatus::Open, false) => MarketStatusAction::PreOpen,
222                    (MarketStatus::Open, true) => MarketStatusAction::Trading,
223                    (MarketStatus::Suspended, _) => MarketStatusAction::Pause,
224                    (MarketStatus::Closed, _) => MarketStatusAction::Close,
225                    // Unreachable: unmodeled market status skips the whole definition above.
226                    (MarketStatus::Unknown, _) => MarketStatusAction::None,
227                },
228            };
229            let is_trading = action == MarketStatusAction::Trading;
230            Some(InstrumentStatus::new(
231                instrument_id,
232                action,
233                ts_event,
234                ts_init,
235                None,
236                None,
237                Some(is_trading),
238                None,
239                None,
240            ))
241        })
242        .collect()
243}
244
245/// Generates a deterministic [`TradeId`] for a Betfair fill.
246///
247/// Uses `bet_id` and cumulative `sm` (size matched) which together uniquely
248/// identify each fill state, since `sm` increases monotonically with each fill.
249pub fn make_trade_id(uo: &UnmatchedOrder) -> TradeId {
250    let sm = normalize_betfair_quantity(uo.sm.unwrap_or(Decimal::ZERO));
251    make_trade_id_for_size(&uo.id, sm)
252}
253
254/// Tracks cumulative fill state per bet to compute incremental fills from the
255/// Betfair OCM stream.
256///
257/// Betfair provides cumulative `sm` (size matched) and `avp` (average price
258/// matched) on each order update. This tracker maintains per-bet state to
259/// derive individual fill quantities and prices for each update.
260#[derive(Clone, Debug, Default)]
261pub struct FillTracker {
262    filled_qty: AHashMap<String, Decimal>,
263    voided_qty: AHashMap<String, Decimal>,
264    avg_px: AHashMap<String, Decimal>,
265    published_trade_ids: AHashSet<String>,
266    fill_lots: AHashMap<String, Vec<FillLot>>,
267    fill_voids: AHashMap<(String, TradeId), Decimal>,
268}
269
270#[derive(Debug, Clone)]
271struct FillLot {
272    trade_id: TradeId,
273    quantity: Decimal,
274    price: Price,
275    accounting_px: Price,
276}
277
278/// One cumulative per-fill allocation derived from Betfair's cumulative `sv`.
279#[derive(Debug, Clone)]
280pub struct FillVoidAllocation {
281    pub trade_id: TradeId,
282    pub voided_qty: Quantity,
283    pub last_px: Price,
284}
285
286impl FillTracker {
287    /// Creates a new [`FillTracker`] instance.
288    #[must_use]
289    pub fn new() -> Self {
290        Self::default()
291    }
292
293    /// Computes a [`FillReport`] for an unmatched order update.
294    ///
295    /// A new fill is incremental. A price restatement repeats the surviving lot's trade ID
296    /// when matched and voided quantities are unchanged, the average changed, and exactly one
297    /// lot survives. Returns `None` when those conditions are not met, including a duplicate
298    /// trade ID or an overfill.
299    #[expect(clippy::too_many_arguments)]
300    pub fn maybe_fill_report(
301        &mut self,
302        uo: &UnmatchedOrder,
303        order_qty: Decimal,
304        instrument_id: InstrumentId,
305        account_id: AccountId,
306        currency: Currency,
307        ts_event: UnixNanos,
308        ts_init: UnixNanos,
309    ) -> Option<FillReport> {
310        let raw_sm = uo.sm?;
311        let sm = normalize_betfair_quantity(raw_sm);
312        let order_qty = normalize_betfair_quantity(resolve_stream_order_quantity(order_qty, uo));
313
314        if sm > order_qty {
315            log::warn!(
316                "Rejecting potential overfill for bet_id={}: order_qty={order_qty}, sm={sm}",
317                uo.id,
318            );
319            return None;
320        }
321
322        let (trade_id, last_qty, last_px) =
323            if uo.sv.is_some_and(|sv| sv > Decimal::ZERO) && self.has_fill_lots(&uo.id) {
324                self.advance_cumulative_fill_with_voids(
325                    &uo.id,
326                    raw_sm,
327                    uo.sv.unwrap_or(Decimal::ZERO),
328                    uo.avp,
329                    uo.p,
330                )?
331            } else {
332                self.advance_cumulative_fill(&uo.id, raw_sm, uo.avp, uo.p)?
333            };
334
335        let venue_order_id = VenueOrderId::from(uo.id.as_str());
336        let order_side = OrderSide::from(uo.side);
337        let client_order_id = uo
338            .rfo
339            .as_deref()
340            .filter(|s| !s.is_empty())
341            .map(ClientOrderId::from);
342        let ts_fill = uo.md.map_or(ts_event, parse_millis_timestamp);
343
344        Some(make_fill_report(
345            account_id,
346            instrument_id,
347            venue_order_id,
348            trade_id,
349            order_side,
350            last_qty,
351            last_px,
352            currency,
353            client_order_id,
354            ts_fill,
355            ts_init,
356        ))
357    }
358
359    pub(crate) fn advance_cumulative_fill(
360        &mut self,
361        bet_id: &str,
362        raw_size_matched: Decimal,
363        average_price_matched: Option<Decimal>,
364        fallback_price: Decimal,
365    ) -> Option<(TradeId, Quantity, Price)> {
366        self.advance_cumulative_fill_inner(
367            bet_id,
368            raw_size_matched,
369            None,
370            average_price_matched,
371            fallback_price,
372        )
373    }
374
375    pub(crate) fn advance_cumulative_fill_with_voids(
376        &mut self,
377        bet_id: &str,
378        raw_size_matched: Decimal,
379        cumulative_voided: Decimal,
380        average_price_matched: Option<Decimal>,
381        fallback_price: Decimal,
382    ) -> Option<(TradeId, Quantity, Price)> {
383        self.advance_cumulative_fill_inner(
384            bet_id,
385            raw_size_matched,
386            Some(cumulative_voided),
387            average_price_matched,
388            fallback_price,
389        )
390    }
391
392    fn advance_cumulative_fill_inner(
393        &mut self,
394        bet_id: &str,
395        raw_size_matched: Decimal,
396        cumulative_voided: Option<Decimal>,
397        average_price_matched: Option<Decimal>,
398        fallback_price: Decimal,
399    ) -> Option<(TradeId, Quantity, Price)> {
400        let size_matched = normalize_betfair_quantity(raw_size_matched);
401        if size_matched <= Decimal::ZERO {
402            return None;
403        }
404
405        let previous_filled = self
406            .filled_qty
407            .get(bet_id)
408            .copied()
409            .map_or(Decimal::ZERO, normalize_betfair_quantity);
410
411        if size_matched == previous_filled {
412            let restatement =
413                self.matched_price_restatement(bet_id, cumulative_voided, average_price_matched);
414            if let Some((_, _, last_px)) = restatement {
415                self.set_surviving_accounting_px(bet_id, last_px);
416            }
417
418            self.record_cumulative_state(bet_id, size_matched, average_price_matched);
419            return restatement;
420        }
421
422        if size_matched < previous_filled {
423            return None;
424        }
425
426        let trade_id = make_trade_id_for_size(bet_id, size_matched);
427        let raw_trade_id = make_trade_id_for_size(bet_id, raw_size_matched);
428        if self.published_trade_ids.contains(trade_id.as_str())
429            || self.published_trade_ids.contains(raw_trade_id.as_str())
430        {
431            self.record_cumulative_state(bet_id, size_matched, average_price_matched);
432            self.published_trade_ids.insert(trade_id.to_string());
433            return None;
434        }
435
436        let fill_qty = size_matched - previous_filled;
437        let fill_price = if let Some(cumulative_voided) = cumulative_voided {
438            self.compute_fill_price_with_voids(
439                bet_id,
440                average_price_matched,
441                fallback_price,
442                size_matched,
443                fill_qty,
444                cumulative_voided,
445            )
446        } else {
447            self.compute_fill_price(
448                bet_id,
449                average_price_matched,
450                fallback_price,
451                previous_filled,
452                size_matched,
453            )
454        };
455        let last_qty = parse_betfair_quantity(fill_qty).ok()?;
456        let last_px = parse_betfair_price(fill_price).ok()?;
457
458        self.record_cumulative_state(bet_id, size_matched, average_price_matched);
459        self.published_trade_ids.insert(trade_id.to_string());
460        self.fill_lots
461            .entry(bet_id.to_string())
462            .or_default()
463            .push(FillLot {
464                trade_id,
465                quantity: fill_qty,
466                price: last_px,
467                accounting_px: last_px,
468            });
469
470        Some((trade_id, last_qty, last_px))
471    }
472
473    /// Allocates cumulative Betfair `sv` to known applied fill lots, newest first.
474    ///
475    /// First-seen voids without known fill lots are recorded but emit no correction.
476    pub fn maybe_fill_voids(&mut self, uo: &UnmatchedOrder) -> Vec<FillVoidAllocation> {
477        let cumulative = normalize_betfair_quantity(uo.sv.unwrap_or(Decimal::ZERO));
478        let previous = self
479            .voided_qty
480            .get(&uo.id)
481            .copied()
482            .unwrap_or(Decimal::ZERO);
483
484        if cumulative <= previous {
485            return Vec::new();
486        }
487
488        let Some(lots) = self.fill_lots.get(&uo.id) else {
489            self.voided_qty.insert(uo.id.clone(), cumulative);
490            return Vec::new();
491        };
492        let mut remaining = cumulative - previous;
493        let mut desired = Vec::new();
494
495        for lot in lots.iter().rev() {
496            if remaining <= Decimal::ZERO {
497                break;
498            }
499            let key = (uo.id.clone(), lot.trade_id);
500            let prior = self.fill_voids.get(&key).copied().unwrap_or(Decimal::ZERO);
501            let available = lot.quantity.saturating_sub(prior);
502            let increment = remaining.min(available);
503            if increment > Decimal::ZERO {
504                desired.push((lot, prior + increment));
505                remaining -= increment;
506            }
507        }
508
509        if remaining > Decimal::ZERO {
510            log::warn!(
511                "Betfair cumulative void exceeds known fill lots for bet_id={}: sv={cumulative}, unmatched={remaining}",
512                uo.id,
513            );
514            return Vec::new();
515        }
516
517        let mut updates = Vec::new();
518
519        for (lot, allocation) in desired.into_iter().rev() {
520            let key = (uo.id.clone(), lot.trade_id);
521            let Ok(voided_qty) = parse_betfair_quantity(allocation) else {
522                continue;
523            };
524            self.fill_voids.insert(key, allocation);
525            updates.push(FillVoidAllocation {
526                trade_id: lot.trade_id,
527                voided_qty,
528                last_px: lot.price,
529            });
530        }
531        self.voided_qty.insert(uo.id.clone(), cumulative);
532        updates
533    }
534
535    #[must_use]
536    pub(crate) fn has_fill_lots(&self, bet_id: &str) -> bool {
537        self.fill_lots
538            .get(bet_id)
539            .is_some_and(|lots| !lots.is_empty())
540    }
541
542    /// Returns whether a cumulative Betfair void update has not yet been applied.
543    #[must_use]
544    pub fn has_unseen_fill_void(&self, uo: &UnmatchedOrder) -> bool {
545        let cumulative = normalize_betfair_quantity(uo.sv.unwrap_or(Decimal::ZERO));
546        let previous = self
547            .voided_qty
548            .get(&uo.id)
549            .copied()
550            .unwrap_or(Decimal::ZERO);
551        cumulative > previous
552    }
553
554    /// Returns whether an unchanged matched and voided quantity carries a new average while
555    /// exactly one fill lot survives, without recording that average.
556    #[must_use]
557    pub(crate) fn has_pending_price_restatement(
558        &self,
559        bet_id: &str,
560        size_matched: Decimal,
561        size_voided: Decimal,
562        average_price_matched: Option<Decimal>,
563    ) -> bool {
564        let size_voided = normalize_betfair_quantity(size_voided);
565        let previous_voided = self
566            .voided_qty
567            .get(bet_id)
568            .copied()
569            .unwrap_or(Decimal::ZERO);
570
571        if size_voided > previous_voided {
572            return false;
573        }
574
575        let size_matched = normalize_betfair_quantity(size_matched);
576        let cumulative = if self.has_fill_lots(bet_id) {
577            size_matched + size_voided
578        } else {
579            size_matched
580        };
581
582        let previous = self
583            .filled_qty
584            .get(bet_id)
585            .copied()
586            .unwrap_or(Decimal::ZERO);
587
588        if cumulative != previous || cumulative <= Decimal::ZERO {
589            return false;
590        }
591
592        self.matched_price_restatement(bet_id, Some(size_voided), average_price_matched)
593            .is_some()
594    }
595
596    /// Returns whether an update with unchanged matched and voided quantities carries a new
597    /// average price while exactly one fill lot survives.
598    #[must_use]
599    pub(crate) fn has_unseen_price_restatement(&self, uo: &UnmatchedOrder) -> bool {
600        self.has_pending_price_restatement(
601            &uo.id,
602            uo.sm.unwrap_or(Decimal::ZERO),
603            uo.sv.unwrap_or(Decimal::ZERO),
604            uo.avp,
605        )
606    }
607
608    /// Returns whether a cumulative Betfair fill update has not yet been applied.
609    #[must_use]
610    pub fn has_unseen_fill(&self, uo: &UnmatchedOrder) -> bool {
611        let size_matched = normalize_betfair_quantity(uo.sm.unwrap_or(Decimal::ZERO));
612        let cumulative = if self.has_fill_lots(&uo.id) {
613            size_matched + normalize_betfair_quantity(uo.sv.unwrap_or(Decimal::ZERO))
614        } else {
615            size_matched
616        };
617        let previous = self
618            .filled_qty
619            .get(&uo.id)
620            .copied()
621            .unwrap_or(Decimal::ZERO);
622        let order_qty = normalize_betfair_quantity(resolve_stream_order_quantity(uo.s, uo));
623        cumulative > previous && cumulative <= order_qty
624    }
625
626    pub(crate) fn sync_fill_lot(
627        &mut self,
628        bet_id: &str,
629        trade_id: TradeId,
630        quantity: Decimal,
631        price: Price,
632        voided_qty: Decimal,
633    ) {
634        let lots = self.fill_lots.entry(bet_id.to_string()).or_default();
635        if let Some(lot) = lots.iter_mut().find(|lot| lot.trade_id == trade_id) {
636            let stale_original = lot.accounting_px != price && price == lot.price;
637            if !stale_original {
638                lot.accounting_px = price;
639            }
640        } else {
641            lots.push(FillLot {
642                trade_id,
643                quantity: normalize_betfair_quantity(quantity),
644                price,
645                accounting_px: price,
646            });
647        }
648        let gross_filled = lots.iter().map(|lot| lot.quantity).sum();
649        self.filled_qty.insert(bet_id.to_string(), gross_filled);
650        self.published_trade_ids.insert(trade_id.to_string());
651        if voided_qty > Decimal::ZERO {
652            self.fill_voids.insert(
653                (bet_id.to_string(), trade_id),
654                normalize_betfair_quantity(voided_qty),
655            );
656        }
657    }
658
659    pub(crate) fn set_accounting_px(&mut self, bet_id: &str, trade_id: TradeId, price: Price) {
660        let Some(lots) = self.fill_lots.get_mut(bet_id) else {
661            return;
662        };
663
664        if let Some(lot) = lots.iter_mut().find(|lot| lot.trade_id == trade_id) {
665            lot.accounting_px = price;
666        }
667    }
668
669    pub(crate) fn matched_quantity(&self, bet_id: &str) -> Decimal {
670        let filled = self.filled_qty.get(bet_id).copied().unwrap_or_default();
671        let voided = self.voided_qty.get(bet_id).copied().unwrap_or_default();
672        (filled - voided).max(Decimal::ZERO)
673    }
674
675    pub(crate) fn voided_quantity(&self, bet_id: &str) -> Decimal {
676        self.voided_qty.get(bet_id).copied().unwrap_or_default()
677    }
678
679    pub(crate) fn sync_voided_qty(&mut self, bet_id: &str, voided_qty: Decimal) {
680        self.voided_qty
681            .insert(bet_id.to_string(), normalize_betfair_quantity(voided_qty));
682    }
683
684    fn matched_price_restatement(
685        &self,
686        bet_id: &str,
687        cumulative_voided: Option<Decimal>,
688        average_price_matched: Option<Decimal>,
689    ) -> Option<(TradeId, Quantity, Price)> {
690        if !self.size_voided_unchanged(bet_id, cumulative_voided) {
691            return None;
692        }
693
694        let avp = average_price_matched.map(normalize_betfair_price)?;
695        let prev_avg = self.avg_px.get(bet_id).copied()?;
696        if avp == prev_avg {
697            return None;
698        }
699
700        let (trade_id, surviving_qty) = self.single_surviving_lot(bet_id)?;
701
702        let Ok(last_qty) = parse_betfair_quantity(surviving_qty) else {
703            log::warn!("Cannot restate matched quantity {surviving_qty} for bet_id={bet_id}");
704            return None;
705        };
706
707        let Ok(last_px) = parse_betfair_price(avp) else {
708            log::warn!("Cannot restate matched price {avp} for bet_id={bet_id}");
709            return None;
710        };
711
712        Some((trade_id, last_qty, last_px))
713    }
714
715    fn set_surviving_accounting_px(&mut self, bet_id: &str, price: Price) {
716        let Some(lots) = self.fill_lots.get_mut(bet_id) else {
717            return;
718        };
719
720        for lot in lots.iter_mut() {
721            let voided = self
722                .fill_voids
723                .get(&(bet_id.to_string(), lot.trade_id))
724                .copied()
725                .unwrap_or(Decimal::ZERO);
726
727            if lot.quantity.saturating_sub(voided) > Decimal::ZERO {
728                lot.accounting_px = price;
729            }
730        }
731    }
732
733    fn size_voided_unchanged(&self, bet_id: &str, cumulative_voided: Option<Decimal>) -> bool {
734        let current = cumulative_voided.map_or(Decimal::ZERO, normalize_betfair_quantity);
735        let previous = self
736            .voided_qty
737            .get(bet_id)
738            .copied()
739            .unwrap_or(Decimal::ZERO);
740        current == previous
741    }
742
743    pub(crate) fn seed_missing_averages(&mut self) {
744        let bet_ids = self.fill_lots.keys().cloned().collect::<Vec<_>>();
745        for bet_id in bet_ids {
746            if self.avg_px.contains_key(&bet_id) {
747                continue;
748            }
749
750            let Some(lots) = self.fill_lots.get(&bet_id) else {
751                continue;
752            };
753
754            let mut quantity = Decimal::ZERO;
755            let mut notional = Decimal::ZERO;
756
757            for lot in lots {
758                let voided = self
759                    .fill_voids
760                    .get(&(bet_id.clone(), lot.trade_id))
761                    .copied()
762                    .unwrap_or(Decimal::ZERO);
763                let surviving = lot.quantity.saturating_sub(voided);
764                if surviving <= Decimal::ZERO {
765                    continue;
766                }
767
768                quantity += surviving;
769                notional += surviving * lot.accounting_px.as_decimal();
770            }
771
772            if quantity > Decimal::ZERO {
773                self.avg_px.insert(bet_id, notional / quantity);
774            }
775        }
776    }
777
778    fn single_surviving_lot(&self, bet_id: &str) -> Option<(TradeId, Decimal)> {
779        let lots = self.fill_lots.get(bet_id)?;
780
781        let mut surviving = lots.iter().filter_map(|lot| {
782            let voided = self
783                .fill_voids
784                .get(&(bet_id.to_string(), lot.trade_id))
785                .copied()
786                .unwrap_or(Decimal::ZERO);
787            let surviving_qty = lot.quantity.saturating_sub(voided);
788            (surviving_qty > Decimal::ZERO).then_some((lot.trade_id, surviving_qty))
789        });
790
791        let lot = surviving.next()?;
792        surviving.next().is_none().then_some(lot)
793    }
794
795    fn record_cumulative_state(
796        &mut self,
797        bet_id: &str,
798        size_matched: Decimal,
799        average_price_matched: Option<Decimal>,
800    ) {
801        self.filled_qty.insert(bet_id.to_string(), size_matched);
802        if let Some(avg_px) = average_price_matched.map(normalize_betfair_price) {
803            self.avg_px.insert(bet_id.to_string(), avg_px);
804        }
805    }
806
807    /// Back-calculates the individual fill price from Betfair's cumulative
808    /// average price matched (`avp`).
809    ///
810    /// For the first fill, the average price IS the fill price. For subsequent
811    /// fills, the individual price is derived from:
812    /// `fill_price = (avp * sm - prev_avp * prev_sm) / fill_size`
813    fn compute_fill_price(
814        &self,
815        bet_id: &str,
816        average_price_matched: Option<Decimal>,
817        fallback_price: Decimal,
818        prev_filled: Decimal,
819        sm: Decimal,
820    ) -> Decimal {
821        let Some(avp) = average_price_matched.map(normalize_betfair_price) else {
822            return fallback_price;
823        };
824
825        if prev_filled == Decimal::ZERO {
826            return avp;
827        }
828
829        let Some(prev_avg) = self.avg_px.get(bet_id).copied() else {
830            return avp;
831        };
832
833        if prev_avg == avp {
834            return avp;
835        }
836
837        let fill_size = sm - prev_filled;
838
839        if fill_size == Decimal::ZERO {
840            return prev_avg;
841        }
842
843        let fill_price = (avp * sm - prev_avg * prev_filled) / fill_size;
844
845        if fill_price <= Decimal::ZERO {
846            log::warn!(
847                "Calculated fill price {fill_price} is invalid for bet_id={bet_id}, falling back to avp={avp}",
848            );
849            return avp;
850        }
851
852        fill_price
853    }
854
855    fn compute_fill_price_with_voids(
856        &self,
857        bet_id: &str,
858        average_price_matched: Option<Decimal>,
859        fallback_price: Decimal,
860        gross_matched: Decimal,
861        fill_qty: Decimal,
862        cumulative_voided: Decimal,
863    ) -> Decimal {
864        let Some(avp) = average_price_matched.map(normalize_betfair_price) else {
865            return fallback_price;
866        };
867        let cumulative_voided = normalize_betfair_quantity(cumulative_voided);
868        let previous_voided = self
869            .voided_qty
870            .get(bet_id)
871            .copied()
872            .map_or(Decimal::ZERO, normalize_betfair_quantity);
873        let incremental_void = cumulative_voided.saturating_sub(previous_voided);
874        let surviving_fill_qty = fill_qty.saturating_sub(incremental_void);
875        if surviving_fill_qty <= Decimal::ZERO {
876            return avp;
877        }
878
879        let mut prior_notional = Decimal::ZERO;
880        let mut effective_lots = Vec::new();
881
882        if let Some(lots) = self.fill_lots.get(bet_id) {
883            for lot in lots {
884                let already_voided = self
885                    .fill_voids
886                    .get(&(bet_id.to_string(), lot.trade_id))
887                    .copied()
888                    .unwrap_or(Decimal::ZERO);
889                let effective = lot.quantity.saturating_sub(already_voided);
890                prior_notional += effective * lot.accounting_px.as_decimal();
891                effective_lots.push((effective, lot.accounting_px.as_decimal()));
892            }
893        }
894
895        let mut prior_void = incremental_void.saturating_sub(fill_qty);
896        for (effective, price) in effective_lots.into_iter().rev() {
897            if prior_void <= Decimal::ZERO {
898                break;
899            }
900            let removed = prior_void.min(effective);
901            prior_notional -= removed * price;
902            prior_void -= removed;
903        }
904
905        let surviving_matched = gross_matched.saturating_sub(cumulative_voided);
906        let fill_price = (avp * surviving_matched - prior_notional) / surviving_fill_qty;
907        if fill_price <= Decimal::ZERO {
908            log::warn!(
909                "Calculated post-void fill price {fill_price} is invalid for bet_id={bet_id}, falling back to avp={avp}",
910            );
911            return avp;
912        }
913        fill_price
914    }
915
916    /// Pre-populates state for a bet from existing order data.
917    ///
918    /// Monotonic in `filled_qty`: keeps the larger of the cached and
919    /// in-memory values so a cache that lags the tracker (engine has
920    /// not yet processed an emitted fill) cannot regress it.
921    pub fn sync_order(&mut self, bet_id: &str, filled_qty: Decimal, avg_px: Decimal) {
922        let filled_qty = normalize_betfair_quantity(filled_qty);
923        let avg_px = normalize_betfair_price(avg_px);
924        let current = self
925            .filled_qty
926            .get(bet_id)
927            .copied()
928            .map_or(Decimal::ZERO, normalize_betfair_quantity);
929
930        if filled_qty > current {
931            self.filled_qty.insert(bet_id.to_string(), filled_qty);
932            if avg_px > Decimal::ZERO {
933                self.avg_px.insert(bet_id.to_string(), avg_px);
934            }
935        }
936    }
937
938    /// Seeds the trade-id dedup set so fills already published via another
939    /// channel are not re-emitted when the post-reconnect image arrives.
940    pub fn seed_published_trade_ids<I, S>(&mut self, trade_ids: I)
941    where
942        I: IntoIterator<Item = S>,
943        S: Into<String>,
944    {
945        for id in trade_ids {
946            self.published_trade_ids.insert(id.into());
947        }
948    }
949
950    /// Removes state for a completed bet to prevent unbounded growth.
951    pub fn prune(&mut self, bet_id: &str) {
952        self.filled_qty.remove(bet_id);
953        self.voided_qty.remove(bet_id);
954        self.avg_px.remove(bet_id);
955        self.fill_lots.remove(bet_id);
956        self.fill_voids.retain(|(id, _), _| id != bet_id);
957
958        let prefix = format!("{bet_id}-");
959        self.published_trade_ids
960            .retain(|id| !id.starts_with(&prefix));
961    }
962}
963
964fn make_trade_id_for_size(bet_id: &str, size_matched: Decimal) -> TradeId {
965    TradeId::new(format!("{bet_id}-{size_matched}"))
966}
967
968/// Returns `true` if the unmatched order has cancel, lapse, or void quantities.
969#[must_use]
970pub fn has_cancel_quantity(uo: &UnmatchedOrder) -> bool {
971    let sc = uo.sc.unwrap_or(Decimal::ZERO);
972    let sl = uo.sl.unwrap_or(Decimal::ZERO);
973    let sv = uo.sv.unwrap_or(Decimal::ZERO);
974    (sc + sl + sv) > Decimal::ZERO
975}
976
977/// Returns `true` if the order is execution-complete and has lapsed.
978#[must_use]
979pub fn is_lapsed(uo: &UnmatchedOrder) -> bool {
980    uo.status == StreamingOrderStatus::ExecutionComplete && uo.lsrc.is_some()
981}
982
983/// Returns `true` if the unmatched order is an SP (on-close) bet resting until
984/// BSP reconciliation: execution-complete with no matched, cancelled, lapsed,
985/// or voided quantity and no lapse reason.
986///
987/// SP bets cannot be cancelled once placed, so this state is open, not
988/// terminal.
989#[must_use]
990pub fn is_resting_sp_bet(uo: &UnmatchedOrder) -> bool {
991    uo.status == StreamingOrderStatus::ExecutionComplete
992        && matches!(
993            uo.ot,
994            StreamingOrderType::LimitOnClose | StreamingOrderType::MarketOnClose
995        )
996        && uo.sm.unwrap_or(Decimal::ZERO) <= Decimal::ZERO
997        && uo.lsrc.is_none()
998        && !has_cancel_quantity(uo)
999}
1000
1001/// Parses a streaming [`UnmatchedOrder`] into a Nautilus [`OrderStatusReport`].
1002///
1003/// Resolves the Nautilus order status from the Betfair streaming status
1004/// plus matched/cancelled quantities.
1005///
1006/// # Errors
1007///
1008/// Returns an error if price or quantity values cannot be converted.
1009pub fn parse_order_status_report(
1010    uo: &UnmatchedOrder,
1011    instrument_id: InstrumentId,
1012    account_id: AccountId,
1013    ts_event: UnixNanos,
1014    ts_init: UnixNanos,
1015) -> anyhow::Result<OrderStatusReport> {
1016    let order_side = OrderSide::from(uo.side);
1017    let order_type = OrderType::from(uo.ot);
1018    let time_in_force = parse_stream_time_in_force(uo)?;
1019
1020    let size_matched = uo.sm.unwrap_or(Decimal::ZERO);
1021    let size_cancelled = uo.sc.unwrap_or(Decimal::ZERO);
1022    let size_lapsed = uo.sl.unwrap_or(Decimal::ZERO);
1023    let size_voided = uo.sv.unwrap_or(Decimal::ZERO);
1024
1025    // Include lapsed/voided in the closed quantity for status resolution
1026    let size_closed = size_cancelled + size_lapsed + size_voided;
1027    let order_status = if uo.status == StreamingOrderStatus::ExecutionComplete
1028        && size_voided > Decimal::ZERO
1029        && size_cancelled.is_zero()
1030        && size_lapsed.is_zero()
1031    {
1032        OrderStatus::Voided
1033    } else if is_resting_sp_bet(uo) {
1034        OrderStatus::Accepted
1035    } else {
1036        resolve_streaming_order_status(uo.status, size_matched, size_closed)
1037    };
1038
1039    let quantity_decimal = stream_order_quantity(uo);
1040    anyhow::ensure!(
1041        quantity_decimal > Decimal::ZERO,
1042        "failed to resolve positive quantity for stream order update {} \
1043         (order_type={:?}, persistence_type={:?}, size={}, bsp_liability={:?}, \
1044         size_matched={:?}, size_remaining={:?}, size_cancelled={:?}, size_lapsed={:?}, size_voided={:?})",
1045        uo.id,
1046        uo.ot,
1047        uo.pt,
1048        uo.s,
1049        uo.bsp,
1050        uo.sm,
1051        uo.sr,
1052        uo.sc,
1053        uo.sl,
1054        uo.sv,
1055    );
1056    let quantity = parse_betfair_quantity(quantity_decimal)?;
1057    let filled_qty = parse_betfair_quantity(size_matched)?;
1058
1059    let ts_accepted = parse_millis_timestamp(uo.pd);
1060
1061    // Use the latest lifecycle timestamp, falling back to OCM publish time
1062    let ts_last = [uo.md, uo.cd, uo.ld]
1063        .into_iter()
1064        .flatten()
1065        .max()
1066        .map_or(ts_event, parse_millis_timestamp);
1067
1068    let venue_order_id = VenueOrderId::from(uo.id.as_str());
1069    let client_order_id = uo
1070        .rfo
1071        .as_deref()
1072        .filter(|s| !s.is_empty())
1073        .map(ClientOrderId::from);
1074
1075    let price = parse_betfair_price(uo.p)?;
1076
1077    let mut report = OrderStatusReport::new(
1078        account_id,
1079        instrument_id,
1080        client_order_id,
1081        venue_order_id,
1082        order_side.into(),
1083        order_type,
1084        time_in_force,
1085        order_status,
1086        quantity,
1087        filled_qty,
1088        ts_accepted,
1089        ts_last,
1090        ts_init,
1091        None,
1092    )
1093    .with_price(price);
1094
1095    report.avg_px = uo.avp;
1096    if let Some(lsrc) = uo.lsrc {
1097        report.cancel_reason = Some(lsrc.to_string());
1098    }
1099
1100    Ok(report)
1101}
1102
1103fn parse_stream_time_in_force(uo: &UnmatchedOrder) -> anyhow::Result<TimeInForce> {
1104    if matches!(
1105        uo.ot,
1106        StreamingOrderType::LimitOnClose | StreamingOrderType::MarketOnClose
1107    ) {
1108        // The stream can carry a non-BSP persistence type on SP bets; the
1109        // on-close instruction defines the time in force
1110        return Ok(TimeInForce::AtTheClose);
1111    }
1112
1113    match uo.pt {
1114        Some(persistence_type) => Ok(TimeInForce::from(persistence_type)),
1115        None => anyhow::bail!("missing persistence type for order update {}", uo.id),
1116    }
1117}
1118
1119fn stream_order_quantity(uo: &UnmatchedOrder) -> Decimal {
1120    if uo.s > Decimal::ZERO {
1121        return uo.s;
1122    }
1123
1124    let lifecycle_qty = uo.sm.unwrap_or(Decimal::ZERO)
1125        + uo.sr.unwrap_or(Decimal::ZERO)
1126        + uo.sc.unwrap_or(Decimal::ZERO)
1127        + uo.sl.unwrap_or(Decimal::ZERO)
1128        + uo.sv.unwrap_or(Decimal::ZERO);
1129
1130    if lifecycle_qty > Decimal::ZERO {
1131        return lifecycle_qty;
1132    }
1133
1134    if uses_liability_based_stream_quantity(uo) {
1135        return uo.bsp.unwrap_or(Decimal::ZERO);
1136    }
1137
1138    Decimal::ZERO
1139}
1140
1141fn resolve_stream_order_quantity(order_qty: Decimal, uo: &UnmatchedOrder) -> Decimal {
1142    if order_qty > Decimal::ZERO {
1143        order_qty
1144    } else {
1145        stream_order_quantity(uo)
1146    }
1147}
1148
1149fn uses_liability_based_stream_quantity(uo: &UnmatchedOrder) -> bool {
1150    matches!(
1151        uo.ot,
1152        crate::common::enums::StreamingOrderType::LimitOnClose
1153            | crate::common::enums::StreamingOrderType::MarketOnClose
1154    )
1155}
1156
1157/// Creates a [`FillReport`] for a Betfair order fill.
1158///
1159/// Betfair charges commission on net winnings, not per-fill, so commission
1160/// is set to zero. The `liquidity_side` is unknown from the stream.
1161#[must_use]
1162#[expect(clippy::too_many_arguments)]
1163pub fn make_fill_report(
1164    account_id: AccountId,
1165    instrument_id: InstrumentId,
1166    venue_order_id: VenueOrderId,
1167    trade_id: TradeId,
1168    order_side: OrderSide,
1169    last_qty: Quantity,
1170    last_px: Price,
1171    currency: Currency,
1172    client_order_id: Option<ClientOrderId>,
1173    ts_event: UnixNanos,
1174    ts_init: UnixNanos,
1175) -> FillReport {
1176    FillReport::new(
1177        account_id,
1178        instrument_id,
1179        venue_order_id,
1180        trade_id,
1181        order_side,
1182        last_qty,
1183        last_px,
1184        Money::zero(currency),
1185        LiquiditySide::NoLiquiditySide,
1186        client_order_id,
1187        None,
1188        ts_event,
1189        ts_init,
1190        None,
1191    )
1192}
1193
1194/// Extracts a [`BetfairTicker`] from a runner change if any ticker fields are present.
1195///
1196/// Returns `None` when the runner change contains no ltp, tv, spn, or spf data.
1197#[must_use]
1198pub fn parse_betfair_ticker(
1199    instrument_id: InstrumentId,
1200    rc: &RunnerChange,
1201    ts_event: UnixNanos,
1202    ts_init: UnixNanos,
1203) -> Option<BetfairTicker> {
1204    if rc.ltp.is_none() && rc.tv.is_none() && rc.spn.is_none() && rc.spf.is_none() {
1205        return None;
1206    }
1207
1208    Some(BetfairTicker::new(
1209        instrument_id,
1210        rc.ltp,
1211        rc.tv,
1212        rc.spn,
1213        rc.spf,
1214        ts_event,
1215        ts_init,
1216    ))
1217}
1218
1219/// Extracts [`BetfairStartingPrice`] values from a market definition's runners.
1220///
1221/// Returns one entry per runner that has a non-None BSP value.
1222#[must_use]
1223pub fn parse_betfair_starting_prices(
1224    market_id: &str,
1225    def: &MarketDefinition,
1226    ts_event: UnixNanos,
1227    ts_init: UnixNanos,
1228) -> Vec<BetfairStartingPrice> {
1229    let Some(runners) = &def.runners else {
1230        return Vec::new();
1231    };
1232
1233    runners
1234        .iter()
1235        .filter_map(|rd| {
1236            let bsp = rd.bsp?;
1237            let handicap = rd.hc.unwrap_or(Decimal::ZERO);
1238            let instrument_id = make_instrument_id(market_id, rd.id, handicap);
1239            Some(BetfairStartingPrice::new(
1240                instrument_id,
1241                bsp,
1242                ts_event,
1243                ts_init,
1244            ))
1245        })
1246        .collect()
1247}
1248
1249/// Extracts BSP order book deltas from a runner change's `spb`/`spl` fields.
1250///
1251/// Returns an empty vec when neither `spb` nor `spl` data is present.
1252/// The `side` field uses `OrderSide::Sell` for `spb` (back) and
1253/// `OrderSide::Buy` for `spl` (lay), following Betfair's inverted convention.
1254#[must_use]
1255pub fn parse_bsp_book_deltas(
1256    instrument_id: InstrumentId,
1257    rc: &RunnerChange,
1258    ts_event: UnixNanos,
1259    ts_init: UnixNanos,
1260) -> Vec<BetfairBspBookDelta> {
1261    let spb_len = rc.spb.as_ref().map_or(0, Vec::len);
1262    let spl_len = rc.spl.as_ref().map_or(0, Vec::len);
1263
1264    if spb_len + spl_len == 0 {
1265        return Vec::new();
1266    }
1267
1268    let mut result = Vec::with_capacity(spb_len + spl_len);
1269
1270    for (levels, side) in [
1271        (rc.spb.as_deref().unwrap_or(&[]), OrderSide::Sell),
1272        (rc.spl.as_deref().unwrap_or(&[]), OrderSide::Buy),
1273    ] {
1274        for pv in levels {
1275            let action = if pv.volume == Decimal::ZERO {
1276                BookAction::Delete
1277            } else {
1278                BookAction::Update
1279            };
1280
1281            result.push(BetfairBspBookDelta::new(
1282                instrument_id,
1283                action,
1284                side,
1285                pv.price,
1286                pv.volume,
1287                ts_event,
1288                ts_init,
1289            ));
1290        }
1291    }
1292
1293    result
1294}
1295
1296/// Produces [`InstrumentClose`] events from a market definition's runner statuses.
1297///
1298/// Winners and placed runners get close price 1.0; losers and removed runners
1299/// get close price 0.0. Active runners produce no close event.
1300#[must_use]
1301pub fn parse_instrument_closes(
1302    market_id: &str,
1303    def: &MarketDefinition,
1304    ts_event: UnixNanos,
1305    ts_init: UnixNanos,
1306) -> Vec<InstrumentClose> {
1307    let Some(runners) = &def.runners else {
1308        return Vec::new();
1309    };
1310
1311    runners
1312        .iter()
1313        .filter_map(|rd| {
1314            let status = rd.status.as_ref()?;
1315            let close_price = match status {
1316                RunnerStatus::Winner | RunnerStatus::Placed => Price::from("1.00"),
1317                RunnerStatus::Loser | RunnerStatus::Removed | RunnerStatus::RemovedVacant => {
1318                    Price::from("0.00")
1319                }
1320                RunnerStatus::Active | RunnerStatus::Hidden | RunnerStatus::Unknown => return None,
1321            };
1322
1323            let handicap = rd.hc.unwrap_or(Decimal::ZERO);
1324            let instrument_id = make_instrument_id(market_id, rd.id, handicap);
1325
1326            Some(InstrumentClose::new(
1327                instrument_id,
1328                close_price,
1329                InstrumentCloseType::ContractExpired,
1330                ts_event,
1331                ts_init,
1332            ))
1333        })
1334        .collect()
1335}
1336
1337/// Parses a single [`RaceRunnerChange`] into a [`BetfairRaceRunnerData`].
1338///
1339/// Returns `None` if the runner change has no selection ID.
1340#[must_use]
1341pub fn parse_race_runner_data(
1342    race_id: &str,
1343    market_id: &str,
1344    rrc: &RaceRunnerChange,
1345    ts_event: UnixNanos,
1346    ts_init: UnixNanos,
1347) -> Option<BetfairRaceRunnerData> {
1348    let selection_id = rrc.id?;
1349
1350    Some(BetfairRaceRunnerData::new(
1351        race_id.to_string(),
1352        market_id.to_string(),
1353        selection_id,
1354        rrc.lat.unwrap_or(f64::NAN),
1355        rrc.lng.unwrap_or(f64::NAN),
1356        rrc.spd.unwrap_or(f64::NAN),
1357        rrc.prg.unwrap_or(f64::NAN),
1358        rrc.sfq.unwrap_or(f64::NAN),
1359        ts_event,
1360        ts_init,
1361    ))
1362}
1363
1364/// Parses a [`RaceProgressChange`] into a [`BetfairRaceProgress`].
1365#[must_use]
1366pub fn parse_race_progress(
1367    race_id: &str,
1368    market_id: &str,
1369    rpc: &RaceProgressChange,
1370    ts_event: UnixNanos,
1371    ts_init: UnixNanos,
1372) -> BetfairRaceProgress {
1373    let order_json = serialize_json_value(rpc.ord.as_ref());
1374    let jumps_json = serialize_json_value(rpc.jumps.as_ref());
1375
1376    BetfairRaceProgress::new(
1377        race_id.to_string(),
1378        market_id.to_string(),
1379        rpc.g.clone().unwrap_or_default(),
1380        rpc.st.unwrap_or(f64::NAN),
1381        rpc.rt.unwrap_or(f64::NAN),
1382        rpc.spd.unwrap_or(f64::NAN),
1383        rpc.prg.unwrap_or(f64::NAN),
1384        order_json,
1385        jumps_json,
1386        ts_event,
1387        ts_init,
1388    )
1389}
1390
1391#[must_use]
1392pub fn parse_cricket_match(
1393    cricket: &CricketChange,
1394    ts_event: UnixNanos,
1395    ts_init: UnixNanos,
1396) -> Option<BetfairCricketMatch> {
1397    let event_id = cricket.event_id.clone()?;
1398    let market_id = cricket.market_id.clone()?;
1399
1400    Some(BetfairCricketMatch::new(
1401        event_id,
1402        market_id,
1403        serialize_json_value(cricket.fixture_info.as_ref()),
1404        serialize_json_value(cricket.home_team.as_ref()),
1405        serialize_json_value(cricket.away_team.as_ref()),
1406        serialize_json_value(cricket.match_stats.as_ref()),
1407        serialize_json_value(cricket.incident_list_wrapper.as_ref()),
1408        ts_event,
1409        ts_init,
1410    ))
1411}
1412
1413fn serialize_json_value<T>(value: Option<&T>) -> String
1414where
1415    T: serde::Serialize,
1416{
1417    value.map_or_default(|value| serde_json::to_string(value).unwrap_or_default())
1418}
1419
1420#[cfg(test)]
1421mod tests {
1422    use nautilus_model::enums::{MarketStatusAction, OrderStatus, TimeInForce};
1423    use rstest::rstest;
1424
1425    use super::*;
1426    use crate::{
1427        common::{
1428            consts::{BETFAIR_PRICE_PRECISION, BETFAIR_QUANTITY_PRECISION},
1429            enums::{StreamingOrderType, StreamingPersistenceType, StreamingSide},
1430            testing::load_test_json,
1431        },
1432        stream::messages::{PV, RunnerChange, RunnerDefinition, StreamMessage, stream_decode},
1433    };
1434
1435    fn assert_decimal_option_eq(actual: Option<Decimal>, expected: Decimal) {
1436        assert_eq!(actual, Some(expected));
1437    }
1438
1439    #[rstest]
1440    fn test_parse_runner_book_snapshot() {
1441        let data = load_test_json("stream/mcm_live_IMAGE.json");
1442        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1443
1444        if let StreamMessage::MarketChange(mcm) = msg {
1445            let mc = mcm.mc.as_ref().unwrap();
1446            let change = &mc[0];
1447            let rc = &change.rc.as_ref().unwrap()[0];
1448            let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
1449
1450            let deltas = parse_runner_book_deltas(
1451                instrument_id,
1452                rc,
1453                true,
1454                mcm.pt,
1455                parse_millis_timestamp(mcm.pt),
1456                parse_millis_timestamp(mcm.pt),
1457            )
1458            .unwrap()
1459            .expect("should produce deltas");
1460
1461            // Clear + atb levels + atl levels
1462            let atb_len = rc.atb.as_ref().unwrap().len();
1463            let atl_len = rc.atl.as_ref().unwrap().len();
1464            assert_eq!(deltas.deltas.len(), 1 + atb_len + atl_len);
1465
1466            // First delta is Clear with F_SNAPSHOT
1467            assert_eq!(deltas.deltas[0].action, BookAction::Clear);
1468            assert!(RecordFlag::F_SNAPSHOT.matches(deltas.deltas[0].flags));
1469
1470            // Subsequent deltas are Add with F_SNAPSHOT
1471            for delta in &deltas.deltas[1..] {
1472                assert_eq!(delta.action, BookAction::Add);
1473                assert!(RecordFlag::F_SNAPSHOT.matches(delta.flags));
1474            }
1475
1476            // Last delta has F_LAST
1477            let last = deltas.deltas.last().unwrap();
1478            assert!(RecordFlag::F_LAST.matches(last.flags));
1479
1480            // Verify buy/sell sides
1481            let buy_count = deltas
1482                .deltas
1483                .iter()
1484                .filter(|d| d.order.side == Some(OrderSide::Buy))
1485                .count();
1486            let sell_count = deltas
1487                .deltas
1488                .iter()
1489                .filter(|d| d.order.side == Some(OrderSide::Sell))
1490                .count();
1491            assert_eq!(buy_count, atb_len);
1492            assert_eq!(sell_count, atl_len);
1493        } else {
1494            panic!("expected MarketChange");
1495        }
1496    }
1497
1498    #[rstest]
1499    fn test_parse_runner_book_snapshot_skips_zero_volume_levels() {
1500        let rc: RunnerChange = serde_json::from_str(
1501            r#"{
1502                "id": 123,
1503                "atb": [[2.0, 0.0], [2.1, 3.0]],
1504                "atl": [[2.2, 0.0], [2.3, 4.0]]
1505            }"#,
1506        )
1507        .unwrap();
1508        let instrument_id = make_instrument_id("1.234", rc.id, Decimal::ZERO);
1509
1510        let deltas = parse_runner_book_deltas(
1511            instrument_id,
1512            &rc,
1513            true,
1514            1_551_400_000_000,
1515            parse_millis_timestamp(1_551_400_000_000),
1516            parse_millis_timestamp(1_551_400_000_000),
1517        )
1518        .unwrap()
1519        .expect("should produce deltas");
1520
1521        assert_eq!(deltas.deltas.len(), 3);
1522        assert_eq!(deltas.deltas[0].action, BookAction::Clear);
1523        assert!(
1524            deltas
1525                .deltas
1526                .iter()
1527                .filter(|delta| delta.action == BookAction::Add)
1528                .all(|delta| !delta.order.size.is_zero())
1529        );
1530    }
1531
1532    #[rstest]
1533    fn test_parse_runner_book_update() {
1534        let data = load_test_json("stream/mcm_UPDATE.json");
1535        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1536
1537        if let StreamMessage::MarketChange(mcm) = msg {
1538            let mc = mcm.mc.as_ref().unwrap();
1539            let change = &mc[0];
1540            let rc = &change.rc.as_ref().unwrap()[0];
1541            let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
1542
1543            let deltas = parse_runner_book_deltas(
1544                instrument_id,
1545                rc,
1546                false,
1547                mcm.pt,
1548                parse_millis_timestamp(mcm.pt),
1549                parse_millis_timestamp(mcm.pt),
1550            )
1551            .unwrap()
1552            .expect("should produce deltas");
1553
1554            // No Clear delta for updates
1555            assert!(deltas.deltas.iter().all(|d| d.action != BookAction::Clear));
1556
1557            // Last delta has F_LAST
1558            let last = deltas.deltas.last().unwrap();
1559            assert!(RecordFlag::F_LAST.matches(last.flags));
1560
1561            // No snapshot flags
1562            for delta in &deltas.deltas {
1563                assert!(!RecordFlag::F_SNAPSHOT.matches(delta.flags));
1564            }
1565        } else {
1566            panic!("expected MarketChange");
1567        }
1568    }
1569
1570    #[rstest]
1571    fn test_parse_runner_book_update_zero_volume_is_delete() {
1572        let data = load_test_json("stream/mcm_UPDATE.json");
1573        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1574
1575        if let StreamMessage::MarketChange(mcm) = msg {
1576            let mc = mcm.mc.as_ref().unwrap();
1577            let change = &mc[0];
1578            let rc = &change.rc.as_ref().unwrap()[0];
1579            let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
1580
1581            let deltas = parse_runner_book_deltas(
1582                instrument_id,
1583                rc,
1584                false,
1585                mcm.pt,
1586                parse_millis_timestamp(mcm.pt),
1587                parse_millis_timestamp(mcm.pt),
1588            )
1589            .unwrap()
1590            .unwrap();
1591
1592            // atl has [[4.7, 0]] which should be Delete
1593            assert!(
1594                deltas.deltas.iter().any(|d| d.action == BookAction::Delete),
1595                "zero volume should produce Delete action"
1596            );
1597        } else {
1598            panic!("expected MarketChange");
1599        }
1600    }
1601
1602    #[rstest]
1603    fn test_parse_runner_book_no_levels_returns_none() {
1604        let rc = RunnerChange {
1605            id: 12345,
1606            hc: None,
1607            atb: None,
1608            atl: None,
1609            batb: None,
1610            batl: None,
1611            bdatb: None,
1612            bdatl: None,
1613            spb: None,
1614            spl: None,
1615            spn: None,
1616            spf: None,
1617            trd: None,
1618            ltp: None,
1619            tv: None,
1620        };
1621
1622        let result = parse_runner_book_deltas(
1623            make_instrument_id("1.123", 12345, Decimal::ZERO),
1624            &rc,
1625            false,
1626            0,
1627            UnixNanos::default(),
1628            UnixNanos::default(),
1629        );
1630
1631        assert!(result.unwrap().is_none());
1632    }
1633
1634    #[rstest]
1635    fn test_make_trade_tick() {
1636        let instrument_id = make_instrument_id("1.180737206", 19248890, Decimal::ZERO);
1637        let tick = make_trade_tick(
1638            instrument_id,
1639            Price::new(2.42, BETFAIR_PRICE_PRECISION),
1640            Quantity::new(100.0, BETFAIR_QUANTITY_PRECISION),
1641            TradeId::from("test-trade-1"),
1642            UnixNanos::default(),
1643            UnixNanos::default(),
1644        );
1645
1646        assert_eq!(tick.instrument_id, instrument_id);
1647        assert_eq!(tick.price.as_f64(), 2.42);
1648        assert_eq!(tick.size.as_f64(), 100.0);
1649        assert_eq!(tick.aggressor_side, AggressorSide::NoAggressor);
1650    }
1651
1652    fn make_status_def(
1653        status: MarketStatus,
1654        in_play: bool,
1655        runner_status: RunnerStatus,
1656    ) -> MarketDefinition {
1657        MarketDefinition {
1658            runners: Some(vec![RunnerDefinition {
1659                id: 456,
1660                hc: None,
1661                sort_priority: None,
1662                name: None,
1663                status: Some(runner_status),
1664                adjustment_factor: None,
1665                bsp: None,
1666                removal_date: None,
1667            }]),
1668            bet_delay: None,
1669            betting_type: None,
1670            bsp_market: None,
1671            bsp_reconciled: None,
1672            competition_id: None,
1673            competition_name: None,
1674            complete: None,
1675            country_code: None,
1676            cross_matching: None,
1677            discount_allowed: None,
1678            each_way_divisor: None,
1679            event_id: None,
1680            event_name: None,
1681            event_type_id: None,
1682            event_type_name: None,
1683            in_play: Some(in_play),
1684            line_interval: None,
1685            line_max_unit: None,
1686            line_min_unit: None,
1687            market_base_rate: None,
1688            market_id: None,
1689            market_name: None,
1690            market_time: None,
1691            market_type: None,
1692            number_of_active_runners: None,
1693            number_of_winners: None,
1694            open_date: None,
1695            persistence_enabled: None,
1696            price_ladder_definition: None,
1697            race_type: None,
1698            regulators: None,
1699            runners_voidable: None,
1700            settled_time: None,
1701            status: Some(status),
1702            suspend_time: None,
1703            timezone: None,
1704            turn_in_play_enabled: None,
1705            venue: None,
1706            version: None,
1707        }
1708    }
1709
1710    #[rstest]
1711    #[case(MarketStatus::Open, false, MarketStatusAction::PreOpen, false)]
1712    #[case(MarketStatus::Open, true, MarketStatusAction::Trading, true)]
1713    #[case(MarketStatus::Closed, false, MarketStatusAction::Close, false)]
1714    #[case(MarketStatus::Closed, true, MarketStatusAction::Close, false)]
1715    #[case(MarketStatus::Suspended, false, MarketStatusAction::Pause, false)]
1716    #[case(MarketStatus::Suspended, true, MarketStatusAction::Pause, false)]
1717    #[case(MarketStatus::Inactive, false, MarketStatusAction::Close, false)]
1718    fn test_parse_instrument_statuses_market_state(
1719        #[case] status: MarketStatus,
1720        #[case] in_play: bool,
1721        #[case] expected_action: MarketStatusAction,
1722        #[case] expected_is_trading: bool,
1723    ) {
1724        let def = make_status_def(status, in_play, RunnerStatus::Active);
1725        let results =
1726            parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1727
1728        assert_eq!(results.len(), 1);
1729        assert_eq!(results[0].action, expected_action);
1730        assert_eq!(results[0].is_trading, Some(expected_is_trading));
1731    }
1732
1733    #[rstest]
1734    fn test_parse_instrument_statuses_skips_unknown_market_status() {
1735        // An unmodeled market status must not publish a fabricated non-trading
1736        // state; the whole definition is skipped.
1737        let def = make_status_def(MarketStatus::Unknown, true, RunnerStatus::Active);
1738        let results =
1739            parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1740
1741        assert!(results.is_empty());
1742    }
1743
1744    #[rstest]
1745    fn test_parse_instrument_statuses_skips_unknown_runner() {
1746        // An unmodeled runner status must not be emitted as tradable, even in an
1747        // open in-play market; we skip it rather than fabricate tradability.
1748        let def = make_status_def(MarketStatus::Open, true, RunnerStatus::Unknown);
1749        let results =
1750            parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1751
1752        assert!(results.is_empty());
1753    }
1754
1755    #[rstest]
1756    #[case(RunnerStatus::Removed)]
1757    #[case(RunnerStatus::RemovedVacant)]
1758    fn test_parse_instrument_statuses_scratched_runner_closes(#[case] runner_status: RunnerStatus) {
1759        // Even with Open + in_play the runner must close when scratched
1760        let def = make_status_def(MarketStatus::Open, true, runner_status);
1761        let results =
1762            parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1763
1764        assert_eq!(results.len(), 1);
1765        assert_eq!(results[0].action, MarketStatusAction::Close);
1766        assert_eq!(results[0].is_trading, Some(false));
1767    }
1768
1769    #[rstest]
1770    #[case::missing_runners("runners")]
1771    #[case::missing_status("status")]
1772    fn test_parse_instrument_statuses_returns_empty(#[case] drop_field: &str) {
1773        let mut def = make_status_def(MarketStatus::Open, true, RunnerStatus::Active);
1774        match drop_field {
1775            "runners" => def.runners = None,
1776            "status" => def.status = None,
1777            _ => unreachable!(),
1778        }
1779
1780        let results =
1781            parse_instrument_statuses("1.123", &def, UnixNanos::default(), UnixNanos::default());
1782
1783        assert!(results.is_empty());
1784    }
1785
1786    #[rstest]
1787    fn test_parse_instrument_statuses_mixed_runners() {
1788        // Three runners in one market definition: an Active runner should follow the
1789        // market-level mapping while Removed/RemovedVacant override to Close. Verify
1790        // that selection id and handicap propagate into the emitted instrument id.
1791        let mut def = make_status_def(MarketStatus::Open, true, RunnerStatus::Active);
1792        def.runners = Some(vec![
1793            RunnerDefinition {
1794                id: 101,
1795                hc: None,
1796                sort_priority: Some(1),
1797                name: None,
1798                status: Some(RunnerStatus::Active),
1799                adjustment_factor: None,
1800                bsp: None,
1801                removal_date: None,
1802            },
1803            RunnerDefinition {
1804                id: 202,
1805                hc: Some(Decimal::new(25, 1)), // 2.5 handicap
1806                sort_priority: Some(2),
1807                name: None,
1808                status: Some(RunnerStatus::Removed),
1809                adjustment_factor: None,
1810                bsp: None,
1811                removal_date: None,
1812            },
1813            RunnerDefinition {
1814                id: 303,
1815                hc: None,
1816                sort_priority: Some(3),
1817                name: None,
1818                status: Some(RunnerStatus::RemovedVacant),
1819                adjustment_factor: None,
1820                bsp: None,
1821                removal_date: None,
1822            },
1823        ]);
1824
1825        let results =
1826            parse_instrument_statuses("1.999", &def, UnixNanos::default(), UnixNanos::default());
1827
1828        assert_eq!(results.len(), 3);
1829
1830        assert_eq!(results[0].action, MarketStatusAction::Trading);
1831        assert_eq!(results[0].is_trading, Some(true));
1832
1833        assert_eq!(results[1].action, MarketStatusAction::Close);
1834        assert_eq!(results[1].is_trading, Some(false));
1835
1836        assert_eq!(results[2].action, MarketStatusAction::Close);
1837        assert_eq!(results[2].is_trading, Some(false));
1838
1839        // Each runner produces a distinct instrument id (selection id + handicap)
1840        assert_ne!(results[0].instrument_id, results[1].instrument_id);
1841        assert_ne!(results[1].instrument_id, results[2].instrument_id);
1842        assert_ne!(results[0].instrument_id, results[2].instrument_id);
1843    }
1844
1845    #[rstest]
1846    fn test_parse_order_status_report_new_order() {
1847        let data = load_test_json("stream/ocm_NEW_FULL_IMAGE.json");
1848        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1849
1850        if let StreamMessage::OrderChange(ocm) = msg {
1851            let oc = ocm.oc.as_ref().unwrap();
1852            let omc = &oc[0];
1853            let orc = &omc.orc.as_ref().unwrap()[0];
1854            let uo = &orc.uo.as_ref().unwrap()[0];
1855
1856            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1857            let report = parse_order_status_report(
1858                uo,
1859                instrument_id,
1860                AccountId::from("BETFAIR-001"),
1861                parse_millis_timestamp(ocm.pt),
1862                parse_millis_timestamp(ocm.pt),
1863            )
1864            .unwrap();
1865
1866            // Partially filled: sm=4.75, sr=0.25, status=E
1867            assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
1868            assert_eq!(report.order_side, Some(OrderSide::Sell)); // Back → Sell
1869            assert_eq!(report.order_type, OrderType::Limit);
1870            assert_eq!(report.filled_qty.as_f64(), 4.75);
1871            assert_eq!(report.quantity.as_f64(), 5.0);
1872            assert!(report.price.is_some());
1873            assert_eq!(report.price.unwrap().as_f64(), 12.0);
1874        } else {
1875            panic!("expected OrderChange");
1876        }
1877    }
1878
1879    #[rstest]
1880    fn test_parse_order_status_report_filled() {
1881        let data = load_test_json("stream/ocm_FILLED.json");
1882        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1883
1884        if let StreamMessage::OrderChange(ocm) = msg {
1885            let oc = ocm.oc.as_ref().unwrap();
1886            let omc = &oc[0];
1887            let orc = &omc.orc.as_ref().unwrap()[0];
1888            let uo = &orc.uo.as_ref().unwrap()[0];
1889
1890            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1891            let report = parse_order_status_report(
1892                uo,
1893                instrument_id,
1894                AccountId::from("BETFAIR-001"),
1895                parse_millis_timestamp(ocm.pt),
1896                parse_millis_timestamp(ocm.pt),
1897            )
1898            .unwrap();
1899
1900            assert_eq!(report.order_status, OrderStatus::Filled);
1901            assert_eq!(report.order_side, Some(OrderSide::Buy)); // Lay → Buy
1902            assert_eq!(report.filled_qty.as_f64(), 10.0);
1903            assert_eq!(report.quantity.as_f64(), 10.0);
1904
1905            // Has client_order_id from rfo field
1906            assert!(report.client_order_id.is_some());
1907        } else {
1908            panic!("expected OrderChange");
1909        }
1910    }
1911
1912    #[rstest]
1913    fn test_parse_order_status_report_cancelled() {
1914        let data = load_test_json("stream/ocm_CANCEL.json");
1915        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1916
1917        if let StreamMessage::OrderChange(ocm) = msg {
1918            let oc = ocm.oc.as_ref().unwrap();
1919            let omc = &oc[0];
1920            let orc = &omc.orc.as_ref().unwrap()[0];
1921            let uo = &orc.uo.as_ref().unwrap()[0];
1922
1923            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1924            let report = parse_order_status_report(
1925                uo,
1926                instrument_id,
1927                AccountId::from("BETFAIR-001"),
1928                parse_millis_timestamp(ocm.pt),
1929                parse_millis_timestamp(ocm.pt),
1930            )
1931            .unwrap();
1932
1933            assert_eq!(report.order_status, OrderStatus::Canceled);
1934            assert_eq!(report.order_side, Some(OrderSide::Sell)); // Back → Sell
1935            assert_eq!(report.filled_qty.as_f64(), 0.0);
1936            assert_eq!(report.quantity.as_f64(), 10.0);
1937        } else {
1938            panic!("expected OrderChange");
1939        }
1940    }
1941
1942    #[rstest]
1943    fn test_parse_order_status_report_duplicate_execution() {
1944        let data = load_test_json("stream/ocm_DUPLICATE_EXECUTION.json");
1945        let msgs: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
1946
1947        if let StreamMessage::OrderChange(ocm) = &msgs[0] {
1948            let oc = ocm.oc.as_ref().unwrap();
1949            let omc = &oc[0];
1950            let orc = &omc.orc.as_ref().unwrap()[0];
1951            let uo = &orc.uo.as_ref().unwrap()[0];
1952
1953            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1954            let report = parse_order_status_report(
1955                uo,
1956                instrument_id,
1957                AccountId::from("BETFAIR-001"),
1958                parse_millis_timestamp(ocm.pt),
1959                parse_millis_timestamp(ocm.pt),
1960            )
1961            .unwrap();
1962
1963            // Partially filled: sm=1.12, status=E
1964            assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
1965            assert_eq!(report.order_side, Some(OrderSide::Buy)); // Lay → Buy
1966            assert_eq!(report.filled_qty.as_f64(), 1.12);
1967        } else {
1968            panic!("expected OrderChange");
1969        }
1970    }
1971
1972    #[rstest]
1973    fn test_parse_order_status_report_sp_resting() {
1974        let data = load_test_json("stream/ocm_SP_RESTING.json");
1975        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
1976
1977        if let StreamMessage::OrderChange(ocm) = msg {
1978            let oc = ocm.oc.as_ref().unwrap();
1979            let omc = &oc[0];
1980            let orc = &omc.orc.as_ref().unwrap()[0];
1981            let uo = &orc.uo.as_ref().unwrap()[0];
1982
1983            assert!(is_resting_sp_bet(uo));
1984
1985            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
1986            let report = parse_order_status_report(
1987                uo,
1988                instrument_id,
1989                AccountId::from("BETFAIR-001"),
1990                parse_millis_timestamp(ocm.pt),
1991                parse_millis_timestamp(ocm.pt),
1992            )
1993            .unwrap();
1994
1995            // A resting SP bet reports execution-complete with zero size
1996            // fields, but cannot be cancelled and is still open until BSP
1997            // reconciliation
1998            assert_eq!(report.order_status, OrderStatus::Accepted);
1999            assert_eq!(report.time_in_force, TimeInForce::AtTheClose);
2000            assert_eq!(report.order_side, Some(OrderSide::Sell)); // Back → Sell
2001            assert_eq!(report.filled_qty.as_f64(), 0.0);
2002            assert_eq!(report.quantity.as_f64(), 2.0);
2003        } else {
2004            panic!("expected OrderChange");
2005        }
2006    }
2007
2008    fn sp_unmatched_order(size_matched: Decimal, size_lapsed: Decimal) -> UnmatchedOrder {
2009        UnmatchedOrder {
2010            id: "442849719274".to_string(),
2011            p: Decimal::new(10000, 1),
2012            s: Decimal::ZERO,
2013            side: StreamingSide::Back,
2014            status: StreamingOrderStatus::ExecutionComplete,
2015            pt: Some(StreamingPersistenceType::MarketOnClose),
2016            ot: StreamingOrderType::MarketOnClose,
2017            pd: 1789423573000,
2018            bsp: Some(Decimal::new(2, 0)),
2019            rfo: None,
2020            rfs: None,
2021            rc: None,
2022            rac: None,
2023            md: None,
2024            cd: None,
2025            ld: None,
2026            avp: None,
2027            sm: Some(size_matched),
2028            sr: Some(Decimal::ZERO),
2029            sl: Some(size_lapsed),
2030            sc: Some(Decimal::ZERO),
2031            sv: Some(Decimal::ZERO),
2032            lsrc: None,
2033        }
2034    }
2035
2036    #[rstest]
2037    fn test_parse_order_status_report_sp_reconciled() {
2038        // At BSP reconciliation an SP bet is no longer resting: a matched bet
2039        // resolves Filled and a lapsed bet resolves Canceled
2040        let matched = sp_unmatched_order(Decimal::new(2, 0), Decimal::ZERO);
2041        assert!(!is_resting_sp_bet(&matched));
2042
2043        let report = parse_order_status_report(
2044            &matched,
2045            InstrumentId::from("1.262362241-6532924-0.BETFAIR"),
2046            AccountId::from("BETFAIR-001"),
2047            UnixNanos::default(),
2048            UnixNanos::default(),
2049        )
2050        .unwrap();
2051
2052        assert_eq!(report.order_status, OrderStatus::Filled);
2053        assert_eq!(report.filled_qty.as_f64(), 2.0);
2054        assert_eq!(report.quantity.as_f64(), 2.0);
2055
2056        let lapsed = sp_unmatched_order(Decimal::ZERO, Decimal::new(2, 0));
2057        assert!(!is_resting_sp_bet(&lapsed));
2058
2059        let report = parse_order_status_report(
2060            &lapsed,
2061            InstrumentId::from("1.262362241-6532924-0.BETFAIR"),
2062            AccountId::from("BETFAIR-001"),
2063            UnixNanos::default(),
2064            UnixNanos::default(),
2065        )
2066        .unwrap();
2067
2068        assert_eq!(report.order_status, OrderStatus::Canceled);
2069    }
2070
2071    #[rstest]
2072    fn test_parse_order_status_report_multiple_fills() {
2073        let data = load_test_json("stream/ocm_multiple_fills.json");
2074        let msgs: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2075
2076        if let StreamMessage::OrderChange(ocm) = &msgs[0] {
2077            let oc = ocm.oc.as_ref().unwrap();
2078            let omc = &oc[0];
2079            let orc = &omc.orc.as_ref().unwrap()[0];
2080            let uo = &orc.uo.as_ref().unwrap()[0];
2081
2082            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2083            let report = parse_order_status_report(
2084                uo,
2085                instrument_id,
2086                AccountId::from("BETFAIR-001"),
2087                parse_millis_timestamp(ocm.pt),
2088                parse_millis_timestamp(ocm.pt),
2089            )
2090            .unwrap();
2091
2092            // Partially filled: sm=16.19, status=E, has rfo
2093            assert_eq!(report.order_status, OrderStatus::PartiallyFilled);
2094            assert_eq!(report.order_side, Some(OrderSide::Sell)); // Back → Sell
2095            assert_eq!(report.filled_qty.as_f64(), 16.19);
2096            assert!(report.client_order_id.is_some());
2097            assert!(report.avg_px.is_some());
2098        } else {
2099            panic!("expected OrderChange");
2100        }
2101    }
2102
2103    #[rstest]
2104    fn test_parse_runner_book_snapshot_empty_book() {
2105        // A snapshot with no levels should still produce a clear delta
2106        let rc = RunnerChange {
2107            id: 12345,
2108            hc: None,
2109            atb: Some(vec![]),
2110            atl: Some(vec![]),
2111            batb: None,
2112            batl: None,
2113            bdatb: None,
2114            bdatl: None,
2115            spb: None,
2116            spl: None,
2117            spn: None,
2118            spf: None,
2119            trd: None,
2120            ltp: None,
2121            tv: None,
2122        };
2123
2124        let result = parse_runner_book_deltas(
2125            make_instrument_id("1.123", 12345, Decimal::ZERO),
2126            &rc,
2127            true,
2128            1000,
2129            UnixNanos::default(),
2130            UnixNanos::default(),
2131        )
2132        .unwrap()
2133        .expect("should produce snapshot deltas");
2134
2135        // Just the Clear delta with F_LAST
2136        assert_eq!(result.deltas.len(), 1);
2137        assert_eq!(result.deltas[0].action, BookAction::Clear);
2138        assert!(RecordFlag::F_LAST.matches(result.deltas[0].flags));
2139        assert!(RecordFlag::F_SNAPSHOT.matches(result.deltas[0].flags));
2140    }
2141
2142    #[rstest]
2143    fn test_make_fill_report() {
2144        let instrument_id = make_instrument_id("1.180604981", 1209555, Decimal::ZERO);
2145        let fill = make_fill_report(
2146            AccountId::from("BETFAIR-001"),
2147            instrument_id,
2148            VenueOrderId::from("229430281339"),
2149            TradeId::from("229430281339-0"),
2150            OrderSide::Buy,
2151            Quantity::new(10.0, BETFAIR_QUANTITY_PRECISION),
2152            Price::new(1.1, BETFAIR_PRICE_PRECISION),
2153            Currency::GBP(),
2154            None,
2155            UnixNanos::default(),
2156            UnixNanos::default(),
2157        );
2158
2159        assert_eq!(fill.instrument_id, instrument_id);
2160        assert_eq!(fill.order_side, OrderSide::Buy);
2161        assert_eq!(fill.last_qty.as_f64(), 10.0);
2162        assert_eq!(fill.last_px.as_f64(), 1.1);
2163        assert_eq!(fill.commission.as_f64(), 0.0);
2164        assert_eq!(fill.liquidity_side, LiquiditySide::NoLiquiditySide);
2165    }
2166
2167    #[rstest]
2168    fn test_fill_tracker_single_full_fill() {
2169        let data = load_test_json("stream/ocm_FILLED.json");
2170        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2171
2172        if let StreamMessage::OrderChange(ocm) = msg {
2173            let oc = ocm.oc.as_ref().unwrap();
2174            let omc = &oc[0];
2175            let orc = &omc.orc.as_ref().unwrap()[0];
2176            let uo = &orc.uo.as_ref().unwrap()[0];
2177            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2178            let ts = parse_millis_timestamp(ocm.pt);
2179
2180            let mut tracker = FillTracker::new();
2181            let fill = tracker
2182                .maybe_fill_report(
2183                    uo,
2184                    uo.s,
2185                    instrument_id,
2186                    AccountId::from("BETFAIR-001"),
2187                    Currency::GBP(),
2188                    ts,
2189                    ts,
2190                )
2191                .expect("should produce fill");
2192
2193            assert_eq!(fill.last_qty.as_f64(), 10.0);
2194            assert_eq!(fill.last_px.as_f64(), 1.1);
2195            assert_eq!(fill.order_side, OrderSide::Buy);
2196            assert!(fill.client_order_id.is_some());
2197        } else {
2198            panic!("expected OrderChange");
2199        }
2200    }
2201
2202    #[rstest]
2203    fn test_fill_tracker_incremental_fills() {
2204        let data = load_test_json("stream/ocm_multiple_fills.json");
2205        let msgs: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2206        let instrument_id = make_instrument_id("1.179082386", 50210, Decimal::ZERO);
2207
2208        let mut tracker = FillTracker::new();
2209        let account_id = AccountId::from("BETFAIR-001");
2210        let currency = Currency::GBP();
2211
2212        // First fill: sm=16.19 (from zero)
2213        let uo1 = extract_uo(&msgs[0]);
2214        let ts1 = extract_ts(&msgs[0]);
2215        let fill1 = tracker
2216            .maybe_fill_report(uo1, uo1.s, instrument_id, account_id, currency, ts1, ts1)
2217            .expect("should produce first fill");
2218        assert_eq!(fill1.last_qty.as_f64(), 16.19);
2219        assert_eq!(fill1.last_px.as_f64(), 5.8);
2220
2221        // Second fill: sm=16.96 (delta=0.77)
2222        let uo2 = extract_uo(&msgs[1]);
2223        let ts2 = extract_ts(&msgs[1]);
2224        let fill2 = tracker
2225            .maybe_fill_report(uo2, uo2.s, instrument_id, account_id, currency, ts2, ts2)
2226            .expect("should produce second fill");
2227        assert_eq!(fill2.last_qty.as_f64(), 0.77);
2228        assert_eq!(fill2.last_px.as_f64(), 5.8);
2229
2230        // Third fill: sm=17.73 (delta=0.77)
2231        let uo3 = extract_uo(&msgs[2]);
2232        let ts3 = extract_ts(&msgs[2]);
2233        let fill3 = tracker
2234            .maybe_fill_report(uo3, uo3.s, instrument_id, account_id, currency, ts3, ts3)
2235            .expect("should produce third fill");
2236        assert_eq!(fill3.last_qty.as_f64(), 0.77);
2237    }
2238
2239    #[rstest]
2240    fn test_fill_tracker_different_price() {
2241        let data = load_test_json("stream/ocm_filled_different_price.json");
2242        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2243
2244        if let StreamMessage::OrderChange(ocm) = msg {
2245            let oc = ocm.oc.as_ref().unwrap();
2246            let omc = &oc[0];
2247            let orc = &omc.orc.as_ref().unwrap()[0];
2248            let uo = &orc.uo.as_ref().unwrap()[0];
2249            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2250            let ts = parse_millis_timestamp(ocm.pt);
2251
2252            let mut tracker = FillTracker::new();
2253            let fill = tracker
2254                .maybe_fill_report(
2255                    uo,
2256                    uo.s,
2257                    instrument_id,
2258                    AccountId::from("BETFAIR-001"),
2259                    Currency::GBP(),
2260                    ts,
2261                    ts,
2262                )
2263                .expect("should produce fill");
2264
2265            // Order placed at 1.3 but average fill price is 1.2
2266            assert_eq!(fill.last_qty.as_f64(), 20.0);
2267            assert_eq!(fill.last_px.as_f64(), 1.2);
2268        } else {
2269            panic!("expected OrderChange");
2270        }
2271    }
2272
2273    #[rstest]
2274    fn test_fill_tracker_cancel_no_fill() {
2275        let data = load_test_json("stream/ocm_CANCEL.json");
2276        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2277
2278        if let StreamMessage::OrderChange(ocm) = msg {
2279            let oc = ocm.oc.as_ref().unwrap();
2280            let omc = &oc[0];
2281            let orc = &omc.orc.as_ref().unwrap()[0];
2282            let uo = &orc.uo.as_ref().unwrap()[0];
2283            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2284            let ts = parse_millis_timestamp(ocm.pt);
2285
2286            let mut tracker = FillTracker::new();
2287            let result = tracker.maybe_fill_report(
2288                uo,
2289                uo.s,
2290                instrument_id,
2291                AccountId::from("BETFAIR-001"),
2292                Currency::GBP(),
2293                ts,
2294                ts,
2295            );
2296            assert!(result.is_none(), "cancelled order should not produce fill");
2297        } else {
2298            panic!("expected OrderChange");
2299        }
2300    }
2301
2302    #[rstest]
2303    fn test_fill_tracker_lapsed_no_fill() {
2304        let data = load_test_json("stream/ocm_error_fill.json");
2305        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2306
2307        if let StreamMessage::OrderChange(ocm) = msg {
2308            let oc = ocm.oc.as_ref().unwrap();
2309            let omc = &oc[0];
2310            let orc = &omc.orc.as_ref().unwrap()[0];
2311            let uo = &orc.uo.as_ref().unwrap()[0];
2312            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2313            let ts = parse_millis_timestamp(ocm.pt);
2314
2315            let mut tracker = FillTracker::new();
2316            let result = tracker.maybe_fill_report(
2317                uo,
2318                uo.s,
2319                instrument_id,
2320                AccountId::from("BETFAIR-001"),
2321                Currency::GBP(),
2322                ts,
2323                ts,
2324            );
2325            assert!(result.is_none(), "lapsed order should not produce fill");
2326        } else {
2327            panic!("expected OrderChange");
2328        }
2329    }
2330
2331    #[rstest]
2332    fn test_fill_tracker_duplicate_dedup() {
2333        let data = load_test_json("stream/ocm_FILLED.json");
2334        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2335
2336        if let StreamMessage::OrderChange(ocm) = msg {
2337            let oc = ocm.oc.as_ref().unwrap();
2338            let omc = &oc[0];
2339            let orc = &omc.orc.as_ref().unwrap()[0];
2340            let uo = &orc.uo.as_ref().unwrap()[0];
2341            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
2342            let ts = parse_millis_timestamp(ocm.pt);
2343            let account_id = AccountId::from("BETFAIR-001");
2344            let currency = Currency::GBP();
2345
2346            let mut tracker = FillTracker::new();
2347
2348            // First call produces fill
2349            let fill1 =
2350                tracker.maybe_fill_report(uo, uo.s, instrument_id, account_id, currency, ts, ts);
2351            assert!(fill1.is_some());
2352
2353            // Second call with same data produces nothing (dedup)
2354            let fill2 =
2355                tracker.maybe_fill_report(uo, uo.s, instrument_id, account_id, currency, ts, ts);
2356            assert!(fill2.is_none(), "duplicate fill should be suppressed");
2357        } else {
2358            panic!("expected OrderChange");
2359        }
2360    }
2361
2362    #[rstest]
2363    fn test_fill_tracker_price_back_calculation() {
2364        let data = load_test_json("stream/ocm_multiple_fills.json");
2365        let msgs: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2366        let instrument_id = make_instrument_id("1.179082386", 50210, Decimal::ZERO);
2367        let account_id = AccountId::from("BETFAIR-001");
2368        let currency = Currency::GBP();
2369        let mut tracker = FillTracker::new();
2370
2371        // Process first fill at avp=5.8
2372        let uo1 = extract_uo(&msgs[0]);
2373        let ts1 = extract_ts(&msgs[0]);
2374        let fill1 = tracker
2375            .maybe_fill_report(uo1, uo1.s, instrument_id, account_id, currency, ts1, ts1)
2376            .unwrap();
2377        assert_eq!(fill1.last_px.as_f64(), 5.8);
2378
2379        // Second fill also at avp=5.8 (same price, avg unchanged)
2380        let uo2 = extract_uo(&msgs[1]);
2381        let ts2 = extract_ts(&msgs[1]);
2382        let fill2 = tracker
2383            .maybe_fill_report(uo2, uo2.s, instrument_id, account_id, currency, ts2, ts2)
2384            .unwrap();
2385        assert_eq!(fill2.last_px.as_f64(), 5.8);
2386    }
2387
2388    #[rstest]
2389    fn test_has_cancel_quantity() {
2390        let data = load_test_json("stream/ocm_CANCEL.json");
2391        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2392
2393        if let StreamMessage::OrderChange(ocm) = msg {
2394            let uo = &ocm.oc.as_ref().unwrap()[0].orc.as_ref().unwrap()[0]
2395                .uo
2396                .as_ref()
2397                .unwrap()[0];
2398            assert!(has_cancel_quantity(uo));
2399        } else {
2400            panic!("expected OrderChange");
2401        }
2402    }
2403
2404    #[rstest]
2405    fn test_has_cancel_quantity_filled_order() {
2406        let data = load_test_json("stream/ocm_FILLED.json");
2407        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2408
2409        if let StreamMessage::OrderChange(ocm) = msg {
2410            let uo = &ocm.oc.as_ref().unwrap()[0].orc.as_ref().unwrap()[0]
2411                .uo
2412                .as_ref()
2413                .unwrap()[0];
2414            assert!(!has_cancel_quantity(uo));
2415        } else {
2416            panic!("expected OrderChange");
2417        }
2418    }
2419
2420    fn extract_uo(msg: &StreamMessage) -> &UnmatchedOrder {
2421        if let StreamMessage::OrderChange(ocm) = msg {
2422            &ocm.oc.as_ref().unwrap()[0].orc.as_ref().unwrap()[0]
2423                .uo
2424                .as_ref()
2425                .unwrap()[0]
2426        } else {
2427            panic!("expected OrderChange")
2428        }
2429    }
2430
2431    fn extract_ts(msg: &StreamMessage) -> UnixNanos {
2432        if let StreamMessage::OrderChange(ocm) = msg {
2433            parse_millis_timestamp(ocm.pt)
2434        } else {
2435            panic!("expected OrderChange")
2436        }
2437    }
2438
2439    #[rstest]
2440    fn test_parse_race_runner_data_from_fixture() {
2441        let data = load_test_json("stream/rcm_single.json");
2442        let msg = stream_decode(data.as_bytes()).unwrap();
2443
2444        let StreamMessage::RaceChange(rcm) = msg else {
2445            panic!("expected RaceChange");
2446        };
2447
2448        let race = &rcm.rc.as_ref().unwrap()[0];
2449        let rrc = &race.rrc.as_ref().unwrap()[0];
2450        let ts = parse_millis_timestamp(rcm.pt);
2451
2452        let runner = parse_race_runner_data(
2453            race.id.as_deref().unwrap(),
2454            race.mid.as_deref().unwrap(),
2455            rrc,
2456            ts,
2457            ts,
2458        )
2459        .unwrap();
2460
2461        assert_eq!(runner.race_id, "28587288.1650");
2462        assert_eq!(runner.market_id, "1.1234567");
2463        assert_eq!(runner.selection_id, 7390417);
2464        assert!((runner.latitude - 51.4189543).abs() < 1e-6);
2465        assert!((runner.longitude - (-0.4058491)).abs() < 1e-6);
2466        assert!((runner.speed - 17.8).abs() < 1e-6);
2467        assert!((runner.progress - 2051.0).abs() < 1e-6);
2468        assert!((runner.stride_frequency - 2.07).abs() < 1e-6);
2469    }
2470
2471    #[rstest]
2472    fn test_parse_race_progress_from_fixture() {
2473        let data = load_test_json("stream/rcm_single.json");
2474        let msg = stream_decode(data.as_bytes()).unwrap();
2475
2476        let StreamMessage::RaceChange(rcm) = msg else {
2477            panic!("expected RaceChange");
2478        };
2479
2480        let race = &rcm.rc.as_ref().unwrap()[0];
2481        let rpc = race.rpc.as_ref().unwrap();
2482        let ts = parse_millis_timestamp(rcm.pt);
2483
2484        let progress = parse_race_progress(
2485            race.id.as_deref().unwrap(),
2486            race.mid.as_deref().unwrap(),
2487            rpc,
2488            ts,
2489            ts,
2490        );
2491
2492        assert_eq!(progress.race_id, "28587288.1650");
2493        assert_eq!(progress.market_id, "1.1234567");
2494        assert_eq!(progress.gate_name, "1f");
2495        assert!((progress.sectional_time - 10.6).abs() < 1e-6);
2496        assert!((progress.running_time - 46.7).abs() < 1e-6);
2497        assert!((progress.speed - 17.8).abs() < 1e-6);
2498        assert!((progress.progress - 87.5).abs() < 1e-6);
2499
2500        let order: Vec<i64> = serde_json::from_str(&progress.order).unwrap();
2501        assert_eq!(order, vec![7390417, 5600338, 11527189, 6395118, 8706072]);
2502
2503        let jumps: Vec<serde_json::Value> = serde_json::from_str(&progress.jumps).unwrap();
2504        assert_eq!(jumps.len(), 2);
2505        assert_eq!(jumps[0]["J"], 2);
2506    }
2507
2508    #[rstest]
2509    fn test_parse_cricket_match_from_fixture() {
2510        let data = load_test_json("stream/ccm_single.json");
2511        let msg = stream_decode(data.as_bytes()).unwrap();
2512
2513        let StreamMessage::CricketChange(ccm) = msg else {
2514            panic!("expected CricketChange");
2515        };
2516
2517        let change = &ccm.cc.as_ref().unwrap()[0];
2518        let ts = parse_millis_timestamp(ccm.pt);
2519        let cricket = parse_cricket_match(change, ts, ts).unwrap();
2520
2521        assert_eq!(cricket.event_id, "35741575");
2522        assert_eq!(cricket.market_id, "1.259334639");
2523        let stats: serde_json::Value = serde_json::from_str(&cricket.match_stats).unwrap();
2524        assert_eq!(stats["inningsStats"][0]["inningsRuns"], 100);
2525    }
2526
2527    #[rstest]
2528    #[case(None, Some("1.259334639".to_string()))]
2529    #[case(Some("35741575".to_string()), None)]
2530    fn test_parse_cricket_match_missing_required_id_returns_none(
2531        #[case] event_id: Option<String>,
2532        #[case] market_id: Option<String>,
2533    ) {
2534        let change = CricketChange {
2535            event_id,
2536            market_id,
2537            fixture_info: None,
2538            home_team: None,
2539            away_team: None,
2540            match_stats: Some(serde_json::json!({"inningsStats": []})),
2541            incident_list_wrapper: None,
2542        };
2543        let ts = UnixNanos::from(1_000_000_000u64);
2544        let result = parse_cricket_match(&change, ts, ts);
2545
2546        assert!(result.is_none());
2547    }
2548
2549    #[rstest]
2550    fn test_parse_race_runner_data_multi_runner() {
2551        let data = load_test_json("stream/rcm_multi_runner.json");
2552        let msg = stream_decode(data.as_bytes()).unwrap();
2553
2554        let StreamMessage::RaceChange(rcm) = msg else {
2555            panic!("expected RaceChange");
2556        };
2557
2558        let race = &rcm.rc.as_ref().unwrap()[0];
2559        let ts = parse_millis_timestamp(rcm.pt);
2560        let race_id = race.id.as_deref().unwrap();
2561        let market_id = race.mid.as_deref().unwrap();
2562
2563        let runners: Vec<_> = race
2564            .rrc
2565            .as_ref()
2566            .unwrap()
2567            .iter()
2568            .filter_map(|rrc| parse_race_runner_data(race_id, market_id, rrc, ts, ts))
2569            .collect();
2570
2571        assert_eq!(runners.len(), 5);
2572        assert_eq!(runners[0].selection_id, 35467839);
2573        assert_eq!(runners[4].selection_id, 41694785);
2574        assert!((runners[0].speed - 16.33).abs() < 1e-6);
2575        assert!((runners[4].speed - 17.11).abs() < 1e-6);
2576    }
2577
2578    #[rstest]
2579    fn test_parse_race_runner_data_missing_id_returns_none() {
2580        let rrc = RaceRunnerChange {
2581            ft: Some(1000),
2582            id: None,
2583            lat: Some(51.0),
2584            lng: Some(-0.4),
2585            spd: Some(15.0),
2586            prg: Some(500.0),
2587            sfq: Some(2.0),
2588        };
2589        let ts = UnixNanos::from(1_000_000_000u64);
2590        let result = parse_race_runner_data("race1", "market1", &rrc, ts, ts);
2591        assert!(result.is_none());
2592    }
2593
2594    #[rstest]
2595    fn test_parse_race_runner_data_absent_fields_are_nan() {
2596        let rrc = RaceRunnerChange {
2597            ft: None,
2598            id: Some(12345),
2599            lat: None,
2600            lng: None,
2601            spd: None,
2602            prg: None,
2603            sfq: None,
2604        };
2605        let ts = UnixNanos::from(1_000_000_000u64);
2606        let runner = parse_race_runner_data("race1", "market1", &rrc, ts, ts).unwrap();
2607        assert!(runner.latitude.is_nan());
2608        assert!(runner.longitude.is_nan());
2609        assert!(runner.speed.is_nan());
2610        assert!(runner.progress.is_nan());
2611        assert!(runner.stride_frequency.is_nan());
2612    }
2613
2614    #[rstest]
2615    fn test_parse_race_progress_absent_fields() {
2616        let rpc = RaceProgressChange {
2617            ft: None,
2618            g: None,
2619            st: None,
2620            rt: None,
2621            spd: None,
2622            prg: None,
2623            ord: None,
2624            jumps: None,
2625        };
2626        let ts = UnixNanos::from(1_000_000_000u64);
2627        let progress = parse_race_progress("race1", "market1", &rpc, ts, ts);
2628        assert_eq!(progress.gate_name, "");
2629        assert!(progress.sectional_time.is_nan());
2630        assert!(progress.running_time.is_nan());
2631        assert_eq!(progress.order, "");
2632        assert_eq!(progress.jumps, "");
2633    }
2634
2635    fn runner_change_with_ticker(
2636        id: u64,
2637        ltp: Option<Decimal>,
2638        tv: Option<Decimal>,
2639        spn: Option<Decimal>,
2640        spf: Option<Decimal>,
2641    ) -> RunnerChange {
2642        RunnerChange {
2643            id,
2644            hc: None,
2645            atb: None,
2646            atl: None,
2647            batb: None,
2648            batl: None,
2649            bdatb: None,
2650            bdatl: None,
2651            spb: None,
2652            spl: None,
2653            spn,
2654            spf,
2655            trd: None,
2656            ltp,
2657            tv,
2658        }
2659    }
2660
2661    #[rstest]
2662    fn test_parse_betfair_ticker_all_fields() {
2663        let rc = runner_change_with_ticker(
2664            9249757,
2665            Some(Decimal::new(55, 1)),
2666            Some(Decimal::new(189032, 2)),
2667            Some(Decimal::new(568, 2)),
2668            Some(Decimal::new(573, 2)),
2669        );
2670        let ts = UnixNanos::from(1_000_000_000u64);
2671        let instrument_id = make_instrument_id("1.185781465", 9249757, Decimal::ZERO);
2672
2673        let ticker = parse_betfair_ticker(instrument_id, &rc, ts, ts).unwrap();
2674
2675        assert_eq!(ticker.instrument_id, instrument_id);
2676        assert_decimal_option_eq(ticker.last_traded_price, Decimal::new(55, 1));
2677        assert_decimal_option_eq(ticker.traded_volume, Decimal::new(189032, 2));
2678        assert_decimal_option_eq(ticker.starting_price_near, Decimal::new(568, 2));
2679        assert_decimal_option_eq(ticker.starting_price_far, Decimal::new(573, 2));
2680    }
2681
2682    #[rstest]
2683    fn test_parse_betfair_ticker_partial_fields() {
2684        let rc = runner_change_with_ticker(
2685            9249757,
2686            Some(Decimal::new(55, 1)),
2687            Some(Decimal::new(189032, 2)),
2688            None,
2689            None,
2690        );
2691        let ts = UnixNanos::from(1_000_000_000u64);
2692        let instrument_id = make_instrument_id("1.185781465", 9249757, Decimal::ZERO);
2693
2694        let ticker = parse_betfair_ticker(instrument_id, &rc, ts, ts).unwrap();
2695
2696        assert_decimal_option_eq(ticker.last_traded_price, Decimal::new(55, 1));
2697        assert_decimal_option_eq(ticker.traded_volume, Decimal::new(189032, 2));
2698        assert!(ticker.starting_price_near.is_none());
2699        assert!(ticker.starting_price_far.is_none());
2700    }
2701
2702    #[rstest]
2703    fn test_parse_betfair_ticker_no_fields_returns_none() {
2704        let rc = runner_change_with_ticker(9249757, None, None, None, None);
2705        let ts = UnixNanos::from(1_000_000_000u64);
2706        let instrument_id = make_instrument_id("1.185781465", 9249757, Decimal::ZERO);
2707
2708        assert!(parse_betfair_ticker(instrument_id, &rc, ts, ts).is_none());
2709    }
2710
2711    #[rstest]
2712    fn test_parse_betfair_ticker_only_tv() {
2713        let rc =
2714            runner_change_with_ticker(40273293, None, Some(Decimal::new(320115, 2)), None, None);
2715        let ts = UnixNanos::from(1_000_000_000u64);
2716        let instrument_id = make_instrument_id("1.185781465", 40273293, Decimal::ZERO);
2717
2718        let ticker = parse_betfair_ticker(instrument_id, &rc, ts, ts).unwrap();
2719
2720        assert!(ticker.last_traded_price.is_none());
2721        assert_decimal_option_eq(ticker.traded_volume, Decimal::new(320115, 2));
2722        assert!(ticker.starting_price_near.is_none());
2723        assert!(ticker.starting_price_far.is_none());
2724    }
2725
2726    #[rstest]
2727    fn test_parse_betfair_ticker_from_fixture() {
2728        let data = load_test_json("stream/mcm_BSP_settled.json");
2729        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2730
2731        if let StreamMessage::MarketChange(mcm) = msg {
2732            let mc = mcm.mc.as_ref().unwrap();
2733            let change = &mc[0];
2734            let rc_list = change.rc.as_ref().unwrap();
2735
2736            // Runner 9249757 has ltp=5.5, tv=1890.32, spn=5.68, spf=5.73
2737            let rc = rc_list.iter().find(|r| r.id == 9249757).unwrap();
2738            let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
2739            let ts = parse_millis_timestamp(mcm.pt);
2740
2741            let ticker = parse_betfair_ticker(instrument_id, rc, ts, ts).unwrap();
2742
2743            assert_decimal_option_eq(ticker.last_traded_price, Decimal::new(55, 1));
2744            assert_decimal_option_eq(ticker.traded_volume, Decimal::new(189032, 2));
2745            assert_decimal_option_eq(ticker.starting_price_near, Decimal::new(568, 2));
2746            assert_decimal_option_eq(ticker.starting_price_far, Decimal::new(573, 2));
2747
2748            // Runner 40273293 has ltp=2.1, tv=3201.15 but no spn/spf
2749            let rc2 = rc_list.iter().find(|r| r.id == 40273293).unwrap();
2750            let instrument_id2 = make_instrument_id(&change.id, rc2.id, Decimal::ZERO);
2751            let ticker2 = parse_betfair_ticker(instrument_id2, rc2, ts, ts).unwrap();
2752
2753            assert_decimal_option_eq(ticker2.last_traded_price, Decimal::new(21, 1));
2754            assert_decimal_option_eq(ticker2.traded_volume, Decimal::new(320115, 2));
2755            assert!(ticker2.starting_price_near.is_none());
2756            assert!(ticker2.starting_price_far.is_none());
2757
2758            // Runner 23678734 has only tv=0, no ltp
2759            let rc3 = rc_list.iter().find(|r| r.id == 23678734).unwrap();
2760            let instrument_id3 = make_instrument_id(&change.id, rc3.id, Decimal::ZERO);
2761            let ticker3 = parse_betfair_ticker(instrument_id3, rc3, ts, ts).unwrap();
2762
2763            assert!(ticker3.last_traded_price.is_none());
2764            assert_decimal_option_eq(ticker3.traded_volume, Decimal::ZERO);
2765        } else {
2766            panic!("Expected MarketChange");
2767        }
2768    }
2769
2770    #[rstest]
2771    fn test_parse_betfair_starting_prices_from_fixture() {
2772        let data = load_test_json("stream/mcm_BSP_settled.json");
2773        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2774
2775        if let StreamMessage::MarketChange(mcm) = msg {
2776            let mc = mcm.mc.as_ref().unwrap();
2777            let def = mc[0].market_definition.as_ref().unwrap();
2778            let ts = parse_millis_timestamp(mcm.pt);
2779
2780            let prices = parse_betfair_starting_prices(&mc[0].id, def, ts, ts);
2781
2782            // 3 runners have bsp values, 1 (REMOVED) does not
2783            assert_eq!(prices.len(), 3);
2784
2785            let bsp_map: std::collections::HashMap<String, Decimal> = prices
2786                .iter()
2787                .map(|p| (p.instrument_id.to_string(), p.bsp))
2788                .collect();
2789
2790            let id_winner = make_instrument_id("1.185781465", 9249757, Decimal::ZERO).to_string();
2791            let id_placed = make_instrument_id("1.185781465", 40273293, Decimal::ZERO).to_string();
2792            let id_loser = make_instrument_id("1.185781465", 11120000, Decimal::ZERO).to_string();
2793
2794            assert_eq!(bsp_map[&id_winner], Decimal::new(573, 2));
2795            assert_eq!(bsp_map[&id_placed], Decimal::new(214, 2));
2796            assert_eq!(bsp_map[&id_loser], Decimal::new(2856, 2));
2797        } else {
2798            panic!("Expected MarketChange");
2799        }
2800    }
2801
2802    #[rstest]
2803    fn test_parse_betfair_starting_prices_no_runners() {
2804        let def = MarketDefinition {
2805            runners: None,
2806            bet_delay: None,
2807            betting_type: None,
2808            bsp_market: None,
2809            bsp_reconciled: None,
2810            competition_id: None,
2811            competition_name: None,
2812            complete: None,
2813            country_code: None,
2814            cross_matching: None,
2815            discount_allowed: None,
2816            each_way_divisor: None,
2817            event_id: None,
2818            event_name: None,
2819            event_type_id: None,
2820            event_type_name: None,
2821            in_play: None,
2822            line_interval: None,
2823            line_max_unit: None,
2824            line_min_unit: None,
2825            market_base_rate: None,
2826            market_id: None,
2827            market_name: None,
2828            market_time: None,
2829            market_type: None,
2830            number_of_active_runners: None,
2831            number_of_winners: None,
2832            open_date: None,
2833            persistence_enabled: None,
2834            price_ladder_definition: None,
2835            race_type: None,
2836            regulators: None,
2837            runners_voidable: None,
2838            settled_time: None,
2839            status: None,
2840            suspend_time: None,
2841            timezone: None,
2842            turn_in_play_enabled: None,
2843            venue: None,
2844            version: None,
2845        };
2846        let ts = UnixNanos::from(1_000_000_000u64);
2847
2848        let prices = parse_betfair_starting_prices("1.12345", &def, ts, ts);
2849
2850        assert!(prices.is_empty());
2851    }
2852
2853    #[rstest]
2854    fn test_parse_bsp_book_deltas_from_fixture() {
2855        let data = load_test_json("stream/mcm_BSP.json");
2856        let messages: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2857
2858        // Find the MCM with runner changes containing spb/spl data
2859        let mcm = messages
2860            .iter()
2861            .find_map(|m| match m {
2862                StreamMessage::MarketChange(mcm) => {
2863                    let mc = mcm.mc.as_ref()?;
2864                    let has_spb = mc.iter().any(|c| {
2865                        c.rc.as_ref()
2866                            .is_some_and(|rcs| rcs.iter().any(|r| r.spb.is_some()))
2867                    });
2868
2869                    if has_spb { Some(mcm) } else { None }
2870                }
2871                _ => None,
2872            })
2873            .expect("fixture should contain MCM with spb data");
2874
2875        let mc = mcm.mc.as_ref().unwrap();
2876        let change = &mc[0];
2877        let rc_list = change.rc.as_ref().unwrap();
2878
2879        // Runner 9249757 has spb and spl arrays
2880        let rc = rc_list.iter().find(|r| r.id == 9249757).unwrap();
2881        let instrument_id = make_instrument_id(&change.id, rc.id, Decimal::ZERO);
2882        let ts = parse_millis_timestamp(mcm.pt);
2883
2884        let deltas = parse_bsp_book_deltas(instrument_id, rc, ts, ts);
2885
2886        let spb_count = rc.spb.as_ref().unwrap().len();
2887        let spl_count = rc.spl.as_ref().unwrap().len();
2888        assert_eq!(deltas.len(), spb_count + spl_count);
2889
2890        // SPB entries are Sell side
2891        assert_eq!(deltas[0].side, OrderSide::Sell);
2892        assert_eq!(deltas[0].price, Decimal::new(1000, 0));
2893        assert_eq!(deltas[0].size, Decimal::new(3338, 2));
2894        assert_eq!(deltas[0].action, BookAction::Update);
2895
2896        // SPL entries are Buy side
2897        let spl_start = spb_count;
2898        assert_eq!(deltas[spl_start].side, OrderSide::Buy);
2899        assert_eq!(deltas[spl_start].price, Decimal::new(7, 0));
2900        assert_eq!(deltas[spl_start].size, Decimal::new(10, 0));
2901    }
2902
2903    #[rstest]
2904    fn test_parse_bsp_book_deltas_zero_volume_is_delete() {
2905        let rc = RunnerChange {
2906            id: 12345,
2907            hc: None,
2908            atb: None,
2909            atl: None,
2910            batb: None,
2911            batl: None,
2912            bdatb: None,
2913            bdatl: None,
2914            spb: Some(vec![PV {
2915                price: Decimal::new(50, 1),
2916                volume: Decimal::ZERO,
2917            }]),
2918            spl: None,
2919            spn: None,
2920            spf: None,
2921            trd: None,
2922            ltp: None,
2923            tv: None,
2924        };
2925        let ts = UnixNanos::from(1_000_000_000u64);
2926        let instrument_id = make_instrument_id("1.12345", 12345, Decimal::ZERO);
2927
2928        let deltas = parse_bsp_book_deltas(instrument_id, &rc, ts, ts);
2929
2930        assert_eq!(deltas.len(), 1);
2931        assert_eq!(deltas[0].action, BookAction::Delete);
2932        assert_eq!(deltas[0].price, Decimal::new(5, 0));
2933        assert_eq!(deltas[0].size, Decimal::ZERO);
2934    }
2935
2936    #[rstest]
2937    fn test_parse_bsp_book_deltas_no_spb_spl_returns_empty() {
2938        let rc = runner_change_with_ticker(12345, None, None, None, None);
2939        let ts = UnixNanos::from(1_000_000_000u64);
2940        let instrument_id = make_instrument_id("1.12345", 12345, Decimal::ZERO);
2941
2942        let deltas = parse_bsp_book_deltas(instrument_id, &rc, ts, ts);
2943
2944        assert!(deltas.is_empty());
2945    }
2946
2947    #[rstest]
2948    fn test_parse_instrument_closes_from_fixture() {
2949        let data = load_test_json("stream/mcm_BSP_settled.json");
2950        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
2951
2952        if let StreamMessage::MarketChange(mcm) = msg {
2953            let mc = mcm.mc.as_ref().unwrap();
2954            let def = mc[0].market_definition.as_ref().unwrap();
2955            let ts = parse_millis_timestamp(mcm.pt);
2956
2957            let closes = parse_instrument_closes(&mc[0].id, def, ts, ts);
2958
2959            // 4 runners: WINNER, PLACED, LOSER, REMOVED - all produce close events
2960            assert_eq!(closes.len(), 4);
2961
2962            let close_map: std::collections::HashMap<String, Price> = closes
2963                .iter()
2964                .map(|c| (c.instrument_id.to_string(), c.close_price))
2965                .collect();
2966
2967            let id_winner = make_instrument_id("1.185781465", 9249757, Decimal::ZERO).to_string();
2968            let id_placed = make_instrument_id("1.185781465", 40273293, Decimal::ZERO).to_string();
2969            let id_loser = make_instrument_id("1.185781465", 11120000, Decimal::ZERO).to_string();
2970            let id_removed = make_instrument_id("1.185781465", 37433527, Decimal::ZERO).to_string();
2971
2972            assert_eq!(close_map[&id_winner], Price::from("1.00"));
2973            assert_eq!(close_map[&id_placed], Price::from("1.00"));
2974            assert_eq!(close_map[&id_loser], Price::from("0.00"));
2975            assert_eq!(close_map[&id_removed], Price::from("0.00"));
2976        } else {
2977            panic!("Expected MarketChange");
2978        }
2979    }
2980
2981    #[rstest]
2982    fn test_parse_instrument_closes_active_runners_excluded() {
2983        let data = load_test_json("stream/mcm_BSP.json");
2984        let messages: Vec<StreamMessage> = serde_json::from_str(&data).unwrap();
2985
2986        // Find the MCM with a market definition containing ACTIVE runners
2987        let mcm = messages
2988            .iter()
2989            .find_map(|m| match m {
2990                StreamMessage::MarketChange(mcm) => {
2991                    let mc = mcm.mc.as_ref()?;
2992                    mc.iter()
2993                        .find(|c| c.market_definition.is_some())
2994                        .map(|_| mcm)
2995                }
2996                _ => None,
2997            })
2998            .expect("fixture should contain MCM with market definition");
2999
3000        let mc = mcm.mc.as_ref().unwrap();
3001        let change = mc.iter().find(|c| c.market_definition.is_some()).unwrap();
3002        let def = change.market_definition.as_ref().unwrap();
3003        let ts = parse_millis_timestamp(mcm.pt);
3004
3005        let closes = parse_instrument_closes(&change.id, def, ts, ts);
3006
3007        assert!(
3008            closes.is_empty(),
3009            "Active runners should not produce close events, found {}",
3010            closes.len()
3011        );
3012    }
3013
3014    fn make_test_uo(
3015        bet_id: &str,
3016        size: Decimal,
3017        sm: Option<Decimal>,
3018        avp: Option<Decimal>,
3019    ) -> UnmatchedOrder {
3020        UnmatchedOrder {
3021            id: bet_id.to_string(),
3022            p: Decimal::new(25, 1),
3023            s: size,
3024            side: StreamingSide::Back,
3025            status: StreamingOrderStatus::Executable,
3026            pt: Some(StreamingPersistenceType::Lapse),
3027            ot: StreamingOrderType::Limit,
3028            pd: 1616568581000,
3029            bsp: None,
3030            rfo: None,
3031            rfs: None,
3032            rc: None,
3033            rac: None,
3034            md: None,
3035            cd: None,
3036            ld: None,
3037            avp,
3038            sm,
3039            sr: None,
3040            sl: None,
3041            sc: None,
3042            sv: None,
3043            lsrc: None,
3044        }
3045    }
3046
3047    #[rstest]
3048    fn test_make_trade_id_normalizes_float_tail_sm() {
3049        let uo = make_test_uo(
3050            "430069890490",
3051            Decimal::new(4287, 2),
3052            Some(Decimal::new(4_287_000_000_000_001, 14)),
3053            Some(Decimal::new(25, 1)),
3054        );
3055
3056        let trade_id = make_trade_id(&uo);
3057
3058        assert_eq!(trade_id.as_str(), "430069890490-42.87");
3059    }
3060
3061    #[rstest]
3062    fn test_fill_tracker_sync_order_prevents_duplicate_fill() {
3063        let mut tracker = FillTracker::new();
3064
3065        // Sync existing fill state: 10 matched at 2.5
3066        tracker.sync_order("123456", Decimal::new(10, 0), Decimal::new(25, 1));
3067
3068        let uo = make_test_uo(
3069            "123456",
3070            Decimal::new(20, 0),
3071            Some(Decimal::new(10, 0)),
3072            Some(Decimal::new(25, 1)),
3073        );
3074
3075        let instrument_id = InstrumentId::from("1.234567-123456-0.0.BETFAIR");
3076        let account_id = AccountId::from("BETFAIR-001");
3077        let currency = Currency::from("GBP");
3078        let ts = UnixNanos::default();
3079
3080        // Same sm=10 as synced, should not emit a fill
3081        let result =
3082            tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3083        assert!(
3084            result.is_none(),
3085            "should not emit fill for already-synced qty"
3086        );
3087    }
3088
3089    #[rstest]
3090    fn test_fill_tracker_sync_order_is_monotonic() {
3091        let mut tracker = FillTracker::new();
3092
3093        // Tracker already has 10 from prior stream activity
3094        tracker.sync_order("123456", Decimal::new(10, 0), Decimal::new(25, 1));
3095
3096        // Cache lags (engine hasn't processed the last fill yet) and reports 5
3097        tracker.sync_order("123456", Decimal::new(5, 0), Decimal::new(20, 1));
3098
3099        // Next OCM with sm=15 must emit incremental fill of 5, not 10
3100        let uo = make_test_uo(
3101            "123456",
3102            Decimal::new(20, 0),
3103            Some(Decimal::new(15, 0)),
3104            Some(Decimal::new(25, 1)),
3105        );
3106        let result = tracker.maybe_fill_report(
3107            &uo,
3108            uo.s,
3109            InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3110            AccountId::from("BETFAIR-001"),
3111            Currency::from("GBP"),
3112            UnixNanos::default(),
3113            UnixNanos::default(),
3114        );
3115        let fill = result.expect("should emit incremental fill");
3116        assert_eq!(fill.last_qty, Quantity::from("5.00"));
3117    }
3118
3119    #[rstest]
3120    fn test_fill_tracker_sync_order_allows_incremental_fill() {
3121        let mut tracker = FillTracker::new();
3122
3123        // Sync: 10 matched at 2.5
3124        tracker.sync_order("123456", Decimal::new(10, 0), Decimal::new(25, 1));
3125
3126        let uo = make_test_uo(
3127            "123456",
3128            Decimal::new(20, 0),
3129            Some(Decimal::new(15, 0)),
3130            Some(Decimal::new(26, 1)),
3131        );
3132
3133        let instrument_id = InstrumentId::from("1.234567-123456-0.0.BETFAIR");
3134        let account_id = AccountId::from("BETFAIR-001");
3135        let currency = Currency::from("GBP");
3136        let ts = UnixNanos::default();
3137
3138        // sm=15 vs synced 10, should emit incremental fill of 5
3139        let result =
3140            tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3141        assert!(result.is_some(), "should emit fill for new matched qty");
3142        let fill = result.unwrap();
3143        assert_eq!(fill.last_qty, Quantity::from("5.00"));
3144    }
3145
3146    #[rstest]
3147    fn test_fill_tracker_seed_published_trade_ids_blocks_replay() {
3148        let mut tracker = FillTracker::new();
3149
3150        let uo_for_id = make_test_uo(
3151            "123456",
3152            Decimal::new(20, 0),
3153            Some(Decimal::new(10, 0)),
3154            Some(Decimal::new(25, 1)),
3155        );
3156        let trade_id = make_trade_id(&uo_for_id);
3157
3158        // Seeded trade-id must block even with an empty FillTracker
3159        // (cumulative-size gate would otherwise let this fill through)
3160        tracker.seed_published_trade_ids([trade_id.to_string()]);
3161
3162        let result = tracker.maybe_fill_report(
3163            &uo_for_id,
3164            uo_for_id.s,
3165            InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3166            AccountId::from("BETFAIR-001"),
3167            Currency::from("GBP"),
3168            UnixNanos::default(),
3169            UnixNanos::default(),
3170        );
3171
3172        assert!(
3173            result.is_none(),
3174            "seeded trade-id should suppress duplicate fill",
3175        );
3176
3177        let next_update = make_test_uo(
3178            "123456",
3179            Decimal::new(20, 0),
3180            Some(Decimal::new(15, 0)),
3181            Some(Decimal::new(25, 1)),
3182        );
3183        let next_fill = tracker
3184            .maybe_fill_report(
3185                &next_update,
3186                next_update.s,
3187                InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3188                AccountId::from("BETFAIR-001"),
3189                Currency::from("GBP"),
3190                UnixNanos::default(),
3191                UnixNanos::default(),
3192            )
3193            .expect("later cumulative state should emit only the new delta");
3194        assert_eq!(next_fill.last_qty, Quantity::from("5.00"));
3195    }
3196
3197    #[rstest]
3198    fn test_fill_tracker_accepts_sm_float_tail_at_order_quantity() {
3199        let mut tracker = FillTracker::new();
3200        let uo = make_test_uo(
3201            "430069890490",
3202            Decimal::new(4287, 2),
3203            Some(Decimal::new(4_287_000_000_000_001, 14)),
3204            Some(Decimal::new(25, 1)),
3205        );
3206
3207        let result = tracker.maybe_fill_report(
3208            &uo,
3209            uo.s,
3210            InstrumentId::from("1.234567-430069890490-0.0.BETFAIR"),
3211            AccountId::from("BETFAIR-001"),
3212            Currency::from("GBP"),
3213            UnixNanos::default(),
3214            UnixNanos::default(),
3215        );
3216
3217        let fill = result.expect("float tail at order quantity should emit fill");
3218        assert_eq!(fill.last_qty, Quantity::from("42.87"));
3219        assert_eq!(fill.trade_id.as_str(), "430069890490-42.87");
3220
3221        let duplicate = tracker.maybe_fill_report(
3222            &uo,
3223            uo.s,
3224            InstrumentId::from("1.234567-430069890490-0.0.BETFAIR"),
3225            AccountId::from("BETFAIR-001"),
3226            Currency::from("GBP"),
3227            UnixNanos::default(),
3228            UnixNanos::default(),
3229        );
3230        assert!(
3231            duplicate.is_none(),
3232            "same normalized sm should not emit a duplicate fill"
3233        );
3234    }
3235
3236    #[rstest]
3237    fn test_fill_tracker_normalized_duplicate_updates_average_price_anchor() {
3238        let mut tracker = FillTracker::new();
3239
3240        let first = tracker.advance_cumulative_fill(
3241            "123456",
3242            Decimal::new(10, 0),
3243            Some(Decimal::new(20, 1)),
3244            Decimal::new(20, 1),
3245        );
3246        let normalized_duplicate = tracker.advance_cumulative_fill(
3247            "123456",
3248            Decimal::new(10001, 3),
3249            Some(Decimal::new(30, 1)),
3250            Decimal::new(30, 1),
3251        );
3252        let next = tracker
3253            .advance_cumulative_fill(
3254                "123456",
3255                Decimal::new(11, 0),
3256                Some(Decimal::new(30, 1)),
3257                Decimal::new(30, 1),
3258            )
3259            .expect("new cumulative quantity should emit a fill");
3260
3261        let first = first.expect("first fill");
3262        let restatement = normalized_duplicate.expect("changed average restates the surviving lot");
3263        assert_eq!(restatement.0, first.0);
3264        assert_eq!(restatement.1, Quantity::from("10.00"));
3265        assert_eq!(restatement.2, Price::from("3.00"));
3266        assert_eq!(next.1, Quantity::from("1.00"));
3267        assert_eq!(next.2, Price::from("3.00"));
3268    }
3269
3270    #[rstest]
3271    fn test_fill_tracker_changed_average_with_two_lots_emits_nothing() {
3272        let mut tracker = FillTracker::new();
3273        let first = tracker
3274            .advance_cumulative_fill(
3275                "bet",
3276                Decimal::from(2),
3277                Some(Decimal::from(12)),
3278                Decimal::from(12),
3279            )
3280            .expect("first lot");
3281        let second = tracker
3282            .advance_cumulative_fill(
3283                "bet",
3284                Decimal::from(4),
3285                Some(Decimal::from(10)),
3286                Decimal::from(10),
3287            )
3288            .expect("second lot");
3289        let restatement = tracker.advance_cumulative_fill(
3290            "bet",
3291            Decimal::from(4),
3292            Some(Decimal::new(900, 2)),
3293            Decimal::from(12),
3294        );
3295        let later = tracker
3296            .advance_cumulative_fill(
3297                "bet",
3298                Decimal::from(6),
3299                Some(Decimal::from(8)),
3300                Decimal::from(12),
3301            )
3302            .expect("later fill uses the corrected average");
3303
3304        assert_ne!(first.0, second.0);
3305        assert!(restatement.is_none());
3306        // (8 * 6 - 9 * 4) / 2 = 6, not (8 * 6 - 10 * 4) / 2 = 4
3307        assert_eq!(later.1, Quantity::from("2.00"));
3308        assert_eq!(later.2, Price::from("6.00"));
3309    }
3310
3311    #[rstest]
3312    fn test_fill_tracker_void_with_new_average_does_not_restate_price() {
3313        let mut tracker = FillTracker::new();
3314        tracker
3315            .advance_cumulative_fill(
3316                "bet",
3317                Decimal::from(2),
3318                Some(Decimal::from(12)),
3319                Decimal::from(12),
3320            )
3321            .expect("fill");
3322        let restatement = tracker.advance_cumulative_fill_with_voids(
3323            "bet",
3324            Decimal::from(2),
3325            Decimal::from(1),
3326            Some(Decimal::new(947, 2)),
3327            Decimal::from(12),
3328        );
3329
3330        assert!(restatement.is_none());
3331    }
3332
3333    #[rstest]
3334    fn test_fill_tracker_post_void_fill_uses_restated_accounting_price() {
3335        let mut tracker = FillTracker::new();
3336        let bet_id = "bet-void-restate";
3337        tracker
3338            .advance_cumulative_fill(
3339                bet_id,
3340                Decimal::from(2),
3341                Some(Decimal::from(12)),
3342                Decimal::from(12),
3343            )
3344            .expect("fill");
3345
3346        let voided = tracker.maybe_fill_voids(&UnmatchedOrder {
3347            id: bet_id.to_string(),
3348            sv: Some(Decimal::from(1)),
3349            ..make_test_uo(bet_id, Decimal::from(2), Some(Decimal::from(1)), None)
3350        });
3351
3352        let restatement = tracker
3353            .advance_cumulative_fill_with_voids(
3354                bet_id,
3355                Decimal::from(2),
3356                Decimal::from(1),
3357                Some(Decimal::new(947, 2)),
3358                Decimal::from(12),
3359            )
3360            .expect("one surviving lot restates");
3361        let later = tracker
3362            .advance_cumulative_fill_with_voids(
3363                bet_id,
3364                Decimal::from(3),
3365                Decimal::from(1),
3366                Some(Decimal::from(10)),
3367                Decimal::from(12),
3368            )
3369            .expect("later fill");
3370
3371        assert_eq!(voided[0].last_px, Price::from("12.00"));
3372        assert_eq!(restatement.2, Price::from("9.47"));
3373        assert_eq!(later.2, Price::from("10.53"));
3374    }
3375
3376    #[rstest]
3377    fn test_fill_tracker_overfill_rejected() {
3378        let mut tracker = FillTracker::new();
3379
3380        // sm=30 exceeds order size s=20
3381        let uo = make_test_uo(
3382            "999001",
3383            Decimal::new(20, 0),
3384            Some(Decimal::new(30, 0)),
3385            Some(Decimal::new(25, 1)),
3386        );
3387
3388        let instrument_id = InstrumentId::from("1.234567-999001-0.0.BETFAIR");
3389        let account_id = AccountId::from("BETFAIR-001");
3390        let currency = Currency::from("GBP");
3391        let ts = UnixNanos::default();
3392
3393        let result =
3394            tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3395        assert!(
3396            result.is_none(),
3397            "overfill (sm > order_qty) should be rejected"
3398        );
3399    }
3400
3401    #[rstest]
3402    fn test_fill_tracker_zero_sm_returns_none() {
3403        let mut tracker = FillTracker::new();
3404
3405        let uo = make_test_uo("999002", Decimal::new(10, 0), Some(Decimal::ZERO), None);
3406
3407        let instrument_id = InstrumentId::from("1.234567-999002-0.0.BETFAIR");
3408        let result = tracker.maybe_fill_report(
3409            &uo,
3410            uo.s,
3411            instrument_id,
3412            AccountId::from("BETFAIR-001"),
3413            Currency::from("GBP"),
3414            UnixNanos::default(),
3415            UnixNanos::default(),
3416        );
3417        assert!(result.is_none(), "zero sm should not produce a fill");
3418    }
3419
3420    #[rstest]
3421    fn test_fill_tracker_no_avp_uses_order_price() {
3422        let data = load_test_json("stream/ocm_FILLED_no_avp.json");
3423        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
3424
3425        if let StreamMessage::OrderChange(ocm) = msg {
3426            let oc = ocm.oc.as_ref().unwrap();
3427            let omc = &oc[0];
3428            let orc = &omc.orc.as_ref().unwrap()[0];
3429            let uo = &orc.uo.as_ref().unwrap()[0];
3430            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
3431            let ts = parse_millis_timestamp(ocm.pt);
3432
3433            let mut tracker = FillTracker::new();
3434            let fill = tracker
3435                .maybe_fill_report(
3436                    uo,
3437                    uo.s,
3438                    instrument_id,
3439                    AccountId::from("BETFAIR-001"),
3440                    Currency::GBP(),
3441                    ts,
3442                    ts,
3443                )
3444                .expect("should produce fill even without avp");
3445
3446            // No avp field, so fill price falls back to order price (p=3.5)
3447            assert_eq!(fill.last_qty.as_f64(), 25.0);
3448            assert_eq!(fill.last_px.as_f64(), 3.5);
3449        } else {
3450            panic!("expected OrderChange");
3451        }
3452    }
3453
3454    #[rstest]
3455    fn test_fill_tracker_weighted_avg_back_calculation() {
3456        let mut tracker = FillTracker::new();
3457        let instrument_id = InstrumentId::from("1.234567-999003-0.0.BETFAIR");
3458        let account_id = AccountId::from("BETFAIR-001");
3459        let currency = Currency::from("GBP");
3460        let ts = UnixNanos::default();
3461
3462        // First fill: 10 @ avp=2.0
3463        let uo1 = make_test_uo(
3464            "999003",
3465            Decimal::new(30, 0),
3466            Some(Decimal::new(10, 0)),
3467            Some(Decimal::new(20, 1)),
3468        );
3469        let fill1 = tracker
3470            .maybe_fill_report(&uo1, uo1.s, instrument_id, account_id, currency, ts, ts)
3471            .expect("first fill");
3472        assert_eq!(fill1.last_px.as_f64(), 2.0);
3473        assert_eq!(fill1.last_qty.as_f64(), 10.0);
3474
3475        // Second fill: sm=20, avp=2.5
3476        // Back-calc: (2.5*20 - 2.0*10) / 10 = (50-20)/10 = 3.0
3477        let uo2 = make_test_uo(
3478            "999003",
3479            Decimal::new(30, 0),
3480            Some(Decimal::new(20, 0)),
3481            Some(Decimal::new(25, 1)),
3482        );
3483        let fill2 = tracker
3484            .maybe_fill_report(&uo2, uo2.s, instrument_id, account_id, currency, ts, ts)
3485            .expect("second fill");
3486        assert_eq!(fill2.last_qty.as_f64(), 10.0);
3487        assert_eq!(fill2.last_px.as_f64(), 3.0);
3488    }
3489
3490    #[rstest]
3491    fn test_fill_tracker_negative_fill_price_falls_back_to_avp() {
3492        let mut tracker = FillTracker::new();
3493        let instrument_id = InstrumentId::from("1.234567-999004-0.0.BETFAIR");
3494        let account_id = AccountId::from("BETFAIR-001");
3495        let currency = Currency::from("GBP");
3496        let ts = UnixNanos::default();
3497
3498        // First fill: 10 @ avp=5.0
3499        let uo1 = make_test_uo(
3500            "999004",
3501            Decimal::new(20, 0),
3502            Some(Decimal::new(10, 0)),
3503            Some(Decimal::new(50, 1)),
3504        );
3505        tracker
3506            .maybe_fill_report(&uo1, uo1.s, instrument_id, account_id, currency, ts, ts)
3507            .expect("first fill");
3508
3509        // Second fill: sm=15, avp=1.0
3510        // Back-calc: (1.0*15 - 5.0*10) / 5 = (15-50)/5 = -7.0
3511        // Negative price should fall back to avp=1.0
3512        let uo2 = make_test_uo(
3513            "999004",
3514            Decimal::new(20, 0),
3515            Some(Decimal::new(15, 0)),
3516            Some(Decimal::new(10, 1)),
3517        );
3518        let fill2 = tracker
3519            .maybe_fill_report(&uo2, uo2.s, instrument_id, account_id, currency, ts, ts)
3520            .expect("second fill should use avp fallback");
3521        assert_eq!(fill2.last_qty.as_f64(), 5.0);
3522        assert_eq!(fill2.last_px.as_f64(), 1.0);
3523    }
3524
3525    #[rstest]
3526    fn test_fill_tracker_prune_clears_state() {
3527        let mut tracker = FillTracker::new();
3528        let instrument_id = InstrumentId::from("1.234567-999005-0.0.BETFAIR");
3529        let account_id = AccountId::from("BETFAIR-001");
3530        let currency = Currency::from("GBP");
3531        let ts = UnixNanos::default();
3532
3533        // Fill order fully
3534        let uo = make_test_uo(
3535            "999005",
3536            Decimal::new(10, 0),
3537            Some(Decimal::new(10, 0)),
3538            Some(Decimal::new(25, 1)),
3539        );
3540        let fill1 =
3541            tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3542        assert!(fill1.is_some());
3543
3544        // Same data again - deduplicated
3545        let fill2 =
3546            tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3547        assert!(fill2.is_none(), "should be deduplicated");
3548
3549        // Prune the bet
3550        tracker.prune("999005");
3551
3552        // After prune, same data can produce a fill again (simulates re-processing)
3553        let fill3 =
3554            tracker.maybe_fill_report(&uo, uo.s, instrument_id, account_id, currency, ts, ts);
3555        assert!(fill3.is_some(), "after prune, should produce fill again");
3556    }
3557
3558    #[rstest]
3559    fn test_fill_tracker_sm_none_returns_none() {
3560        let mut tracker = FillTracker::new();
3561
3562        // sm=None (no matched quantity field at all)
3563        let uo = make_test_uo("999006", Decimal::new(10, 0), None, None);
3564
3565        let instrument_id = InstrumentId::from("1.234567-999006-0.0.BETFAIR");
3566        let result = tracker.maybe_fill_report(
3567            &uo,
3568            uo.s,
3569            instrument_id,
3570            AccountId::from("BETFAIR-001"),
3571            Currency::from("GBP"),
3572            UnixNanos::default(),
3573            UnixNanos::default(),
3574        );
3575        assert!(result.is_none(), "None sm should not produce a fill");
3576    }
3577
3578    #[rstest]
3579    fn test_parse_order_status_report_missing_persistence_type_for_market_on_close() {
3580        let uo = UnmatchedOrder {
3581            s: Decimal::ZERO,
3582            pt: None,
3583            ot: StreamingOrderType::MarketOnClose,
3584            sr: Some(Decimal::new(10, 0)),
3585            ..make_test_uo("999007", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3586        };
3587
3588        let report = parse_order_status_report(
3589            &uo,
3590            InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3591            AccountId::from("BETFAIR-001"),
3592            UnixNanos::default(),
3593            UnixNanos::default(),
3594        )
3595        .unwrap();
3596
3597        assert_eq!(report.quantity, Quantity::from("10.00"));
3598        assert_eq!(report.time_in_force, TimeInForce::AtTheClose);
3599    }
3600
3601    #[rstest]
3602    fn test_parse_order_status_report_missing_persistence_type_for_limit_on_close() {
3603        let uo = UnmatchedOrder {
3604            s: Decimal::ZERO,
3605            pt: None,
3606            ot: StreamingOrderType::LimitOnClose,
3607            sr: Some(Decimal::new(10, 0)),
3608            ..make_test_uo("999013", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3609        };
3610
3611        let report = parse_order_status_report(
3612            &uo,
3613            InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3614            AccountId::from("BETFAIR-001"),
3615            UnixNanos::default(),
3616            UnixNanos::default(),
3617        )
3618        .unwrap();
3619
3620        assert_eq!(report.quantity, Quantity::from("10.00"));
3621        assert_eq!(report.time_in_force, TimeInForce::AtTheClose);
3622    }
3623
3624    #[rstest]
3625    fn test_parse_order_status_report_market_on_close_uses_bsp_liability() {
3626        let uo = UnmatchedOrder {
3627            s: Decimal::ZERO,
3628            bsp: Some(Decimal::new(20, 1)),
3629            pt: None,
3630            ot: StreamingOrderType::MarketOnClose,
3631            ..make_test_uo("999010", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3632        };
3633
3634        let report = parse_order_status_report(
3635            &uo,
3636            InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3637            AccountId::from("BETFAIR-001"),
3638            UnixNanos::default(),
3639            UnixNanos::default(),
3640        )
3641        .unwrap();
3642
3643        assert_eq!(report.quantity, Quantity::from("2.00"));
3644        assert_eq!(report.time_in_force, TimeInForce::AtTheClose);
3645    }
3646
3647    #[rstest]
3648    fn test_parse_order_status_report_fails_for_non_positive_quantity() {
3649        let uo = UnmatchedOrder {
3650            s: Decimal::ZERO,
3651            sm: Some(Decimal::ZERO),
3652            sr: Some(Decimal::ZERO),
3653            sc: Some(Decimal::ZERO),
3654            sl: Some(Decimal::ZERO),
3655            sv: Some(Decimal::ZERO),
3656            ..make_test_uo("999014", Decimal::ZERO, Some(Decimal::ZERO), None)
3657        };
3658
3659        let result = parse_order_status_report(
3660            &uo,
3661            InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3662            AccountId::from("BETFAIR-001"),
3663            UnixNanos::default(),
3664            UnixNanos::default(),
3665        );
3666
3667        assert!(result.is_err());
3668        assert!(
3669            result
3670                .unwrap_err()
3671                .to_string()
3672                .contains("failed to resolve positive quantity for stream order update 999014")
3673        );
3674    }
3675
3676    #[rstest]
3677    fn test_parse_order_status_report_includes_lapse_reason() {
3678        let uo = UnmatchedOrder {
3679            status: StreamingOrderStatus::ExecutionComplete,
3680            sl: Some(Decimal::ONE),
3681            lsrc: Some(crate::common::enums::LapseStatusReasonCode::SpInPlay),
3682            ..make_test_uo("999012", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3683        };
3684
3685        let report = parse_order_status_report(
3686            &uo,
3687            InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3688            AccountId::from("BETFAIR-001"),
3689            UnixNanos::default(),
3690            UnixNanos::default(),
3691        )
3692        .unwrap();
3693
3694        assert_eq!(report.order_status, OrderStatus::Canceled);
3695        assert_eq!(report.cancel_reason.as_deref(), Some("SP_IN_PLAY"));
3696    }
3697
3698    #[rstest]
3699    fn test_parse_order_status_report_blank_rfo_normalizes_to_none() {
3700        // Some venues send rfo:"" instead of omitting it. ClientOrderId rejects
3701        // empty strings, so the parser must treat blank refs as missing.
3702        let uo = UnmatchedOrder {
3703            rfo: Some(String::new()),
3704            ..make_test_uo("999013", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3705        };
3706
3707        let report = parse_order_status_report(
3708            &uo,
3709            InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3710            AccountId::from("BETFAIR-001"),
3711            UnixNanos::default(),
3712            UnixNanos::default(),
3713        )
3714        .unwrap();
3715
3716        assert!(report.client_order_id.is_none());
3717    }
3718
3719    #[rstest]
3720    fn test_fill_tracker_blank_rfo_normalizes_to_none() {
3721        let mut tracker = FillTracker::new();
3722        let uo = UnmatchedOrder {
3723            rfo: Some(String::new()),
3724            sm: Some(Decimal::new(5, 0)),
3725            avp: Some(Decimal::new(25, 1)),
3726            ..make_test_uo("999015", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3727        };
3728
3729        let fill = tracker
3730            .maybe_fill_report(
3731                &uo,
3732                uo.s,
3733                InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3734                AccountId::from("BETFAIR-001"),
3735                Currency::from("GBP"),
3736                UnixNanos::default(),
3737                UnixNanos::default(),
3738            )
3739            .expect("blank rfo should still produce a fill");
3740
3741        assert!(fill.client_order_id.is_none());
3742    }
3743
3744    #[rstest]
3745    fn test_fill_tracker_first_seen_void_records_without_correction() {
3746        let mut tracker = FillTracker::new();
3747        let uo = UnmatchedOrder {
3748            status: StreamingOrderStatus::ExecutionComplete,
3749            sm: Some(Decimal::new(50, 0)),
3750            sv: Some(Decimal::new(50, 0)),
3751            ..make_test_uo("999016", Decimal::new(50, 0), None, None)
3752        };
3753
3754        let first = tracker.maybe_fill_voids(&uo);
3755        let duplicate = tracker.maybe_fill_voids(&uo);
3756
3757        assert!(first.is_empty());
3758        assert!(duplicate.is_empty());
3759        assert!(!tracker.has_unseen_fill_void(&uo));
3760    }
3761
3762    #[rstest]
3763    fn test_fill_tracker_emits_only_increased_cumulative_void() {
3764        let mut tracker = FillTracker::new();
3765        let instrument_id = InstrumentId::from("1.234567-123456-0.0.BETFAIR");
3766        let account_id = AccountId::from("BETFAIR-001");
3767        let mut uo = make_test_uo(
3768            "999017",
3769            Decimal::new(60, 0),
3770            Some(Decimal::new(60, 0)),
3771            Some(Decimal::new(25, 1)),
3772        );
3773        tracker
3774            .maybe_fill_report(
3775                &uo,
3776                uo.s,
3777                instrument_id,
3778                account_id,
3779                Currency::GBP(),
3780                UnixNanos::default(),
3781                UnixNanos::default(),
3782            )
3783            .expect("matched size should establish a fill lot");
3784
3785        uo.sv = Some(Decimal::new(40, 0));
3786        let first = tracker.maybe_fill_voids(&uo);
3787        let duplicate = tracker.maybe_fill_voids(&uo);
3788        uo.sv = Some(Decimal::new(50, 0));
3789        let unseen_before_update = tracker.has_unseen_fill_void(&uo);
3790        let increased = tracker.maybe_fill_voids(&uo);
3791
3792        assert_eq!(first.len(), 1);
3793        assert_eq!(first[0].voided_qty, Quantity::from("40.00"));
3794        assert!(duplicate.is_empty());
3795        assert!(unseen_before_update);
3796        assert_eq!(increased.len(), 1);
3797        assert_eq!(increased[0].trade_id, first[0].trade_id);
3798        assert_eq!(increased[0].voided_qty, Quantity::from("50.00"));
3799        assert!(!tracker.has_unseen_fill_void(&uo));
3800    }
3801
3802    #[rstest]
3803    fn test_fill_tracker_allocates_cumulative_void_to_newest_fill_lot_first() {
3804        let mut tracker = FillTracker::new();
3805        let bet_id = "999019";
3806        let older_trade_id = TradeId::from("999019-30.00");
3807        let newer_trade_id = TradeId::from("999019-100.00");
3808        tracker.sync_fill_lot(
3809            bet_id,
3810            older_trade_id,
3811            Decimal::new(30, 0),
3812            Price::from("2.00"),
3813            Decimal::ZERO,
3814        );
3815        tracker.sync_fill_lot(
3816            bet_id,
3817            newer_trade_id,
3818            Decimal::new(70, 0),
3819            Price::from("3.00"),
3820            Decimal::ZERO,
3821        );
3822        let uo = UnmatchedOrder {
3823            sv: Some(Decimal::new(50, 0)),
3824            ..make_test_uo(bet_id, Decimal::new(100, 0), None, None)
3825        };
3826
3827        let corrections = tracker.maybe_fill_voids(&uo);
3828
3829        assert_eq!(corrections.len(), 1);
3830        assert_eq!(corrections[0].trade_id, newer_trade_id);
3831        assert_eq!(corrections[0].voided_qty, Quantity::from("50.00"));
3832        assert_eq!(corrections[0].last_px, Price::from("3.00"));
3833    }
3834
3835    #[rstest]
3836    fn test_fill_tracker_prices_new_fill_from_post_void_average() {
3837        let mut tracker = FillTracker::new();
3838        let bet_id = "999021";
3839        let older_trade_id = TradeId::from("999021-50.00");
3840        tracker.sync_fill_lot(
3841            bet_id,
3842            older_trade_id,
3843            Decimal::new(50, 0),
3844            Price::from("2.00"),
3845            Decimal::ZERO,
3846        );
3847        let (_, last_qty, last_px) = tracker
3848            .advance_cumulative_fill_with_voids(
3849                bet_id,
3850                Decimal::new(100, 0),
3851                Decimal::new(40, 0),
3852                Some(Decimal::new(25, 1)),
3853                Decimal::new(20, 1),
3854            )
3855            .expect("gross lifecycle increase should produce a fill");
3856
3857        let uo = UnmatchedOrder {
3858            sm: Some(Decimal::new(60, 0)),
3859            sv: Some(Decimal::new(40, 0)),
3860            ..make_test_uo(bet_id, Decimal::new(100, 0), None, None)
3861        };
3862        let corrections = tracker.maybe_fill_voids(&uo);
3863
3864        assert_eq!(last_qty, Quantity::from("50.00"));
3865        assert_eq!(last_px, Price::from("5.00"));
3866        assert_eq!(corrections.len(), 1);
3867        assert_eq!(corrections[0].voided_qty, Quantity::from("40.00"));
3868        assert_eq!(corrections[0].last_px, Price::from("5.00"));
3869    }
3870
3871    #[rstest]
3872    fn test_fill_tracker_preserves_prior_void_allocation_when_new_fill_arrives() {
3873        let mut tracker = FillTracker::new();
3874        let bet_id = "999020";
3875        let older_trade_id = TradeId::from("999020-60.00");
3876        let newer_trade_id = TradeId::from("999020-80.00");
3877        tracker.sync_fill_lot(
3878            bet_id,
3879            older_trade_id,
3880            Decimal::new(60, 0),
3881            Price::from("2.00"),
3882            Decimal::ZERO,
3883        );
3884        let mut uo = UnmatchedOrder {
3885            sv: Some(Decimal::new(40, 0)),
3886            ..make_test_uo(bet_id, Decimal::new(80, 0), None, None)
3887        };
3888
3889        let first = tracker.maybe_fill_voids(&uo);
3890        tracker.sync_fill_lot(
3891            bet_id,
3892            newer_trade_id,
3893            Decimal::new(20, 0),
3894            Price::from("3.00"),
3895            Decimal::ZERO,
3896        );
3897        uo.sv = Some(Decimal::new(50, 0));
3898        let increased = tracker.maybe_fill_voids(&uo);
3899
3900        assert_eq!(first.len(), 1);
3901        assert_eq!(first[0].trade_id, older_trade_id);
3902        assert_eq!(first[0].voided_qty, Quantity::from("40.00"));
3903        assert_eq!(increased.len(), 1);
3904        assert_eq!(increased[0].trade_id, newer_trade_id);
3905        assert_eq!(increased[0].voided_qty, Quantity::from("10.00"));
3906    }
3907
3908    #[rstest]
3909    fn test_fill_tracker_reconnect_increased_void_does_not_replay_gross_fill() {
3910        let mut tracker = FillTracker::new();
3911        let instrument_id = InstrumentId::from("1.234567-123456-0.0.BETFAIR");
3912        let account_id = AccountId::from("BETFAIR-001");
3913        let mut uo = make_test_uo(
3914            "999018",
3915            Decimal::new(60, 0),
3916            Some(Decimal::new(60, 0)),
3917            Some(Decimal::new(25, 1)),
3918        );
3919        let trade_id = make_trade_id(&uo);
3920        tracker.sync_fill_lot(
3921            &uo.id,
3922            trade_id,
3923            Decimal::new(60, 0),
3924            Price::from("2.50"),
3925            Decimal::new(40, 0),
3926        );
3927        tracker.sync_voided_qty(&uo.id, Decimal::new(40, 0));
3928        uo.sv = Some(Decimal::new(50, 0));
3929
3930        let fill = tracker.maybe_fill_report(
3931            &uo,
3932            uo.s,
3933            instrument_id,
3934            account_id,
3935            Currency::GBP(),
3936            UnixNanos::default(),
3937            UnixNanos::default(),
3938        );
3939        let corrections = tracker.maybe_fill_voids(&uo);
3940
3941        assert!(fill.is_none());
3942        assert_eq!(corrections.len(), 1);
3943        assert_eq!(corrections[0].trade_id, trade_id);
3944        assert_eq!(corrections[0].voided_qty, Quantity::from("50.00"));
3945    }
3946
3947    #[rstest]
3948    fn test_parse_order_status_report_missing_persistence_type_fails_for_limit_order() {
3949        let uo = UnmatchedOrder {
3950            pt: None,
3951            ..make_test_uo("999008", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3952        };
3953
3954        let result = parse_order_status_report(
3955            &uo,
3956            InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3957            AccountId::from("BETFAIR-001"),
3958            UnixNanos::default(),
3959            UnixNanos::default(),
3960        );
3961
3962        assert!(result.is_err());
3963        assert_eq!(
3964            result.unwrap_err().to_string(),
3965            "missing persistence type for order update 999008"
3966        );
3967    }
3968
3969    #[rstest]
3970    fn test_fill_tracker_uses_lifecycle_quantity_when_stream_size_is_zero() {
3971        let mut tracker = FillTracker::new();
3972        let uo = UnmatchedOrder {
3973            s: Decimal::ZERO,
3974            sr: Some(Decimal::new(10, 0)),
3975            sm: Some(Decimal::new(5, 0)),
3976            avp: Some(Decimal::new(20, 1)),
3977            ..make_test_uo("999009", Decimal::new(10, 0), Some(Decimal::ZERO), None)
3978        };
3979
3980        let fill = tracker
3981            .maybe_fill_report(
3982                &uo,
3983                uo.s,
3984                InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
3985                AccountId::from("BETFAIR-001"),
3986                Currency::from("GBP"),
3987                UnixNanos::default(),
3988                UnixNanos::default(),
3989            )
3990            .expect("zero stream size should fall back to lifecycle quantities");
3991
3992        assert_eq!(fill.last_qty, Quantity::from("5.00"));
3993    }
3994
3995    #[rstest]
3996    fn test_fill_tracker_uses_bsp_liability_when_stream_size_is_zero() {
3997        let mut tracker = FillTracker::new();
3998        let uo = UnmatchedOrder {
3999            s: Decimal::ZERO,
4000            bsp: Some(Decimal::new(20, 1)),
4001            pt: None,
4002            ot: StreamingOrderType::MarketOnClose,
4003            sm: Some(Decimal::new(10, 1)),
4004            avp: Some(Decimal::new(20, 1)),
4005            ..make_test_uo("999011", Decimal::new(10, 0), Some(Decimal::ZERO), None)
4006        };
4007
4008        let fill = tracker
4009            .maybe_fill_report(
4010                &uo,
4011                uo.s,
4012                InstrumentId::from("1.234567-123456-0.0.BETFAIR"),
4013                AccountId::from("BETFAIR-001"),
4014                Currency::from("GBP"),
4015                UnixNanos::default(),
4016                UnixNanos::default(),
4017            )
4018            .expect("zero stream size should fall back to bsp liability");
4019
4020        assert_eq!(fill.last_qty, Quantity::from("1.00"));
4021    }
4022
4023    #[rstest]
4024    fn test_fill_tracker_partial_void_still_emits_fill() {
4025        let data = load_test_json("stream/ocm_VOIDED_partial.json");
4026        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
4027
4028        if let StreamMessage::OrderChange(ocm) = msg {
4029            let oc = ocm.oc.as_ref().unwrap();
4030            let omc = &oc[0];
4031            let orc = &omc.orc.as_ref().unwrap()[0];
4032            let uo = &orc.uo.as_ref().unwrap()[0];
4033            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
4034            let ts = parse_millis_timestamp(ocm.pt);
4035
4036            let mut tracker = FillTracker::new();
4037            let fill = tracker
4038                .maybe_fill_report(
4039                    uo,
4040                    uo.s,
4041                    instrument_id,
4042                    AccountId::from("BETFAIR-001"),
4043                    Currency::GBP(),
4044                    ts,
4045                    ts,
4046                )
4047                .expect("should produce fill for matched portion");
4048
4049            // Order: s=100, sm=60, sv=40 -> fill qty should be 60
4050            assert_eq!(fill.last_qty.as_f64(), 60.0);
4051            assert_eq!(fill.last_px.as_f64(), 1.5);
4052            assert_eq!(fill.order_side, OrderSide::Sell);
4053
4054            let report = parse_order_status_report(
4055                uo,
4056                instrument_id,
4057                AccountId::from("BETFAIR-001"),
4058                ts,
4059                ts,
4060            )
4061            .unwrap();
4062            assert_eq!(report.filled_qty, Quantity::from("60.00"));
4063        } else {
4064            panic!("expected OrderChange");
4065        }
4066    }
4067
4068    #[rstest]
4069    fn test_fill_tracker_no_fill_when_sv_zero_and_fully_filled() {
4070        let data = load_test_json("stream/ocm_FILLED_sv_zero.json");
4071        let msg: StreamMessage = serde_json::from_str(&data).unwrap();
4072
4073        if let StreamMessage::OrderChange(ocm) = msg {
4074            let oc = ocm.oc.as_ref().unwrap();
4075            let omc = &oc[0];
4076            let orc = &omc.orc.as_ref().unwrap()[0];
4077            let uo = &orc.uo.as_ref().unwrap()[0];
4078            let instrument_id = make_instrument_id(&omc.id, orc.id, Decimal::ZERO);
4079            let ts = parse_millis_timestamp(ocm.pt);
4080
4081            let mut tracker = FillTracker::new();
4082            let fill = tracker
4083                .maybe_fill_report(
4084                    uo,
4085                    uo.s,
4086                    instrument_id,
4087                    AccountId::from("BETFAIR-001"),
4088                    Currency::GBP(),
4089                    ts,
4090                    ts,
4091                )
4092                .expect("fully filled order should produce fill");
4093
4094            assert_eq!(fill.last_qty.as_f64(), 50.0);
4095            assert_eq!(fill.last_px.as_f64(), 2.0);
4096
4097            // sv=0, so no void event should be generated (tested separately)
4098            assert_eq!(uo.sv, Some(Decimal::ZERO));
4099        } else {
4100            panic!("expected OrderChange");
4101        }
4102    }
4103}