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 toml::Value;
use tracing::{info, trace};
use crate::http::request::Response;
use crate::utils::utils::parse_params_to_str;


#[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) -> Response {
        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_instruments_info(&mut self, symbol: String) -> Response {
        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_account_transaction_log(&mut self) -> Response {
        let mut params = serde_json::json!({
            "accountType":"UNIFIED",
            "category":"linear",
            "currency":"USDT",
         });
        params["startTime"] = serde_json::json!(1703124000000 as i64);
        params["endTime"] = serde_json::json!(1703664000000  as i64);
        let data = self.request("GET".to_string(),
                                "/v5".to_string(),
                                "/account/transaction-log".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }

    //查詢平倉盈虧
    pub async fn get_position_closed_pnl(&mut self, symbol: String) -> Response {
        let mut params = serde_json::json!({
            "symbol":symbol,
            "limit":"200"
         });
        params["startTime"] = serde_json::json!(1703124000000 as i64);
        params["endTime"] = serde_json::json!(1703664000000  as i64);
        let data = self.request("GET".to_string(),
                                "/contract/v3".to_string(),
                                "/private/position/closed-pnl".to_string(),
                                true,
                                params.to_string(),
        ).await;
        data
    }

    //查詢錢包資金紀錄
    pub async fn get_account_wallet_fund_records(&mut self, start_time: i64, end_time: i64) -> Response {
        let mut params = serde_json::json!({
            "coin":"USDT",
            "walletFundType":"RealisedPNL",
            "limit":"50",
         });
        // if start_time > 0 {
        params["startTime"] = serde_json::json!(1703124000000 as i64);
        // }
        // if end_time > 0 {
        params["endTime"] = serde_json::json!(1703664000000  as i64);
        // }

        let data = self.request("GET".to_string(),
                                "/contract/v3".to_string(),
                                "/private/account/wallet/fund-records".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) -> Response
    {
        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 mut res = Response::new();
                res.code = "-1".to_string();
                res.msg = "登陆参数错误".to_string();
                return res;
            } 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 = 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<Response, reqwest::Error> {
        /****请求接口与 地址*/
        let url = format!("{}{}", self.base_url.to_string(), request_path);
        let request_type = request_type.clone().to_uppercase();
        let addrs_url = format!("{}?{}", url.clone(), parse_params_to_str(params.clone()));
        // let addrs_url: String = if  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 mut res = Response::new();
                res.code = "-1".to_string();
                res.msg = "请求类型错误".to_string();
                res.data = "".to_string();
                return Ok(res);
            }
        };

        let response = req.send().await?;
        let mut res = Response::new();
        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);
            res.code = "200".to_string();
            res.msg = "success".to_string();
            res.data = body;
        } else {
            let body = response.text().await?;
            trace!("error-----{}", body);
            // res_data = ResponseData::error(self.label.clone(), body.to_string())
            res.code = "-1".to_string();
            res.msg = body;
            res.data = "".to_string();
        }

        Ok(res)
    }


    //res_data 解析
    pub fn res_data_analysis(result: Result<Response, reqwest::Error>, base_url: String, params: String) -> Response {
        let res = Response::new();
        trace!("原始数据：{:?}",result);
        match result {
            Ok(mut res_data) => {
                if res_data.code != "200" {
                    // res_data
                    trace!("不等于200");
                    let msg = res_data.msg;
                    let body: String = res_data.data.as_str().parse().unwrap();
                    let json_value = serde_json::from_str::<Value>(&body);

                    match json_value {
                        Ok(_data) => {
                            let mut error = Response::new();
                            error.code = "-1".to_string();
                            error.msg = format!("请求错误{:?}", res.msg);
                            error.data = format!("请求地址：{},请求参数：{}", base_url, params);
                            error
                        }
                        Err(e) => {
                            let mut error = Response::new();
                            error.code = "-1".to_string();
                            error.msg = format!("json 解析失败:{}，相关参数:{}", e, msg);
                            error.data = "".to_string();
                            error
                        }
                    }
                } else {
                    res_data
                }
            }
            Err(err) => {
                let mut error = Response::new();
                error.code = "-1".to_string();
                error.msg = format!("json 解析失败:{}，相关参数:{}", err, params);
                error.data = "".to_string();
                error
            }
        }
    }

    fn get_timestamp() -> String {
        chrono::Utc::now().timestamp_millis()
            .to_string()
    }
}