betex 0.35.0

use super::reject::RejectReason;
use crate::book::common::BatchProcessState;
use crate::types::*;
use serde::{Deserialize, Serialize};
use std::fmt;

#[derive(
    Debug,
    Clone,
    Copy,
    Serialize,
    Deserialize,
    PartialEq,
    Eq,
    Hash,
    strum::Display,
    strum::EnumString,
    rkyv::Archive,
    rkyv::Serialize,
    rkyv::Deserialize,
)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
pub enum Side {
    /// Yes/long side.
    ///
    /// Mapping:
    /// - Exchange odds: Back
    /// - Binary: Buy
    Yes,
    /// No/short side.
    ///
    /// Mapping:
    /// - Exchange odds: Lay
    /// - Binary: Sell
    No,
}

#[allow(non_upper_case_globals)]
impl Side {
    /// Alias for `Yes` (exchange BACK).
    pub const Back: Self = Self::Yes;
    /// Alias for `No` (exchange LAY).
    pub const Lay: Self = Self::No;
    /// Alias for `Yes` (binary BUY).
    pub const Buy: Self = Self::Yes;
    /// Alias for `No` (binary SELL).
    pub const Sell: Self = Self::No;
}

pub type BinarySide = Side;
pub type BinaryTimeInForce = TimeInForce;

#[derive(
    Debug,
    Clone,
    Copy,
    Serialize,
    Deserialize,
    PartialEq,
    Eq,
    Hash,
    strum::Display,
    strum::EnumString,
    rkyv::Archive,
    rkyv::Serialize,
    rkyv::Deserialize,
)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
pub enum Persistence {
    Lapse,
    Persist,
    MarketOnClose,
}

/// Time-in-force policy for order execution.
#[derive(
    Debug,
    Clone,
    Copy,
    Serialize,
    Deserialize,
    PartialEq,
    Eq,
    Hash,
    rkyv::Archive,
    rkyv::Serialize,
    rkyv::Deserialize,
)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum TimeInForce {
    /// Good-til-Cancelled: match what's available now, then rest the remainder.
    Gtc,
    /// Immediate-or-Cancel: match what's available now, then cancel the remainder.
    ImmediateOrCancel,
    /// Fill-or-Kill with an optional minimum fill size.
    ///
    /// `min_fill = None` requires the full order quantity. `Some(qty)` requires
    /// `qty` to be positive and no greater than the order quantity.
    ///
    /// Units:
    /// - Exchange orders: stake (Money quanta)
    /// - Binary orders: shares
    FillOrKill { min_fill: Option<Quantity> },
}

impl TimeInForce {
    pub(crate) fn required_fok_fill(
        self,
        order_qty: Quantity,
    ) -> Result<Option<Quantity>, RejectReason> {
        let Self::FillOrKill { min_fill } = self else {
            return Ok(None);
        };

        let required = match min_fill {
            Some(qty) if qty.0 == 0 || qty.0 > order_qty.0 => {
                return Err(RejectReason::InvalidTimeInForce);
            }
            Some(qty) => qty,
            None => order_qty,
        };
        Ok(Some(required))
    }
}

/// Reduce-only target for amending an exchange-odds order.
///
/// `TotalStake` is interpreted as the caller's desired total order stake after
/// fills already observed by the engine. `RemainingStake` is interpreted
/// directly as the desired live remainder.
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ReduceOrderTarget {
    TotalStake(Money),
    RemainingStake(Money),
}

/// Optional state guard for reduce-only exchange order amendments.
///
/// When any supplied field differs from current engine state, the command is
/// rejected with `OrderStateChanged`.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub struct ReduceOrderCondition {
    #[serde(default)]
    pub expected_odds: Option<OddsX10000>,
    #[serde(default)]
    pub expected_stake: Option<Money>,
    #[serde(default)]
    pub expected_matched_stake: Option<Money>,
    #[serde(default)]
    pub expected_remaining_stake: Option<Money>,
}

/// Reduce-only target for amending a binary YES order.
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum ReduceBinaryOrderTarget {
    TotalShares(u64),
    RemainingShares(u64),
}

/// Optional state guard for reduce-only binary order amendments.
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub struct ReduceBinaryOrderCondition {
    #[serde(default)]
    pub expected_price_ticks: Option<u16>,
    #[serde(default)]
    pub expected_qty_shares: Option<u64>,
    #[serde(default)]
    pub expected_filled_shares: Option<u64>,
    #[serde(default)]
    pub expected_remaining_shares: Option<u64>,
}

