//! binance exchange order structs

#![allow(dead_code)]

use std::convert::TryFrom;

use cxmr_api_clients_errors::Error;
use cxmr_balances::points;
use cxmr_currency::CurrencyPair;
use cxmr_exchanges::{
    MarketOrder, OrderExecution, OrderFee, OrderFill, OrderSide, OrderStatus, OrderTime,
};

use crate::public::parse::order_type;

/// Response of create order.
#[derive(Deserialize)]
pub struct BncOrder {
    symbol: String, // "BTCUSDT"
    #[serde(rename = "orderId")]
    order_id: u64,
    #[serde(rename = "clientOrderId")]
    client_order_id: String, // "6gCrw2kRUAF9CvJDGP16IP"
    time: u64,
    #[serde(rename = "updateTime")]
    update_time: u64,
    #[serde(rename = "transactTime")]
    transact_time: Option<u64>,
    price: Option<String>, // "1.00000000"
    #[serde(rename = "stopPrice")]
    stop_price: Option<String>, // "1.00000000"
    #[serde(rename = "icebergQty")]
    iceberg_qty: Option<String>, // "1.00000000"
    #[serde(rename = "origQty")]
    orig_qty: Option<String>, // "10.00000000"
    #[serde(rename = "executedQty")]
    executed_qty: Option<String>, // "10.00000000"
    #[serde(rename = "cummulativeQuoteQty")]
    cummulative_quote_qty: Option<String>, // "10.00000000"
    status: Option<String>, // "FILLED"
    #[serde(rename = "timeInForce")]
    time_in_force: Option<String>, // "GTC"
    #[serde(rename = "type")]
    kind: Option<String>, // "MARKET"
    side: Option<String>,  // "SELL"
    fills: Option<Vec<BncOrderFill>>,
    #[serde(rename = "isWorking")]
    is_working: Option<bool>,
}

impl TryFrom<BncOrder> for OrderExecution {
    type Error = Error;
    #[inline]
    fn try_from(res: BncOrder) -> Result<OrderExecution, Error> {
        let fills = if let Some(fills) = res.fills {
            Some(
                fills
                    .into_iter()
                    .map(|f| OrderFill::try_from(f))
                    .collect::<Result<_, _>>()?,
            )
        } else if let Some(_) = res.executed_qty {
            Some(vec![OrderFill::try_from(&res)?])
        } else {
            None
        };
        Ok(OrderExecution {
            rate: res
                .price
                .and_then(|v| v.parse::<f64>().ok())
                .map(|v| points(v))
                .filter(|v| *v != 0),
            stop: res
                .stop_price
                .and_then(|v| v.parse::<f64>().ok())
                .map(|v| points(v))
                .filter(|v| *v != 0),
            amount: res
                .orig_qty
                .and_then(|v| v.parse::<f64>().ok())
                .map(|v| points(v))
                .filter(|v| *v != 0),
            // iceberg: res
            //     .iceberg_qty
            //     .and_then(|v| v.parse::<f64>().ok())
            //     .map(|v| points(v))
            //     .filter(|v| v != 0),
            executed: res
                .executed_qty
                .and_then(|v| v.parse::<f64>().ok())
                .map(|v| points(v))
                .filter(|v| *v != 0),
            status: res
                .status
                .map(|s| order_status(&s))
                .unwrap_or_else(|| Ok(OrderStatus::New))?,
            fills: fills,
        })
    }
}

impl BncOrder {
    #[inline]
    pub fn market_order(self, pair: CurrencyPair) -> Result<MarketOrder, Error> {
        Ok(MarketOrder {
            id: self.client_order_id,
            pair: pair,
            rate: self
                .price
                .and_then(|v| v.parse::<f64>().ok())
                .map(|v| points(v))
                .filter(|v| *v != 0)?,
            amount: self
                .orig_qty
                .and_then(|v| v.parse::<f64>().ok())
                .map(|v| points(v))
                .filter(|v| *v != 0)?,
            stop: self
                .stop_price
                .and_then(|v| v.parse::<f64>().ok())
                .map(|v| points(v))
                .filter(|v| *v != 0),
            executed: self
                .executed_qty
                .and_then(|v| v.parse::<f64>().ok())
                .map(|v| points(v))
                .filter(|v| *v != 0),
            status: order_status(&self.status?)?,
            kind: order_type(&self.kind?)?,
            side: order_side(&self.side?)?,
            time: order_time(&self.time_in_force?)?,
            created_at: self.time,
            updated_at: self.update_time,
        })
    }
}

impl TryFrom<&BncOrder> for OrderFill {
    type Error = Error;
    #[inline]
    fn try_from(res: &BncOrder) -> Result<OrderFill, Error> {
        Ok(OrderFill {
            rate: points(res.price.clone()?.parse()?),
            amount: points(res.executed_qty.clone()?.parse()?),
            fee: None,
        })
    }
}

#[derive(Deserialize)]
pub struct BncOrderFill {
    price: String,      // "1.00000000"
    qty: String,        // "10.00000000"
    commission: String, // "4.00000000"
    #[serde(rename = "commissionAsset")]
    commission_asset: String, // "USDT"
}

impl TryFrom<BncOrderFill> for OrderFill {
    type Error = Error;
    #[inline]
    fn try_from(f: BncOrderFill) -> Result<OrderFill, Error> {
        Ok(OrderFill {
            rate: points(f.price.parse()?),
            amount: points(f.qty.parse()?),
            fee: Some(OrderFee::new(
                points(f.commission.parse()?),
                f.commission_asset.as_str().into(),
            )),
        })
    }
}

#[inline]
pub fn order_side_to_str(side: &OrderSide) -> &str {
    match side {
        &OrderSide::Ask => "SELL",
        &OrderSide::Bid => "BUY",
    }
}

#[inline]
pub fn order_side(s: &str) -> Result<OrderSide, Error> {
    match s {
        "SELL" => Ok(OrderSide::Ask),
        "BUY" => Ok(OrderSide::Bid),
        _ => Err(Error::UnexpectedOrderSide(s.to_string())),
    }
}

#[inline]
pub fn order_time_to_str(t: &OrderTime) -> &str {
    match t {
        &OrderTime::GoodTilCancel => "GTC",
        &OrderTime::ImmediateOrCancel => "IOC",
        &OrderTime::FillOrKill => "FOK",
    }
}

#[inline]
pub fn order_time(s: &str) -> Result<OrderTime, Error> {
    match s {
        "GTC" => Ok(OrderTime::GoodTilCancel),
        "IOC" => Ok(OrderTime::ImmediateOrCancel),
        "FOK" => Ok(OrderTime::FillOrKill),
        _ => Err(Error::UnexpectedOrderTime(s.to_string())),
    }
}

pub fn order_status(s: &str) -> Result<OrderStatus, Error> {
    match s {
        "NEW" => Ok(OrderStatus::New),
        "PARTIALLY_FILLED" => Ok(OrderStatus::PartiallyFilled),
        "FILLED" => Ok(OrderStatus::Filled),
        "CANCELED" => Ok(OrderStatus::Canceled),
        "PENDING_CANCEL" => Ok(OrderStatus::PendingCancel),
        "REJECTED" => Ok(OrderStatus::Rejected),
        "EXPIRED" => Ok(OrderStatus::Expired),
        _ => Err(Error::UnexpectedOrderStatus(s.to_string())),
    }
}