as-rust/exchanges/src/bybit_swap_rest.rs

use std::collections::BTreeMap;

use reqwest::Client;
use reqwest::header::HeaderMap;
use ring::hmac;
use rust_decimal::Decimal;
use rust_decimal::prelude::FromPrimitive;
use rust_decimal_macros::dec;
use tracing::{info, trace};

use crate::http_tool::RestTool;
use crate::response_base::ResponseData;

#[derive(Clone, Debug)]
pub struct BybitSwapRest {
    pub label: String,
    base_url: String,
    client: reqwest::Client,
    /*******参数*/
    //登陆所需参数
    login_param: BTreeMap<String, String>,
    delays: Vec<i64>,
    max_delay: i64,
    avg_delay: Decimal,
}

impl BybitSwapRest {
    /*******************************************************************************************************/
    /*****************************************获取一个对象****************************************************/
    /*******************************************************************************************************/

    pub fn new(is_colo: bool, login_param: BTreeMap<String, String>) -> BybitSwapRest
    {
        return BybitSwapRest::new_label("default-BybitSwapRest".to_string(), is_colo, login_param);
    }
    pub fn new_label(label: String, is_colo: bool, login_param: BTreeMap<String, String>) -> BybitSwapRest {
        let base_url = if is_colo {
            "https://api.bytick.com".to_string()
        } else {
            "https://api.bytick.com".to_string()
        };

        if is_colo {
            info!("开启高速(未配置，走普通：{})通道",base_url);
        } else {
            info!("走普通通道：{}",base_url);
        }
        /*****返回结构体*******/
        BybitSwapRest {
            label,
            base_url,
            client: Client::new(),
            login_param,
            delays: vec![],
            max_delay: 0,
            avg_delay: dec!(0.0),
        }
    }

    /*******************************************************************************************************/
    /*****************************************rest请求函数********************************************************/
    /*******************************************************************************************************/
    //服務器時間
    pub async fn get_server_time(&mut self) -> ResponseData {
        let  params = serde_json::json!({
         });
        let data = self.request("GET".to_string(),
                                "/v5".to_string(),
                                "/market/time".to_string(),
                                false,
                                params.to_string(),
        ).await;
        data
    }
    //查詢公告
    pub async fn get_announcements(&mut self) -> ResponseData {
        let  params = serde_json::json!({
            "locale":"zh-TW"
         });
        let data = self.request("GET".to_string(),
                                "/v5".to_string(),
                                "/announcements/index".to_string(),
                                false,
                                params.to_string(),
        ).await;
        data
    }
    //查詢可交易產品的規格信息
    pub async fn get_instruments_info(&mut self, symbol: String) -> ResponseData {
        let  params = serde_json::json!({
            "category":"linear",
            "symbol":symbol
         });
        let data = self.request("GET".to_string(),
                                "/v5".to_string(),
                                "/market/instruments-info".to_string(),
                                false,
                                params.to_string(),
        ).await;
        data
    }

