交易操作

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 起：直接用 from_config() 创建，无需手动构造 HttpClient
    let tc = TradeClient::from_config(config, &account);

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

    // 使用辅助函数构造 OrderRequest，再按需补充字段
    let mut order_req = limit_order(&account, "AAPL", "STK", "BUY", 10, 150.0);
    order_req.market = Some("US".into());
    order_req.currency = Some("USD".into());
    order_req.time_in_force = Some("DAY".into());

    // 预览订单
    let preview = tc.preview_order(order_req.clone()).await?;
    println!("预览结果: {:?}", preview);

    // 实际下单
    if let Some(placed) = tc.place_order(order_req).await? {
        println!("订单 id={} order_id={}", placed.id, placed.order_id);
    }
    Ok(())
}

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

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

let cs = tc.get_contract("AAPL", "STK").await?;
if let Some(c) = cs.first() {
    println!("{} contractId={:?} exchange={:?}", c.symbol, c.contract_id, c.exchange);
}

// 查询港股
let hk = tc.get_contract("00700", "STK").await?;

let cs = tc.get_contracts(&["AAPL", "TSLA", "MSFT"], "STK").await?;
let names: Vec<String> = cs.iter().map(|c| c.symbol.clone()).collect();
println!("count={} {}", cs.len(), names.join(","));

let opt_contracts = tc.get_quote_contract("AAPL", "OPT", "20260619").await?;
println!("count={}", opt_contracts.len());

use tigeropen::model::order::{
    market_order, limit_order, stop_order, stop_limit_order, trail_order,
    auction_limit_order, auction_market_order, iceberg_order, new_order_leg, OrderRequest,
};

// 限价单
let mut buy = limit_order("YOUR_ACCOUNT", "AAPL", "STK", "BUY", 10, 150.0);
buy.market = Some("US".into());
buy.currency = Some("USD".into());

// 冰山单（基本参数）
let order = iceberg_order("YOUR_ACCOUNT", "AAPL", "STK", "BUY", 1000, 180.0, 100);

// 冰山单（设置可选参数）
let mut order = iceberg_order("YOUR_ACCOUNT", "AAPL", "STK", "BUY", 1000, 180.0, 100);
order.min_display_size = Some(50);
order.check_intervals = Some(30);
order.price_type = Some("LIMIT_PRICE".into());
order.start_time = Some(start_time);
order.end_time = Some(end_time);

// 市价单
let sell = market_order("YOUR_ACCOUNT", "AAPL", "STK", "SELL", 10);

// 止损单
let stop = stop_order("YOUR_ACCOUNT", "AAPL", "STK", "SELL", 100, 140.0);

// 止损限价单
let stp_lmt = stop_limit_order("YOUR_ACCOUNT", "AAPL", "STK", "SELL", 100, 139.0, 140.0);

// 追踪止损单
let trail = trail_order("YOUR_ACCOUNT", "AAPL", "STK", "SELL", 100, 5.0);

// 竞价限价 / 竞价市价（港股适用）
let al = auction_limit_order("YOUR_ACCOUNT", "00700", "STK", "BUY", 100, 400.0);
let am = auction_market_order("YOUR_ACCOUNT", "00700", "STK", "BUY", 100);

// 期权单（手动组装）
let opt = OrderRequest {
    account: Some("YOUR_ACCOUNT".into()),
    symbol: Some("AAPL".into()),
    sec_type: Some("OPT".into()),
    action: Some("BUY".into()),
    order_type: Some("LMT".into()),
    total_quantity: Some(1),
    limit_price: Some(5.0),
    expiry: Some("20250117".into()),
    strike: Some("150".into()),
    right: Some("CALL".into()),
    time_in_force: Some("DAY".into()),
    ..OrderRequest::default()
};

// 附加止盈/止损子单
let mut with_legs = limit_order("YOUR_ACCOUNT", "AAPL", "STK", "BUY", 10, 150.0);
with_legs.order_legs = Some(vec![
    new_order_leg("PROFIT", 160.0, "GTC"),
    new_order_leg("LOSS", 145.0, "GTC"),
]);

use tigeropen::model::order::{limit_order, market_order};

