use crate::{qs_params, session::CallbackProvider, Messages};
use crate::{MarketSession, Product, SecurityType, Session, Store};
use anyhow::Result;
use http::Method;
use std::sync::Arc;
use strum::EnumString;

pub struct Api<T: Store> {
  session: Arc<Session<T>>,
}

impl<T> Api<T>
where
  T: Store,
{
  pub fn new(session: Arc<Session<T>>) -> Self {
    Self { session }
  }

  pub async fn list(
    &self,
    account_id_key: &str,
    params: ListOrdersRequest,
    callbacks: impl CallbackProvider,
  ) -> Result<OrdersResponse> {
    let orders: serde_json::Value = self
      .session
      .send(
        Method::GET,
        format!("/v1/accounts/{}/orders", account_id_key),
        qs_params(&params)?,
        callbacks,
      )
      .await?;
    debug!("orders json: {}", serde_json::to_string_pretty(&orders)?);
    Ok(serde_json::from_value(orders.get("OrdersResponse").unwrap().clone())?)
  }

  pub async fn preview(
    &self,
    account_id_key: &str,
    params: PreviewOrderRequest,
    callbacks: impl CallbackProvider,
  ) -> Result<PreviewOrderResponse> {
    let preview: serde_json::Value = self
      .session
      .clone()
      .send(
        Method::POST,
        format!("/v1/accounts/{}/orders/preview", account_id_key),
        Some(params),
        callbacks,
      )
      .await?;
    debug!("preview json: {}", serde_json::to_string_pretty(&preview)?);
    Ok(serde_json::from_value(
      preview.get("PreviewOrderResponse").unwrap().clone(),
    )?)
  }

  pub async fn place(
    &self,
    account_id_key: &str,
    params: PlaceOrderRequest,
    callbacks: impl CallbackProvider,
  ) -> Result<PlaceOrderResponse> {
    let place: serde_json::Value = self
      .session
      .clone()
      .send(
        Method::POST,
        format!("/v1/accounts/{}/orders/place", account_id_key),
        Some(params),
        callbacks,
      )
      .await?;
    debug!("placed order json: {}", serde_json::to_string_pretty(&place)?);
    Ok(serde_json::from_value(
      place.get("PlaceOrderResponse").unwrap().clone(),
    )?)
  }

  pub async fn cancel(
    &self,
    account_id_key: &str,
    params: CancelOrderRequest,
    callback: impl CallbackProvider,
  ) -> Result<CancelOrderResponse> {
    let cancellation: serde_json::Value = self
      .session
      .clone()
      .send(
        Method::PUT,
        format!("/v1/accounts/{}/orders/cancel", account_id_key),
        Some(params),
        callback,
      )
      .await?;
    debug!("cancellation json: {}", serde_json::to_string_pretty(&cancellation)?);
    Ok(serde_json::from_value(
      cancellation.get("CancelOrderResponse").unwrap().clone(),
    )?)
  }

  pub async fn change_preview(
    &self,
    account_id_key: &str,
    order_id: &str,
    params: PreviewOrderRequest,
    callback: impl CallbackProvider,
  ) -> Result<PreviewOrderResponse> {
    let preview: serde_json::Value = self
      .session
      .clone()
      .send(
        Method::PUT,
        format!("/v1/accounts/{}/orders/{}/change/preview", account_id_key, order_id),
        Some(params),
        callback,
      )
      .await?;
    debug!("changed preview json: {}", serde_json::to_string_pretty(&preview)?);
    Ok(serde_json::from_value(
      preview.get("PreviewOrderResponse").unwrap().clone(),
    )?)
  }

  pub async fn change_order(
    &self,
    account_id_key: &str,
    order_id: &str,
    params: PlaceOrderRequest,
    callback: impl CallbackProvider,
  ) -> Result<PlaceOrderResponse> {
    let place: serde_json::Value = self
      .session
      .clone()
      .send(
        Method::PUT,
        format!("/v1/accounts/{}/orders/{}/change/place", account_id_key, order_id),
        Some(params),
        callback,
      )
      .await?;
    debug!("changed placed order json: {}", serde_json::to_string_pretty(&place)?);
    Ok(serde_json::from_value(
      place.get("PlaceOrderResponse").unwrap().clone(),
    )?)
  }
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct CancelOrderRequest {
  pub order_id: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct CancelOrderResponse {
  pub account_id: String,
  pub order_id: i64,
  pub cancel_time: i64,
  #[serde(rename = "Messages", skip_serializing_if = "Messages::is_empty")]
  pub messages: Messages,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct PlaceOrderRequest {
  pub order_type: Option<OrderType>,
  pub client_order_id: String,
  #[serde(rename = "Order", skip_serializing_if = "Vec::is_empty")]
  pub order: Vec<OrderDetail>,
  #[serde(rename = "PreviewIds", skip_serializing_if = "Vec::is_empty")]
  pub preview_ids: Vec<PreviewId>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct PlaceOrderResponse {
  #[serde(skip_serializing_if = "Option::is_none")]
  pub order_type: Option<OrderType>,
  #[serde(skip_serializing_if = "Messages::is_empty")]
  pub message_list: Messages,
  pub total_order_value: f64,
  pub total_commission: f64,
  pub order_id: i64,
  #[serde(rename = "Order", skip_serializing_if = "Vec::is_empty")]
  pub order: Vec<OrderDetail>,
  pub dst_flag: bool,
  pub account_id: String,
  pub option_level_cd: i32,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub margin_level_cd: Option<MarginLevelCd>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub portfolio_margin: Option<PortfolioMargin>,
  pub is_employee: bool,
  pub commission_msg: String,
  #[serde(rename = "OrderIds", skip_serializing_if = "Vec::is_empty")]
  pub order_ids: Vec<OrderId>,
  #[serde(rename = "Disclosure", skip_serializing_if = "Option::is_none")]
  pub disclosure: Option<Disclosure>,
  pub placed_time: i64,
  pub client_order_id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct OrderId {
  pub order_id: i64,
  pub cash_margin: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct PreviewOrderRequest {
  pub order_type: Option<OrderType>,
  pub client_order_id: String,
  #[serde(rename = "Order", skip_serializing_if = "Vec::is_empty")]
  pub order: Vec<OrderDetail>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct PreviewOrderResponse {
  #[serde(skip_serializing_if = "Option::is_none")]
  pub order_id: Option<OrderType>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub message_list: Option<Messages>,
  pub total_order_value: f64,
  pub total_commission: f64,
  #[serde(skip_serializing_if = "Vec::is_empty")]
  pub order: Vec<OrderDetail>,
  #[serde(rename = "PreviewIds", skip_serializing_if = "Vec::is_empty")]
  pub preview_ids: Vec<PreviewId>,
  pub preview_time: i64,
  pub dst_flag: bool,
  pub account_id: String,
  pub option_level_cd: i32,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub margin_level_cd: Option<MarginLevelCd>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub portfolio_margin: Option<PortfolioMargin>,
  pub is_employee: bool,
  pub commission_message: String,
  #[serde(rename = "Disclosure", skip_serializing_if = "Option::is_none")]
  pub disclosure: Option<Disclosure>,
  pub client_order_id: String,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub margin_bp_details: Option<MarginBuyingPowerDetails>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub cash_bp_details: Option<CashBuyingPowerDetails>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub dt_bp_details: Option<DtBuyingPowerDetails>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct OrderBuyPowerEffect {
  pub current_bp: f64,
  pub current_oor: f64,
  pub current_net_bp: f64,
  pub current_order_impact: f64,
  pub net_bp: f64,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct CashBuyingPowerDetails {
  #[serde(rename = "settledUnsettled", skip_serializing_if = "Option::is_none")]
  pub settled_unsettled: Option<OrderBuyPowerEffect>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub settled: Option<OrderBuyPowerEffect>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct MarginBuyingPowerDetails {
  #[serde(rename = "nonMarginable", skip_serializing_if = "Option::is_none")]
  pub non_marginable: Option<OrderBuyPowerEffect>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub marginable: Option<OrderBuyPowerEffect>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct DtBuyingPowerDetails {
  #[serde(rename = "nonMarginable", skip_serializing_if = "Option::is_none")]
  pub non_marginable: Option<OrderBuyPowerEffect>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub marginable: Option<OrderBuyPowerEffect>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct Disclosure {
  pub eh_disclosure_flag: bool,
  pub ah_disclosure_flag: bool,
  pub conditional_disclosure_flag: bool,
  pub ao_disclosure_flag: bool,
  #[serde(rename = "mfFLConsent")]
  pub mf_fl_consent: bool,
  #[serde(rename = "mfEOConsent")]
  pub mf_eo_consent: bool,
}

#[derive(Debug, Deserialize, Clone, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct PortfolioMargin {
  pub house_excess_equity_new: f64,
  pub pm_eligible: f64,
  pub house_excess_equity_curr: f64,
  pub house_excess_equity_change: f64,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct PreviewId {
  pub preview_id: i64,
  pub cash_margin: String,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct ListOrdersRequest {
  pub marker: Option<String>,
  pub count: Option<usize>,
  pub status: Option<OrderStatus>,
  pub from_date: Option<String>,
  pub to_date: Option<String>,
  pub symbol: Option<Vec<String>>,
  pub security_type: Option<SecurityType>,
  pub transaction_type: Option<TransactionType>,
  pub market_session: Option<MarketSession>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct OrdersResponse {
  pub marker: String,
  pub next: String,
  #[serde(rename = "Order", skip_serializing_if = "Vec::is_empty")]
  pub order: Vec<Order>,
  #[serde(rename = "Messages", skip_serializing_if = "Messages::is_empty")]
  pub messages: Messages,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct Order {
  pub order_id: i64,
  pub details: String,
  pub order_type: String,
  pub total_order_value: f64,
  pub total_commission: f64,
  #[serde(rename = "OrderDetail", skip_serializing_if = "Vec::is_empty")]
  pub order_detail: Vec<OrderDetail>,
  #[serde(rename = "Events")]
  pub events: Events,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct OrderDetail {
  pub order_number: isize,
  pub account_id: String,
  pub preview_time: i64,
  pub placed_time: i64,
  pub executed_time: i64,
  pub order_value: f64,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub status: Option<OrderStatus>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub order_type: Option<OrderType>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub order_term: Option<OrderTerm>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub price_type: Option<PriceType>,
  pub price_value: String,
  pub limit_price: f64,
  pub stop_price: f64,
  pub stop_limit_price: f64,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub offset_type: Option<OffsetType>,
  pub offset_value: f64,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub market_session: Option<MarketSession>,
  pub routing_destination: RoutingDestination,
  pub bracketed_limit_price: f64,
  pub initial_stop_price: f64,
  pub trail_price: f64,
  pub trigger_price: f64,
  pub condition_price: f64,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub condition_type: Option<ConditionType>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub condition_follow_price: Option<ConditionFollowPrice>,
  pub condition_security_type: String,
  pub replaced_by_order_id: isize,
  pub replaces_order_id: isize,
  pub all_or_none: bool,
  pub preview_id: i64,
  #[serde(rename = "Instrument", skip_serializing_if = "Vec::is_empty")]
  pub instrument: Vec<Instrument>,
  #[serde(rename = "messages", skip_serializing_if = "Option::is_none")]
  pub messages: Option<Messages>,
  pub pre_clearance_code: String,
  pub override_restricted_cd: i32,
  pub investment_amount: f64,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub position_quantity: Option<PositionQuantity>,
  pub aip_flag: bool,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub eq_qual: Option<EgQual>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub re_invest_option: Option<ReInvestOption>,
  pub estimated_commission: f64,
  pub estimated_fees: f64,
  pub estimated_total_amount: f64,
  pub net_price: f64,
  pub net_bid: f64,
  pub net_ask: f64,
  pub gcd: i32,
  pub ratio: String,
  pub mfprice_type: String,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct Event {
  pub name: EventName,
  pub date_time: i64,
  pub order_number: isize,
  #[serde(skip_serializing_if = "Vec::is_empty")]
  pub instrument: Vec<Instrument>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct Instrument {
  pub product: Product,
  pub symbol_description: String,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub order_action: Option<OrderAction>,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub quantity_type: Option<QuantityType>,
  pub quantity: f64,
  pub cancel_quantity: f64,
  pub ordered_quantity: f64,
  pub filled_quantity: f64,
  pub average_execution_price: f64,
  pub estimated_commission: f64,
  pub estimated_fees: f64,
  pub bid: f64,
  pub ask: f64,
  pub lastprice: f64,
  pub currency: Currency,
  #[serde(rename = "Lots")]
  pub lots: Lots,
  #[serde(rename = "MFQuantity")]
  pub mf_quantity: MFQuantity,
  pub osi_key: String,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub mf_transaction: Option<MFTransaction>,
  pub reserve_order: bool,
  pub reserve_quantity: f64,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct MFQuantity {
  pub cash: f64,
  pub margin: f64,
  pub cusip: String,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct Lots {
  #[serde(rename = "Lot", skip_serializing_if = "Vec::is_empty")]
  pub lot: Vec<Lot>,
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct Lot {
  pub id: i64,
  pub size: f64,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "UPPERCASE")]
pub enum Currency {
  #[serde(rename = "USD")]
  Usd,
  #[serde(rename = "EUR")]
  Eur,
  #[serde(rename = "GBP")]
  Gbp,
  #[serde(rename = "HKD")]
  Hkd,
  #[serde(rename = "JPY")]
  Jpy,
  #[serde(rename = "CAD")]
  Cad,
}

impl Default for Currency {
  fn default() -> Self {
    Currency::Usd
  }
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum QuantityType {
  #[serde(rename = "QUANTITY")]
  Quantity,
  #[serde(rename = "DOLLAR")]
  Dollar,
  #[serde(rename = "ALL_I_OWN")]
  AllIOwn,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum MFTransaction {
  #[serde(rename = "BUY")]
  Buy,
  #[serde(rename = "SELL")]
  Sell,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum OrderAction {
  #[serde(rename = "BUY")]
  Buy,
  #[serde(rename = "SELL")]
  Sell,
  #[serde(rename = "BUY_TO_COVER")]
  BuyToCover,
  #[serde(rename = "SELL_SHORT")]
  SellShort,
  #[serde(rename = "BUY_OPEN")]
  BuyOpen,
  #[serde(rename = "BUY_CLOSE")]
  BuyClose,
  #[serde(rename = "SELL_OPEN")]
  SellOpen,
  #[serde(rename = "SELL_CLOSE")]
  SellClose,
  #[serde(rename = "EXCHANGE")]
  Exchange,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum EventName {
  #[serde(rename = "UNSPECIFIED")]
  Unspecified,
  #[serde(rename = "ORDER_PLACED")]
  OrderPlaced,
  #[serde(rename = "SENT_TO_CMS")]
  SentToCms,
  #[serde(rename = "SENT_TO_MARKET")]
  SentToMarket,
  #[serde(rename = "MARKET_SENT_ACKNOWLEDGED")]
  MarketSentAcknowledged,
  #[serde(rename = "CANCEL_REQUESTED")]
  CancelRequested,
  #[serde(rename = "ORDER_MODIFIED")]
  OrderModified,
  #[serde(rename = "ORDER_SENT_TO_BROKER_REVIEW")]
  OrderSentToBrokerReview,
  #[serde(rename = "SYSTEM_REJECTED")]
  SystemRejected,
  #[serde(rename = "ORDER_REJECTED")]
  OrderRejected,
  #[serde(rename = "ORDER_CANCELLED")]
  OrderCancelled,
  #[serde(rename = "CANCEL_REJECTED")]
  CancelRejected,
  #[serde(rename = "ORDER_EXPIRED")]
  OrderExpired,
  #[serde(rename = "ORDER_EXECUTED")]
  OrderExecuted,
  #[serde(rename = "ORDER_ADJUSTED")]
  OrderAdjusted,
  #[serde(rename = "ORDER_REVERSED")]
  OrderReversed,
  #[serde(rename = "REVERSE_CANCELLATION")]
  ReverseCancellation,
  #[serde(rename = "REVERSE_EXPIRATION")]
  ReverseExpiration,
  #[serde(rename = "OPTION_POSITION_ASSIGNED")]
  OptionPositionAssigned,
  #[serde(rename = "OPEN_ORDER_ADJUSTED")]
  OpenOrderAdjusted,
  #[serde(rename = "CA_CANCELLED")]
  CaCancelled,
  #[serde(rename = "CA_BOOKED")]
  CaBooked,
  #[serde(rename = "IPO_ALLOCATED")]
  IpoAllocated,
  #[serde(rename = "DONE_TRADE_EXECUTED")]
  DoneTradeExecuted,
  #[serde(rename = "REJECTION_REVERSAL")]
  RejectionReversal,
}

impl Default for EventName {
  fn default() -> Self {
    EventName::Unspecified
  }
}

#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "camelCase", default)]
pub struct Events {
  #[serde(rename = "Events", skip_serializing_if = "Vec::is_empty")]
  pub event: Vec<Event>,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum OrderStatus {
  #[serde(rename = "OPEN")]
  Open,
  #[serde(rename = "EXECUTED")]
  Executed,
  #[serde(rename = "CANCELLED")]
  Cancelled,
  #[serde(rename = "INDIVIDUAL_FILLS")]
  IndividualFills,
  #[serde(rename = "CANCEL_REQUESTED")]
  CancelRequested,
  #[serde(rename = "EXPIRED")]
  Expired,
  #[serde(rename = "REJECTED")]
  Rejected,
  #[serde(rename = "PARTIAL")]
  Partial,
  #[serde(rename = "DO_NOT_EXERCISE")]
  DoNotExercise,
  #[serde(rename = "DONE_TRADE_EXECUTED")]
  DoneTradeExecuted,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum TransactionType {
  #[serde(rename = "ATNM")]
  Atnm,
  #[serde(rename = "BUY")]
  Buy,
  #[serde(rename = "SELL")]
  Sell,
  #[serde(rename = "SELL_SHORT")]
  SellShort,
  #[serde(rename = "BUY_TO_COVER")]
  BuyToCover,
  #[serde(rename = "MF_EXCHANGE")]
  MfExchange,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum OrderTerm {
  #[serde(rename = "GOOD_UNTIL_CANCEL")]
  GoodUntilCancel,
  #[serde(rename = "GOOD_FOR_DAY")]
  GoodForDay,
  #[serde(rename = "GOOD_TILL_DATE")]
  GoodTillDate,
  #[serde(rename = "IMMEDIATE_OR_CANCEL")]
  ImmediateOrCancel,
  #[serde(rename = "FILL_OR_KILL")]
  FillOrKill,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum OrderType {
  #[serde(rename = "EQ")]
  Eq,
  #[serde(rename = "OPTN")]
  Optn,
  #[serde(rename = "SPREADS")]
  Spreads,
  #[serde(rename = "BUY_WRITES")]
  BuyWrites,
  #[serde(rename = "BUTTERFLY")]
  Butterfly,
  #[serde(rename = "IRON_BUTTERFLY")]
  IronButterfly,
  #[serde(rename = "CONDOR")]
  Condor,
  #[serde(rename = "IRON_CONDOR")]
  IronCondor,
  #[serde(rename = "MF")]
  Mf,
  #[serde(rename = "MMF")]
  Mmf,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum PriceType {
  #[serde(rename = "MARKET")]
  Market,
  #[serde(rename = "LIMIT")]
  Limit,
  #[serde(rename = "STOP")]
  Stop,
  #[serde(rename = "STOP_LIMIT")]
  StopLimit,
  #[serde(rename = "TRAILING_STOP_CNST_BY_LOWER_TRIGGER")]
  TrailingStopCnstByLowerTrigger,
  #[serde(rename = "UPPER_TRIGGER_BY_TRAILING_STOP_CNST")]
  UpperTriggerByTrailingStopCnst,
  #[serde(rename = "TRAILING_STOP_PRCT_BY_LOWER_TRIGGER")]
  TrailingStopPrctByLowerTrigger,
  #[serde(rename = "UPPER_TRIGGER_BY_TRAILING_STOP_PRCT")]
  UpperTriggerByTrailingStopPrct,
  #[serde(rename = "TRAILING_STOP_CNST")]
  TrailingStopCnst,
  #[serde(rename = "TRAILING_STOP_PRCT")]
  TrailingStopPrct,
  #[serde(rename = "HIDDEN_STOP")]
  HiddenStop,
  #[serde(rename = "HIDDEN_STOP_BY_LOWER_TRIGGER")]
  HiddenStopByLowerTrigger,
  #[serde(rename = "UPPER_TRIGGER_BY_HIDDEN_STOP")]
  UpperTriggerByHiddenStop,
  #[serde(rename = "NET_DEBIT")]
  NetDebit,
  #[serde(rename = "NET_CREDIT")]
  NetCredit,
  #[serde(rename = "NET_EVEN")]
  NetEven,
  #[serde(rename = "MARKET_ON_OPEN")]
  MarketOnOpen,
  #[serde(rename = "MARKET_ON_CLOSE")]
  MarketOnClose,
  #[serde(rename = "LIMIT_ON_OPEN")]
  LimitOnOpen,
  #[serde(rename = "LIMIT_ON_CLOSE")]
  LimitOnClose,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum OffsetType {
  #[serde(rename = "TRAILING_STOP_CNST")]
  TrailingStopCnst,
  #[serde(rename = "TRAILING_STOP_PRCT")]
  TrailingStopPrct,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum RoutingDestination {
  #[serde(rename = "AUTO")]
  Auto,
  #[serde(rename = "AMEX")]
  Amex,
  #[serde(rename = "BOX")]
  Box,
  #[serde(rename = "CBOE")]
  Cboe,
  #[serde(rename = "ISE")]
  Ise,
  #[serde(rename = "NOM")]
  Nom,
  #[serde(rename = "NYSE")]
  Nyse,
  #[serde(rename = "PHX")]
  Phx,
}

impl Default for RoutingDestination {
  fn default() -> Self {
    RoutingDestination::Auto
  }
}
#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum ConditionType {
  #[serde(rename = "CONTINGENT_GTE")]
  Gte,
  #[serde(rename = "CONTINGENT_LTE")]
  Lte,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum ConditionFollowPrice {
  #[serde(rename = "ASK")]
  Ask,
  #[serde(rename = "BID")]
  Bid,
  #[serde(rename = "LAST")]
  Last,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum PositionQuantity {
  #[serde(rename = "ENTIRE_POSITION")]
  EntirePosition,
  #[serde(rename = "CASH")]
  Cash,
  #[serde(rename = "MARGIN")]
  Margin,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum EgQual {
  #[serde(rename = "EG_QUAL_UNSPECIFIED")]
  EgQualUnspecified,
  #[serde(rename = "EG_QUAL_QUALIFIED")]
  EgQualQualified,
  #[serde(rename = "EG_QUAL_NOT_IN_FORCE")]
  EgQualNotInForce,
  #[serde(rename = "EG_QUAL_NOT_A_MARKET_ORDER")]
  EgQualNotAMarketOrder,
  #[serde(rename = "EG_QUAL_NOT_AN_ELIGIBLE_SECURITY")]
  EgQualNotAnEligibleSecurity,
  #[serde(rename = "EG_QUAL_INVALID_ORDER_TYPE")]
  EgQualInvalidOrderType,
  #[serde(rename = "EG_QUAL_SIZE_NOT_QUALIFIED")]
  EgQualSizeNotQualified,
  #[serde(rename = "EG_QUAL_OUTSIDE_GUARANTEED_PERIOD")]
  EgQualOutsideGuaranteedPeriod,
  #[serde(rename = "EG_QUAL_INELIGIBLE_GATEWAY")]
  EgQualIneligibleGateway,
  #[serde(rename = "EG_QUAL_INELIGIBLE_DUE_TO_IPO")]
  EgQualIneligibleDueToIpo,
  #[serde(rename = "EG_QUAL_INELIGIBLE_DUE_TO_SELF_DIRECTED")]
  EgQualIneligibleDueToSelfDirected,
  #[serde(rename = "EG_QUAL_INELIGIBLE_DUE_TO_CHANGEORDER")]
  EgQualIneligibleDueToChangeorder,
}

#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum ReInvestOption {
  #[serde(rename = "REINVEST")]
  Reinvest,
  #[serde(rename = "DEPOSIT")]
  Deposit,
  #[serde(rename = "CURRENT_HOLDING")]
  CurrentHolding,
}
#[derive(Debug, Clone, Copy, Deserialize, Serialize, EnumString)]
#[strum(serialize_all = "lowercase")]
pub enum MarginLevelCd {
  #[serde(rename = "UNSPECIFIED")]
  Unspecified,
  #[serde(rename = "MARGIN_TRADING_NOT_ALLOWED")]
  MarginTradingNotAllowed,
  #[serde(rename = "MARGIN_TRADING_ALLOWED")]
  MarginTradingAllowed,
  #[serde(rename = "MARGIN_TRADING_ALLOWED_ON_OPTIONS")]
  MarginTradingAllowedOnOptions,
  #[serde(rename = "MARGIN_TRADING_ALLOWED_ON_PM")]
  MarginTradingAllowedOnPm,
}