Trading

use tigeropen::config::ClientConfig;
use tigeropen::model::order::limit_order;
use tigeropen::model::trade_requests::{OrdersRequest, PositionsRequest};
use tigeropen::trade::TradeClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig::builder().build()?;
    let account = config.account.clone();
    // v0.5.0+: use from_config() directly — no need to create HttpClient manually
    let tc = TradeClient::from_config(config, &account);

    // Query positions (v0.4.0: Request struct)
    let positions = tc.get_positions(PositionsRequest::default()).await?;
    println!("positions={}", positions.len());

    // Build a limit order via helper
    let mut order = limit_order(&account, "AAPL", "STK", "BUY", 100, 150.0);
    order.market = Some("US".into());
    order.currency = Some("USD".into());

    // Preview before placing
    if let Some(preview) = tc.preview_order(order.clone()).await? {
        println!("commission={} initMargin={}", preview.commission, preview.init_margin);
    }

    // Place the order
    if let Some(placed) = tc.place_order(order).await? {
        println!("id={} orderId={}", placed.id, placed.order_id);
    }

    Ok(())
}

use tigeropen::model::enums::OrderStatus;

println!("{}", OrderStatus::Filled.code());        // 6
println!("{}", OrderStatus::PendingSubmit.code());  // 8

pub async fn get_contract(&self, symbol: &str, sec_type: &str) -> Result<Vec<Contract>, TigerError>

let contracts = tc.get_contract("AAPL", "STK").await?;

pub async fn get_contracts(&self, symbols: &[&str], sec_type: &str) -> Result<Vec<Contract>, TigerError>

let contracts = tc.get_contracts(&["AAPL", "TSLA", "MSFT"], "STK").await?;

pub async fn get_quote_contract(&self, symbol: &str, sec_type: &str, expiry: &str) -> Result<Vec<Contract>, TigerError>

let contracts = tc.get_quote_contract("AAPL", "OPT", "20260619").await?;

pub async fn place_order(&self, order: OrderRequest) -> Result<Option<PlaceOrderResult>, TigerError>

if let Some(placed) = tc.place_order(req).await? {
    println!("id={} orderId={}", placed.id, placed.order_id);
}

use tigeropen::model::order::{iceberg_order, iceberg_order_full};

// Basic iceberg order (defaults to LIMIT_PRICE mode)
let order = iceberg_order("YOUR_ACCOUNT", "AAPL", "STK", "BUY", 1000, 180.0, 100);

// Full parameters
// price_type: "LIMIT_PRICE" / "ASK_PRICE" / "BID_PRICE" / "LATEST_PRICE"
let order = iceberg_order_full(
    "YOUR_ACCOUNT", "AAPL", "STK", "BUY", 1000, 180.0,
    100, Some(50), Some(30), Some("LIMIT_PRICE"), Some(start_time), Some(end_time));

if let Some(placed) = tc.place_order(order).await? {
    println!("iceberg id={}", placed.id);
}

pub async fn preview_order(&self, order: OrderRequest) -> Result<Option<PreviewResult>, TigerError>

pub async fn modify_order(&self, id: i64, order: OrderRequest) -> Result<Option<OrderIdResult>, TigerError>

pub async fn cancel_order(&self, id: i64) -> Result<Option<OrderIdResult>, TigerError>

use tigeropen::model::trade_requests::OrdersRequest;

// Simple call
let orders = tc.get_orders(OrdersRequest::default()).await?;

