package com.xcong.excoin.modules.okxApi;

import com.xcong.excoin.modules.okxApi.enums.OkxEnums;
import lombok.extern.slf4j.Slf4j;
import org.java_websocket.client.WebSocketClient;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

@Slf4j
public class OkxGridTradeService {

    public enum StrategyState {
        WAITING_KLINE, OPENING, ACTIVE, STOPPED
    }

    private final String accountName;
    private final OkxConfig config;
    private final OkxTradeExecutor executor;

    private volatile StrategyState state = StrategyState.WAITING_KLINE;

    private final List<BigDecimal> shortPriceQueue = Collections.synchronizedList(new ArrayList<>());
    private final List<BigDecimal> longPriceQueue = Collections.synchronizedList(new ArrayList<>());

    private BigDecimal shortBaseEntryPrice;
    private BigDecimal longBaseEntryPrice;
    private volatile boolean baseLongOpened = false;
    private volatile boolean baseShortOpened = false;
    private volatile boolean shortActive = false;
    private volatile boolean longActive = false;

    private volatile BigDecimal lastKlinePrice;
    private volatile BigDecimal cumulativePnl = BigDecimal.ZERO;
    private volatile BigDecimal unrealizedPnl = BigDecimal.ZERO;
    private volatile BigDecimal longEntryPrice = BigDecimal.ZERO;
    private volatile BigDecimal shortEntryPrice = BigDecimal.ZERO;
    private volatile BigDecimal longPositionSize = BigDecimal.ZERO;
    private volatile BigDecimal shortPositionSize = BigDecimal.ZERO;

    public OkxGridTradeService(OkxConfig config, String accountName) {
        this.config = config;
        this.accountName = accountName;
        this.executor = new OkxTradeExecutor(config.getContract(), config.getMarginMode(), accountName);
    }

    public void setWebSocketClient(WebSocketClient wsClient) {
        this.executor.setWebSocketClient(wsClient);
    }

    public void startGrid() {
        if (state != StrategyState.WAITING_KLINE && state != StrategyState.STOPPED) {
            log.warn("[{}] 策略已在运行中, state:{}", config.getContract(), state);
            return;
        }
        state = StrategyState.WAITING_KLINE;
        cumulativePnl = BigDecimal.ZERO;
        unrealizedPnl = BigDecimal.ZERO;
        longEntryPrice = BigDecimal.ZERO;
        shortEntryPrice = BigDecimal.ZERO;
        longPositionSize = BigDecimal.ZERO;
        shortPositionSize = BigDecimal.ZERO;
        baseLongOpened = false;
        baseShortOpened = false;
        longActive = false;
        shortActive = false;
        shortPriceQueue.clear();
        longPriceQueue.clear();
        log.info("[{}] 网格策略已启动", config.getContract());
    }

    public void stopGrid() {
        state = StrategyState.STOPPED;
        executor.cancelAllPriceTriggeredOrders();
        executor.shutdown();
        log.info("[{}] 策略已停止, 累计盈亏: {}", config.getContract(), cumulativePnl);
    }

    public void onKline(BigDecimal closePrice) {
        lastKlinePrice = closePrice;
        updateUnrealizedPnl();
        if (state == StrategyState.STOPPED) {
            return;
        }

        if (state == StrategyState.WAITING_KLINE) {
            state = StrategyState.OPENING;
            log.info("[{}] 首根K线到达，开基底仓位...", config.getContract());
            executor.openLong(config.getQuantity(), () -> {
                log.info("[{}] 基底多单已提交", config.getContract());
            }, null);
            executor.openShort(config.getQuantity(), () -> {
                log.info("[{}] 基底空单已提交", config.getContract());
            }, null);
            return;
        }

        if (state != StrategyState.ACTIVE) {
            return;
        }
        processShortGrid(closePrice);
        processLongGrid(closePrice);
    }