#[derive(
    Debug,
    Clone,
    Copy,
    Default,
    Serialize,
    Deserialize,
    PartialEq,
    Eq,
    Hash,
    strum::Display,
    strum::EnumString,
    rkyv::Archive,
    rkyv::Serialize,
    rkyv::Deserialize,
)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
#[strum(serialize_all = "SCREAMING_SNAKE_CASE")]
pub enum MarketState {
    /// Market is open and accepts orders.
    #[default]
    Open,
    /// Market is temporarily suspended (no matching).
    Suspended,
    /// Market is closed and will be removed when the close batch completes.
    Closed,
    /// Market is deactivated (same trading effect as suspended).
    Deactivated,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Command {
    /// Optional client-provided correlation id (UUID-like string, max 36 bytes).
    ///
    /// Propagated into market/order creation events for downstream correlation when present.
    #[serde(default)]
    pub correlation_id: Option<CorrelationId>,
    /// Optional client-provided metadata propagated to emitted book event envelopes.
    #[serde(default)]
    pub metadata: Option<serde_json::Value>,
    /// Target market id for the command.
    pub market_id: MarketId,
    /// The command payload.
    pub kind: CommandKind,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub struct RunnerChange {
    pub runner_id: RunnerId,
    pub runner_label: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum CommandKind {
    /// Engine-level: create and initialize a market/book.
    CreateMarket {
        name: String,
        market_model: MarketModel,
        /// Concrete exchange book selection. Required for exchange-odds markets; omit otherwise.
        book_type: Option<BookType>,
        market_kind: MarketKind,
        #[serde(default)]
        market_state: MarketState,
        #[serde(default)]
        market_phase: MarketPhase,
        /// Empty means "dynamic multi-runner" (runners may be added later).
        runner_ids: Vec<RunnerId>,
        runner_labels: Vec<String>,
    },
    /// Add or revive runners in a dynamic multi-runner market.
    AddRunners {
        runner_ids: Vec<RunnerId>,
        runner_labels: Vec<String>,
    },
    /// Add/revive and remove runners in one dynamic multi-runner command.
    ChangeRunners {
        add: Vec<RunnerChange>,
        remove: Vec<RunnerChange>,
    },
    /// Place a new order on a market/runner.
    PlaceOrder {
        runner_id: RunnerId,
        account_id: AccountId,
        client_order_id: Option<ClientOrderId>,
        side: Side,
        odds: OddsX10000,
        stake: Money,
        persistence: Persistence,
        time_in_force: TimeInForce,
    },
    /// Place a new canonical YES-only prediction-market order.
    PlaceBinaryOrder {
        account_id: AccountId,
        client_order_id: Option<ClientOrderId>,
        side: Side,
        /// Uniform probability ticks in `[0..max_price_ticks]` for this market.
        price_ticks: u16,
        /// Quantity in shares (each share pays out `max_price_ticks` quanta on YES resolution).
        qty_shares: u64,
        time_in_force: TimeInForce,
    },
    /// Cancel an existing order.
    CancelOrder {
        account_id: AccountId,
        order_id: OrderId,
    },
    /// Reduce-only amend of an existing exchange order.
    ///
    /// The command may reprice and/or reduce the current live remainder, but it
    /// must not increase live stake or required reserve/liability.
    ReduceOrder {
        account_id: AccountId,
        order_id: OrderId,
        new_odds: Option<OddsX10000>,
        #[serde(default)]
        target: Option<ReduceOrderTarget>,
        #[serde(default)]
        condition: Option<ReduceOrderCondition>,
    },
    /// Reduce-only amend of an existing prediction-market order.
    ReduceBinaryOrder {
        account_id: AccountId,
        order_id: OrderId,
        new_price_ticks: Option<u16>,
        #[serde(default)]
        target: Option<ReduceBinaryOrderTarget>,
        #[serde(default)]
        condition: Option<ReduceBinaryOrderCondition>,
    },
    /// Update market trading state.
    SetMarketState { state: MarketState },
    /// Move a market into the pre-live waiting phase.
    AwaitLiveMarket,
    /// Return a pre-live waiting market to the pre-event trading phase without changing lifecycle state.
    ReturnToPreMarket {
        /// Human-readable reason recorded on the phase transition.
        #[serde(default)]
        reason: String,
    },
    /// Move a market into the live phase without changing lifecycle state.
    GoLiveMarket,
    /// Close a market in bounded event batches (starts a close process).
    CloseMarket {
        /// Human-readable reason recorded on the close state transition.
        #[serde(default)]
        reason: String,
    },
    /// Internal: continue an in-progress batch cleanup process.
    ContinueBatchProcess,
    /// Cancel matching live orders in bounded event batches without closing the market.
    BatchCancelOrders {
        from_created_at_inclusive: Option<DateTime>,
        to_created_at_inclusive: Option<DateTime>,
        account_id: Option<AccountId>,
        runner_id: Option<RunnerId>,
        reason: String,
    },
    /// Remove a runner from the market, optionally applying a reduction factor (in bps).
    RemoveRunner {
        runner_id: RunnerId,
        reduction_factor_bps: Option<u32>,
    },
    /// Remove multiple runners from the market, sharing one optional reduction factor.
    RemoveRunners {
        runner_ids: Vec<RunnerId>,
        reduction_factor_bps: Option<u32>,
    },
    /// Emit a passthrough void-trades marker (administrative).
    VoidTrades {
        timestamp: DateTime,
        start_time: DateTime,
        end_time: DateTime,
        void_reason: String,
    },
    /// Halt a market/book (administrative).
    ///
    /// The reason is caller-provided text recorded on the halt state transition.
    HaltMarket { reason: String },
    /// Resume a market/book after a halt (administrative).
    ResumeMarket,
}

impl Command {
    /// Extract the market_id from the command.
    pub fn market_id(&self) -> MarketId {
        self.market_id
    }
}

impl CommandKind {
    #[inline]
    pub fn is_internal_batch_continue(&self) -> bool {
        matches!(self, Self::ContinueBatchProcess)
    }

    #[inline]
    pub fn is_batch_interleavable_state_admin_command(&self) -> bool {
        matches!(
            self,
            Self::SetMarketState { .. }
                | Self::AwaitLiveMarket
                | Self::ReturnToPreMarket { .. }
                | Self::GoLiveMarket
                | Self::HaltMarket { .. }
                | Self::ResumeMarket
        )
    }

    #[inline]
    pub fn is_allowed_while_halted(&self, has_active_batch: bool) -> bool {
        if has_active_batch {
            self.is_internal_batch_continue()
                || self.is_batch_interleavable_state_admin_command()
                || matches!(self, Self::CloseMarket { .. })
        } else {
            matches!(
                self,
                Self::AwaitLiveMarket
                    | Self::ReturnToPreMarket { .. }
                    | Self::GoLiveMarket
                    | Self::AddRunners { .. }
                    | Self::ChangeRunners { .. }
                    | Self::RemoveRunner { .. }
                    | Self::RemoveRunners { .. }
                    | Self::BatchCancelOrders { .. }
                    | Self::ContinueBatchProcess
            )
        }
    }

    #[inline]
    pub fn validate_book_gate(
        &self,
        batch_state: Option<&BatchProcessState>,
        is_halted: bool,
    ) -> Result<(), RejectReason> {
        let is_internal_batch_continue = self.is_internal_batch_continue();
        let is_batch_interleavable_state_admin = self.is_batch_interleavable_state_admin_command();
        let is_close_market = matches!(self, Self::CloseMarket { .. });

        if let Some(batch_state) = batch_state {
            let allow_close_during_non_close_batch = is_close_market && !batch_state.is_close();
            if !is_internal_batch_continue
                && !is_batch_interleavable_state_admin
                && !allow_close_during_non_close_batch
            {
                return Err(RejectReason::MarketBatchCancelling);
            }
        }

        if is_halted && !self.is_allowed_while_halted(batch_state.is_some()) {
            return Err(RejectReason::MarketHalted);
        }

        Ok(())
    }

    #[inline]
    pub fn may_affect_batch_scheduler(&self) -> bool {
        matches!(
            self,
            Self::SetMarketState {
                state: MarketState::Closed | MarketState::Suspended | MarketState::Deactivated
            } | Self::AwaitLiveMarket
                | Self::GoLiveMarket
                | Self::CloseMarket { .. }
                | Self::ContinueBatchProcess
                | Self::BatchCancelOrders { .. }
                | Self::ChangeRunners { .. }
                | Self::RemoveRunner { .. }
                | Self::RemoveRunners { .. }
        )
    }
}

impl fmt::Display for Command {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.kind)
    }
}

impl fmt::Display for CommandKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = match self {
            CommandKind::CreateMarket { .. } => "CREATE_MARKET",
            CommandKind::AddRunners { .. } => "ADD_RUNNERS",
            CommandKind::ChangeRunners { .. } => "CHANGE_RUNNERS",
            CommandKind::PlaceOrder { .. } => "PLACE_ORDER",
            CommandKind::PlaceBinaryOrder { .. } => "PLACE_BINARY_ORDER",
            CommandKind::CancelOrder { .. } => "CANCEL_ORDER",
            CommandKind::ReduceOrder { .. } => "REDUCE_ORDER",
            CommandKind::ReduceBinaryOrder { .. } => "REDUCE_BINARY_ORDER",
            CommandKind::SetMarketState { .. } => "SET_MARKET_STATE",
            CommandKind::AwaitLiveMarket => "AWAIT_LIVE_MARKET",
            CommandKind::ReturnToPreMarket { .. } => "RETURN_TO_PRE_MARKET",
            CommandKind::GoLiveMarket => "GO_LIVE_MARKET",
            CommandKind::CloseMarket { .. } => "CLOSE_MARKET",
            CommandKind::ContinueBatchProcess => "CONTINUE_BATCH_PROCESS",
            CommandKind::BatchCancelOrders { .. } => "BATCH_CANCEL_ORDERS",
            CommandKind::RemoveRunner { .. } => "REMOVE_RUNNER",
            CommandKind::RemoveRunners { .. } => "REMOVE_RUNNERS",
            CommandKind::VoidTrades { .. } => "VOID_TRADES",
            CommandKind::HaltMarket { .. } => "HALT_MARKET",
            CommandKind::ResumeMarket => "RESUME_MARKET",
        };
        write!(f, "{s}")
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::book::{BatchMode, BatchProcessState};

