exchange.git - Gitblit

package com.xcong.excoin.modules.gateApi;
 
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
 
/**
 * 网格元素，表示网格交易策略中的一个价格层级。
 *
 * <p>每个网格层级包含该价格位置上的多仓和空仓挂单信息，
 * 通过编号和网格价格唯一标识一个网格层级。
 *
 * <h3>关键字段</h3>
 * <ul>
 *   <li><b>编号</b>：网格层级的唯一标识</li>
 *   <li><b>网格价格</b>：该层级对应的触发价格</li>
 *   <li><b>多仓挂单</b>：是否已有多头挂单、多头挂单参数</li>
 *   <li><b>空仓挂单</b>：是否有空头挂单、空头挂单参数</li>
 * </ul>
 *
 * <h3>使用示例</h3>
 * <pre>
 *   GridElement element = GridElement.builder()
 *       .id(1)
 *       .gridPrice(new BigDecimal("2300.0"))
 *       .build();
 *
 *   // 挂多仓单
 *   TraderParam longParam = TraderParam.builder()
 *       .direction(TraderParam.Direction.LONG)
 *       .entryPrice(new BigDecimal("2293.7"))
 *       .takeProfitPrice(new BigDecimal("2301.6"))
 *       .build();
 *   element.setHasLongOrder(true);
 *   element.setLongTraderParam(longParam);
 * </pre>
 *
 * @author Administrator
 */
public class GridElement {
 
    /** 网格层级编号 */
    private int id;
    /** 网格触发价格 */
    private BigDecimal gridPrice;
    /** 是否存在多仓挂单 */
    private boolean hasLongOrder;
    /** 是否存在空仓挂单 */
    private boolean hasShortOrder;
    /** 多仓挂单参数 */
    private TraderParam longTraderParam;
    /** 空仓挂单参数 */
    private TraderParam shortTraderParam;
    /** 上一个网格编号，null 表示无上一级 */
    private Integer upId;
    /** 下一个网格编号，null 表示无下一级 */
    private Integer downId;
    /** 多仓挂单订单 ID */
    private String longOrderId;
    /** 空仓挂单订单 ID */
    private String shortOrderId;
    /** 多仓止盈订单 ID */
    private String longTakeProfitOrderId;
    /** 空仓止盈订单 ID */
    private String shortTakeProfitOrderId;
 
    /** 全局 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
    private static final Map<Integer, GridElement> INDEX = new ConcurrentHashMap<>();
    /** 全局价格索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
    private static final Map<BigDecimal, GridElement> PRICE_INDEX = new ConcurrentHashMap<>();
    /** 全局多仓订单 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
    private static final Map<String, GridElement> LONG_ORDER_ID_INDEX = new ConcurrentHashMap<>();
    /** 全局空仓订单 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
    private static final Map<String, GridElement> SHORT_ORDER_ID_INDEX = new ConcurrentHashMap<>();
    /** 全局多仓止盈订单 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
    private static final Map<String, GridElement> LONG_TP_ORDER_ID_INDEX = new ConcurrentHashMap<>();
    /** 全局空仓止盈订单 ID 索引，由 {@link GateConfig#setGridElements(List)} 触发重建，O(1) 查找 */
    private static final Map<String, GridElement> SHORT_TP_ORDER_ID_INDEX = new ConcurrentHashMap<>();
 
    /**
     * 根据 ID 快速查找网格元素（O(1)）。
     *
     * @param id 网格层级编号
     * @return 对应的 GridElement，不存在则返回 null
     */
    public static GridElement findById(int id) {
        return INDEX.get(id);
    }
 
    /**
     * 根据价格快速查找网格元素（O(1)）。
     *
     * @param price 网格价格
     * @return 对应的 GridElement，不存在则返回 null
     */
    public static GridElement findByPrice(BigDecimal price) {
        return PRICE_INDEX.get(price);
    }
 
    /**
     * 根据多仓挂单订单 ID 快速查找网格元素（O(1)）。
     *
     * @param orderId 多仓挂单订单 ID
     * @return 对应的 GridElement，不存在则返回 null
     */
    public static GridElement findByLongOrderId(String orderId) {
        return LONG_ORDER_ID_INDEX.get(orderId);
    }
 
    /**
     * 根据空仓挂单订单 ID 快速查找网格元素（O(1)）。
     *
     * @param orderId 空仓挂单订单 ID
     * @return 对应的 GridElement，不存在则返回 null
     */
    public static GridElement findByShortOrderId(String orderId) {
        return SHORT_ORDER_ID_INDEX.get(orderId);
    }
 
    /**
     * 根据多仓止盈订单 ID 快速查找网格元素（O(1)）。
     *
     * @param orderId 多仓止盈订单 ID
     * @return 对应的 GridElement，不存在则返回 null
     */
    public static GridElement findByLongTakeProfitOrderId(String orderId) {
        return LONG_TP_ORDER_ID_INDEX.get(orderId);
    }
 