    public void onPositionUpdate(String posSide, BigDecimal size, BigDecimal entryPrice) {
        if (state == StrategyState.STOPPED || state == StrategyState.WAITING_KLINE) {
            return;
        }

        boolean hasPosition = size.compareTo(BigDecimal.ZERO) > 0;

        if (OkxEnums.POSSIDE_LONG.equals(posSide)) {
            if (hasPosition) {
                longActive = true;
                longEntryPrice = entryPrice;
                if (!baseLongOpened) {
                    longPositionSize = size;
                    longBaseEntryPrice = entryPrice;
                    baseLongOpened = true;
                    log.info("[{}] 基底多成交价: {}", config.getContract(), longBaseEntryPrice);
                    tryGenerateQueues();
                } else if (size.compareTo(longPositionSize) > 0) {
                    longPositionSize = size;
                    if (longPriceQueue.isEmpty()) {
                        log.warn("[{}] 多仓队列为空，无法设止盈", config.getContract());
                    } else {
                        BigDecimal tpPrice = longPriceQueue.get(0);
                        executor.placeTakeProfit(tpPrice, OkxEnums.ORDER_TYPE_CLOSE_LONG, config.getQuantity());
                        log.info("[{}] 多单止盈已设, entry:{}, tp:{}, size:{}", config.getContract(), entryPrice, tpPrice, config.getQuantity());
                    }
                } else {
                    longPositionSize = size;
                }
            } else {
                longActive = false;
                longPositionSize = BigDecimal.ZERO;
            }
        } else if (OkxEnums.POSSIDE_SHORT.equals(posSide)) {
            if (hasPosition) {
                shortActive = true;
                shortEntryPrice = entryPrice;
                if (!baseShortOpened) {
                    shortPositionSize = size;
                    shortBaseEntryPrice = entryPrice;
                    baseShortOpened = true;
                    log.info("[{}] 基底空成交价: {}", config.getContract(), shortBaseEntryPrice);
                    tryGenerateQueues();
                } else if (size.compareTo(shortPositionSize) > 0) {
                    shortPositionSize = size;
                    if (shortPriceQueue.isEmpty()) {
                        log.warn("[{}] 空仓队列为空，无法设止盈", config.getContract());
                    } else {
                        BigDecimal tpPrice = shortPriceQueue.get(0);
                        executor.placeTakeProfit(tpPrice, OkxEnums.ORDER_TYPE_CLOSE_SHORT, config.getQuantity());
                        log.info("[{}] 空单止盈已设, entry:{}, tp:{}, size:{}", config.getContract(), entryPrice, tpPrice, config.getQuantity());
                    }
                } else {
                    shortPositionSize = size;
                }
            } else {
                shortActive = false;
                shortPositionSize = BigDecimal.ZERO;
            }
        }
    }

    public void onOrderFilled(String posSide, BigDecimal fillSz, BigDecimal pnl) {
        if (state == StrategyState.STOPPED) {
            return;
        }
        cumulativePnl = cumulativePnl.add(pnl);
        log.info("[{}] 订单成交盈亏: {}, 方向:{}, 累计:{}", config.getContract(), pnl, posSide, cumulativePnl);

        if (cumulativePnl.compareTo(config.getOverallTp()) >= 0) {
            log.info("[{}] 已达止盈目标 {}→已停止", config.getContract(), cumulativePnl);
            state = StrategyState.STOPPED;
        } else if (cumulativePnl.compareTo(config.getMaxLoss().negate()) <= 0) {
            log.info("[{}] 已达亏损上限 {}→已停止", config.getContract(), cumulativePnl);
            state = StrategyState.STOPPED;
        }
    }