// 限价买入
let mut buy = limit_order(&account, "AAPL", "STK", "BUY", 10, 150.0);
buy.market = Some("US".into());
buy.currency = Some("USD".into());
if let Some(placed) = tc.place_order(buy).await? {
    println!("id={} order_id={}", placed.id, placed.order_id);
}

// 市价卖出
let sell = market_order(&account, "AAPL", "STK", "SELL", 10);
tc.place_order(sell).await?;

// 盘前/盘后交易
let mut ext = limit_order(&account, "AAPL", "STK", "BUY", 5, 148.0);
ext.outside_rth = Some(true);
ext.time_in_force = Some("DAY".into());
tc.place_order(ext).await?;

let order_req = limit_order(&account, "AAPL", "STK", "BUY", 10, 150.0);
if let Some(p) = tc.preview_order(order_req).await? {
    println!("isPass={} commission={:.2} initMargin={:.2}", p.is_pass, p.commission, p.init_margin);
}

// 将订单 12345 的限价从 150 改为 148
let mut mod_req = limit_order(&account, "AAPL", "STK", "BUY", 10, 150.0);
mod_req.limit_price = Some(148.0);
if let Some(r) = tc.modify_order(12345, mod_req).await? {
    println!("改单 id={}", r.id);
}

if let Some(r) = tc.cancel_order(12345).await? {
    println!("撤单 id={}", r.id);
}

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

// 最简调用
let orders = tc.get_orders(OrdersRequest::default()).await?;
println!("count={}", orders.len());

// 带过滤：近 100 条已成交的美股订单
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),
    sort_by: Some("LATEST_CREATED".to_string()),
    ..Default::default()
}).await?;
for o in &filtered {
    println!("{} {} {} status={}", o.id, o.symbol, o.action, o.status);
}

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

let order = tc.get_order(GetOrderRequest {
    id: Some(123456789),
    ..Default::default()
}).await?;
if let Some(o) = order {
    println!("{} {} status={} filled={}/{}", o.id, o.symbol, o.status, o.filled_quantity, o.total_quantity);
}

// 最简调用
let active = tc.get_active_orders(OrdersRequest::default()).await?;
println!("active count={}", active.len());

let inactive = tc.get_inactive_orders(OrdersRequest::default()).await?;
println!("inactive count={}", inactive.len());

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 filled = tc.get_filled_orders(OrdersRequest::default()).await?;

// 带时间过滤：近 30 天已成交订单
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?;
println!("近 30 天成交订单 count={}", recent.len());

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

// 查询指定订单成交明细
let txs = tc.get_order_transactions(OrderTransactionsRequest {
    order_id: Some(12345),
    symbol: Some("AAPL".to_string()),
    sec_type: Some("STK".to_string()),
    ..Default::default()
}).await?;
for t in &txs {
    println!("id={} price={:.2} qty={}", t.id, t.price, t.filled_quantity);
}

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

// 最简调用
let positions = tc.get_positions(PositionsRequest::default()).await?;
let total_mv: f64 = positions.iter().map(|p| p.market_value.unwrap_or(0.0)).sum();
println!("count={} totalMarketValue={:.2}", positions.len(), total_mv);

// 仅查询美股持仓
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(a) = assets.first() {
    println!(
        "account={} buyingPower={:.2} netLiquidation={:.2} segments={}",
        a.account, a.buying_power, a.net_liquidation, a.segments.len()
    );
}

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

if let Some(pa) = tc.get_prime_assets(AssetsRequest::default()).await? {
    let total_bp: f64 = pa.segments.iter().map(|s| s.buying_power).sum();
    println!(
        "account={} segments={} totalBuyingPower={:.2}",
        pa.account_id, pa.segments.len(), total_bp
    );
}

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

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

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

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

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?;
for r in &rows {
    println!("{} holding={:?} pnl={:?}", r.date, r.holding_value, r.pnl);
}

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={:?} cashBuy={:?}", est.tradable_quantity, est.max_cash_buy_quantity);
}

use std::time::{SystemTime, UNIX_EPOCH};
use tigeropen::model::trade_requests::FundDetailsRequest;

