betex 0.27.3

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,
    /// Fill-or-Kill with an optional minimum fill size.
    ///
    /// Units:
    /// - Exchange orders: stake (Money quanta)
    /// - Binary orders: shares
    FillOrKill { min_fill: Option<Quantity> },
}

#[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,
}

#[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)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum CommandKind {
    /// Engine-level: create and initialize a market/book.
    CreateMarket {
        name: String,
        market_model: MarketModel,
        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>,
    },
    /// 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,
    },
    /// Replace an existing order by updating price and/or stake.
    ReplaceOrder {
        account_id: AccountId,
        order_id: OrderId,
        new_odds: Option<OddsX10000>,
        new_stake: Option<Money>,
    },
    /// Replace an existing prediction-market order by updating price and/or quantity.
    ReplaceBinaryOrder {
        account_id: AccountId,
        order_id: OrderId,
        new_price_ticks: Option<u16>,
        new_qty_shares: Option<u64>,
    },
    /// Update market trading state.
    SetMarketState { state: MarketState },
    /// Move a market into the pre-live waiting phase.
    AwaitLiveMarket,
    /// Move a market into the live phase and open it unless halted.
    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>,
    },
    /// 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::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::GoLiveMarket
                    | 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
            } | Self::AwaitLiveMarket
                | Self::GoLiveMarket
                | Self::CloseMarket { .. }
                | Self::ContinueBatchProcess
                | Self::BatchCancelOrders { .. }
        )
    }
}

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::PlaceOrder { .. } => "PLACE_ORDER",
            CommandKind::PlaceBinaryOrder { .. } => "PLACE_BINARY_ORDER",
            CommandKind::CancelOrder { .. } => "CANCEL_ORDER",
            CommandKind::ReplaceOrder { .. } => "REPLACE_ORDER",
            CommandKind::ReplaceBinaryOrder { .. } => "REPLACE_BINARY_ORDER",
            CommandKind::SetMarketState { .. } => "SET_MARKET_STATE",
            CommandKind::AwaitLiveMarket => "AWAIT_LIVE_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::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::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::Open,
            }
            .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::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::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::GoLiveMarket.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(())
        );
    }
}