alpaca_option/

types.rs

use alpaca_core::float;
use rust_decimal::prelude::ToPrimitive;
use rust_decimal::Decimal;
use serde::{Deserialize, Deserializer, Serialize};
use ts_rs::TS;

use crate::contract;
use crate::error::{OptionError, OptionResult};
use crate::rate::risk_free_rate_for_years;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, TS)]
#[serde(rename_all = "lowercase")]
pub enum OptionRight {
    Call,
    Put,
}

impl Default for OptionRight {
    fn default() -> Self {
        Self::Call
    }
}

impl OptionRight {
    pub fn from_str(input: &str) -> OptionResult<Self> {
        match input.trim().to_ascii_lowercase().as_str() {
            "call" => Ok(Self::Call),
            "put" => Ok(Self::Put),
            "c" => Ok(Self::Call),
            "p" => Ok(Self::Put),
            _ => Err(OptionError::new(
                "invalid_option_right",
                format!("invalid option right: {input}"),
            )),
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Call => "call",
            Self::Put => "put",
        }
    }

    pub fn from_code(code: char) -> OptionResult<Self> {
        match code {
            'C' => Ok(Self::Call),
            'P' => Ok(Self::Put),
            _ => Err(OptionError::new(
                "invalid_option_right_code",
                format!("invalid option right code: {code}"),
            )),
        }
    }

    pub fn code(&self) -> char {
        match self {
            Self::Call => 'C',
            Self::Put => 'P',
        }
    }