    private void tryGenerateQueues() {
        if (baseLongOpened && baseShortOpened) {
            generateShortQueue();
            generateLongQueue();
            state = StrategyState.ACTIVE;
            log.info("[{}] 网格队列已生成, 空队首:{} → 尾:{}, 多队首:{} → 尾:{}, 已激活",
                    config.getContract(),
                    shortPriceQueue.isEmpty() ? "N/A" : shortPriceQueue.get(0),
                    shortPriceQueue.isEmpty() ? "N/A" : shortPriceQueue.get(shortPriceQueue.size() - 1),
                    longPriceQueue.isEmpty() ? "N/A" : longPriceQueue.get(0),
                    longPriceQueue.isEmpty() ? "N/A" : longPriceQueue.get(longPriceQueue.size() - 1));
        }
    }

    private void generateShortQueue() {
        shortPriceQueue.clear();
        BigDecimal fixedStep = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        BigDecimal prev = shortBaseEntryPrice;
        for (int i = 0; i < config.getGridQueueSize(); i++) {
            prev = prev.subtract(fixedStep).setScale(1, RoundingMode.HALF_UP);
            shortPriceQueue.add(prev);
        }
        shortPriceQueue.sort((a, b) -> b.compareTo(a));
        log.info("[{}] 空队列:{} 步长:{}", config.getContract(), shortPriceQueue, fixedStep);
    }

    private void generateLongQueue() {
        longPriceQueue.clear();
        BigDecimal fixedStep = longBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        BigDecimal prev = longBaseEntryPrice;
        for (int i = 0; i < config.getGridQueueSize(); i++) {
            prev = prev.add(fixedStep).setScale(1, RoundingMode.HALF_UP);
            longPriceQueue.add(prev);
        }
        Collections.sort(longPriceQueue);
        log.info("[{}] 多队列:{} 步长:{}", config.getContract(), longPriceQueue, fixedStep);
    }

    /**
     * 空仓网格处理（价格跌破空仓队列中的高价）。
     *
     * <h3>匹配规则</h3>
     * 遍历空仓队列（降序），收集所有大于当前价的元素为 matched。
     * 队列为降序排列，一旦遇 price ≤ currentPrice 即停止遍历。
     *
     * <h3>执行流程</h3>
     * <ol>
     *   <li>匹配队列元素 → 为空则直接返回</li>
     *   <li>空仓队列：移除 matched 元素，尾部以固定步长(shortBasePrice × gridRate)递减补充新元素</li>
     *   <li>多仓队列：以多仓队列首元素（最小价）为种子，以多仓固定步长递减加入新元素</li>
     *   <li>保证金检查 → 安全则开空一次</li>
     *   <li>额外反向开多：若多仓均价 > 空仓均价 且 当前价夹在中间且远离多仓均价</li>
     * </ol>
     *
     * <h3>多仓队列转移过滤</h3>
     * 新增元素若与多仓持仓均价差距小于 gridRate，则跳过该元素（避免在持仓成本附近生成无效网格线）。
     */
    private void processShortGrid(BigDecimal currentPrice) {
        List<BigDecimal> matched = new ArrayList<>();
        synchronized (shortPriceQueue) {
            for (BigDecimal p : shortPriceQueue) {
                if (p.compareTo(currentPrice) > 0) {
                    matched.add(p);
                } else {
                    break;
                }
            }
        }
        log.info("[{}] 原空队列:{}", config.getContract(), shortPriceQueue);
        if (matched.isEmpty()) {
            log.info("[{}] 空仓队列未触发, 当前价:{}", config.getContract(), currentPrice);
            return;
        }
        log.info("[{}] 空仓队列触发, 匹配{}个元素, 当前价:{}", config.getContract(), matched.size(), currentPrice);

        BigDecimal shortFixedStep = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        BigDecimal longFixedStep = longBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        replenishOwnQueue(shortPriceQueue, matched, shortFixedStep, true, "空");

        transferBetweenQueues(longPriceQueue, matched, matched.get(matched.size() - 1),
                longFixedStep, false, longEntryPrice, BigDecimal::compareTo, "多", currentPrice);

        if (!isMarginSafe()) {
            log.warn("[{}] 保证金超限，跳过空单开仓", config.getContract());
        } else {
            executor.openShort(config.getQuantity(), null, null);
            if (shortEntryPrice.compareTo(BigDecimal.ZERO) > 0
                    && longEntryPrice.compareTo(BigDecimal.ZERO) > 0
                    && longEntryPrice.compareTo(shortEntryPrice) > 0
                    && currentPrice.compareTo(shortEntryPrice) > 0
                    && currentPrice.compareTo(longEntryPrice.subtract(longFixedStep)) < 0) {
                executor.openLong(config.getQuantity(), null, null);
                log.info("[{}] 触发价在多/空持仓价之间且多>空且远离多仓均价, 额外开多一次, 当前价:{}", config.getContract(), currentPrice);
            }
        }
    }

