/* Copyright 2023 Architect Financial Technologies LLC. This is free
 * software released under the GNU Affero Public License version 3. */
//! simplifed order flow client

use crate::{
    config::Common,
    protocol::{
        limits::{LimitScope, LimitSet},
        orderflow::{
            AberrantFill, ChanId, FillId, NormalFill, Order, OrderId, OrderState,
        },
        Account, Dir,
    },
    symbology::TradableProduct,
};
use anyhow::{bail, Result};
use enumflags2::BitFlags;
use netidx::{
    chars::Chars, pack::Pack, pool::Pooled, protocol::value::Value, utils::pack,
};
use netidx_protocols::{call_rpc, rpc::client::Proc};
use rust_decimal::Decimal;
use std::result;

/// This provides a simplified, but still pretty fast, api to query
/// the OMS, send, and cancel orders.
pub struct OmsQueryApi {
    get_order_state: Proc,
    get_channel_id: Proc,
    list_open: Proc,
    get_reject_reason: Proc,
    get_order_details: Proc,
    list_fills: Proc,
    get_fill_details: Proc,
    send_limit_order: Proc,
    cancel_order: Proc,
}

impl OmsQueryApi {
    /// Create a new simple order client
    pub async fn new(common: &Common) -> Result<Self> {
        let base = common.paths.core_flow();
        let subscriber = &common.subscriber;
        Ok(Self {
            get_order_state: Proc::new(subscriber, base.append("get-order-state"))
                .await?,
            list_open: Proc::new(subscriber, base.append("list-open")).await?,
            get_reject_reason: Proc::new(subscriber, base.append("get-reject-reason"))
                .await?,
            get_order_details: Proc::new(subscriber, base.append("get-order-details"))
                .await?,
            list_fills: Proc::new(subscriber, base.append("list-fills")).await?,
            get_fill_details: Proc::new(subscriber, base.append("get-fill-details"))
                .await?,
            send_limit_order: Proc::new(subscriber, base.append("send-limit-order"))
                .await?,
            get_channel_id: Proc::new(subscriber, base.append("get-channel-id")).await?,
            cancel_order: Proc::new(subscriber, base.append("cancel-order")).await?,
        })
    }

    /// Get the state of the specified order ids. This will return a
    /// state for every order id indicated. If an order is not found
    /// then it's state will be BitFlags::empty. len of the returned
    /// vector will always equal the len of the specified vector.
    pub async fn get_order_state(
        &self,
        ids: &Pooled<Vec<OrderId>>,
    ) -> Result<Pooled<Vec<BitFlags<OrderState>>>> {
        let ids = Value::Bytes(pack(ids)?.freeze());
        let res = call_rpc!(&self.get_order_state, ids: ids).await?;
        match res {
            Value::Error(e) => bail!(e.to_string()),
            Value::Bytes(b) => Ok(Pack::decode(&mut &*b)?),
            _ => bail!("unexpected response"),
        }
    }

    /// Return a list of open orders for the specified set and scope
    pub async fn list_open(
        &self,
        set: LimitSet,
        scope: LimitScope,
    ) -> Result<Pooled<Vec<OrderId>>> {
        let res = call_rpc!(&self.list_open, set: set, scope: scope).await?;
        match res {
            Value::Error(e) => bail!(e.to_string()),
            Value::Bytes(b) => Ok(Pack::decode(&mut &*b)?),
            _ => bail!("unexpected reponse"),
        }
    }

    /// Return the reason why the specified set of orders was
    /// rejected. This will be None if the order was not rejected.
    pub async fn get_reject_reason(
        &self,
        ids: &Pooled<Vec<OrderId>>,
    ) -> Result<Pooled<Vec<Option<Chars>>>> {
        let ids = Value::Bytes(pack(ids)?.freeze());
        let res = call_rpc!(&self.get_reject_reason, ids: ids).await?;
        match res {
            Value::Error(e) => bail!(e.to_string()),
            Value::Bytes(b) => Ok(Pack::decode(&mut &*b)?),
            _ => bail!("unexpected response"),
        }
    }

    /// Get the full details of the specified set of orders. If an
    /// order is not found for a given id, then no order state will be
    /// returned. len of the returned vector will always be <= len of
    /// the specified vector.
    pub async fn get_order_details(
        &self,
        ids: &Pooled<Vec<OrderId>>,
    ) -> Result<Pooled<Vec<Order>>> {
        let ids = Value::Bytes(pack(ids)?.freeze());
        let res = call_rpc!(&self.get_order_details, ids: ids).await?;
        match res {
            Value::Error(e) => bail!(e.to_string()),
            Value::Bytes(b) => Ok(Pack::decode(&mut &*b)?),
            _ => bail!("unexpected response"),
        }
    }

    /// List fills in the specified set and scope
    pub async fn list_fills(
        &self,
        set: LimitSet,
        scope: LimitScope,
    ) -> Result<Pooled<Vec<(OrderId, FillId)>>> {
        let res = call_rpc!(&self.list_fills, set: set, scope: scope).await?;
        match res {
            Value::Error(e) => bail!(e.to_string()),
            Value::Bytes(b) => Ok(Pack::decode(&mut &*b)?),
            _ => bail!("unexpected response"),
        }
    }

    /// Get the full details for a fill. If no fill is found for the
    /// specified id then no details will be returned for that id. len
    /// of the returned vector <= len of the specified vector.
    pub async fn get_fill_details(
        &self,
        ids: &Pooled<Vec<FillId>>,
    ) -> Result<Pooled<Vec<result::Result<NormalFill, AberrantFill>>>> {
        let ids = Value::Bytes(pack(ids)?.freeze());
        let res = call_rpc!(&self.get_fill_details, ids: ids).await?;
        match res {
            Value::Error(e) => bail!(e.to_string()),
            Value::Bytes(b) => Ok(Pack::decode(&mut &*b)?),
            _ => bail!("unexpected response"),
        }
    }

    /// Send a limit order, returning the order id if the order was
    /// sent successfully.
    pub async fn send_limit_order(
        &self,
        target: TradableProduct,
        account: Account,
        dir: Dir,
        price: Decimal,
        quantity: Decimal,
    ) -> Result<OrderId> {
        let res = call_rpc!(
            &self.send_limit_order,
            target: target,
            account: account,
            dir: dir,
            price: price,
            quantity: quantity
        )
        .await?;
        match res {
            Value::Error(e) => bail!(e.to_string()),
            v => Ok(v.cast_to()?),
        }
    }

    /// Cancel the specified order. A successful return does not mean
    /// the order is out, it just means the cancel has been received
    /// by the OMS and will be sent on to the counterparty.
    pub async fn cancel_order(&self, id: OrderId) -> Result<()> {
        let res = call_rpc!(&self.cancel_order, id: id).await?;
        match res {
            Value::Error(e) => bail!(e.to_string()),
            Value::Ok => Ok(()),
            _ => bail!("unexpected response"),
        }
    }

    /// Get the channel id of this orderflow channel. This is
    /// necessary if you want to allocate your own orderid for some
    /// reason. This is a very low level operation which isn't
    /// recommended.
    pub async fn get_channel_id(&self) -> Result<ChanId> {
        let args: [(&'static str, Value); 0] = [];
        let res = self.get_channel_id.call(args).await?;
        match res {
            Value::Error(e) => bail!(e.to_string()),
            v => Ok(v.cast_to()?),
        }
    }
}