    #[test]
    fn may_affect_batch_scheduler_flags_only_batch_relevant_commands() {
        assert!(
            CommandKind::CloseMarket {
                reason: "x".to_string(),
            }
            .may_affect_batch_scheduler()
        );
        assert!(CommandKind::ContinueBatchProcess.may_affect_batch_scheduler());
        assert!(
            CommandKind::BatchCancelOrders {
                from_created_at_inclusive: None,
                to_created_at_inclusive: None,
                account_id: None,
                runner_id: None,
                reason: "x".to_string(),
            }
            .may_affect_batch_scheduler()
        );
        assert!(
            CommandKind::RemoveRunner {
                runner_id: RunnerId(1),
                reduction_factor_bps: None,
            }
            .may_affect_batch_scheduler()
        );
        assert!(
            CommandKind::RemoveRunners {
                runner_ids: vec![RunnerId(1), RunnerId(2)],
                reduction_factor_bps: None,
            }
            .may_affect_batch_scheduler()
        );
        assert!(
            CommandKind::ChangeRunners {
                add: vec![RunnerChange {
                    runner_id: RunnerId(3),
                    runner_label: "C".to_string(),
                }],
                remove: vec![RunnerChange {
                    runner_id: RunnerId(1),
                    runner_label: "A".to_string(),
                }],
            }
            .may_affect_batch_scheduler()
        );
        assert!(CommandKind::AwaitLiveMarket.may_affect_batch_scheduler());
        assert!(CommandKind::GoLiveMarket.may_affect_batch_scheduler());
        assert!(
            CommandKind::SetMarketState {
                state: MarketState::Closed,
            }
            .may_affect_batch_scheduler()
        );
        assert!(
            CommandKind::SetMarketState {
                state: MarketState::Suspended,
            }
            .may_affect_batch_scheduler()
        );
        assert!(
            CommandKind::SetMarketState {
                state: MarketState::Deactivated,
            }
            .may_affect_batch_scheduler()
        );

        assert!(
            !CommandKind::ReturnToPreMarket {
                reason: "x".to_string(),
            }
            .may_affect_batch_scheduler()
        );
        assert!(
            !CommandKind::SetMarketState {
                state: MarketState::Open,
            }
            .may_affect_batch_scheduler()
        );
        assert!(
            !CommandKind::AddRunners {
                runner_ids: vec![RunnerId(1), RunnerId(2)],
                runner_labels: vec!["A".to_string(), "B".to_string()],
            }
            .may_affect_batch_scheduler()
        );
        assert!(
            !CommandKind::PlaceOrder {
                runner_id: RunnerId(1),
                account_id: AccountId::from(1_u64),
                client_order_id: None,
                side: Side::Yes,
                odds: OddsX10000(20_000),
                stake: Money(100),
                persistence: Persistence::Persist,
                time_in_force: TimeInForce::Gtc,
            }
            .may_affect_batch_scheduler()
        );
    }

