Core Types

pub struct Price(i64);

let p1 = Price::from_raw(100);
let p2 = Price::from_raw(50);

// Addition
assert_eq!((p1 + p2).raw(), 150);

// Subtraction
assert_eq!((p1 - p2).raw(), 50);

// Multiplication by scalar
assert_eq!((p1 * 2).raw(), 200);

// Division by scalar
assert_eq!((p1 / 2).raw(), 50);

// Saturating operations (prevent overflow)
let max = Price::MAX;
assert_eq!(max.saturating_add(p1), Price::MAX);

// Checked operations (return Option)
if let Some(result) = p1.checked_add(p2) {
    println!("Sum: {}", result.raw());
}

pub struct Quantity(u32);

let q1 = Quantity::new(100);
let q2 = Quantity::new(50);

// Arithmetic
assert_eq!((q1 + q2).value(), 150);
assert_eq!((q1 - q2).value(), 50);
assert_eq!((q1 * 2).value(), 200);

// Saturating operations
let result = q1.saturating_add(q2);

pub struct SignedQuantity(i64);

let long = SignedQuantity::new(100);
let short = SignedQuantity::new(-50);

assert!(long.is_long());
assert!(short.is_short());
assert_eq!((long + short).value(), 50);
assert_eq!(short.abs().value(), 50);

#[repr(u8)]
pub enum Side {
    Buy = 0,
    Sell = 1,
}

// From boolean
let side = Side::from_is_buy(true);
assert_eq!(side, Side::Buy);

// From u8
let side = Side::from_u8(0);
assert_eq!(side, Some(Side::Buy));

// To u8
let value: u8 = Side::Buy.as_u8();
assert_eq!(value, 0);

// Using Not operator
assert_eq!(!Side::Buy, Side::Sell);

pub struct Timestamp(i64);

let ts = Timestamp::now();
let later = ts.add_nanos(1000);
assert!(later > ts);

// Time arithmetic
let t1 = Timestamp::from_nanos(1000);
let t2 = t1.add_micros(1);  // Add 1 microsecond
let t3 = t1.add_millis(1);  // Add 1 millisecond

// Duration calculation
let duration = t2.duration_since(t1);
println!("Duration: {} ns", duration);

// Convert to chrono DateTime
let dt = ts.to_datetime();
println!("DateTime: {}", dt);

pub struct OrderId(u64);

// From u64
let id: OrderId = 12345u64.into();

// To u64
let value: u64 = id.into();

pub struct Order {
    pub id: OrderId,
    pub instrument_id: u32,
    pub side: Side,
    pub order_type: OrderType,
    pub time_in_force: TimeInForce,
    pub status: OrderStatus,
    pub price: Price,
    pub stop_price: Price,
    pub quantity: Quantity,
    pub filled_quantity: Quantity,
    pub avg_fill_price: i64,
    pub created_at: Timestamp,
    pub updated_at: Timestamp,
}

pub enum OrderType {
    Limit,      // Specify price and quantity
    Market,     // Execute at best available price
    Stop,       // Trigger at stop price, then execute as market
    StopLimit,  // Trigger at stop price, then place limit order
}

pub enum TimeInForce {
    GTC,  // Good till cancelled
    IOC,  // Immediate or cancel (partial fills allowed)
    FOK,  // Fill or kill (no partial fills)
    Day,  // Expires at end of trading session
    GTD,  // Good till date
}

pub enum OrderStatus {
    Pending,          // Order is pending submission
    Submitted,        // Order has been submitted to exchange
    Open,             // Order is open in the order book
    PartiallyFilled,  // Order is partially filled
    Filled,           // Order is completely filled
    Cancelled,        // Order has been cancelled
    Rejected,         // Order was rejected
    Expired,          // Order has expired
}

pub struct Quote {
    pub instrument_id: u32,
    pub bid_price: Price,
    pub bid_quantity: Quantity,
    pub ask_price: Price,
    pub ask_quantity: Quantity,
    pub timestamp: Timestamp,
}

pub struct Trade {
    pub id: u64,
    pub instrument_id: u32,
    pub price: Price,
    pub quantity: Quantity,
    pub aggressor_side: Side,
    pub timestamp: Timestamp,
}

pub struct Fill {
    pub order_id: OrderId,
    pub price: Price,
    pub quantity: Quantity,
    pub side: Side,
    pub is_maker: bool,
    pub timestamp: Timestamp,
    pub fee: f64,
}

pub struct Level {
    pub price: Price,
    pub quantity: Quantity,
    pub order_count: u32,
}