betex 0.4.0

//! Book event types.

use super::types::*;
use crate::{
    protocol::command::{Persistence, Side, TimeInForce},
    protocol::reject::RejectReason,
    types::*,
};
use serde::{Deserialize, Serialize};
use smallvec::SmallVec;
use std::fmt;

/// A reusable event buffer that avoids heap allocation for typical operations (1-4 events).
pub type EventVec = SmallVec<[BookEventEnvelope; 4]>;

/// A single event in the book's stream.
#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    rkyv::Archive,
    rkyv::Serialize,
    rkyv::Deserialize,
)]
pub struct BookEventEnvelope {
    pub market_id: MarketId,
    /// Unix timestamp in milliseconds (UTC) shared across all events in a tx.
    #[rkyv(with = crate::types::DateTimeUtcAsUnixMillis)]
    pub timestamp: DateTime,
    pub event: BookEvent,
}

#[derive(
    Debug,
    Clone,
    Copy,
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    rkyv::Archive,
    rkyv::Serialize,
    rkyv::Deserialize,
)]
pub struct OrderInfo {
    pub id: OrderId,
    pub side: Side,
}

/// Book event types.
#[derive(
    Debug,
    Clone,
    PartialEq,
    Eq,
    Serialize,
    Deserialize,
    rkyv::Archive,
    rkyv::Serialize,
    rkyv::Deserialize,
)]
pub enum BookEvent {
    /// Engine-level: create and initialize a market/book (must be journaled before any per-market events).
    MarketCreated {
        name: String,
        market_model: MarketModel,
        market_kind: MarketKind,
        /// Empty means "dynamic multi-runner" (runners may be added later).
        runner_ids: Vec<RunnerId>,
        runner_labels: Vec<String>,
    },
    MarketStateChanged {
        to: BookMarketState,
        reason: String,
    },
    OrderAccepted {
        order_id: OrderId,
        account_id: AccountId,
        runner_id: RunnerId,
        side: Side,
        price: OddsX10000,
        stake: Money,
        persistence: Persistence,
        time_in_force: TimeInForce,
    },
    BinaryOrderAccepted {
        order_id: OrderId,
        account_id: AccountId,
        side: Side,
        price_ticks: u16,
        qty_shares: u64,
        time_in_force: TimeInForce,
    },
    OrderRejected {
        order_id: OrderId,
        reason: RejectReason,
    },
    OrderUpdated {
        order_id: OrderId,
        matched: Money,
        remaining: Money,
        state: BookOrderState,
    },
    BinaryOrderUpdated {
        order_id: OrderId,
        filled_shares: u64,
        remaining_shares: u64,
        state: BookOrderState,
    },
    OrderCancelled {
        order_id: OrderId,
        reason: String,
    },
    OrderLapsed {
        order_id: OrderId,
        reason: String,
    },
    OrderVoided {
        order_id: OrderId,
        reason: String,
    },
    TradeMatched {
        trade_id: TradeId,
        maker: OrderInfo,
        taker: OrderInfo,
        runner_id: RunnerId,
        price: OddsX10000,
        stake: Money,
    },
    BinaryTradeMatched {
        trade_id: TradeId,
        maker: OrderInfo,
        taker: OrderInfo,
        price_ticks: u16,
        qty_shares: u64,
    },
    TradeVoided {
        trade_id: TradeId,
        reason: String,
    },
    RunnerRemoved {
        runner_id: RunnerId,
        reduction_factor_bps: Option<u32>,
    },
    MarketSettled {
        runner_results: Vec<(RunnerId, RunnerResult)>,
        dead_heat_divisor: Option<u32>,
    },
    /// Market orders settled (batched order cancellations during close).
    MarketOrdersSettled {
        cursor_after: Option<OrderId>,
        order_ids: Vec<OrderId>,
        is_final: bool,
    },
    /// Engine-level: market removed from memory (terminal cleanup).
    MarketRemoved {
        reason: String,
    },
}

impl fmt::Display for BookEventEnvelope {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "BOOK_EVENT_ENVELOPE market_id={:?} timestamp_ms={} event={}",
            self.market_id,
            self.timestamp.timestamp_millis(),
            self.event
        )
    }
}

impl fmt::Display for BookEvent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let kind = match self {
            BookEvent::MarketCreated { .. } => "MARKET_CREATED",
            BookEvent::MarketStateChanged { .. } => "MARKET_STATE_CHANGED",
            BookEvent::OrderAccepted { .. } => "ORDER_ACCEPTED",
            BookEvent::BinaryOrderAccepted { .. } => "BINARY_ORDER_ACCEPTED",
            BookEvent::OrderRejected { .. } => "ORDER_REJECTED",
            BookEvent::OrderUpdated { .. } => "ORDER_UPDATED",
            BookEvent::BinaryOrderUpdated { .. } => "BINARY_ORDER_UPDATED",
            BookEvent::OrderCancelled { .. } => "ORDER_CANCELLED",
            BookEvent::OrderLapsed { .. } => "ORDER_LAPSED",
            BookEvent::OrderVoided { .. } => "ORDER_VOIDED",
            BookEvent::TradeMatched { .. } => "TRADE_MATCHED",
            BookEvent::BinaryTradeMatched { .. } => "BINARY_TRADE_MATCHED",
            BookEvent::TradeVoided { .. } => "TRADE_VOIDED",
            BookEvent::RunnerRemoved { .. } => "RUNNER_REMOVED",
            BookEvent::MarketSettled { .. } => "MARKET_SETTLED",
            BookEvent::MarketOrdersSettled { .. } => "MARKET_ORDERS_SETTLED",
            BookEvent::MarketRemoved { .. } => "MARKET_REMOVED",
        };
        f.write_str(kind)
    }
}