    #[test]
    fn batch_interleavable_state_admin_helper_is_whitelist_only() {
        assert!(
            CommandKind::SetMarketState {
                state: MarketState::Open,
            }
            .is_batch_interleavable_state_admin_command()
        );
        assert!(CommandKind::AwaitLiveMarket.is_batch_interleavable_state_admin_command());
        assert!(
            CommandKind::ReturnToPreMarket {
                reason: "x".to_string(),
            }
            .is_batch_interleavable_state_admin_command()
        );
        assert!(CommandKind::GoLiveMarket.is_batch_interleavable_state_admin_command());
        assert!(
            CommandKind::HaltMarket {
                reason: "x".to_string(),
            }
            .is_batch_interleavable_state_admin_command()
        );
        assert!(CommandKind::ResumeMarket.is_batch_interleavable_state_admin_command());

        assert!(
            !CommandKind::CloseMarket {
                reason: "x".to_string(),
            }
            .is_batch_interleavable_state_admin_command()
        );
        assert!(!CommandKind::ContinueBatchProcess.is_batch_interleavable_state_admin_command());
        assert!(
            !CommandKind::BatchCancelOrders {
                from_created_at_inclusive: None,
                to_created_at_inclusive: None,
                account_id: None,
                runner_id: None,
                reason: "x".to_string(),
            }
            .is_batch_interleavable_state_admin_command()
        );
        assert!(
            !CommandKind::RemoveRunner {
                runner_id: RunnerId(1),
                reduction_factor_bps: None,
            }
            .is_batch_interleavable_state_admin_command()
        );
        assert!(
            !CommandKind::RemoveRunners {
                runner_ids: vec![RunnerId(1), RunnerId(2)],
                reduction_factor_bps: None,
            }
            .is_batch_interleavable_state_admin_command()
        );
        assert!(
            !CommandKind::AddRunners {
                runner_ids: vec![RunnerId(1), RunnerId(2)],
                runner_labels: vec!["A".to_string(), "B".to_string()],
            }
            .is_batch_interleavable_state_admin_command()
        );
        assert!(
            !CommandKind::ChangeRunners {
                add: vec![RunnerChange {
                    runner_id: RunnerId(3),
                    runner_label: "C".to_string(),
                }],
                remove: vec![],
            }
            .is_batch_interleavable_state_admin_command()
        );
        assert!(
            !CommandKind::PlaceOrder {
                runner_id: RunnerId(1),
                account_id: AccountId::from(1_u64),
                client_order_id: None,
                side: Side::Yes,
                odds: OddsX10000(20_000),
                stake: Money(100),
                persistence: Persistence::Persist,
                time_in_force: TimeInForce::Gtc,
            }
            .is_batch_interleavable_state_admin_command()
        );
    }