    /**
     * 多仓网格处理（价格涨破多仓队列中的低价）。
     *
     * <h3>匹配规则</h3>
     * 遍历多仓队列（升序），收集所有小于当前价的元素为 matched。
     * 队列为升序排列，一旦遇 price ≥ currentPrice 即停止遍历。
     *
     * <h3>执行流程</h3>
     * <ol>
     *   <li>匹配队列元素 → 为空则直接返回</li>
     *   <li>多仓队列：移除 matched 元素，尾部以固定步长(longBasePrice × gridRate)递增补充新元素</li>
     *   <li>空仓队列：以空仓队列首元素（最高价）为种子，以空仓固定步长递增加入新元素</li>
     *   <li>保证金检查 → 安全则开多一次</li>
     *   <li>额外反向开空：若多仓均价 > 空仓均价 且 当前价夹在中间且远离空仓均价</li>
     * </ol>
     *
     * <h3>空仓队列转移过滤</h3>
     * 新增元素若与空仓持仓均价差距小于 gridRate，则跳过该元素（避免在持仓成本附近生成无效网格线）。
     */
    private void processLongGrid(BigDecimal currentPrice) {
        List<BigDecimal> matched = new ArrayList<>();
        synchronized (longPriceQueue) {
            for (BigDecimal p : longPriceQueue) {
                if (p.compareTo(currentPrice) < 0) {
                    matched.add(p);
                } else {
                    break;
                }
            }
        }
        log.info("[{}] 原多队列:{}", config.getContract(), longPriceQueue);
        if (matched.isEmpty()) {
            log.info("[{}] 多仓队列未触发, 当前价:{}", config.getContract(), currentPrice);
            return;
        }
        log.info("[{}] 多仓队列触发, 匹配{}个元素, 当前价:{}", config.getContract(), matched.size(), currentPrice);

        BigDecimal longFixedStep = longBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        BigDecimal shortFixedStep = shortBaseEntryPrice.multiply(config.getGridRate()).setScale(1, RoundingMode.HALF_UP);
        replenishOwnQueue(longPriceQueue, matched, longFixedStep, false, "多");

        transferBetweenQueues(shortPriceQueue, matched, matched.get(0),
                shortFixedStep, true, shortEntryPrice, (a, b) -> b.compareTo(a), "空", currentPrice);

        if (!isMarginSafe()) {
            log.warn("[{}] 保证金超限，跳过多单开仓", config.getContract());
        } else {
            executor.openLong(config.getQuantity(), null, null);
            if (shortEntryPrice.compareTo(BigDecimal.ZERO) > 0
                    && longEntryPrice.compareTo(BigDecimal.ZERO) > 0
                    && longEntryPrice.compareTo(shortEntryPrice) > 0
                    && currentPrice.compareTo(shortEntryPrice.add(shortFixedStep)) > 0
                    && currentPrice.compareTo(longEntryPrice) < 0) {
                executor.openShort(config.getQuantity(), null, null);
                log.info("[{}] 触发价在多/空持仓价之间且多>空且远离空仓均价, 额外开空一次, 当前价:{}", config.getContract(), currentPrice);
            }
        }
    }