    /**
     * 根据空仓止盈订单 ID 快速查找网格元素（O(1)）。
     *
     * @param orderId 空仓止盈订单 ID
     * @return 对应的 GridElement，不存在则返回 null
     */
    public static GridElement findByShortTakeProfitOrderId(String orderId) {
        return SHORT_TP_ORDER_ID_INDEX.get(orderId);
    }
 
    /**
     * 从列表中重建全局 ID 索引和价格索引。
     * 由 {@link GateConfig#setGridElements(List)} 在每次列表变更后调用。
     */
    public static void rebuildIndex(List<GridElement> elements) {
        INDEX.clear();
        PRICE_INDEX.clear();
        LONG_ORDER_ID_INDEX.clear();
        SHORT_ORDER_ID_INDEX.clear();
        LONG_TP_ORDER_ID_INDEX.clear();
        SHORT_TP_ORDER_ID_INDEX.clear();
        for (GridElement e : elements) {
            INDEX.put(e.getId(), e);
            putDynamicIndices(e);
        }
        logAll();
    }
 
    /**
     * 刷新动态索引（价格索引、多仓/空仓订单 ID 索引）。
     * 在对 GridElement 的 {@link #longOrderId}、{@link #shortOrderId}、
     * {@link #longTraderParam}、{@link #shortTraderParam} 等字段修改后调用，
     * 使快速查找方法获取到最新数据。
     */
    public static void refreshIndices() {
        PRICE_INDEX.clear();
        LONG_ORDER_ID_INDEX.clear();
        SHORT_ORDER_ID_INDEX.clear();
        LONG_TP_ORDER_ID_INDEX.clear();
        SHORT_TP_ORDER_ID_INDEX.clear();
        for (GridElement e : INDEX.values()) {
            putDynamicIndices(e);
        }
        logAll();
    }
 
    /**
     * 打印全部网格数据到日志。
     */
    public static void logAll() {
        List<GridElement> sorted = new ArrayList<>(INDEX.values());
        sorted.sort((a, b) -> Integer.compare(a.getId(), b.getId()));
        StringBuilder sb = new StringBuilder("\n========== 网格数据 ==========\n");
        for (GridElement e : sorted) {
            if (e.isHasLongOrder() || e.isHasShortOrder()){
                sb.append(String.format(
                        "  ID=%4d  价格=%s  up=%s  down=%s  多仓=%s(%s)  空仓=%s(%s)  多止盈=%s  空止盈=%s\n",
                        e.getId(),
                        e.getGridPrice(),
                        e.getUpId(),
                        e.getDownId(),
                        e.isHasLongOrder() ? "有" : "无",
                        e.getLongOrderId() != null ? e.getLongOrderId() : "-",
                        e.isHasShortOrder() ? "有" : "无",
                        e.getShortOrderId() != null ? e.getShortOrderId() : "-",
                        e.getLongTakeProfitOrderId() != null ? e.getLongTakeProfitOrderId() : "-",
                        e.getShortTakeProfitOrderId() != null ? e.getShortTakeProfitOrderId() : "-"
                ));
            }
        }
        sb.append(String.format(
                "------------------------------------------------------------\n" +
                "  索引统计: ID=%d  价格=%d  多仓订单ID=%d  空仓订单ID=%d  多止盈ID=%d  空止盈ID=%d\n",
                INDEX.size(),
                PRICE_INDEX.size(),
                LONG_ORDER_ID_INDEX.size(),
                SHORT_ORDER_ID_INDEX.size(),
                LONG_TP_ORDER_ID_INDEX.size(),
                SHORT_TP_ORDER_ID_INDEX.size()
        ));
        sb.append(String.format("  多仓订单ID索引: %s\n", LONG_ORDER_ID_INDEX.keySet()));
        sb.append(String.format("  空仓订单ID索引: %s\n", SHORT_ORDER_ID_INDEX.keySet()));
        sb.append(String.format("  多止盈ID索引: %s\n", LONG_TP_ORDER_ID_INDEX.keySet()));
        sb.append(String.format("  空止盈ID索引: %s\n", SHORT_TP_ORDER_ID_INDEX.keySet()));
        sb.append("================================\n");
        System.out.println(sb);
    }
 
    /**
     * 获取所有已挂多仓条件单的网格元素。
     *      小于空仓仓位线的多单
     *
     * @return 已挂多仓条件单的 GridElement 列表
     */
    public static List<GridElement> findAllLongOrders(BigDecimal currentPrice) {
        List<GridElement> result = new ArrayList<>();
        for (GridElement e : INDEX.values()) {
            if (e.isHasLongOrder() && e.getGridPrice().compareTo(currentPrice) < 0) {
                result.add(e);
            }
        }
        return result;
    }
 