// Filtered: last 100 filled US stock orders
let filtered = tc.get_orders(OrdersRequest {
    market: Some("US".to_string()),
    sec_type: Some("STK".to_string()),
    states: Some(vec!["Filled".to_string()]),
    limit: Some(100),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::GetOrderRequest;

let order = tc.get_order(GetOrderRequest {
    id: Some(123456789),
    ..Default::default()
}).await?;

let active = tc.get_active_orders(OrdersRequest::default()).await?;

let inactive = tc.get_inactive_orders(OrdersRequest::default()).await?;

use std::time::{SystemTime, UNIX_EPOCH};

let now = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_millis() as i64).unwrap_or(0);
let recent = tc.get_filled_orders(OrdersRequest {
    start_date: Some(now - 30 * 24 * 3600 * 1000),
    end_date: Some(now),
    limit: Some(200),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::OrderTransactionsRequest;

let txs = tc.get_order_transactions(OrderTransactionsRequest {
    symbol: Some("AAPL".to_string()), // required on the wire
    sec_type: Some("STK".to_string()),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::PositionsRequest;

let positions = tc.get_positions(PositionsRequest::default()).await?;

// Filter to US stocks only
let us = tc.get_positions(PositionsRequest {
    market: Some("US".to_string()),
    sec_type: Some("STK".to_string()),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::AssetsRequest;

let assets = tc.get_assets(AssetsRequest::default()).await?;

if let Some(pa) = tc.get_prime_assets(AssetsRequest::default()).await? {
    println!("account={} segments={}", pa.account_id, pa.segments.len());
}

use tigeropen::model::trade_requests::ManagedAccountsRequest;

let subs = tc.get_managed_accounts(ManagedAccountsRequest::default()).await?;
for s in &subs {
    println!("{} type={:?} status={:?}", s.account, s.account_type, s.status);
}

use tigeropen::model::trade_requests::DerivativeContractsRequest;

let cs = tc.get_derivative_contracts(DerivativeContractsRequest {
    symbols: vec!["AAPL".to_string()],
    sec_type: "OPT".to_string(),
    expiry: Some("20260619".to_string()),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::AnalyticsAssetRequest;

let rows = tc.get_analytics_asset(AnalyticsAssetRequest {
    start_date: Some("2025-01-01".to_string()),
    end_date: Some("2025-12-31".to_string()),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::AggregateAssetsRequest;

if let Some(agg) = tc.get_aggregate_assets(AggregateAssetsRequest {
    base_currency: Some("USD".to_string()),
    ..Default::default()
}).await? {
    println!("netLiq={:?} currencies={}", agg.net_liquidation, agg.currency_assets.len());
}

use tigeropen::model::trade_requests::EstimateTradableQuantityRequest;

if let Some(est) = tc.get_estimate_tradable_quantity(EstimateTradableQuantityRequest {
    symbol: "AAPL".to_string(),
    sec_type: "STK".to_string(),
    action: "BUY".to_string(),
    order_type: Some("LMT".to_string()),
    limit_price: Some(150.0),
    ..Default::default()
}).await? {
    println!("tradable={:?}", est.tradable_quantity);
}

use tigeropen::model::trade_requests::FundDetailsRequest;

let rows = tc.get_fund_details(FundDetailsRequest {
    currency: Some("USD".to_string()),
    limit: Some(100),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::FundingHistoryRequest;

let rows = tc.get_funding_history(FundingHistoryRequest::default()).await?;

use tigeropen::model::trade_requests::ForexOrderRequest;

if let Some(res) = tc.place_forex_order(ForexOrderRequest {
    source_currency: "USD".to_string(),
    source_amount: Some(10000.0),
    target_currency: "HKD".to_string(),
    ..Default::default()
}).await? {
    println!("rate={:?} target={:?}", res.rate, res.target_amount);
}

pub async fn option_exercise_check(
    &self,
    req: OptionExerciseCheckRequest,
) -> Result<Option<OptionExerciseCheckResult>, TigerError>

use tigeropen::trade::request::OptionExerciseCheckRequest;

let result = tc.option_exercise_check(OptionExerciseCheckRequest {
    contract_id: Some(1234567890),
    exercise_type: Some("Exercise".into()),
    quantity: Some(1.0),
    executing_date: Some("2025-06-20".into()),
    is_force: Some(false),
    ..Default::default()
}).await?;

if let Some(r) = result {
    println!("symbol={} availableQty={} stkBefore={} stkAfter={}",
        r.symbol, r.available_quantity, r.stk_position_before, r.stk_position_after);
}

// Expire type — set ITM rate
let result2 = tc.option_exercise_check(OptionExerciseCheckRequest {
    contract_id: Some(1234567890),
    exercise_type: Some("Expire".into()),
    quantity: Some(1.0),
    itm_rate: Some(5),
    ..Default::default()
}).await?;

pub async fn get_option_exercise_positions(
    &self,
    req: OptionExercisePositionRequest,
) -> Result<Option<OptionExercisePositionPageResult>, TigerError>

use tigeropen::trade::request::OptionExercisePositionRequest;

if let Some(page) = tc.get_option_exercise_positions(OptionExercisePositionRequest {
    exercise_type: Some("Exercise".into()),
    ..Default::default()
}).await? {
    println!("itemCount={} pageCount={}", page.item_count, page.page_count);
    for pos in &page.items {
        println!("contractId={} symbol={} availableQty={}",
            pos.contract_id, pos.symbol, pos.available_quantity);
    }
}

pub async fn submit_option_exercise(
    &self,
    req: OptionExerciseSubmitRequest,
) -> Result<Option<bool>, TigerError>

use tigeropen::trade::request::OptionExerciseSubmitRequest;

// Early exercise
let ok = tc.submit_option_exercise(OptionExerciseSubmitRequest {
    contract_id: Some(1234567890),
    exercise_type: Some("Exercise".into()),
    quantity: Some(1.0),
    executing_date: Some("2025-06-20".into()),
    is_force: Some(false),
    ..Default::default()
}).await?;
println!("submitted: {:?}", ok);

// Early waive
let ok2 = tc.submit_option_exercise(OptionExerciseSubmitRequest {
    contract_id: Some(1234567890),
    exercise_type: Some("Expire".into()),
    quantity: Some(1.0),
    ..Default::default()
}).await?;

pub async fn get_option_exercise_records(
    &self,
    req: OptionExerciseRecordsRequest,
) -> Result<Option<OptionExerciseRecordPageResult>, TigerError>

use tigeropen::trade::request::OptionExerciseRecordsRequest;

if let Some(page) = tc.get_option_exercise_records(OptionExerciseRecordsRequest {
    page: Some(1),
    size: Some(20),
    ..Default::default()
}).await? {
    println!("itemCount={} pageCount={}", page.item_count, page.page_count);
    for r in &page.items {
        println!("id={} type={} status={}", r.id, r.exercise_type, r.status);
    }
}

pub async fn cancel_option_exercise(
    &self,
    req: OptionExerciseCancelRequest,
) -> Result<Option<bool>, TigerError>

use tigeropen::trade::request::OptionExerciseCancelRequest;

let ok = tc.cancel_option_exercise(OptionExerciseCancelRequest {
    id: Some(record_id),
    ..Default::default()
}).await?;
println!("cancelled: {:?}", ok);