    //查看持仓信息
    pub async fn get_positions(&mut self, symbol: String) -> ResponseData {
        let mut params = serde_json::json!({
            "category":"linear",
         });
        if symbol.len() > 0 {
            params.as_object_mut().unwrap().insert("symbol".parse().unwrap(), serde_json::Value::from(symbol));
        }
        let data = self.request("GET".to_string(),
                                "/v5".to_string(),
                                "/position/list".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }
    //设置持仓模式
    pub async fn set_position_mode(&mut self, symbol: String, mode: i64) -> ResponseData {
        let params = serde_json::json!({
             "category": "linear",
             "symbol": symbol,
             "mode": mode,
         });
        let data = self.request("POST".to_string(),
                                "/v5".to_string(),
                                "/position/switch-mode".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }

    //設置槓桿
    pub async fn set_leverage(&mut self, symbol: String,
                              lever: String) -> ResponseData {
        let params = serde_json::json!({
             "category": "linear",
             "symbol": symbol,
             "buyLeverage": lever,
             "sellLeverage": lever,
         });
        let data = self.request("POST".to_string(),
                                "/v5".to_string(),
                                "/position/set-leverage".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }


    //查詢錢包餘額
    pub async fn get_account_balance(&mut self) -> ResponseData {
        let  params = serde_json::json!({
            "accountType":"UNIFIED"
         });
        let data = self.request("GET".to_string(),
                                "/v5".to_string(),
                                "/account/wallet-balance".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }

    //創建委託單
    pub async fn swap_order(&mut self, params: serde_json::Value) -> ResponseData {
        let data = self.request("POST".to_string(),
                                "/v5".to_string(),
                                "/order/create".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }
    //查詢實時委託單
    pub async fn get_order(&mut self, symbol: String, order_id: String, order_link_id: String) -> ResponseData {
        let mut params = serde_json::json!({
            "category":"linear",
            "symbol":symbol,
         });
        if order_id.len() > 0 {
            params.as_object_mut().unwrap().insert("orderId".parse().unwrap(), serde_json::Value::from(order_id));
        }
        if order_link_id.len() > 0 {
            params.as_object_mut().unwrap().insert("orderLinkId".parse().unwrap(), serde_json::Value::from(order_link_id));
        }
        let data = self.request("GET".to_string(),
                                "/v5".to_string(),
                                "/order/realtime".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }

    //撤单
    pub async fn cancel_order(&mut self, symbol: String, order_id: String, order_link_id: String) -> ResponseData {
        let mut params = serde_json::json!({
             "category": "linear",
             "symbol": symbol,
         });
        if order_id.len() > 0 {
            params.as_object_mut().unwrap().insert("orderId".parse().unwrap(), serde_json::Value::from(order_id));
        }
        if order_link_id.len() > 0 {
            params.as_object_mut().unwrap().insert("orderLinkId".parse().unwrap(), serde_json::Value::from(order_link_id));
        }
        let data = self.request("POST".to_string(),
                                "/v5".to_string(),
                                "/order/cancel".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }
    /*******************************************************************************************************/
    /*****************************************工具函数********************************************************/
    /*******************************************************************************************************/
    pub fn get_delays(&self) -> Vec<i64> {
        self.delays.clone()
    }
    pub fn get_avg_delay(&self) -> Decimal {
        self.avg_delay.clone()
    }
    pub fn get_max_delay(&self) -> i64 {
        self.max_delay.clone()
    }
    fn get_delay_info(&mut self) {
        let last_100 = if self.delays.len() > 100 {
            self.delays[self.delays.len() - 100..].to_vec()
        } else {
            self.delays.clone()
        };

        let max_value = last_100.iter().max().unwrap();
        if max_value.clone().to_owned() > self.max_delay {
            self.max_delay = max_value.clone().to_owned();
        }

        let sum: i64 = last_100.iter().sum();
        let sum_v = Decimal::from_i64(sum).unwrap();
        let len_v = Decimal::from_u64(last_100.len() as u64).unwrap();
        self.avg_delay = (sum_v / len_v).round_dp(1);
        self.delays = last_100.clone().into_iter().collect();
    }
    //调用请求
    pub async fn request(&mut self,
                         method: String,
                         prefix_url: String,
                         request_url: String,
                         is_login: bool,
                         params: String) -> ResponseData
    {
        trace!("login_param:{:?}", self.login_param);
        //解析账号信息
        let mut access_key = "".to_string();
        let mut secret_key = "".to_string();
        // let mut passphrase = "".to_string();
        if self.login_param.contains_key("access_key") {
            access_key = self.login_param.get("access_key").unwrap().to_string();
        }
        if self.login_param.contains_key("secret_key") {
            secret_key = self.login_param.get("secret_key").unwrap().to_string();
        }
        // if self.login_param.contains_key("pass_key") {
        //     passphrase = self.login_param.get("pass_key").unwrap().to_string();
        // }
        let mut is_login_param = true;
        if access_key == "" || secret_key == "" {
            is_login_param = false
        }


        //请求头配置-如果需要登陆则存在额外配置
        let mut body = "".to_string();
        let timestamp = Self::get_timestamp();
        let mut headers = HeaderMap::new();
        headers.insert("Content-Type", "application/json; charset=utf-8".parse().unwrap());
        headers.insert("X-BAPI-RECV-WINDOW", "5000".parse().unwrap());

        if method == "POST" {
            body = params.clone();
        }


        //是否需要登陆-- 组装sing
        if is_login {
            if !is_login_param {
                let e = ResponseData::error(self.label.clone(), "登陆参数错误！".to_string());
                return e;
            } else {
                //需要登陆-且登陆参数齐全
                trace!("param:{}", params);
                trace!("body:{}", body);
                //组装sing
                let sing = Self::sign(
                    access_key.clone(),
                    secret_key.clone(),
                    method.clone(),
                    params.clone(),
                    timestamp.clone(),
                );
                //组装header
                headers.extend(Self::headers(sing, timestamp, access_key));
            }
        }


        // trace!("headers:{:?}", headers);
        let base_url = format!("{}{}", prefix_url.clone(), request_url.clone());
        let start_time = chrono::Utc::now().timestamp_millis();
        let get_response = self.http_toll(
            format!("{}{}", prefix_url.clone(), request_url.clone()),
            method.to_string(),
            params.clone(),
            headers,
        ).await;
        let time_array = chrono::Utc::now().timestamp_millis() - start_time;
        self.delays.push(time_array);
        self.get_delay_info();
        let res_data = Self::res_data_analysis(get_response, base_url, params);
        res_data
    }

    pub fn headers(sign: String, timestamp: String, access_key: String) -> HeaderMap {
        let mut headers = HeaderMap::new();
        headers.insert("X-BAPI-SIGN-TYPE", "2".parse().unwrap());
        headers.insert("X-BAPI-API-KEY", access_key.parse().unwrap());
        headers.insert("X-BAPI-TIMESTAMP", timestamp.parse().unwrap());
        headers.insert("X-BAPI-SIGN", sign.parse().unwrap());
        // headers.insert("X-Referer", passphrase.parse().unwrap());
        headers
    }
    pub fn sign(access_key: String,
                secret_key: String,
                method: String,
                params: String,   timestamp: String) -> String
    {
        /*签名生成*/
        let url_param_str = RestTool::parse_params_to_str(params.clone());
        let parameters = if method == "GET" {
            url_param_str
        } else {
            params
        };

        let message = format!("{}{}5000{}", timestamp, access_key, parameters);
        trace!("message:{}",message);

        // 做签名
        let hmac_key = ring::hmac::Key::new(hmac::HMAC_SHA256, secret_key.as_bytes());
        let result = ring::hmac::sign(&hmac_key, &message.as_bytes());
        let sign = hex::encode(result.as_ref());
        sign
    }

    async fn http_toll(&mut self, request_path: String, request_type: String, params: String, headers: HeaderMap) -> Result<ResponseData, reqwest::Error> {
        let res_data: ResponseData;
        /****请求接口与 地址*/
        let url = format!("{}{}", self.base_url.to_string(), request_path);
        let request_type = request_type.clone().to_uppercase();
        let addrs_url: String = if RestTool::parse_params_to_str(params.clone()) == "" {
            url.clone()
        } else {
            format!("{}?{}", url.clone(), RestTool::parse_params_to_str(params.clone()))
        };
        trace!("url:{}", url);
        trace!("addrs_url:{}", addrs_url);
        let params_json: serde_json::Value = serde_json::from_str(&params).unwrap();
        trace!("params_json:{}",params_json);
        trace!("headers:{:?}",headers);


        let req = match request_type.as_str() {
            "GET" => self.client.get(addrs_url.clone()).headers(headers),
            "POST" => self.client.post(url.clone()).body(params).headers(headers),
            "DELETE" => self.client.delete(addrs_url.clone()).headers(headers),
            // "PUT" => self.client.put(url.clone()).json(&params),
            _ => return Ok(ResponseData::error(self.label.clone(), format!("错误的请求类型:{}", request_type.clone()))), // 处理未知请求类型
        };

        let response = req.send().await?;
        if response.status().is_success() {
            // 读取响应的内容
            let body = response.text().await?;
            // trace!("ok-----{}", body);
            res_data = ResponseData::new(self.label.clone(), "200".to_string(), "success".to_string(), body);
        } else {
            let body = response.text().await?;
            // trace!("error-----{}", body);
            res_data = ResponseData::error(self.label.clone(), body.to_string())
        }

        Ok(res_data)
    }


    //res_data 解析
    pub fn res_data_analysis(result: Result<ResponseData, reqwest::Error>, base_url: String, params: String) -> ResponseData {
        // trace!("原始数据：{:?}",result);
        match result {
            Ok(res_data) => {
                if res_data.code != "200" {
                    // trace!("不等于200");
                    let message: String = res_data.message;
                    let json_value: serde_json::Value = serde_json::from_str(&message).unwrap();
                    let code = json_value["code"].as_str().unwrap();
                    let msg = json_value["msg"].as_str().unwrap();
                    let error = ResponseData::new("".to_string(),
                                                  format!("{}", code),
                                                  format!("{}", msg),
                                                  format!("请求地址：{},请求参数：{}", base_url, params));
                    error
                } else {
                    let body: String = res_data.data.as_str().parse().unwrap();
                    let json_value: serde_json::Value = serde_json::from_str(&body).unwrap();
                    // trace!("json_value：{:?}",json_value.to_string().as_str());
                    let code: i64 = if json_value["retCode"].as_i64().is_some() {
                        json_value["retCode"].as_i64().unwrap()
                    } else if json_value["ret_code"].as_i64().is_some() {
                        json_value["ret_code"].as_i64().unwrap()
                    } else {
                        -1
                    };

                    let msg: &str = if json_value["retMsg"].as_str().is_some() {
                        json_value["retMsg"].as_str().unwrap()
                    } else if json_value["ret_msg"].as_str().is_some() {
                        json_value["ret_msg"].as_str().unwrap()
                    } else {
                        ""
                    };


                    if code == 0 {
                        let data = serde_json::to_string(&json_value["result"]).unwrap();
                        let mut success = ResponseData::new("".to_string(), "200".to_string(), "success".to_string(), data.parse().unwrap());
                        success.time = json_value["time"].as_i64().unwrap();
                        success
                    } else {
                        let error = ResponseData::new("".to_string(),
                                                      format!("{}", code),
                                                      format!("{}", msg),
                                                      format!("请求地址：{},请求参数：{}", base_url, params));
                        error
                    }
                }
            }
            Err(err) => {
                let error = ResponseData::error("".to_string(), format!("json 解析失败:{}", err));
                error
            }
        }
    }
    fn get_timestamp() -> String {
        chrono::Utc::now().timestamp_millis()
            .to_string()
    }
}