    /**
     * 获取所有已挂空仓条件单的网格元素。
     *      大于多仓仓位线的空单
     *
     * @return 已挂空仓条件单的 GridElement 列表
     */
    public static List<GridElement> findAllShortOrders(BigDecimal currentPrice) {
        List<GridElement> result = new ArrayList<>();
        for (GridElement e : INDEX.values()) {
            if (e.isHasShortOrder() && e.getGridPrice().compareTo(currentPrice) < 0) {
                result.add(e);
            }
        }
        return result;
    }
 
    private static void putDynamicIndices(GridElement e) {
        PRICE_INDEX.put(e.getGridPrice(), e);
        if (e.getLongOrderId() != null) {
            LONG_ORDER_ID_INDEX.put(e.getLongOrderId(), e);
        }
        if (e.getShortOrderId() != null) {
            SHORT_ORDER_ID_INDEX.put(e.getShortOrderId(), e);
        }
        if (e.getLongTakeProfitOrderId() != null) {
            LONG_TP_ORDER_ID_INDEX.put(e.getLongTakeProfitOrderId(), e);
        }
        if (e.getShortTakeProfitOrderId() != null) {
            SHORT_TP_ORDER_ID_INDEX.put(e.getShortTakeProfitOrderId(), e);
        }
    }
 
    /**
     * @return 根据 upId 获取上一个网格元素，无上一级则返回 null
     */
    public GridElement getUp() {
        return upId != null ? INDEX.get(upId) : null;
    }
 
    /**
     * @return 根据 downId 获取下一个网格元素，无下一级则返回 null
     */
    public GridElement getDown() {
        return downId != null ? INDEX.get(downId) : null;
    }
 
    private GridElement(Builder builder) {
        this.id = builder.id;
        this.gridPrice = builder.gridPrice;
        this.hasLongOrder = builder.hasLongOrder;
        this.hasShortOrder = builder.hasShortOrder;
        this.longTraderParam = builder.longTraderParam;
        this.shortTraderParam = builder.shortTraderParam;
        this.upId = builder.upId;
        this.downId = builder.downId;
        this.longOrderId = builder.longOrderId;
        this.shortOrderId = builder.shortOrderId;
        this.longTakeProfitOrderId = builder.longTakeProfitOrderId;
        this.shortTakeProfitOrderId = builder.shortTakeProfitOrderId;
    }
 
    // ==================== 网格层级编号 ====================
 
    /** @return 网格层级编号 */
    public int getId() { return id; }
    /** 设置网格层级编号 */
    public void setId(int id) { this.id = id; }
 
    // ==================== 网格价格 ====================
 
    /** @return 网格触发价格 */
    public BigDecimal getGridPrice() { return gridPrice; }
    /** 设置网格触发价格 */
    public void setGridPrice(BigDecimal gridPrice) { this.gridPrice = gridPrice; }
 
    // ==================== 多仓挂单标记 ====================
 
    /** @return 是否存在多仓挂单 */
    public boolean isHasLongOrder() { return hasLongOrder; }
    /** 标记是否存在多仓挂单 */
    public void setHasLongOrder(boolean hasLongOrder) { this.hasLongOrder = hasLongOrder; }
 
    // ==================== 空仓挂单标记 ====================
 
    /** @return 是否存在空仓挂单 */
    public boolean isHasShortOrder() { return hasShortOrder; }
    /** 标记是否存在空仓挂单 */
    public void setHasShortOrder(boolean hasShortOrder) { this.hasShortOrder = hasShortOrder; }
 
    // ==================== 多仓挂单参数 ====================
 
    /** @return 多仓挂单参数 */
    public TraderParam getLongTraderParam() { return longTraderParam; }
    /** 设置多仓挂单参数 */
    public void setLongTraderParam(TraderParam longTraderParam) { this.longTraderParam = longTraderParam; }
 
    // ==================== 空仓挂单参数 ====================
 
    /** @return 空仓挂单参数 */
    public TraderParam getShortTraderParam() { return shortTraderParam; }
    /** 设置空仓挂单参数 */
    public void setShortTraderParam(TraderParam shortTraderParam) { this.shortTraderParam = shortTraderParam; }
 
    // ==================== 上一个网格编号 ====================
 
    /** @return 上一个网格编号，null 表示无上一级 */
    public Integer getUpId() { return upId; }
    /** 设置上一个网格编号 */
    public void setUpId(Integer upId) { this.upId = upId; }
 
    // ==================== 下一个网格编号 ====================
 
    /** @return 下一个网格编号，null 表示无下一级 */
    public Integer getDownId() { return downId; }
    /** 设置下一个网格编号 */
    public void setDownId(Integer downId) { this.downId = downId; }
 