let now = SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_millis() as i64).unwrap_or(0);
let rows = tc.get_fund_details(FundDetailsRequest {
    start_date: Some(now - 30 * 24 * 3600 * 1000),
    end_date: Some(now),
    currency: Some("USD".to_string()),
    limit: Some(100),
    ..Default::default()
}).await?;
for r in &rows {
    println!("{:?} {:?} amount={:?} balance={:?}", r.occur_time, r.fund_type, r.amount, r.balance);
}

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

let rows = tc.get_funding_history(FundingHistoryRequest::default()).await?;
for r in &rows {
    println!("{:?} {:?} amount={:?} status={:?}", r.id, r.currency, r.amount, r.status);
}

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!("id={:?} rate={:?} target={:?}", res.id, res.rate, res.target_amount);
}

use tigeropen::model::trade_requests::SegmentFundRequest;

let avail = tc.get_segment_fund_available(SegmentFundRequest {
    from_segment: Some("S".to_string()),
    to_segment: Some("C".to_string()),
    currency: Some("USD".to_string()),
    ..Default::default()
}).await?;
for a in &avail {
    println!("{:?}->{:?} {:?} available={:?}", a.from_segment, a.to_segment, a.currency, a.available_amt);
}

let history = tc.get_segment_fund_history(SegmentFundRequest {
    limit: Some(50),
    ..Default::default()
}).await?;
for h in &history {
    println!("{:?} {:?}->{:?} amount={:?} status={:?}", h.id, h.from_segment, h.to_segment, h.amount, h.status);
}

if let Some(res) = tc.transfer_segment_fund(SegmentFundRequest {
    from_segment: Some("S".to_string()),
    to_segment: Some("C".to_string()),
    currency: Some("USD".to_string()),
    amount: Some(1000.0),
    ..Default::default()
}).await? {
    println!("transferId={:?} status={:?}", res.id, res.status);
}

if let Some(res) = tc.cancel_segment_fund(SegmentFundRequest {
    id: Some("TX123456".to_string()),
    ..Default::default()
}).await? {
    println!("cancelled id={:?} status={:?}", res.id, res.status);
}

use tigeropen::client::http_client::HttpClient;
use tigeropen::config::ClientConfig;

let config = ClientConfig::builder().build()?;
// 交易接口用普通 HttpClient；行情接口须用 HttpClient::with_quote_server
let http = HttpClient::new(config);

// 直接调用 trade API
let resp = http.execute_trade_request("market_state", serde_json::json!({ "market": "US" })).await?;
println!("原始响应: {:?}", resp);

use tigeropen::model::trade_requests::OptionExerciseCheckRequest;

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

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

// Expire 类型，设置价内率
let result = tc.option_exercise_check(OptionExerciseCheckRequest {
    contract_id: Some(1234567890),
    exercise_type: Some("Expire".to_string()),
    quantity: Some(1.0),
    itm_rate: Some(5),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::OptionExercisePositionRequest;

if let Some(page) = tc.get_option_exercise_positions(OptionExercisePositionRequest {
    exercise_type: Some("Exercise".to_string()),
    ..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);
    }
}

use tigeropen::model::trade_requests::OptionExerciseSubmitRequest;

// 提前行权
let ok = tc.submit_option_exercise(OptionExerciseSubmitRequest {
    contract_id: Some(1234567890),
    exercise_type: Some("Exercise".to_string()),
    quantity: Some(1.0),
    executing_date: Some("2025-06-20".to_string()),
    is_force: Some(false),
    ..Default::default()
}).await?;
println!("{}", if ok.unwrap_or(false) { "提交成功" } else { "提交失败" });

// 提前放弃行权
let ok = tc.submit_option_exercise(OptionExerciseSubmitRequest {
    contract_id: Some(1234567890),
    exercise_type: Some("Expire".to_string()),
    quantity: Some(1.0),
    ..Default::default()
}).await?;

use tigeropen::model::trade_requests::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);
    }
}

use tigeropen::model::trade_requests::OptionExerciseCancelRequest;

let ok = tc.cancel_option_exercise(OptionExerciseCancelRequest {
    id: Some(record_id),
    ..Default::default()
}).await?;
println!("{}", if ok.unwrap_or(false) { "撤销成功" } else { "撤销失败" });