package com.spot.utils;

import com.spot.dto.mq.PriceMessage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 价格缓存管理器 - 存储各交易对的最新价格
 *
 * @author jean
 * @date 2026-05-07
 */
@Component
@Slf4j
public class PriceCache {

    /**
     * 价格缓存 Map
     * Key: symbol（交易对，如：BTCUSDT）
     * Value: PriceMessage（价格消息，包含价格和时间戳）
     */
    private static final ConcurrentHashMap<String, PriceMessage> PRICE_CACHE = new ConcurrentHashMap<>();

    /**
     * 更新交易对价格
     *
     * @param symbol 交易对
     * @param price  最新价格
     */
    public static void updatePrice(String symbol, BigDecimal price) {
        if (symbol == null || symbol.trim().isEmpty() || price == null) {
            log.warn("无效的价格更新参数 - Symbol: {}, Price: {}", symbol, price);
            return;
        }
        String upperSymbol = symbol.toUpperCase();
        PriceMessage priceMessage = new PriceMessage(upperSymbol, price);
        PRICE_CACHE.put(upperSymbol, priceMessage);
    }

    /**
     * 更新交易对价格（带时间戳）
     *
     * @param priceMessage 价格消息
     */
    public static void updatePrice(PriceMessage priceMessage) {
        if (priceMessage == null || priceMessage.getSymbol() == null || priceMessage.getPrice() == null) {
            log.warn("无效的价格消息 - {}", priceMessage);
            return;
        }
        String upperSymbol = priceMessage.getSymbol().toUpperCase();
        priceMessage.setSymbol(upperSymbol);
        PRICE_CACHE.put(upperSymbol, priceMessage);
    }

    /**
     * 获取交易对的最新价格
     *
     * @param symbol 交易对
     * @return 最新价格，不存在时返回 null
     */
    public static BigDecimal getPrice(String symbol) {
        if (symbol == null || symbol.trim().isEmpty()) {
            return null;
        }
        PriceMessage priceMessage = PRICE_CACHE.get(symbol.toUpperCase());
        return priceMessage != null ? priceMessage.getPrice() : null;
    }

    /**
     * 获取交易对的价格消息（包含时间戳）
     *
     * @param symbol 交易对
     * @return 价格消息
     */
    public static PriceMessage getPriceMessage(String symbol) {
        if (symbol == null || symbol.trim().isEmpty()) {
            return null;
        }
        return PRICE_CACHE.get(symbol.toUpperCase());
    }

    /**
     * 检查交易对是否存在价格缓存
     *
     * @param symbol 交易对
     * @return 是否存在
     */
    public static boolean hasPrice(String symbol) {
        if (symbol == null || symbol.trim().isEmpty()) {
            return false;
        }
        return PRICE_CACHE.containsKey(symbol.toUpperCase());
    }

    /**
     * 获取所有缓存的交易对价格
     *
     * @return 价格缓存快照
     */
    public static ConcurrentHashMap<String, PriceMessage> getAllPrices() {
        return new ConcurrentHashMap<>(PRICE_CACHE);
    }

    /**
     * 获取缓存中的交易对数量
     *
     * @return 缓存数量
     */
    public static int getCacheSize() {
        return PRICE_CACHE.size();
    }

    /**
     * 移除指定交易对的价格缓存
     *
     * @param symbol 交易对
     * @return 被移除的价格消息
     */
    public static PriceMessage removePrice(String symbol) {
        if (symbol == null || symbol.trim().isEmpty()) {
            return null;
        }
        return PRICE_CACHE.remove(symbol.toUpperCase());
    }

    /** 清空所有价格缓存 */
    public static void clearAll() {
        PRICE_CACHE.clear();
    }
}