    // ==================== 多仓挂单订单 ID ====================
 
    /** @return 多仓挂单订单 ID */
    public String getLongOrderId() { return longOrderId; }
    /** 设置多仓挂单订单 ID */
    public void setLongOrderId(String longOrderId) { this.longOrderId = longOrderId; }
 
    // ==================== 空仓挂单订单 ID ====================
 
    /** @return 空仓挂单订单 ID */
    public String getShortOrderId() { return shortOrderId; }
    /** 设置空仓挂单订单 ID */
    public void setShortOrderId(String shortOrderId) { this.shortOrderId = shortOrderId; }
 
    // ==================== 多仓止盈订单 ID ====================
 
    /** @return 多仓止盈订单 ID */
    public String getLongTakeProfitOrderId() { return longTakeProfitOrderId; }
    /** 设置多仓止盈订单 ID */
    public void setLongTakeProfitOrderId(String longTakeProfitOrderId) { this.longTakeProfitOrderId = longTakeProfitOrderId; }
 
    // ==================== 空仓止盈订单 ID ====================
 
    /** @return 空仓止盈订单 ID */
    public String getShortTakeProfitOrderId() { return shortTakeProfitOrderId; }
    /** 设置空仓止盈订单 ID */
    public void setShortTakeProfitOrderId(String shortTakeProfitOrderId) { this.shortTakeProfitOrderId = shortTakeProfitOrderId; }
 
    public static Builder builder() {
        return new Builder();
    }
 
    /**
     * GridElement 的流式构造器。
     *
     * <h3>必填项</h3>
     * {@code id}、{@code gridPrice} 必须设置。
     *
     * <h3>默认值</h3>
     * hasLongOrder/hasShortOrder 默认为 false，upId/downId/TraderParam 默认为 null
     */
    public static class Builder {
        /** 网格层级编号（必填） */
        private int id;
        /** 网格触发价格（必填） */
        private BigDecimal gridPrice;
        /** 是否有多仓挂单，默认 false */
        private boolean hasLongOrder = false;
        /** 是否有空仓挂单，默认 false */
        private boolean hasShortOrder = false;
        /** 多仓挂单参数 */
        private TraderParam longTraderParam;
        /** 空仓挂单参数 */
        private TraderParam shortTraderParam;
        /** 上一个网格编号，默认 null（无上一级） */
        private Integer upId;
        /** 下一个网格编号，默认 null（无下一级） */
        private Integer downId;
        /** 多仓挂单订单 ID */
        private String longOrderId;
        /** 空仓挂单订单 ID */
        private String shortOrderId;
        /** 多仓止盈订单 ID */
        private String longTakeProfitOrderId;
        /** 空仓止盈订单 ID */
        private String shortTakeProfitOrderId;
 
        /** 设置网格层级编号 */
        public Builder id(int id) { this.id = id; return this; }
        /** 设置网格触发价格 */
        public Builder gridPrice(BigDecimal gridPrice) { this.gridPrice = gridPrice; return this; }
        /** 设置是否存在多仓挂单 */
        public Builder hasLongOrder(boolean hasLongOrder) { this.hasLongOrder = hasLongOrder; return this; }
        /** 设置是否存在空仓挂单 */
        public Builder hasShortOrder(boolean hasShortOrder) { this.hasShortOrder = hasShortOrder; return this; }
        /** 设置多仓挂单参数 */
        public Builder longTraderParam(TraderParam longTraderParam) { this.longTraderParam = longTraderParam; return this; }
        /** 设置空仓挂单参数 */
        public Builder shortTraderParam(TraderParam shortTraderParam) { this.shortTraderParam = shortTraderParam; return this; }
        /** 设置上一个网格编号 */
        public Builder upId(Integer upId) { this.upId = upId; return this; }
        /** 设置下一个网格编号 */
        public Builder downId(Integer downId) { this.downId = downId; return this; }
        /** 设置多仓挂单订单 ID */
        public Builder longOrderId(String longOrderId) { this.longOrderId = longOrderId; return this; }
        /** 设置空仓挂单订单 ID */
        public Builder shortOrderId(String shortOrderId) { this.shortOrderId = shortOrderId; return this; }
        /** 设置多仓止盈订单 ID */
        public Builder longTakeProfitOrderId(String longTakeProfitOrderId) { this.longTakeProfitOrderId = longTakeProfitOrderId; return this; }
        /** 设置空仓止盈订单 ID */
        public Builder shortTakeProfitOrderId(String shortTakeProfitOrderId) { this.shortTakeProfitOrderId = shortTakeProfitOrderId; return this; }
 
        public GridElement build() {
            return new GridElement(this);
        }
    }
}