package com.ruoyi.logistics.service;

import com.ruoyi.common.redis.service.RedisService;
import com.ruoyi.logistics.constant.RedisCacheConstants;
import com.ruoyi.logistics.domain.BizFinancialFeeItems;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 费用类型缓存服务
 * 
 * @author lydgt
 * @date 2026-02-04
 */
@Service
public class FeeItemsCacheService {

    private static final Logger log = LoggerFactory.getLogger(FeeItemsCacheService.class);

    @Autowired
    private IBizFinancialFeeItemsService BizFinancialFeeItemsService;

    @Autowired
    private RedisService redisService;

    /**
     * 初始化费用类型数据到Redis
     */
    @PostConstruct
    public void initFeeItemsCache() {
        loadFeeItemsToRedis();
    }

    /**
     * 加载费用类型数据到Redis中
     */
    public void loadFeeItemsToRedis() {
        try {
            log.info("开始加载费用类型数据到Redis缓存...");
            
            // 查询所有费用类型数据
            List<BizFinancialFeeItems> feeItemsList = BizFinancialFeeItemsService.selectAllBizFinancialFeeItems();
            
            if (feeItemsList != null && !feeItemsList.isEmpty()) {
                // 创建Map用于存储费用类型数据，key为extFeeCode，value为BizFinancialFeeItems对象
                Map<String, BizFinancialFeeItems> feeItemsMap = new HashMap<>();
                
                for (BizFinancialFeeItems feeItem : feeItemsList) {
                    if (feeItem.getExtFeeCode() != null) {
                        feeItemsMap.put(feeItem.getExtFeeCode(), feeItem);
                    }
                }
                
                // 清除旧的缓存数据
                redisService.deleteObject(RedisCacheConstants.FINANCIAL_FEE_ITEM_CACHE_KEY);
                
                // 将费用类型数据保存到Redis中
                if (!feeItemsMap.isEmpty()) {
                    redisService.setCacheMap(RedisCacheConstants.FINANCIAL_FEE_ITEM_CACHE_KEY, feeItemsMap);
                    log.info("成功加载{}条费用类型数据到Redis缓存", feeItemsMap.size());
                } else {
                    log.info("没有找到有效的费用类型数据");
                }
            } else {
                log.info("没有找到费用类型数据");
            }
        } catch (Exception e) {
            log.error("加载费用类型数据到Redis缓存失败", e);
        }
    }

    /**
     * 根据外部费用编码获取费用类型信息
     * 
     * @param extFeeCode 外部费用编码
     * @return 费用类型信息
     */
    public BizFinancialFeeItems getFeeItemByExtFeeCode(String extFeeCode) {
        if (extFeeCode == null) {
            return null;
        }
        
        Map<String, BizFinancialFeeItems> feeItemsMap = getFeeItemsMapFromRedis();
        if (feeItemsMap != null) {
            return feeItemsMap.get(extFeeCode);
        }
        
        return null;
    }

    /**
     * 从Redis获取费用类型Map
     * 
     * @return 费用类型Map
     */
    public Map<String, BizFinancialFeeItems> getFeeItemsMapFromRedis() {
        return redisService.getCacheMap(RedisCacheConstants.FINANCIAL_FEE_ITEM_CACHE_KEY);
    }

    /**
     * 更新缓存中的单个费用类型数据
     * 
     * @param extFeeCode 外部费用编码
     * @param feeItem 费用类型对象
     */
    public void updateFeeItemInCache(String extFeeCode, BizFinancialFeeItems feeItem) {
        if (extFeeCode != null && feeItem != null) {
            redisService.setCacheMapValue(RedisCacheConstants.FINANCIAL_FEE_ITEM_CACHE_KEY, extFeeCode, feeItem);
        }
    }

    /**
     * 删除缓存中的费用类型数据
     * 
     * @param extFeeCode 外部费用编码
     */
    public void removeFeeItemFromCache(String extFeeCode) {
        if (extFeeCode != null) {
            redisService.deleteCacheMapValue(RedisCacheConstants.FINANCIAL_FEE_ITEM_CACHE_KEY, extFeeCode);
        }
    }
}