    #[test]
    fn allowed_while_halted_helper_matches_batch_mode_rules() {
        assert!(CommandKind::ContinueBatchProcess.is_allowed_while_halted(true));
        assert!(
            CommandKind::CloseMarket {
                reason: "x".to_string(),
            }
            .is_allowed_while_halted(true)
        );
        assert!(
            CommandKind::BatchCancelOrders {
                from_created_at_inclusive: None,
                to_created_at_inclusive: None,
                account_id: None,
                runner_id: None,
                reason: "x".to_string(),
            }
            .is_allowed_while_halted(false)
        );
        assert!(CommandKind::ContinueBatchProcess.is_allowed_while_halted(false));
        assert!(CommandKind::AwaitLiveMarket.is_allowed_while_halted(false));
        assert!(
            CommandKind::ReturnToPreMarket {
                reason: "x".to_string(),
            }
            .is_allowed_while_halted(false)
        );
        assert!(CommandKind::GoLiveMarket.is_allowed_while_halted(false));
        assert!(
            CommandKind::AddRunners {
                runner_ids: vec![RunnerId(1), RunnerId(2)],
                runner_labels: vec!["A".to_string(), "B".to_string()],
            }
            .is_allowed_while_halted(false)
        );
        assert!(
            CommandKind::RemoveRunner {
                runner_id: RunnerId(1),
                reduction_factor_bps: None,
            }
            .is_allowed_while_halted(false)
        );
        assert!(
            CommandKind::RemoveRunners {
                runner_ids: vec![RunnerId(1), RunnerId(2)],
                reduction_factor_bps: None,
            }
            .is_allowed_while_halted(false)
        );
        assert!(
            CommandKind::ChangeRunners {
                add: vec![RunnerChange {
                    runner_id: RunnerId(3),
                    runner_label: "C".to_string(),
                }],
                remove: vec![],
            }
            .is_allowed_while_halted(false)
        );
        assert!(
            !CommandKind::RemoveRunner {
                runner_id: RunnerId(1),
                reduction_factor_bps: None,
            }
            .is_allowed_while_halted(true)
        );
        assert!(
            !CommandKind::RemoveRunners {
                runner_ids: vec![RunnerId(1), RunnerId(2)],
                reduction_factor_bps: None,
            }
            .is_allowed_while_halted(true)
        );
        assert!(
            !CommandKind::ChangeRunners {
                add: vec![RunnerChange {
                    runner_id: RunnerId(3),
                    runner_label: "C".to_string(),
                }],
                remove: vec![],
            }
            .is_allowed_while_halted(true)
        );

        assert!(
            !CommandKind::SetMarketState {
                state: MarketState::Deactivated,
            }
            .is_allowed_while_halted(false)
        );
        assert!(
            !CommandKind::CloseMarket {
                reason: "x".to_string(),
            }
            .is_allowed_while_halted(false)
        );
        assert!(
            !CommandKind::PlaceOrder {
                runner_id: RunnerId(1),
                account_id: AccountId::from(1_u64),
                client_order_id: None,
                side: Side::Yes,
                odds: OddsX10000(20_000),
                stake: Money(100),
                persistence: Persistence::Persist,
                time_in_force: TimeInForce::Gtc,
            }
            .is_allowed_while_halted(true)
        );
    }