    pub fn code_string(&self) -> OptionRightCode {
        match self {
            Self::Call => OptionRightCode::C,
            Self::Put => OptionRightCode::P,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum OptionRightCode {
    C,
    P,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum OrderSide {
    Buy,
    Sell,
}

impl OrderSide {
    pub fn from_str(input: &str) -> OptionResult<Self> {
        match input.trim().to_ascii_lowercase().as_str() {
            "buy" => Ok(Self::Buy),
            "sell" => Ok(Self::Sell),
            _ => Err(OptionError::new(
                "invalid_order_side",
                format!("invalid order side: {input}"),
            )),
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Buy => "buy",
            Self::Sell => "sell",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PositionSide {
    Long,
    Short,
}

impl PositionSide {
    pub fn from_str(input: &str) -> OptionResult<Self> {
        match input {
            "long" => Ok(Self::Long),
            "short" => Ok(Self::Short),
            _ => Err(OptionError::new(
                "invalid_position_side",
                format!("invalid position side: {input}"),
            )),
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Long => "long",
            Self::Short => "short",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ExecutionAction {
    Open,
    Close,
}

impl ExecutionAction {
    pub fn from_str(input: &str) -> OptionResult<Self> {
        match input {
            "open" => Ok(Self::Open),
            "close" => Ok(Self::Close),
            _ => Err(OptionError::new(
                "invalid_execution_quote_input",
                format!("invalid execution action: {input}"),
            )),
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Open => "open",
            Self::Close => "close",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum PositionIntent {
    BuyToOpen,
    SellToOpen,
    BuyToClose,
    SellToClose,
}

impl PositionIntent {
    pub fn from_str(input: &str) -> OptionResult<Self> {
        match input.trim().to_ascii_lowercase().as_str() {
            "buy_to_open" => Ok(Self::BuyToOpen),
            "sell_to_open" => Ok(Self::SellToOpen),
            "buy_to_close" => Ok(Self::BuyToClose),
            "sell_to_close" => Ok(Self::SellToClose),
            _ => Err(OptionError::new(
                "invalid_position_intent",
                format!("invalid position intent: {input}"),
            )),
        }
    }

    pub fn as_str(&self) -> &'static str {
        match self {
            Self::BuyToOpen => "buy_to_open",
            Self::SellToOpen => "sell_to_open",
            Self::BuyToClose => "buy_to_close",
            Self::SellToClose => "sell_to_close",
        }
    }

    pub fn is_close(&self) -> bool {
        matches!(self, Self::BuyToClose | Self::SellToClose)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum MoneynessLabel {
    Itm,
    Atm,
    Otm,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AssignmentRiskLevel {
    Danger,
    Critical,
    High,
    Medium,
    Low,
    Safe,
}

impl AssignmentRiskLevel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Danger => "danger",
            Self::Critical => "critical",
            Self::High => "high",
            Self::Medium => "medium",
            Self::Low => "low",
            Self::Safe => "safe",
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
pub struct OptionContract {
    pub underlying_symbol: String,
    pub expiration_date: String,
    pub strike: f64,
    pub option_right: OptionRight,
    pub occ_symbol: String,
}

impl Default for OptionContract {
    fn default() -> Self {
        Self {
            underlying_symbol: String::new(),
            expiration_date: String::new(),
            strike: 0.0,
            option_right: OptionRight::default(),
            occ_symbol: String::new(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
pub struct OptionQuote {
    pub bid: Option<f64>,
    pub ask: Option<f64>,
    pub mark: Option<f64>,
    pub last: Option<f64>,
}

impl Default for OptionQuote {
    fn default() -> Self {
        Self {
            bid: None,
            ask: None,
            mark: None,
            last: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ContractDisplay {
    pub strike: String,
    pub expiration: String,
    pub compact: String,
    pub option_right_code: OptionRightCode,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
pub struct Greeks {
    pub delta: f64,
    pub gamma: f64,
    pub vega: f64,
    pub theta: f64,
    pub rho: f64,
}

impl Default for Greeks {
    fn default() -> Self {
        Self {
            delta: 0.0,
            gamma: 0.0,
            vega: 0.0,
            theta: 0.0,
            rho: 0.0,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlackScholesInput {
    pub spot: f64,
    pub strike: f64,
    pub years: f64,
    pub rate: f64,
    pub dividend_yield: f64,
    pub volatility: f64,
    pub option_right: OptionRight,
}

impl BlackScholesInput {
    pub fn new(
        spot: f64,
        strike: f64,
        years: f64,
        dividend_yield: f64,
        volatility: f64,
        option_right: OptionRight,
    ) -> Self {
        Self {
            spot,
            strike,
            years,
            rate: risk_free_rate_for_years(years),
            dividend_yield,
            volatility,
            option_right,
        }
    }

    pub fn with_rate(mut self, rate: f64) -> Self {
        self.rate = rate;
        self
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BlackScholesImpliedVolatilityInput {
    pub target_price: f64,
    pub spot: f64,
    pub strike: f64,
    pub years: f64,
    pub rate: f64,
    pub dividend_yield: f64,
    pub option_right: OptionRight,
    pub lower_bound: Option<f64>,
    pub upper_bound: Option<f64>,
    pub tolerance: Option<f64>,
    pub max_iterations: Option<usize>,
}

impl BlackScholesImpliedVolatilityInput {
    pub fn new(
        target_price: f64,
        spot: f64,
        strike: f64,
        years: f64,
        dividend_yield: f64,
        option_right: OptionRight,
    ) -> Self {
        Self {
            target_price,
            spot,
            strike,
            years,
            rate: risk_free_rate_for_years(years),
            dividend_yield,
            option_right,
            lower_bound: None,
            upper_bound: None,
            tolerance: None,
            max_iterations: None,
        }
    }

    pub fn with_rate(mut self, rate: f64) -> Self {
        self.rate = rate;
        self
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
pub struct OptionSnapshot {
    pub as_of: String,
    pub contract: OptionContract,
    pub quote: OptionQuote,
    pub greeks: Option<Greeks>,
    pub implied_volatility: Option<f64>,
    pub underlying_price: Option<f64>,
}

impl Default for OptionSnapshot {
    fn default() -> Self {
        Self {
            as_of: String::new(),
            contract: OptionContract::default(),
            quote: OptionQuote::default(),
            greeks: None,
            implied_volatility: None,
            underlying_price: None,
        }
    }
}

fn parse_snapshot_number(input: &str) -> Option<f64> {
    let trimmed = input.trim();
    if trimmed.is_empty() {
        return None;
    }

    let value = trimmed.parse::<f64>().ok()?;
    value.is_finite().then_some(value)
}

fn format_snapshot_number(value: f64) -> String {
    float::round(value, 2).to_string()
}

fn normalized_quote_price(quote: &OptionQuote) -> f64 {
    if let Some(mark) = quote.mark.filter(|value| value.is_finite()) {
        return mark;
    }

    match (
        quote.bid.filter(|value| value.is_finite()),
        quote.ask.filter(|value| value.is_finite()),
    ) {
        (Some(bid), Some(ask)) => float::round((bid + ask) / 2.0, 12),
        (Some(bid), None) => bid,
        (None, Some(ask)) => ask,
        (None, None) => quote.last.filter(|value| value.is_finite()).unwrap_or(0.0),
    }
}

fn canonical_contract_or_fallback(occ_symbol: &str) -> OptionContract {
    let normalized = occ_symbol.trim().to_ascii_uppercase();
    contract::parse_occ_symbol(&normalized).unwrap_or(OptionContract {
        occ_symbol: normalized,
        ..OptionContract::default()
    })
}

impl OptionSnapshot {
    pub fn is_empty(&self) -> bool {
        self.as_of.trim().is_empty()
            && self.contract.occ_symbol.trim().is_empty()
            && self.quote == OptionQuote::default()
            && self.greeks.is_none()
            && self.implied_volatility.is_none()
            && self.underlying_price.is_none()
    }

    pub fn occ_symbol(&self) -> &str {
        &self.contract.occ_symbol
    }

    pub fn timestamp(&self) -> &str {
        &self.as_of
    }

    pub fn bid(&self) -> f64 {
        self.quote
            .bid
            .filter(|value| value.is_finite())
            .unwrap_or(0.0)
    }

    pub fn ask(&self) -> f64 {
        self.quote
            .ask
            .filter(|value| value.is_finite())
            .unwrap_or(0.0)
    }

    pub fn price(&self) -> f64 {
        normalized_quote_price(&self.quote)
    }

    pub fn iv(&self) -> f64 {
        self.implied_volatility
            .filter(|value| value.is_finite())
            .unwrap_or(0.0)
    }

    pub fn delta(&self) -> f64 {
        self.greeks_or_default().delta
    }

    pub fn gamma(&self) -> f64 {
        self.greeks_or_default().gamma
    }

    pub fn vega(&self) -> f64 {
        self.greeks_or_default().vega
    }

    pub fn theta(&self) -> f64 {
        self.greeks_or_default().theta
    }

    pub fn rho(&self) -> f64 {
        self.greeks_or_default().rho
    }

    pub fn underlying_price(&self) -> f64 {
        self.underlying_price
            .filter(|value| value.is_finite())
            .unwrap_or(0.0)
    }

    pub fn greeks_or_default(&self) -> Greeks {
        self.greeks.clone().unwrap_or_default()
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, TS)]
pub struct OptionPosition {
    pub contract: String,
    pub snapshot: OptionSnapshot,
    pub qty: i32,
    #[serde(with = "alpaca_core::decimal::price_string_contract")]
    #[ts(type = "string")]
    pub avg_cost: Decimal,
    pub leg_type: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub option_right: Option<OptionRight>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub strike: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub valuation_years: Option<f64>,
}

#[derive(Debug, Deserialize)]
struct OptionPositionWire {
    contract: String,
    #[serde(default)]
    snapshot: Option<OptionSnapshot>,
    qty: i32,
    #[serde(with = "alpaca_core::decimal::price_string_contract")]
    avg_cost: Decimal,
    leg_type: String,
    #[serde(default)]
    option_right: Option<OptionRight>,
    #[serde(default)]
    strike: Option<f64>,
    #[serde(default)]
    valuation_years: Option<f64>,
}

impl<'de> Deserialize<'de> for OptionPosition {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let wire = OptionPositionWire::deserialize(deserializer)?;
        Ok(Self {
            contract: wire.contract,
            snapshot: wire.snapshot.unwrap_or_default(),
            qty: wire.qty,
            avg_cost: wire.avg_cost,
            leg_type: wire.leg_type,
            option_right: wire.option_right,
            strike: wire.strike,
            valuation_years: wire.valuation_years,
        })
    }
}

fn position_side_from_qty_and_leg_type(qty: i32, leg_type: &str) -> PositionSide {
    if qty < 0 {
        PositionSide::Short
    } else if qty > 0 {
        PositionSide::Long
    } else if leg_type.trim().to_ascii_lowercase().starts_with("short") {
        PositionSide::Short
    } else {
        PositionSide::Long
    }
}

impl OptionPosition {
    pub fn from_snapshot(
        snapshot: &OptionSnapshot,
        qty: i32,
        avg_cost: Decimal,
        leg_type: impl Into<String>,
    ) -> Self {
        Self {
            contract: snapshot.occ_symbol().to_string(),
            snapshot: snapshot.clone(),
            qty,
            avg_cost,
            leg_type: leg_type.into(),
            option_right: None,
            strike: None,
            valuation_years: None,
        }
    }

    pub fn occ_symbol(&self) -> &str {
        self.contract.trim()
    }

    pub fn qty(&self) -> i32 {
        self.qty
    }

    pub fn contract_info(&self) -> OptionContract {
        canonical_contract_or_fallback(&self.contract)
    }

    pub fn position_side(&self) -> PositionSide {
        position_side_from_qty_and_leg_type(self.qty, &self.leg_type())
    }

    pub fn quantity(&self) -> u32 {
        self.qty.unsigned_abs()
    }

    pub fn snapshot_ref(&self) -> Option<&OptionSnapshot> {
        (!self.snapshot.is_empty()).then_some(&self.snapshot)
    }

    pub fn avg_cost(&self) -> f64 {
        self.avg_cost.to_f64().unwrap_or(0.0)
    }

    pub fn leg_type(&self) -> String {
        if !self.leg_type.trim().is_empty() {
            return self.leg_type.trim().to_ascii_lowercase();
        }

        let contract = self.contract_info();
        format!(
            "{}{}",
            self.position_side().as_str(),
            contract.option_right.as_str()
        )
    }

    pub fn cost(&self) -> Decimal {
        self.avg_cost * Decimal::from(self.qty) * Decimal::from(100)
    }

    pub fn value(&self) -> Decimal {
        alpaca_core::decimal::from_f64(self.snapshot.price(), 2)
            * Decimal::from(self.qty)
            * Decimal::from(100)
    }

    pub fn marked_value(&self) -> Decimal {
        self.value()
    }

    pub fn with_model_inputs(
        &self,
        implied_volatility: f64,
        underlying_price: Option<f64>,
    ) -> Self {
        let mut position = self.clone();
        position.snapshot.implied_volatility = Some(implied_volatility);
        if let Some(underlying_price) = underlying_price {
            position.snapshot.underlying_price = Some(underlying_price);
        }
        position
    }

    pub fn with_qty_multiplier(&self, multiplier: i32) -> Self {
        let mut position = self.clone();
        position.qty *= multiplier;
        position
    }

    pub fn effective_iv_or(&self, fallback_iv: Option<f64>, default_iv: f64) -> f64 {
        let snapshot_iv = self.snapshot.iv();
        if snapshot_iv.is_finite() && snapshot_iv > 0.0 {
            snapshot_iv
        } else if let Some(fallback_iv) =
            fallback_iv.filter(|value| value.is_finite() && *value > 0.0)
        {
            fallback_iv
        } else {
            default_iv
        }
    }
}

impl Default for OptionPosition {
    fn default() -> Self {
        Self {
            contract: String::new(),
            snapshot: OptionSnapshot::default(),
            qty: 0,
            avg_cost: Decimal::ZERO,
            leg_type: String::new(),
            option_right: None,
            strike: None,
            valuation_years: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ShortItmPosition {
    pub contract: OptionContract,
    pub quantity: u32,
    pub option_price: f64,
    pub intrinsic: f64,
    pub extrinsic: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StrategyLegInput {
    pub contract: OptionContract,
    pub order_side: OrderSide,
    pub ratio_quantity: u32,
    pub premium_per_contract: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct QuotedLeg {
    pub contract: OptionContract,
    pub order_side: OrderSide,
    pub ratio_quantity: u32,
    pub quote: OptionQuote,
    pub snapshot: Option<OptionSnapshot>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GreeksInput {
    pub delta: Option<f64>,
    pub gamma: Option<f64>,
    pub vega: Option<f64>,
    pub theta: Option<f64>,
    pub rho: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExecutionSnapshot {
    pub contract: String,
    pub timestamp: String,
    pub bid: String,
    pub ask: String,
    pub price: String,
    pub greeks: Greeks,
    pub iv: f64,
}

impl From<ExecutionSnapshot> for OptionSnapshot {
    fn from(value: ExecutionSnapshot) -> Self {
        Self {
            as_of: value.timestamp.trim().to_string(),
            contract: canonical_contract_or_fallback(&value.contract),
            quote: OptionQuote {
                bid: parse_snapshot_number(&value.bid),
                ask: parse_snapshot_number(&value.ask),
                mark: parse_snapshot_number(&value.price),
                last: parse_snapshot_number(&value.price),
            },
            greeks: Some(value.greeks),
            implied_volatility: value.iv.is_finite().then_some(value.iv),
            underlying_price: None,
        }
    }
}

impl From<&ExecutionSnapshot> for OptionSnapshot {
    fn from(value: &ExecutionSnapshot) -> Self {
        Self::from(value.clone())
    }
}

impl From<&OptionSnapshot> for ExecutionSnapshot {
    fn from(value: &OptionSnapshot) -> Self {
        Self {
            contract: value.occ_symbol().to_string(),
            timestamp: value.timestamp().to_string(),
            bid: format_snapshot_number(value.bid()),
            ask: format_snapshot_number(value.ask()),
            price: format_snapshot_number(value.price()),
            greeks: value.greeks_or_default(),
            iv: value.iv(),
        }
    }
}

impl From<OptionSnapshot> for ExecutionSnapshot {
    fn from(value: OptionSnapshot) -> Self {
        Self::from(&value)
    }
}

impl From<&OptionSnapshot> for OptionChainRecord {
    fn from(value: &OptionSnapshot) -> Self {
        Self {
            as_of: value.timestamp().to_string(),
            underlying_symbol: value.contract.underlying_symbol.clone(),
            occ_symbol: value.occ_symbol().to_string(),
            expiration_date: value.contract.expiration_date.clone(),
            option_right: value.contract.option_right.clone(),
            strike: value.contract.strike,
            underlying_price: value.underlying_price.filter(|number| number.is_finite()),
            bid: value.quote.bid.filter(|number| number.is_finite()),
            ask: value.quote.ask.filter(|number| number.is_finite()),
            mark: value.quote.mark.filter(|number| number.is_finite()),
            last: value.quote.last.filter(|number| number.is_finite()),
            implied_volatility: value.implied_volatility.filter(|number| number.is_finite()),
            delta: value
                .greeks
                .as_ref()
                .map(|greeks| greeks.delta)
                .filter(|number| number.is_finite()),
            gamma: value
                .greeks
                .as_ref()
                .map(|greeks| greeks.gamma)
                .filter(|number| number.is_finite()),
            vega: value
                .greeks
                .as_ref()
                .map(|greeks| greeks.vega)
                .filter(|number| number.is_finite()),
            theta: value
                .greeks
                .as_ref()
                .map(|greeks| greeks.theta)
                .filter(|number| number.is_finite()),
            rho: value
                .greeks
                .as_ref()
                .map(|greeks| greeks.rho)
                .filter(|number| number.is_finite()),
        }
    }
}

impl From<OptionSnapshot> for OptionChainRecord {
    fn from(value: OptionSnapshot) -> Self {
        Self::from(&value)
    }
}

impl From<&OptionChainRecord> for OptionSnapshot {
    fn from(value: &OptionChainRecord) -> Self {
        Self {
            as_of: value.as_of.trim().to_string(),
            contract: canonical_contract_or_fallback(&value.occ_symbol),
            quote: OptionQuote {
                bid: value.bid.filter(|number| number.is_finite()),
                ask: value.ask.filter(|number| number.is_finite()),
                mark: value
                    .mark
                    .filter(|number| number.is_finite() && *number > 0.0),
                last: value
                    .last
                    .filter(|number| number.is_finite() && *number > 0.0),
            },
            greeks: Some(Greeks {
                delta: value
                    .delta
                    .filter(|number| number.is_finite())
                    .unwrap_or(0.0),
                gamma: value
                    .gamma
                    .filter(|number| number.is_finite())
                    .unwrap_or(0.0),
                vega: value
                    .vega
                    .filter(|number| number.is_finite())
                    .unwrap_or(0.0),
                theta: value
                    .theta
                    .filter(|number| number.is_finite())
                    .unwrap_or(0.0),
                rho: value.rho.filter(|number| number.is_finite()).unwrap_or(0.0),
            }),
            implied_volatility: value.implied_volatility.filter(|number| number.is_finite()),
            underlying_price: value.underlying_price.filter(|number| number.is_finite()),
        }
    }
}

impl From<OptionChainRecord> for OptionSnapshot {
    fn from(value: OptionChainRecord) -> Self {
        Self::from(&value)
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExecutionLeg {
    pub symbol: String,
    pub ratio_qty: String,
    pub side: OrderSide,
    pub position_intent: PositionIntent,
    pub leg_type: String,
    pub snapshot: Option<ExecutionSnapshot>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RollLegSelection {
    pub leg_type: String,
    pub quantity: Option<u32>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct RollRequest {
    pub current_contract: String,
    pub leg_type: Option<String>,
    pub qty: u32,
    pub new_strike: Option<f64>,
    pub new_expiration: String,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExecutionLegInput {
    pub action: ExecutionAction,
    pub leg_type: String,
    pub contract: String,
    pub quantity: Option<u32>,
    pub snapshot: Option<ExecutionSnapshot>,
    pub timestamp: Option<String>,
    pub bid: Option<f64>,
    pub ask: Option<f64>,
    pub price: Option<f64>,
    pub spread_percent: Option<f64>,
    pub greeks: Option<GreeksInput>,
    pub iv: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ExecutionQuoteRange {
    pub best_price: f64,
    pub worst_price: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ScaledExecutionQuote {
    pub structure_quantity: u32,
    pub price: f64,
    pub total_price: f64,
    pub total_dollars: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ScaledExecutionQuoteRange {
    pub structure_quantity: u32,
    pub per_structure: ExecutionQuoteRange,
    pub per_order: ExecutionQuoteRange,
    pub dollars: ExecutionQuoteRange,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ParsedOptionStratUrl {
    pub underlying_display_symbol: String,
    pub leg_fragments: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct OptionStratLegInput {
    pub occ_symbol: String,
    pub underlying_symbol: Option<String>,
    pub expiration_date: Option<String>,
    pub strike: Option<f64>,
    pub option_right: Option<String>,
    pub quantity: i32,
    pub premium_per_contract: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct OptionStratStockInput {
    pub underlying_symbol: String,
    pub quantity: i32,
    pub cost_per_share: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
pub struct OptionStratUrlInput {
    pub underlying_display_symbol: String,
    #[serde(default)]
    pub legs: Vec<OptionStratLegInput>,
    #[serde(default)]
    pub stocks: Vec<OptionStratStockInput>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
pub struct OptionChain {
    pub underlying_symbol: String,
    pub as_of: String,
    pub snapshots: Vec<OptionSnapshot>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
pub struct OptionChainRecord {
    pub as_of: String,
    pub underlying_symbol: String,
    pub occ_symbol: String,
    pub expiration_date: String,
    pub option_right: OptionRight,
    pub strike: f64,
    pub underlying_price: Option<f64>,
    pub bid: Option<f64>,
    pub ask: Option<f64>,
    pub mark: Option<f64>,
    pub last: Option<f64>,
    pub implied_volatility: Option<f64>,
    pub delta: Option<f64>,
    pub gamma: Option<f64>,
    pub vega: Option<f64>,
    pub theta: Option<f64>,
    pub rho: Option<f64>,
}

impl OptionChainRecord {
    pub fn is_delta_valid(&self) -> bool {
        self.delta
            .map(|delta| {
                let abs_delta = delta.abs();
                abs_delta >= 0.05 && abs_delta <= 0.95
            })
            .unwrap_or(false)
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
pub struct MarketStructureOptionRecord {
    pub as_of: String,
    pub underlying_symbol: String,
    pub occ_symbol: String,
    pub expiration_date: String,
    pub option_right: OptionRight,
    pub strike: f64,
    pub underlying_price: Option<f64>,
    pub bid: Option<f64>,
    pub ask: Option<f64>,
    pub mark: Option<f64>,
    pub last: Option<f64>,
    pub implied_volatility: Option<f64>,
    pub delta: Option<f64>,
    pub gamma: Option<f64>,
    pub vega: Option<f64>,
    pub theta: Option<f64>,
    pub rho: Option<f64>,
    pub open_interest: Option<f64>,
    pub open_interest_date: Option<String>,
    pub multiplier: Option<f64>,
    pub minute_volume: Option<u64>,
    pub daily_volume: Option<u64>,
    pub latest_trade_size: Option<u64>,
    pub bid_size: Option<u64>,
    pub ask_size: Option<u64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
pub struct MarketStructureFilters {
    pub expiration_date: Option<String>,
    pub dte_min: Option<f64>,
    pub dte_max: Option<f64>,
    pub strike_price_gte: Option<f64>,
    pub strike_price_lte: Option<f64>,
    pub option_right: Option<OptionRight>,
    #[serde(default)]
    pub require_open_interest: bool,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
pub struct MarketStructureLevel {
    pub strike: f64,
    pub call_open_interest: f64,
    pub put_open_interest: f64,
    pub total_open_interest: f64,
    pub call_gamma_exposure: f64,
    pub put_gamma_exposure: f64,
    pub net_gamma_exposure: f64,
    pub absolute_gamma_exposure: f64,
    pub call_volume: u64,
    pub put_volume: u64,
    pub total_volume: u64,
    pub labels: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
pub struct MarketStructureAnalysis {
    pub underlying_price: Option<f64>,
    pub records_count: usize,
    pub open_interest_coverage: f64,
    pub call_wall: Option<MarketStructureLevel>,
    pub put_wall: Option<MarketStructureLevel>,
    pub absolute_gamma_exposure_wall: Option<MarketStructureLevel>,
    pub net_gamma_exposure: f64,
    pub absolute_gamma_exposure: f64,
    pub levels: Vec<MarketStructureLevel>,
    pub warnings: Vec<String>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum MarketStructureExposureMode {
    GexProxy,
    DealerView,
}

impl Default for MarketStructureExposureMode {
    fn default() -> Self {
        Self::GexProxy
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default, TS)]
pub struct MarketStructureAnalysisOptions {
    #[serde(default)]
    pub mode: MarketStructureExposureMode,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PayoffLegInput {
    pub option_right: OptionRight,
    pub position_side: PositionSide,
    pub strike: f64,
    pub premium: f64,
    pub quantity: u32,
}

impl PayoffLegInput {
    pub fn new(
        option_right: &str,
        position_side: &str,
        strike: f64,
        premium: f64,
        quantity: u32,
    ) -> OptionResult<Self> {
        if quantity == 0 {
            return Err(OptionError::new(
                "invalid_payoff_input",
                format!("quantity must be greater than zero: {quantity}"),
            ));
        }

        Ok(Self {
            option_right: OptionRight::from_str(option_right)?,
            position_side: PositionSide::from_str(position_side)?,
            strike,
            premium,
            quantity,
        })
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OptionStrategyInput {
    pub positions: Vec<OptionPosition>,
    pub qty: i32,
    pub evaluation_time: Option<String>,
    pub entry_cost: Option<f64>,
    pub dividend_yield: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct OptionStrategyCurvePoint {
    pub underlying_price: f64,
    pub mark_value: f64,
    pub pnl: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StrategyPnlInput {
    pub positions: Vec<OptionPosition>,
    pub qty: i32,
    pub underlying_price: f64,
    pub evaluation_time: String,
    pub entry_cost: Option<f64>,
    pub dividend_yield: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StrategyBreakEvenInput {
    pub positions: Vec<OptionPosition>,
    pub qty: i32,
    pub evaluation_time: String,
    pub entry_cost: Option<f64>,
    pub dividend_yield: Option<f64>,
    pub lower_bound: f64,
    pub upper_bound: f64,
    pub scan_step: Option<f64>,
    pub tolerance: Option<f64>,
    pub max_iterations: Option<usize>,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct StrategyBreakEvenSideInput {
    pub pivot: f64,
    pub boundary: f64,
    pub scan_step: f64,
    pub tolerance: Option<f64>,
    pub max_iterations: Option<usize>,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct StrategyPnlPeakSearchInput {
    pub current_price: f64,
    pub step_hint: Option<f64>,
    pub left_boundary: f64,
    pub right_boundary: f64,
    pub tolerance: Option<f64>,
    pub max_search_steps: Option<usize>,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct StrategyPnlPeak {
    pub spot: f64,
    pub pnl: f64,
}

#[derive(Debug, Clone, Copy, Default, PartialEq, Serialize, Deserialize)]
pub struct StrategyPositionTotals {
    pub value: Decimal,
    pub cost: Decimal,
    pub spread: Decimal,
    pub spread_rate: Option<f64>,
}