package com.xcong.excoin.modules.okxApi;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Base64;
import java.util.Date;
import java.util.TimeZone;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;

/**
 * OKX REST API 异步执行器，所有下单/撤单操作经此类提交。
 *
 * <h3>设计目的</h3>
 * REST API 调用可能耗时数百毫秒，若在 WebSocket 回调线程中同步执行会阻塞消息处理，
 * 导致心跳超时误判。本类将所有网络 I/O 提交到独立单线程池异步执行。
 *
 * <h3>与 GateTradeExecutor 的主要差异</h3>
 * <ul>
 *   <li>使用 OkHttp 直接调用 OKX REST API，而非 gateapi SDK</li>
 *   <li>签名算法：HMAC-SHA256（Gate 使用 HMAC-SHA512）</li>
 *   <li>认证头：OK-ACCESS-KEY / OK-ACCESS-SIGN / OK-ACCESS-TIMESTAMP / OK-ACCESS-PASSPHRASE</li>
 *   <li>时间戳格式：ISO 8601（如 2023-01-01T00:00:00.000Z）</li>
 *   <li>合约格式：ETH-USDT-SWAP（短横线分隔）</li>
 * </ul>
 *
 * <h3>线程模型</h3>
 * <ul>
 *   <li><b>单线程 + 有界队列（64）</b> — 保证下单顺序，避免并发竞争</li>
 *   <li><b>CallerRunsPolicy</b> — 队列满时由提交线程直接执行，形成自然背压</li>
 *   <li><b>Daemon 线程</b> — 60s 空闲自动回收</li>
 * </ul>
 *
 * <h3>对外接口</h3>
 * <table>
 *   <tr><th>方法</th><th>用途</th></tr>
 *   <tr><td>openLong / openShort</td><td>市价基底开仓</td></tr>
 *   <tr><td>placeConditionalEntryOrder</td><td>挂条件开仓单（价格触发后市价开仓）</td></tr>
 *   <tr><td>placeTakeProfit</td><td>挂止盈条件单</td></tr>
 *   <tr><td>cancelConditionalOrder</td><td>取消单个条件单</td></tr>
 *   <tr><td>cancelAllPriceTriggeredOrders</td><td>取消所有条件单（策略停止时）</td></tr>
 * </table>
 *
 * <h3>容错</h3>
 * <ul>
 *   <li>止盈单创建失败 → 立即 marketClose() 市价平仓</li>
 *   <li>取消订单失败 → 仅 warn 日志（可能已成交/已取消）</li>
 * </ul>
 *
 * @author Administrator
 */
@Slf4j
public class OkxTradeExecutor {

    /** JSON content-type */
    private static final MediaType JSON_MEDIA_TYPE = MediaType.parse("application/json; charset=utf-8");

    /** OKX 配置 */
    private final OkxConfig config;

    /** 合约名称（如 ETH-USDT-SWAP） */
    private final String contract;

    /** OKHttp 客户端 */
    private final OkHttpClient httpClient;

    /** 交易线程池：单线程 + 有界队列 + 背压策略 */
    private final ExecutorService executor;

    /**
     * 构造 OKX 交易执行器。
     *
     * @param config OKX 配置对象（包含 API 密钥、合约、URL 等信息）
     */
    public OkxTradeExecutor(OkxConfig config) {
        this.config = config;
        this.contract = config.getContract();
        this.httpClient = new OkHttpClient.Builder()
                .connectTimeout(10, TimeUnit.SECONDS)
                .readTimeout(10, TimeUnit.SECONDS)
                .writeTimeout(10, TimeUnit.SECONDS)
                .build();
        this.executor = new ThreadPoolExecutor(
                1, 1,
                60L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(64),
                r -> {
                    Thread t = new Thread(r, "okx-trade-worker");
                    t.setDaemon(true);
                    return t;
                },
                new ThreadPoolExecutor.CallerRunsPolicy()
        );
        ((ThreadPoolExecutor) executor).allowCoreThreadTimeOut(true);
    }

    // ==================== 生命周期 ====================