    #[test]
    fn validate_book_gate_reuses_shared_batch_and_halt_rules() {
        let close_batch = BatchProcessState::close(5, 2);
        let lapse_batch = BatchProcessState::lapse(5, BatchMode::InPlayLapse);

        assert_eq!(
            CommandKind::CloseMarket {
                reason: "x".to_string(),
            }
            .validate_book_gate(Some(&close_batch), false),
            Err(RejectReason::MarketBatchCancelling)
        );
        assert_eq!(
            CommandKind::CloseMarket {
                reason: "x".to_string(),
            }
            .validate_book_gate(Some(&lapse_batch), true),
            Ok(())
        );
        assert_eq!(
            CommandKind::PlaceOrder {
                runner_id: RunnerId(1),
                account_id: AccountId::from(1_u64),
                client_order_id: None,
                side: Side::Yes,
                odds: OddsX10000(20_000),
                stake: Money(100),
                persistence: Persistence::Persist,
                time_in_force: TimeInForce::Gtc,
            }
            .validate_book_gate(Some(&lapse_batch), false),
            Err(RejectReason::MarketBatchCancelling)
        );
        assert_eq!(
            CommandKind::BatchCancelOrders {
                from_created_at_inclusive: None,
                to_created_at_inclusive: None,
                account_id: None,
                runner_id: None,
                reason: "x".to_string(),
            }
            .validate_book_gate(None, true),
            Ok(())
        );
        assert_eq!(
            CommandKind::AddRunners {
                runner_ids: vec![RunnerId(1), RunnerId(2)],
                runner_labels: vec!["A".to_string(), "B".to_string()],
            }
            .validate_book_gate(Some(&lapse_batch), false),
            Err(RejectReason::MarketBatchCancelling)
        );
        assert_eq!(
            CommandKind::ChangeRunners {
                add: vec![RunnerChange {
                    runner_id: RunnerId(3),
                    runner_label: "C".to_string(),
                }],
                remove: vec![],
            }
            .validate_book_gate(Some(&lapse_batch), false),
            Err(RejectReason::MarketBatchCancelling)
        );
    }

    #[test]
    fn change_runners_display_name_is_wire_command_name() {
        let kind = CommandKind::ChangeRunners {
            add: vec![RunnerChange {
                runner_id: RunnerId(3),
                runner_label: "C".to_string(),
            }],
            remove: vec![],
        };

        assert_eq!(kind.to_string(), "CHANGE_RUNNERS");
    }
}