    private void replenishOwnQueue(List<BigDecimal> queue, List<BigDecimal> matched, BigDecimal fixedStep,
                                    boolean isShort, String label) {
        synchronized (queue) {
            queue.removeAll(matched);
            BigDecimal tail = queue.isEmpty() ? matched.get(matched.size() - 1) : queue.get(queue.size() - 1);
            Comparator<BigDecimal> comparator = isShort ? (a, b) -> b.compareTo(a) : BigDecimal::compareTo;
            for (int i = 0; i < matched.size(); i++) {
                tail = isShort
                        ? tail.subtract(fixedStep).setScale(1, RoundingMode.HALF_UP)
                        : tail.add(fixedStep).setScale(1, RoundingMode.HALF_UP);
                queue.add(tail);
                log.info("[{}] {}队列增加:{}", config.getContract(), label, tail);
            }
            queue.sort(comparator);
            log.info("[{}] 现{}队列:{}", config.getContract(), label, queue);
        }
    }

    private void transferBetweenQueues(List<BigDecimal> targetQueue, List<BigDecimal> matched,
                                        BigDecimal firstFallback, BigDecimal fixedStep, boolean isShort,
                                        BigDecimal filterEntryPrice, Comparator<BigDecimal> comparator,
                                        String label, BigDecimal currentPrice) {
        synchronized (targetQueue) {
            BigDecimal first = targetQueue.isEmpty() ? firstFallback : targetQueue.get(0);
            for (int i = 1; i <= matched.size(); i++) {
                BigDecimal offset = fixedStep.multiply(BigDecimal.valueOf(i));
                BigDecimal elem = isShort
                        ? first.add(offset).setScale(1, RoundingMode.HALF_UP)
                        : first.subtract(offset).setScale(1, RoundingMode.HALF_UP);
                if (filterEntryPrice.compareTo(BigDecimal.ZERO) > 0
                        && currentPrice.subtract(filterEntryPrice).abs().compareTo(filterEntryPrice.multiply(config.getGridRate())) < 0) {
                    log.info("[{}] {}队列跳过(price≈entry):{}", config.getContract(), label, elem);
                    continue;
                }
                targetQueue.add(elem);
                log.info("[{}] {}队列增加:{}", config.getContract(), label, elem);
            }
            targetQueue.sort(comparator);
            while (targetQueue.size() > config.getGridQueueSize()) {
                targetQueue.remove(targetQueue.size() - 1);
            }
            log.info("[{}] 现{}队列:{}", config.getContract(), label, targetQueue);
        }
    }

    private boolean isMarginSafe() {
        return true;
    }

    private void updateUnrealizedPnl() {
        BigDecimal price = lastKlinePrice;
        if (price == null || price.compareTo(BigDecimal.ZERO) == 0) {
            return;
        }
        BigDecimal multiplier = config.getContractMultiplier();
        BigDecimal longPnl = BigDecimal.ZERO;
        BigDecimal shortPnl = BigDecimal.ZERO;
        if (longPositionSize.compareTo(BigDecimal.ZERO) > 0 && longEntryPrice.compareTo(BigDecimal.ZERO) > 0) {
            longPnl = longPositionSize.multiply(multiplier).multiply(price.subtract(longEntryPrice));
        }
        if (shortPositionSize.compareTo(BigDecimal.ZERO) > 0 && shortEntryPrice.compareTo(BigDecimal.ZERO) > 0) {
            shortPnl = shortPositionSize.multiply(multiplier).multiply(shortEntryPrice.subtract(price));
        }
        unrealizedPnl = longPnl.add(shortPnl);
        log.info("[{}] 未实现盈亏: {}", config.getContract(), unrealizedPnl);
    }

    public BigDecimal getLastKlinePrice() { return lastKlinePrice; }
    public boolean isStrategyActive() { return state != StrategyState.STOPPED && state != StrategyState.WAITING_KLINE; }
    public BigDecimal getCumulativePnl() { return cumulativePnl; }
    public BigDecimal getUnrealizedPnl() { return unrealizedPnl; }
    public StrategyState getState() { return state; }
    public String getAccountName() { return accountName; }
}