    /**
     * 优雅关闭：等待 10 秒让队列中的任务执行完毕，超时则强制中断。
     * 关闭后的 REST 调用将通过 CallerRunsPolicy 直接在提交线程执行。
     */
    public void shutdown() {
        executor.shutdown();
        try {
            executor.awaitTermination(10, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            executor.shutdownNow();
        }
    }

    /**
     * 提交一个通用任务到交易线程池末尾。
     * 利用单线程池的 FIFO 特性确保任务按提交顺序执行。
     *
     * @param task 待执行的任务
     */
    public void submitTask(Runnable task) {
        executor.execute(task);
    }

    // ==================== 市价开仓 ====================

    /**
     * 异步市价开多。
     *
     * @param quantity  开仓张数（正数，如 "15"）
     * @param onSuccess 成交成功回调，接收 ordId（可为 null）
     * @param onFailure 成交失败回调（可为 null）
     */
    public void openLong(String quantity, Consumer<String> onSuccess, Runnable onFailure) {
        openPosition(quantity, "buy", "开多", onSuccess, onFailure);
    }

    /**
     * 异步市价开空。
     *
     * @param quantity  开仓张数（正数，如 "15"）
     * @param onSuccess 成交成功回调，接收 ordId（可为 null）
     * @param onFailure 成交失败回调（可为 null）
     */
    public void openShort(String quantity, Consumer<String> onSuccess, Runnable onFailure) {
        openPosition(quantity, "sell", "开空", onSuccess, onFailure);
    }

    /**
     * 通用异步市价下单。
     *
     * @param sz        下单张数
     * @param side      交易方向（buy=开多 / sell=开空）
     * @param label     日志标签
     * @param onSuccess 成功回调，接收 ordId
     * @param onFailure 失败回调
     */
    private void openPosition(String sz, String side, String label,
                               Consumer<String> onSuccess, Runnable onFailure) {
        executor.execute(() -> {
            try {
                // long_short_mode 双向持仓下，开仓须指定 posSide
                String posSide = "buy".equals(side) ? "long" : "short";
                JSONObject body = new JSONObject();
                body.put("instId", contract);
                body.put("tdMode", "cross");
                body.put("side", side);
                body.put("posSide", posSide);
                body.put("ordType", "market");
                body.put("sz", sz);

                JSONObject resp = okPost("/api/v5/trade/order", body.toJSONString());
                String code = resp.getString("code");
                if (!"0".equals(code)) {
                    log.error("[TradeExec-OKX] {}失败, code:{}, msg:{}", label, code, resp.getString("msg"));
                    if (onFailure != null) {
                        onFailure.run();
                    }
                    return;
                }
                JSONArray data = resp.getJSONArray("data");
                String ordId = (data != null && !data.isEmpty())
                        ? data.getJSONObject(0).getString("ordId") : null;
                log.info("[TradeExec-OKX] {}成功, sz:{}, ordId:{}", label, sz, ordId);
                if (onSuccess != null) {
                    onSuccess.accept(ordId);
                }
            } catch (Exception e) {
                log.error("[TradeExec-OKX] {}失败", label, e);
                if (onFailure != null) {
                    onFailure.run();
                }
            }
        });
    }

    // ==================== 止盈/止损条件单 ====================

    /**
     * 异步创建止盈条件单（OKX 算法订单 — conditional 类型，tpTriggerPx）。
     *
     * <p>止盈单创建失败时立即调用 {@link #marketClose(String, String)} 市价平仓兜底。
     *
     * @param triggerPrice 触发价格
     * @param orderType    平仓类型："close_long" 平多 / "close_short" 平空
     * @param size         平仓张数（正数，如 "15"）
     * @param onSuccess    成功回调，接收 algoId（可为 null）
     */
    public void placeTakeProfit(BigDecimal triggerPrice,
                                 String orderType,
                                 String size,
                                 Consumer<String> onSuccess) {
        placeConditionalClose(triggerPrice, orderType, size, onSuccess, false);
    }

    /**
     * 异步创建止损条件单（OKX 算法订单 — conditional 类型，slTriggerPx）。
     *
     * <p>止损单创建失败时立即调用 {@link #marketClose(String, String)} 市价平仓兜底。
     *
     * @param triggerPrice 触发价格
     * @param orderType    平仓类型："close_long" 平多 / "close_short" 平空
     * @param size         平仓张数（正数，如 "15"）
     * @param onSuccess    成功回调，接收 algoId（可为 null）
     */
    public void placeStopLoss(BigDecimal triggerPrice,
                               String orderType,
                               String size,
                               Consumer<String> onSuccess) {
        placeConditionalClose(triggerPrice, orderType, size, onSuccess, true);
    }

    /**
     * 通用平仓条件单：isStopLoss=true 用 slTriggerPx/slOrdPx，false 用 tpTriggerPx/tpOrdPx。
     */
    private void placeConditionalClose(BigDecimal triggerPrice,
                                        String orderType,
                                        String size,
                                        Consumer<String> onSuccess,
                                        boolean isStopLoss) {
        executor.execute(() -> {
            String posSide = null;
            try {
                String side;
                if ("close_long".equals(orderType)) {
                    side = "sell";
                    posSide = "long";
                } else if ("close_short".equals(orderType)) {
                    side = "buy";
                    posSide = "short";
                } else {
                    log.error("[TradeExec-OKX] 未知平仓类型: {}", orderType);
                    return;
                }

                String label = isStopLoss ? "止损" : "止盈";
                JSONObject body = new JSONObject();
                body.put("instId", contract);
                body.put("tdMode", "cross");
                body.put("side", side);
                body.put("posSide", posSide);
                body.put("ordType", "conditional");
                body.put("sz", size);
                // 止盈用 tp 系列字段，止损用 sl 系列字段
                if (isStopLoss) {
                    body.put("slTriggerPx", triggerPrice.stripTrailingZeros().toPlainString());
                    body.put("slTriggerPxType", "last");
                    body.put("slOrdPx", "-1");
                } else {
                    body.put("tpTriggerPx", triggerPrice.stripTrailingZeros().toPlainString());
                    body.put("tpTriggerPxType", "last");
                    body.put("tpOrdPx", "-1");
                }

                JSONObject resp = okPost("/api/v5/trade/order-algo", body.toJSONString());
                String code = resp.getString("code");
                if (!"0".equals(code)) {
                    log.error("[TradeExec-OKX] {}单创建失败, code:{}, msg:{}, 立即市价{}",
                            label, code, resp.getString("msg"), label);
                    marketClose(size, posSide);
                    return;
                }
                JSONArray data = resp.getJSONArray("data");
                String algoId = (data != null && !data.isEmpty())
                        ? data.getJSONObject(0).getString("algoId") : null;
                log.info("[TradeExec-OKX] {}单已创建, triggerPx:{}, type:{}, sz:{}, algoId:{}",
                        label, triggerPrice, orderType, size, algoId);
                if (onSuccess != null) {
                    onSuccess.accept(algoId);
                }
            } catch (Exception e) {
                log.error("[TradeExec-OKX] 创建失败, triggerPx:{}, sz:{}, 立即市价{}",
                        triggerPrice, size, e);
                if (posSide != null) {
                    marketClose(size, posSide);
                }
            }
        });
    }

    /**
     * 市价止盈兜底：在止盈条件单创建失败时立即市价平仓。
     *
     * <p>通过 posSide 指定平仓方向：
     * <ul>
     *   <li>posSide=long：平多（side=sell）</li>
     *   <li>posSide=short：平空（side=buy）</li>
     * </ul>
     *
     * @param size    平仓张数（正数）
     * @param posSide 持仓方向（long / short）
     */
    private void marketClose(String size, String posSide) {
        String side = "long".equals(posSide) ? "sell" : "buy";
        marketClose(size, side, posSide);
    }

    /**
     * 对外暴露的市价平仓接口（含回调），供策略层直接调用。
     *
     * @param size      平仓张数（正数）
     * @param posSide   持仓方向（long=平多 / short=平空）
     * @param onSuccess 成功回调（可为 null）
     * @param onFailure 失败回调（可为 null）
     */
    public void marketClosePosition(String size, String posSide,
                                     Runnable onSuccess, Runnable onFailure) {
        executor.execute(() -> {
            String side = "long".equals(posSide) ? "sell" : "buy";
            try {
                JSONObject body = new JSONObject();
                body.put("instId", contract);
                body.put("tdMode", "cross");
                body.put("side", side);
                body.put("posSide", posSide);
                body.put("ordType", "market");
                body.put("sz", size);

                JSONObject resp = okPost("/api/v5/trade/order", body.toJSONString());
                String code = resp.getString("code");
                if (!"0".equals(code)) {
                    log.error("[TradeExec-OKX] 市价平仓失败, side:{}, posSide:{}, sz:{}, code:{}, msg:{}",
                            side, posSide, size, code, resp.getString("msg"));
                    if (onFailure != null) {
                        onFailure.run();
                    }
                    return;
                }
                log.info("[TradeExec-OKX] 市价平仓成功, side:{}, posSide:{}, sz:{}", side, posSide, size);
                if (onSuccess != null) {
                    onSuccess.run();
                }
            } catch (Exception e) {
                log.error("[TradeExec-OKX] 市价平仓失败, side:{}, posSide:{}, sz:{}", side, posSide, size, e);
                if (onFailure != null) {
                    onFailure.run();
                }
            }
        });
    }

    /**
     * 指定方向的市价平仓。
     *
     * @param sz      平仓张数
     * @param side    交易方向（sell=平多 / buy=平空）
     * @param posSide 持仓方向（long / short）
     */
    private void marketClose(String sz, String side, String posSide) {
        try {
            JSONObject body = new JSONObject();
            body.put("instId", contract);
            body.put("tdMode", "cross");
            body.put("side", side);
            body.put("posSide", posSide);
            body.put("ordType", "market");
            body.put("sz", sz);

            JSONObject resp = okPost("/api/v5/trade/order", body.toJSONString());
            String code = resp.getString("code");
            if (!"0".equals(code)) {
                log.warn("[TradeExec-OKX] 市价止盈失败, side:{}, posSide:{}, sz:{}, code:{}, msg:{}",
                        side, posSide, sz, code, resp.getString("msg"));
                return;
            }
            JSONArray data = resp.getJSONArray("data");
            String ordId = (data != null && !data.isEmpty())
                    ? data.getJSONObject(0).getString("ordId") : null;
            log.info("[TradeExec-OKX] 市价止盈成功, side:{}, posSide:{}, sz:{}, ordId:{}",
                    side, posSide, sz, ordId);
        } catch (Exception e) {
            log.error("[TradeExec-OKX] 市价止盈也失败, sz:{}", sz, e);
        }
    }

    // ==================== 条件开仓单 ====================

    /**
     * 异步创建条件开仓单（价格触发后市价开仓）。
     *
     * <p>使用 OKX 的 {@code order-algo} 接口，ordType=trigger（计划委托）。
     * 服务器监控价格，达到触发价后以市价开仓。
     *
     * <h3>与止盈止损的区别</h3>
     * <ul>
     *   <li>开仓 = ordType=trigger，字段 triggerPx + orderPx</li>
     *   <li>止盈 = ordType=conditional，字段 tpTriggerPx + tpOrdPx</li>
     *   <li>止损 = ordType=conditional，字段 slTriggerPx + slOrdPx</li>
     * </ul>
     *
     * @param triggerPrice 触发价格
     * @param isLong       true=开多（side=buy）/ false=开空（side=sell）
     * @param size         开仓张数（正数，如 "1"）
     * @param onSuccess    成功回调，接收 algoId（可为 null）
     * @param onFailure    失败回调（可为 null）
     */
    public void placeConditionalEntryOrder(BigDecimal triggerPrice,
                                            boolean isLong,
                                            String size,
                                            Consumer<String> onSuccess,
                                            Runnable onFailure) {
        executor.execute(() -> {
            try {
                String side = isLong ? "buy" : "sell";
                String posSide = isLong ? "long" : "short";
                // OKX sz 必须为正数，strategy 层传入的负数需转正
                String absSz = size.startsWith("-") ? size.substring(1) : size;

                JSONObject body = new JSONObject();
                body.put("instId", contract);
                body.put("tdMode", "cross");
                body.put("side", side);
                body.put("posSide", posSide);            // 双向持仓模式必须指定
                body.put("ordType", "trigger");          // 计划委托 = 触发后开仓
                body.put("sz", absSz);
                body.put("triggerPx", triggerPrice.stripTrailingZeros().toPlainString());
                body.put("triggerPxType", "last");
                body.put("orderPx", "-1");               // OKX 使用 orderPx，非 ordPx

                JSONObject resp = okPost("/api/v5/trade/order-algo", body.toJSONString());
                String code = resp.getString("code");
                if (!"0".equals(code)) {
                    log.error("[TradeExec-OKX] 条件开仓单创建失败, code:{}, msg:{}",
                            code, resp.getString("msg"));
                    if (onFailure != null) {
                        onFailure.run();
                    }
                    return;
                }
                JSONArray data = resp.getJSONArray("data");
                String algoId = (data != null && !data.isEmpty())
                        ? data.getJSONObject(0).getString("algoId") : null;
                log.info("[TradeExec-OKX] 条件开仓单已创建, triggerPx:{}, isLong:{}, sz:{}, algoId:{}",
                        triggerPrice, isLong, size, algoId);
                if (onSuccess != null) {
                    onSuccess.accept(algoId);
                }
            } catch (Exception e) {
                log.error("[TradeExec-OKX] 条件开仓单创建失败, triggerPx:{}, sz:{}",
                        triggerPrice, size, e);
                if (onFailure != null) {
                    onFailure.run();
                }
            }
        });
    }

    // ==================== 取消订单 ====================

    /**
     * 异步取消单个算法订单（条件单）。
     *
     * @param algoId   算法订单 ID，为 null 时跳过
     * @param onSuccess 成功回调，接收 algoId（可为 null）
     */
    public void cancelConditionalOrder(String algoId, Consumer<String> onSuccess) {
        if (algoId == null) {
            return;
        }
        executor.execute(() -> {
            try {
                JSONArray bodyArr = new JSONArray();
                JSONObject item = new JSONObject();
                item.put("algoId", algoId);
                item.put("instId", contract);
                bodyArr.add(item);

                JSONObject resp = okPost("/api/v5/trade/cancel-algos", bodyArr.toJSONString());
                String code = resp.getString("code");
                if (!"0".equals(code)) {
                    log.warn("[TradeExec-OKX] 取消条件单失败(可能已触发), algoId:{}, code:{}, msg:{}",
                            algoId, code, resp.getString("msg"));
                    return;
                }
                log.info("[TradeExec-OKX] 条件单已取消, algoId:{}", algoId);
                if (onSuccess != null) {
                    onSuccess.accept(algoId);
                }
            } catch (Exception e) {
                log.warn("[TradeExec-OKX] 取消条件单失败(可能已触发), algoId:{}", algoId, e);
            }
        });
    }

    /**
     * 异步清除指定合约的所有算法订单（条件单/止盈止损单）。
     *
     * <p>OKX 的 cancel-algos 接口要求必须传 algoId 或 algoClOrdId，
     * 不能仅凭 instId 批量取消。因此先查询待处理列表，再逐个取消。
     */
    public void cancelAllPriceTriggeredOrders() {
        executor.execute(() -> {
            try {
                // ordType 是 orders-algo-pending 的必填参数，需分别查询 conditional 和 trigger
                JSONArray cancelBody = new JSONArray();
                for (String ordType : new String[]{"conditional", "trigger"}) {
                    String queryPath = "/api/v5/trade/orders-algo-pending?instId=" + contract
                            + "&ordType=" + ordType;
                    try {
                        JSONObject queryResp = okGet(queryPath);
                        if (!"0".equals(queryResp.getString("code"))) {
                            log.warn("[TradeExec-OKX] 查询 pending ordType={} 失败, code:{}, msg:{}",
                                    ordType, queryResp.getString("code"), queryResp.getString("msg"));
                            continue;
                        }
                        JSONArray data = queryResp.getJSONArray("data");
                        if (data != null) {
                            for (int i = 0; i < data.size(); i++) {
                                JSONObject order = data.getJSONObject(i);
                                String algoId = order.getString("algoId");
                                if (algoId == null) {
                                    continue;
                                }
                                JSONObject item = new JSONObject();
                                item.put("algoId", algoId);
                                item.put("instId", contract);
                                cancelBody.add(item);
                            }
                        }
                    } catch (Exception e) {
                        log.warn("[TradeExec-OKX] 查询待处理条件单失败, ordType:{}", ordType, e);
                    }
                }

                if (cancelBody.isEmpty()) {
                    log.info("[TradeExec-OKX] 无待处理条件单");
                    return;
                }

                // 批量取消
                JSONObject cancelResp = okPost("/api/v5/trade/cancel-algos", cancelBody.toJSONString());
                String cancelCode = cancelResp.getString("code");
                if (!"0".equals(cancelCode)) {
                    log.warn("[TradeExec-OKX] 清除条件单部分失败, code:{}, msg:{}",
                            cancelCode, cancelResp.getString("msg"));
                    return;
                }
                log.info("[TradeExec-OKX] 已清除{}个条件单", cancelBody.size());
            } catch (Exception e) {
                log.error("[TradeExec-OKX] 清除条件单失败", e);
            }
        });
    }

    // ==================== HTTP 请求帮助方法 ====================

    /**
     * 发送 OKX 签名 POST 请求并返回解析后的 JSONObject。
     *
     * <p>自动添加 OK-ACCESS-KEY、OK-ACCESS-SIGN、OK-ACCESS-TIMESTAMP、OK-ACCESS-PASSPHRASE
     * 四个认证头。签名算法：base64(HMAC-SHA256(timestamp + method + path + body))。
     *
     * @param path API 路径（如 /api/v5/trade/order）
     * @param body 请求体 JSON 字符串
     * @return 解析后的响应 JSONObject
     * @throws IOException 网络异常或业务错误
     */
    JSONObject okPost(String path, String body) throws IOException {
        String method = "POST";
        String timestamp = getIsoTimestamp();
        String sign = null;
        try {
            sign = sign(timestamp, method, path, body);
        } catch (Exception e) {
            e.printStackTrace();
        }

        Request.Builder builder = new Request.Builder()
                .url(config.getRestBasePath() + path)
                .header("OK-ACCESS-KEY", config.getApiKey())
                .header("OK-ACCESS-SIGN", sign)
                .header("OK-ACCESS-TIMESTAMP", timestamp)
                .header("OK-ACCESS-PASSPHRASE", config.getPassphrase())
                .header("Content-Type", "application/json; charset=utf-8")
                .post(RequestBody.create(JSON_MEDIA_TYPE, body));
        // 模拟盘需加 x-simulated-trading 头，与生产网共用同一 REST 地址
        if (!config.isProduction()) {
            builder.header("x-simulated-trading", "1");
        }
        Request request = builder.build();

        try (Response response = httpClient.newCall(request).execute()) {
            String responseBody = response.body() != null ? response.body().string() : "{}";
            if (!response.isSuccessful()) {
                log.error("[TradeExec-OKX] HTTP {} POST {}: {}", response.code(), path, responseBody);
                throw new IOException("HTTP " + response.code() + ": " + responseBody);
            }
            return JSON.parseObject(responseBody);
        }
    }

    /**
     * 发送 OKX 签名 GET 请求并返回解析后的 JSONObject。
     *
     * <p>GET 请求的签名中 body 为空字符串。
     *
     * @param path API 路径（如 /api/v5/account/positions）
     * @return 解析后的响应 JSONObject
     * @throws IOException 网络异常
     */
    JSONObject okGet(String path) throws IOException {
        String method = "GET";
        String timestamp = getIsoTimestamp();
        String sign = null;
        try {
            sign = sign(timestamp, method, path, "");
        } catch (Exception e) {
            e.printStackTrace();
        }

        Request.Builder builder = new Request.Builder()
                .url(config.getRestBasePath() + path)
                .header("OK-ACCESS-KEY", config.getApiKey())
                .header("OK-ACCESS-SIGN", sign)
                .header("OK-ACCESS-TIMESTAMP", timestamp)
                .header("OK-ACCESS-PASSPHRASE", config.getPassphrase())
                .get();
        // 模拟盘需加 x-simulated-trading 头
        if (!config.isProduction()) {
            builder.header("x-simulated-trading", "1");
        }
        Request request = builder.build();

        try (Response response = httpClient.newCall(request).execute()) {
            String responseBody = response.body() != null ? response.body().string() : "{}";
            if (!response.isSuccessful()) {
                log.error("[TradeExec-OKX] HTTP {} GET {}: {}", response.code(), path, responseBody);
                throw new IOException("HTTP " + response.code() + ": " + responseBody);
            }
            return JSON.parseObject(responseBody);
        }
    }

    // ==================== 签名工具方法 ====================

    /**
     * 生成 OKX API 签名。
     *
     * <p>签名算法：
     * <ol>
     *   <li>拼接签名字符串：{@code timestamp + method + path + body}</li>
     *   <li>使用 apiSecret 对签名字符串做 HMAC-SHA256</li>
     *   <li>Base64 编码</li>
     * </ol>
     *
     * @param timestamp OKX 格式时间戳（ISO 8601）
     * @param method    HTTP 方法（GET/POST）
     * @param path      API 路径（如 /api/v5/trade/order）
     * @param body      请求体（GET 请求传 ""）
     * @return Base64 编码的签名字符串
     * @throws Exception 签名计算异常
     */
    private String sign(String timestamp, String method, String path, String body) throws Exception {
        String signString = timestamp + method + path + body;
        Mac sha256Hmac = Mac.getInstance("HmacSHA256");
        SecretKeySpec secretKey = new SecretKeySpec(config.getApiSecret().getBytes(), "HmacSHA256");
        sha256Hmac.init(secretKey);
        byte[] signedBytes = sha256Hmac.doFinal(signString.getBytes());
        return Base64.getEncoder().encodeToString(signedBytes);
    }

    /**
     * 获取 OKX 格式的 ISO 8601 时间戳。
     *
     * <p>格式示例：{@code 2023-01-01T00:00:00.000Z}
     *
     * @return ISO 8601 格式的 UTC 时间戳字符串
     */
    private String getIsoTimestamp() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
        sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
        return sdf.format(new Date());
    }
}