use crate::modules::client::CLIENT;
use crate::utils::redis::RedisUtil;
use crate::{error::BinanceError, utils::time::now_timestamp_millis};
use hmac::{Hmac, Mac};
use serde::{Deserialize, Serialize};
use sha2::Sha256;

type HmacSha256 = Hmac<Sha256>;
const DEFAULT_QUANTITY: f64 = 0.002;
const STABLE_THRESHOLD: f64 = 0.1; // 市场稳定容差
const SLEEP_MS: u64 = 500;

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct OrderResponse {
    pub order_id: i64,
    pub symbol: String,
    pub status: String,
    pub client_order_id: String,
    pub price: String,
    pub orig_qty: String,
    pub executed_qty: String,
    pub cum_qty: String,
    pub cum_quote: String,
    pub time_in_force: String,
    #[serde(rename = "type")]
    pub order_type: String,
    pub side: String,
    pub position_side: String,
    pub stop_price: String,
    pub update_time: i64,
    pub working_type: String,
    pub price_protect: bool,
    pub orig_type: String,
    #[serde(default)]
    pub success: Option<bool>,
    #[serde(default)]
    pub error: Option<String>,
}

#[derive(Debug, Serialize, Deserialize)]
struct MarketData {
    #[serde(rename = "bidPrice")]
    bid_price: String,
    #[serde(rename = "askPrice")]
    ask_price: String,
}

fn generate_signature(query: &str, secret_key: &str) -> Result<String, BinanceError> {
    let mut mac = HmacSha256::new_from_slice(secret_key.as_bytes())
        .map_err(|_| BinanceError::SigningError)?;
    mac.update(query.as_bytes());
    Ok(hex::encode(mac.finalize().into_bytes()))
}

fn get_market_data() -> Result<(f64, f64), BinanceError> {
    let url = "https://fapi.binance.com/fapi/v1/ticker/bookTicker?symbol=BTCUSDT";
    let response = CLIENT.get(url).send().map_err(BinanceError::ReqwestError)?;
    let data: MarketData = response.json().map_err(BinanceError::ReqwestError)?;
    let bid = data
        .bid_price
        .parse::<f64>()
        .map_err(|_| BinanceError::ApiError("Invalid bid price".to_string()))?;
    let ask = data
        .ask_price
        .parse::<f64>()
        .map_err(|_| BinanceError::ApiError("Invalid ask price".to_string()))?;
    Ok((bid, ask))
}

fn truncate_f64(value: f64, precision: usize) -> f64 {
    let factor = 10f64.powi(precision as i32);
    (value * factor).floor() / factor
}

/// 新的稳定判断逻辑 + 激进挂单价
pub fn place_order(
    api_key: &str,
    secret_key: &str,
    direction: &str,
    quantity: Option<f64>,
    key_group: Option<usize>,
) -> Result<OrderResponse, BinanceError> {
    let quantity = quantity.unwrap_or(DEFAULT_QUANTITY);
    let side = match direction.to_uppercase().as_str() {
        "B" | "BUY" => "BUY",
        "S" | "SELL" => "SELL",
        _ => return Err(BinanceError::ClapError("无效的交易方向".to_string())),
    };

    // 死循环等待市场价格稳定
    let (final_price, _bid, _ask) = loop {
        let (bid1, ask1) = get_market_data()?;
        std::thread::sleep(std::time::Duration::from_secs(1));
        let (bid2, ask2) = get_market_data()?;

        let stable = match side {
            "BUY" => (ask2 - ask1).abs() < STABLE_THRESHOLD,
            "SELL" => (bid2 - bid1).abs() < STABLE_THRESHOLD,
            _ => false,
        };

        if stable {
            let price = match side {
                "BUY" => truncate_f64(bid2, 1),  // 激进挂 bid
                "SELL" => truncate_f64(ask2, 1), // 激进挂 ask
                _ => unreachable!(),
            };
            break (price, bid2, ask2);
        }

        std::thread::sleep(std::time::Duration::from_millis(SLEEP_MS));
    };

    let query = format!(
        "symbol=BTCUSDT&side={}&type=LIMIT&timeInForce=GTC&quantity={}&price={}&timestamp={}",
        side,
        quantity,
        final_price,
        now_timestamp_millis()
    );

    let signature = generate_signature(&query, secret_key)?;
    let url = format!(
        "https://fapi.binance.com/fapi/v1/order?{}&signature={}",
        query, signature
    );

    let response = CLIENT
        .post(&url)
        .header("X-MBX-APIKEY", api_key)
        .send()
        .map_err(BinanceError::ReqwestError)?;

    let raw_response = response.text().map_err(BinanceError::ReqwestError)?;

    match serde_json::from_str::<OrderResponse>(&raw_response) {
        Ok(order) => {
            if let Some(err_msg) = order.error {
                return Err(BinanceError::ApiError(err_msg));
            }

            if let Some(group) = key_group {
                let field = format!("place_orderId{}", group);
                let _ = RedisUtil::set_hash_string("trade", &field, &order.order_id.to_string());
            }

            Ok(order)
        }
        Err(e) => Err(BinanceError::ApiError(format!("无效的订单响应格式: {}", e))),
    }
}

use crate::modules::client::CLIENT;
use crate::utils::redis::RedisUtil;
use crate::{error::BinanceError, utils::time::now_timestamp_millis};

const DEFAULT_QUANTITY: f64 = 0.002;
const STABLE_THRESHOLD: f64 = 0.1;
const SLEEP_MS: u64 = 500;

fn get_market_data() -> Result<(f64, f64), BinanceError>

fn generate_signature(query: &str, secret_key: &str) -> Result<String, BinanceError>

fn truncate_f64(value: f64, precision: usize) -> f64

pub fn place_order(...)