pub struct AlgoState {
    // Position
    pub position_1e8: i64,         // Net position (positive = long)
    pub avg_entry_1e9: u64,        // Average entry price
    pub realized_pnl_1e9: i64,     // Realized PnL (lifetime)
    pub unrealized_pnl_1e9: i64,   // Unrealized PnL (mark-to-market)
 
    // Orders
    pub orders: [OpenOrder; 32],   // Your open orders
    pub order_ct: u8,              // Number of orders
 
    // Session & diagnostics (new in v0.2)
    pub session_pnl_1e9: i64,     // Session realized PnL (resets at UTC midnight)
    pub total_fill_count: u64,     // Lifetime fill count (never resets)
 
    // Symbol metadata (new in v0.2)
    pub symbol: SymbolMeta,        // Tick size, lot size, min qty, min notional
 
    // Risk limits (new in v0.2)
    pub risk: RiskSnapshot,        // Current risk limits for this algo
}

fn on_book(&mut self, book: &L2Book, state: &AlgoState, _features: &OnlineFeatures, actions: &mut Actions) {
    // Check your position
    if state.is_flat() {
        // No position
    } else if state.is_long() {
        // Long position
        let size = state.position_1e8;  // Positive
    } else {
        // Short position
        let size = state.position_1e8;  // Negative
    }
    
    // Position limit check
    if state.position_1e8.abs() > 10_000_000_000 {
        return; // Over limit, don't trade
    }
}

pub struct SymbolMeta {
    pub tick_size_1e9: u64,       // Min price increment (e.g. 10_000_000 = $0.01)
    pub lot_size_1e8: u64,        // Min qty increment (e.g. 1_000 = 0.00001)
    pub min_qty_1e8: u64,         // Min order quantity
    pub min_notional_1e9: u64,    // Min order value (price × qty)
    pub price_precision: u8,      // Decimal places for prices
    pub qty_precision: u8,        // Decimal places for quantities
}

fn on_book(&mut self, book: &L2Book, state: &AlgoState, _features: &OnlineFeatures, actions: &mut Actions) {
    let meta = &state.symbol;
    let mid = book.mid_px_1e9();
    let offset = mid / 2000; // 5 bps
 
    // Round prices to valid tick increments
    let bid_px = meta.round_px(mid - offset);
    let ask_px = meta.round_px(mid + offset);
 
    // Validate quantity before sending
    let qty = 10_000_000i64;
    if meta.check_min_qty(qty) && meta.check_notional(qty, bid_px) {
        self.next_id += 1;
        actions.buy(self.next_id, qty, bid_px);
        self.next_id += 1;
        actions.sell(self.next_id, qty, ask_px);
    }
}

pub struct RiskSnapshot {
    pub max_position_1e8: i64,       // Max absolute position
    pub max_daily_loss_1e9: i64,     // Daily loss limit (0 = disabled)
    pub max_order_notional_1e9: u64, // Max single order value
    pub max_order_rate: u32,         // Max orders/sec
    pub reduce_only: u8,             // 1 = reduce-only mode active
}

fn on_book(&mut self, book: &L2Book, state: &AlgoState, _features: &OnlineFeatures, actions: &mut Actions) {
    let risk = &state.risk;
 
    // Skip if reduce-only mode is active
    if risk.reduce_only == 1 && state.is_flat() { return; }
 
    // Pre-check position limit
    let desired_qty = 10_000_000i64;
    if (state.position_1e8 + desired_qty).abs() > risk.max_position_1e8 {
        return; // Would exceed position limit
    }
 
    self.next_id += 1;
    actions.buy(self.next_id, desired_qty, book.bids[0].px_1e9);
}

pub struct OpenOrder {
    pub order_id: u64,      // Your order ID
    pub px_1e9: u64,        // Limit price
    pub qty_1e8: i64,       // Signed quantity
    pub filled_1e8: i64,    // Amount filled
    pub side: i8,           // 1 = buy, -1 = sell
    pub status: u8,         // PENDING, ACKED, PARTIAL, DEAD
}

use algo_sdk::Status;
 
fn on_book(&mut self, book: &L2Book, state: &AlgoState, _features: &OnlineFeatures, actions: &mut Actions) {
    // Iterate open orders
    for i in 0..state.order_ct as usize {
        let order = &state.orders[i];
        
        if order.status == Status::ACKED || order.status == Status::PARTIAL {
            // This order is live on the exchange
            let remaining = order.remaining_1e8();
        }
    }
}

fn on_book(&mut self, book: &L2Book, state: &AlgoState, _features: &OnlineFeatures, actions: &mut Actions) {
    let pos = state.position_1e8;
    let max_pos = 1_000_000_000; // 10 units
    
    // Calculate available capacity
    let buy_capacity = max_pos - pos - state.open_buy_qty_1e8();
    let sell_capacity = max_pos + pos - state.open_sell_qty_1e8();
    
    // Only bid if we have buy capacity
    if buy_capacity > 10_000_000 {
        self.next_id += 1;
        actions.buy(self.next_id, 10_000_000, book.bids[0].px_1e9);
    }
    
    // Only offer if we have sell capacity
    if sell_capacity > 10_000_000 {
        self.next_id += 1;
        actions.sell(self.next_id, 10_000_000, book.asks[0].px_1e9);
    }
}

fn on_book(&mut self, book: &L2Book, state: &AlgoState, _features: &OnlineFeatures, actions: &mut Actions) {
    let mid = book.mid_px_1e9();
    let threshold = mid / 1000; // 0.1% from mid
    
    for i in 0..state.order_ct as usize {
        let order = &state.orders[i];
        
        if !order.is_live() { continue; }
        
        // Cancel if price is too far from mid
        let distance = if order.px_1e9 > mid {
            order.px_1e9 - mid
        } else {
            mid - order.px_1e9
        };
        
        if distance > threshold {
            actions.cancel(order.order_id);
        }
    }
}

pub struct Fill {
    pub order_id: u64,
    pub px_1e9: u64,
    pub qty_1e8: i64,
    pub recv_ns: u64,    // Fill receive timestamp (nanoseconds)
    pub side: i8,        // 1 = buy, -1 = sell
}
 
fn on_fill(&mut self, fill: &Fill, state: &AlgoState) {
    // State already updated with this fill
    let latency_ms = fill.since_ms(self.order_sent_ns);
    log_warn!("FILL: {} @ {} latency={}ms pos={}",
        fill.qty_1e8, fill.px_1e9, latency_ms, state.position_1e8);
}

pub struct Reject {
    pub order_id: u64,
    pub code: u8,
}
 
fn on_reject(&mut self, reject: &Reject) {
    use algo_sdk::RejectCode;
    
    match reject.code {
        RejectCode::INSUFFICIENT_BALANCE => {
            log_error!("Not enough funds for order {}", reject.order_id);
        }
        RejectCode::INVALID_PARAMS => {
            log_error!("Invalid params on order {}", reject.order_id);
        }
        RejectCode::RATE_LIMIT => {
            log_warn!("Rate limited, backing off");
        }
        RejectCode::POSITION_LIMIT => {
            log_warn!("Position limit hit");
        }
        RejectCode::KILL_SWITCH => {
            log_error!("Kill switch active!");
        }
        _ => {
            log_warn!("Reject {}: {}", reject.order_id, reject.reason());
        }
    }
}