package com.zsElectric.boot.business.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.zsElectric.boot.charging.entity.*;
import com.zsElectric.boot.business.mapper.FirmInfoMapper;
import com.zsElectric.boot.business.mapper.ThirdPartyEquipmentInfoMapper;
import com.zsElectric.boot.business.mapper.ThirdPartyInfoMapper;
import com.zsElectric.boot.business.mapper.ThirdPartyStationInfoMapper;
import com.zsElectric.boot.charging.mapper.ThirdPartyConnectorInfoMapper;
import com.zsElectric.boot.charging.mapper.ThirdPartyEquipmentPricePolicyMapper;
import com.zsElectric.boot.charging.mapper.ThirdPartyPolicyInfoMapper;
import com.zsElectric.boot.business.model.entity.FirmInfo;
import com.zsElectric.boot.business.model.entity.ThirdPartyInfo;
import com.zsElectric.boot.business.model.query.ThirdPartyEquipmentInfoQuery;
import com.zsElectric.boot.business.model.query.ThirdPartyStationInfoQuery;
import com.zsElectric.boot.business.model.vo.PartyStationInfoVO;
import com.zsElectric.boot.business.model.vo.ThirdPartyEquipmentInfoVO;
import com.zsElectric.boot.business.model.vo.ThirdPartyStationInfoVO;
import com.zsElectric.boot.business.service.ThirdPartyChargingService;
import com.zsElectric.boot.charging.vo.ChargingPricePolicyVO;
import com.zsElectric.boot.charging.vo.QueryStationsInfoVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 第三方充电站/充电桩/价格策略统一服务实现
 *
 * @author system
 * @since 2025-12-15
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class ThirdPartyChargingServiceImpl implements ThirdPartyChargingService {

    private final ThirdPartyStationInfoMapper stationInfoMapper;
    private final ThirdPartyEquipmentInfoMapper equipmentInfoMapper;
    private final ThirdPartyConnectorInfoMapper connectorInfoMapper;
    private final ThirdPartyEquipmentPricePolicyMapper pricePolicyMapper;
    private final ThirdPartyPolicyInfoMapper policyInfoMapper;
    private final FirmInfoMapper firmInfoMapper;
    private final ThirdPartyInfoMapper thirdPartyInfoMapper;
    private final ObjectMapper objectMapper;

    // ==================== 充电站信息查询 ====================

    @Override
    public IPage<ThirdPartyStationInfoVO> getStationInfoPage(ThirdPartyStationInfoQuery queryParams) {
        // 构建分页
        Page<ThirdPartyStationInfoVO> page = new Page<>(queryParams.getPageNum(), queryParams.getPageSize());

        // 调用Mapper联表查询
        return stationInfoMapper.selectStationInfoPage(page, queryParams);
    }

    // ==================== 充电桩信息查询 ====================

    @Override
    public IPage<ThirdPartyEquipmentInfoVO> getEquipmentInfoPage(ThirdPartyEquipmentInfoQuery queryParams) {
        // 构建分页
        Page<ThirdPartyEquipmentInfoVO> page = new Page<>(queryParams.getPageNum(), queryParams.getPageSize());

        // 调用Mapper联表查询
        return equipmentInfoMapper.selectEquipmentInfoPage(page, queryParams);
    }

    @Override
    public List<PartyStationInfoVO> getPartyStationInfo() {
        // 查询所有设备信息
        List<ThirdPartyEquipmentInfo> equipmentInfos = equipmentInfoMapper.selectList(null);

        // 获取所有不重复的充电站ID
        List<String> stationIds = equipmentInfos.stream()
                .map(ThirdPartyEquipmentInfo::getStationId)
                .distinct()
                .collect(Collectors.toList());

        if (stationIds.isEmpty()) {
            return List.of();
        }

        // 查询充电站信息
        List<ThirdPartyStationInfo> stationInfos = stationInfoMapper.selectList(
                new LambdaQueryWrapper<ThirdPartyStationInfo>()
                        .in(ThirdPartyStationInfo::getStationId, stationIds)
        );

        // 转换为VO
        return stationInfos.stream()
                .map(station -> {
                    PartyStationInfoVO vo = new PartyStationInfoVO();
                    vo.setId(station.getId());
                    vo.setStationName(station.getStationName());
                    return vo;
                })
                .collect(Collectors.toList());
    }

    // ==================== 充电站数据保存 ====================

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveStationsInfo(QueryStationsInfoVO queryStationsInfoVO) {
        if (queryStationsInfoVO == null || CollectionUtils.isEmpty(queryStationsInfoVO.getStationInfos())) {
            log.warn("充电站信息为空，跳过存储");
            return;
        }

        List<StationInfo> stationInfos = queryStationsInfoVO.getStationInfos();
        log.info("开始保存充电站信息，总数: {}", stationInfos.size());

        for (StationInfo stationInfo : stationInfos) {
            try {
                // 保存充电站信息
                saveStationInfo(stationInfo);

                // 保存设备信息
                if (!CollectionUtils.isEmpty(stationInfo.getEquipmentInfos())) {
                    for (EquipmentInfo equipmentInfo : stationInfo.getEquipmentInfos()) {
                        saveEquipmentInfo(equipmentInfo, stationInfo.getStationID());

                        // 保存接口信息
                        if (!CollectionUtils.isEmpty(equipmentInfo.getConnectorInfos())) {
                            for (ConnectorInfo connectorInfo : equipmentInfo.getConnectorInfos()) {
                                saveConnectorInfo(connectorInfo, equipmentInfo.getEquipmentID(), stationInfo.getStationID());
                            }
                        }
                    }
                }
            } catch (Exception e) {
                log.error("保存充电站信息失败, stationId: {}", stationInfo.getStationID(), e);
                throw new RuntimeException("保存充电站信息失败: " + stationInfo.getStationID(), e);
            }
        }

        log.info("充电站信息保存完成");
    }

    /**
     * 保存充电站信息
     */
    private void saveStationInfo(StationInfo stationInfo) {
        // 查询是否已存在
        ThirdPartyStationInfo existingStation = stationInfoMapper.selectOne(
                new LambdaQueryWrapper<ThirdPartyStationInfo>()
                        .eq(ThirdPartyStationInfo::getStationId, stationInfo.getStationID())
        );

        ThirdPartyStationInfo entity = buildStationEntity(stationInfo, existingStation);

        if (existingStation == null) {
            // 不存在，执行新增
            stationInfoMapper.insert(entity);
            log.debug("充电站信息新增成功 - stationId: {}", stationInfo.getStationID());
        } else if (!isStationSame(existingStation, entity)) {
            // 存在且数据变化，执行更新
            stationInfoMapper.updateById(entity);
            log.debug("充电站信息更新成功 - stationId: {}", stationInfo.getStationID());
        } else {
            log.debug("充电站信息未变化，跳过保存 - stationId: {}", stationInfo.getStationID());
        }
    }

    /**
     * 构建充电站实体
     */
    private ThirdPartyStationInfo buildStationEntity(StationInfo stationInfo, ThirdPartyStationInfo existingStation) {
        ThirdPartyStationInfo entity = new ThirdPartyStationInfo();
        if (existingStation != null) {
            entity.setId(existingStation.getId());
            // 保留原有的配置状态
            entity.setPolicyConfigured(existingStation.getPolicyConfigured());
        }

        // 设置字段值
        entity.setStationId(stationInfo.getStationID());
        entity.setOperatorId(stationInfo.getOperatorID());
        entity.setEquipmentOwnerId(stationInfo.getEquipmentOwnerID());
        entity.setStationName(stationInfo.getStationName());
        entity.setCountryCode(stationInfo.getCountryCode());
        entity.setAreaCode(stationInfo.getAreaCode());
        entity.setAddress(stationInfo.getAddress());
        entity.setStationTel(stationInfo.getStationTel());
        entity.setServiceTel(stationInfo.getServiceTel());
        entity.setStationType(stationInfo.getStationType());
        entity.setStationStatus(stationInfo.getStationStatus());
        entity.setParkNums(stationInfo.getParkNums());

        // 处理经纬度
        if (stationInfo.getStationLng() != null) {
            entity.setStationLng(BigDecimal.valueOf(stationInfo.getStationLng()));
        }
        if (stationInfo.getStationLat() != null) {
            entity.setStationLat(BigDecimal.valueOf(stationInfo.getStationLat()));
        }

        entity.setSiteGuide(stationInfo.getSiteGuide());
        entity.setConstruction(stationInfo.getConstruction());

        // 处理图片列表（转JSON）
        if (!CollectionUtils.isEmpty(stationInfo.getPictures())) {
            try {
                entity.setPictures(objectMapper.writeValueAsString(stationInfo.getPictures()));
            } catch (JsonProcessingException e) {
                log.warn("图片列表转JSON失败", e);
            }
        }

        entity.setBusineHours(stationInfo.getBusineHours());

        // 处理费用（字符串转BigDecimal）
        if (stationInfo.getElectricityFee() != null) {
            try {
                entity.setElectricityFee(new BigDecimal(stationInfo.getElectricityFee()));
            } catch (NumberFormatException e) {
                log.warn("电费转换失败: {}", stationInfo.getElectricityFee(), e);
            }
        }
        if (stationInfo.getServiceFee() != null) {
            try {
                entity.setServiceFee(new BigDecimal(stationInfo.getServiceFee()));
            } catch (NumberFormatException e) {
                log.warn("服务费转换失败: {}", stationInfo.getServiceFee(), e);
            }
        }

        entity.setParkFee(stationInfo.getParkFee());
        entity.setPayment(stationInfo.getPayment());
        entity.setSupportOrder(stationInfo.getSupportOrder());
        entity.setRemark(stationInfo.getRemark());

        return entity;
    }

    /**
     * 判断充电站信息是否相同
     */
    private boolean isStationSame(ThirdPartyStationInfo existing, ThirdPartyStationInfo newEntity) {
        return Objects.equals(existing.getOperatorId(), newEntity.getOperatorId()) &&
                Objects.equals(existing.getEquipmentOwnerId(), newEntity.getEquipmentOwnerId()) &&
                Objects.equals(existing.getStationName(), newEntity.getStationName()) &&
                Objects.equals(existing.getCountryCode(), newEntity.getCountryCode()) &&
                Objects.equals(existing.getAreaCode(), newEntity.getAreaCode()) &&
                Objects.equals(existing.getAddress(), newEntity.getAddress()) &&
                Objects.equals(existing.getStationTel(), newEntity.getStationTel()) &&
                Objects.equals(existing.getServiceTel(), newEntity.getServiceTel()) &&
                Objects.equals(existing.getStationType(), newEntity.getStationType()) &&
                Objects.equals(existing.getStationStatus(), newEntity.getStationStatus()) &&
                Objects.equals(existing.getParkNums(), newEntity.getParkNums()) &&
                isBigDecimalEqual(existing.getStationLng(), newEntity.getStationLng()) &&
                isBigDecimalEqual(existing.getStationLat(), newEntity.getStationLat()) &&
                Objects.equals(existing.getSiteGuide(), newEntity.getSiteGuide()) &&
                Objects.equals(existing.getConstruction(), newEntity.getConstruction()) &&
                Objects.equals(existing.getPictures(), newEntity.getPictures()) &&
                Objects.equals(existing.getBusineHours(), newEntity.getBusineHours()) &&
                isBigDecimalEqual(existing.getElectricityFee(), newEntity.getElectricityFee()) &&
                isBigDecimalEqual(existing.getServiceFee(), newEntity.getServiceFee()) &&
                Objects.equals(existing.getParkFee(), newEntity.getParkFee()) &&
                Objects.equals(existing.getPayment(), newEntity.getPayment()) &&
                Objects.equals(existing.getSupportOrder(), newEntity.getSupportOrder()) &&
                Objects.equals(existing.getRemark(), newEntity.getRemark());
    }

    /**
     * 保存充电设备信息
     */
    private void saveEquipmentInfo(EquipmentInfo equipmentInfo, String stationId) {
        // 查询是否已存在
        ThirdPartyEquipmentInfo existingEquipment = equipmentInfoMapper.selectOne(
                new LambdaQueryWrapper<ThirdPartyEquipmentInfo>()
                        .eq(ThirdPartyEquipmentInfo::getEquipmentId, equipmentInfo.getEquipmentID())
        );

        ThirdPartyEquipmentInfo entity = buildEquipmentEntity(equipmentInfo, stationId, existingEquipment);

        if (existingEquipment == null) {
            // 不存在，执行新增
            equipmentInfoMapper.insert(entity);
            log.debug("充电设备信息新增成功 - equipmentId: {}", equipmentInfo.getEquipmentID());
        } else if (!isEquipmentSame(existingEquipment, entity)) {
            // 存在且数据变化，执行更新
            equipmentInfoMapper.updateById(entity);
            log.debug("充电设备信息更新成功 - equipmentId: {}", equipmentInfo.getEquipmentID());
        } else {
            log.debug("充电设备信息未变化，跳过保存 - equipmentId: {}", equipmentInfo.getEquipmentID());
        }
    }

    /**
     * 构建充电设备实体
     */
    private ThirdPartyEquipmentInfo buildEquipmentEntity(EquipmentInfo equipmentInfo, String stationId, ThirdPartyEquipmentInfo existingEquipment) {
        ThirdPartyEquipmentInfo entity = new ThirdPartyEquipmentInfo();
        if (existingEquipment != null) {
            entity.setId(existingEquipment.getId());
        }

        // 设置字段值
        entity.setEquipmentId(equipmentInfo.getEquipmentID());
        entity.setStationId(stationId);
        entity.setManufacturerId(equipmentInfo.getManufacturerID());
        entity.setManufacturerName(equipmentInfo.getManufacturerName());
        entity.setEquipmentModel(equipmentInfo.getEquipmentModel());
        entity.setProductionDate(equipmentInfo.getProductionDate());
        entity.setEquipmentType(equipmentInfo.getEquipmentType());

        // 处理经纬度
        if (equipmentInfo.getEquipmentLng() != null) {
            entity.setEquipmentLng(BigDecimal.valueOf(equipmentInfo.getEquipmentLng()));
        }
        if (equipmentInfo.getEquipmentLat() != null) {
            entity.setEquipmentLat(BigDecimal.valueOf(equipmentInfo.getEquipmentLat()));
        }

        // 处理功率
        if (equipmentInfo.getPower() != null) {
            entity.setPower(BigDecimal.valueOf(equipmentInfo.getPower()));
        }

        entity.setEquipmentName(equipmentInfo.getEquipmentName());

        return entity;
    }

    /**
     * 判断充电设备信息是否相同
     */
    private boolean isEquipmentSame(ThirdPartyEquipmentInfo existing, ThirdPartyEquipmentInfo newEntity) {
        return Objects.equals(existing.getStationId(), newEntity.getStationId()) &&
                Objects.equals(existing.getManufacturerId(), newEntity.getManufacturerId()) &&
                Objects.equals(existing.getManufacturerName(), newEntity.getManufacturerName()) &&
                Objects.equals(existing.getEquipmentModel(), newEntity.getEquipmentModel()) &&
                Objects.equals(existing.getProductionDate(), newEntity.getProductionDate()) &&
                Objects.equals(existing.getEquipmentType(), newEntity.getEquipmentType()) &&
                isBigDecimalEqual(existing.getEquipmentLng(), newEntity.getEquipmentLng()) &&
                isBigDecimalEqual(existing.getEquipmentLat(), newEntity.getEquipmentLat()) &&
                isBigDecimalEqual(existing.getPower(), newEntity.getPower()) &&
                Objects.equals(existing.getEquipmentName(), newEntity.getEquipmentName());
    }

    /**
     * 保存充电接口信息
     */
    private void saveConnectorInfo(ConnectorInfo connectorInfo, String equipmentId, String stationId) {
        // 查询是否已存在
        ThirdPartyConnectorInfo existingConnector = connectorInfoMapper.selectOne(
                new LambdaQueryWrapper<ThirdPartyConnectorInfo>()
                        .eq(ThirdPartyConnectorInfo::getConnectorId, connectorInfo.getConnectorID())
        );

        ThirdPartyConnectorInfo entity = buildConnectorEntity(connectorInfo, equipmentId, stationId, existingConnector);

        if (existingConnector == null) {
            // 不存在，执行新增
            connectorInfoMapper.insert(entity);
            log.debug("充电接口信息新增成功 - connectorId: {}", connectorInfo.getConnectorID());
        } else if (!isConnectorSame(existingConnector, entity)) {
            // 存在且数据变化，执行更新
            connectorInfoMapper.updateById(entity);
            log.debug("充电接口信息更新成功 - connectorId: {}", connectorInfo.getConnectorID());
        } else {
            log.debug("充电接口信息未变化，跳过保存 - connectorId: {}", connectorInfo.getConnectorID());
        }
    }

    /**
     * 构建充电接口实体
     */
    private ThirdPartyConnectorInfo buildConnectorEntity(ConnectorInfo connectorInfo, String equipmentId, String stationId, ThirdPartyConnectorInfo existingConnector) {
        ThirdPartyConnectorInfo entity = new ThirdPartyConnectorInfo();
        if (existingConnector != null) {
            entity.setId(existingConnector.getId());
        }

        // 设置字段值
        entity.setConnectorId(connectorInfo.getConnectorID());
        entity.setEquipmentId(equipmentId);
        entity.setStationId(stationId);
        entity.setConnectorName(connectorInfo.getConnectorName());
        entity.setConnectorType(connectorInfo.getConnectorType());
        entity.setVoltageUpperLimits(connectorInfo.getVoltageUpperLimits());
        entity.setVoltageLowerLimits(connectorInfo.getVoltageLowerLimits());
        entity.setCurrent(connectorInfo.getCurrent());

        // 处理功率
        if (connectorInfo.getPower() != null) {
            entity.setPower(BigDecimal.valueOf(connectorInfo.getPower()));
        }

        entity.setParkNo(connectorInfo.getParkNo());
        entity.setNationalStandard(connectorInfo.getNationalStandard());

        return entity;
    }

    /**
     * 判断充电接口信息是否相同
     */
    private boolean isConnectorSame(ThirdPartyConnectorInfo existing, ThirdPartyConnectorInfo newEntity) {
        return Objects.equals(existing.getEquipmentId(), newEntity.getEquipmentId()) &&
                Objects.equals(existing.getStationId(), newEntity.getStationId()) &&
                Objects.equals(existing.getConnectorName(), newEntity.getConnectorName()) &&
                Objects.equals(existing.getConnectorType(), newEntity.getConnectorType()) &&
                Objects.equals(existing.getVoltageUpperLimits(), newEntity.getVoltageUpperLimits()) &&
                Objects.equals(existing.getVoltageLowerLimits(), newEntity.getVoltageLowerLimits()) &&
                Objects.equals(existing.getCurrent(), newEntity.getCurrent()) &&
                isBigDecimalEqual(existing.getPower(), newEntity.getPower()) &&
                Objects.equals(existing.getParkNo(), newEntity.getParkNo()) &&
                Objects.equals(existing.getNationalStandard(), newEntity.getNationalStandard());
    }

    // ==================== 价格策略数据保存 ====================

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void savePricePolicyInfo(ChargingPricePolicyVO pricePolicyVO) {
        if (pricePolicyVO == null) {
            log.warn("价格策略信息为空，跳过存储");
            return;
        }

        try {
            // 查询最新的价格策略记录
            ThirdPartyEquipmentPricePolicy latestPolicy = getLatestPricePolicy(
                    pricePolicyVO.getEquipBizSeq(),
                    pricePolicyVO.getConnectorID()
            );

            // 如果数据完全相同，不做任何操作
            if (latestPolicy != null && isPolicySame(latestPolicy, pricePolicyVO)) {
                log.info("价格策略数据未发生变化，跳过保存 - equipBizSeq: {}, connectorId: {}",
                        pricePolicyVO.getEquipBizSeq(), pricePolicyVO.getConnectorID());
                return;
            }

            // 数据发生变化
            Long policyId;
            if (latestPolicy != null) {
                // 已存在记录，执行更新
                policyId = updatePricePolicy(latestPolicy, pricePolicyVO);
                log.info("价格策略信息保存成功(更新记录) - equipBizSeq: {}, connectorId: {}, policyId: {}",
                        pricePolicyVO.getEquipBizSeq(), pricePolicyVO.getConnectorID(), policyId);
            } else {
                // 不存在记录，执行新增
                policyId = insertNewPricePolicy(pricePolicyVO);
                log.info("价格策略信息保存成功(新增记录) - equipBizSeq: {}, connectorId: {}, policyId: {}",
                        pricePolicyVO.getEquipBizSeq(), pricePolicyVO.getConnectorID(), policyId);
            }

            // 保存价格策略明细（对比后更新或新增，不做删除操作）
            if (!CollectionUtils.isEmpty(pricePolicyVO.getPolicyInfos())) {
                savePolicyInfoDetails(pricePolicyVO.getPolicyInfos(), policyId);
            }

        } catch (Exception e) {
            log.error("保存价格策略信息失败 - equipBizSeq: {}, connectorId: {}",
                    pricePolicyVO.getEquipBizSeq(), pricePolicyVO.getConnectorID(), e);
            throw new RuntimeException("保存价格策略信息失败", e);
        }
    }

    @Override
    public IPage<ThirdPartyStationInfoVO> getStationInfoPageByEquipment(ThirdPartyStationInfoQuery queryParams) {
        // 构建分页
        Page<ThirdPartyStationInfoVO> page = new Page<>(queryParams.getPageNum(), queryParams.getPageSize());
        // 调用Mapper联表查询（固定设备所属方MA6DP6BE7）
        IPage<ThirdPartyStationInfoVO> resultPage = stationInfoMapper.selectStationInfoPageByEquipment(page, queryParams);
        
        // 填充单位名称
        for (ThirdPartyStationInfoVO vo : resultPage.getRecords()) {
            if (vo.getSalesType() != null) {
                if (vo.getSalesType() == 1 && vo.getFirmId() != null) {
                    // 企业类型，查询企业名称
                    FirmInfo firmInfo = firmInfoMapper.selectById(vo.getFirmId());
                    if (firmInfo != null) {
                        vo.setUnitName(firmInfo.getName());
                    }
                } else if (vo.getSalesType() == 2 && vo.getThirdPartyId() != null) {
                    // 渠道方类型，查询渠道方名称
                    ThirdPartyInfo thirdPartyInfo = thirdPartyInfoMapper.selectById(vo.getThirdPartyId());
                    if (thirdPartyInfo != null) {
                        vo.setUnitName(thirdPartyInfo.getEcName());
                    }
                }
            }
        }
        
        return resultPage;
    }

    /**
     * 获取最新的价格策略记录
     */
    private ThirdPartyEquipmentPricePolicy getLatestPricePolicy(String equipBizSeq, String connectorId) {
        List<ThirdPartyEquipmentPricePolicy> policies = pricePolicyMapper.selectList(
                Wrappers.<ThirdPartyEquipmentPricePolicy>lambdaQuery()
                        .eq(ThirdPartyEquipmentPricePolicy::getEquipBizSeq, equipBizSeq)
                        .eq(ThirdPartyEquipmentPricePolicy::getConnectorId, connectorId)
                        .orderByDesc(ThirdPartyEquipmentPricePolicy::getCreateTime)
                        .last("LIMIT 1")
        );

        return CollectionUtils.isEmpty(policies) ? null : policies.get(0);
    }

    /**
     * 判断价格策略是否相同（比较主表和明细表）
     */
    private boolean isPolicySame(ThirdPartyEquipmentPricePolicy latestPolicy, ChargingPricePolicyVO newPolicy) {
        // 比较主表字段
        if (!Objects.equals(latestPolicy.getSuccStat(), newPolicy.getSuccStat()) ||
                !Objects.equals(latestPolicy.getFailReason(), newPolicy.getFailReason()) ||
                !Objects.equals(latestPolicy.getSumPeriod(), newPolicy.getSumPeriod())) {
            return false;
        }

        // 查询明细表数据
        List<ThirdPartyPolicyInfo> existingDetails = policyInfoMapper.selectList(
                Wrappers.<ThirdPartyPolicyInfo>lambdaQuery()
                        .eq(ThirdPartyPolicyInfo::getPricePolicyId, latestPolicy.getId())
                        .orderBy(true, true, ThirdPartyPolicyInfo::getStartTime)
        );

        // 比较明细表
        return isPolicyDetailsSame(existingDetails, newPolicy.getPolicyInfos());
    }

    /**
     * 比较价格策略明细是否相同
     */
    private boolean isPolicyDetailsSame(List<ThirdPartyPolicyInfo> existingDetails,
                                        List<ChargingPricePolicyVO.PolicyInfo> newDetails) {
        if (CollectionUtils.isEmpty(existingDetails) && CollectionUtils.isEmpty(newDetails)) {
            return true;
        }

        if (CollectionUtils.isEmpty(existingDetails) || CollectionUtils.isEmpty(newDetails)) {
            return false;
        }

        if (existingDetails.size() != newDetails.size()) {
            return false;
        }

        // 按 StartTime 排序后比较
        List<ChargingPricePolicyVO.PolicyInfo> sortedNewDetails = newDetails.stream()
                .sorted(Comparator.comparing(ChargingPricePolicyVO.PolicyInfo::getStartTime))
                .collect(Collectors.toList());

        for (int i = 0; i < existingDetails.size(); i++) {
            ThirdPartyPolicyInfo existing = existingDetails.get(i);
            ChargingPricePolicyVO.PolicyInfo newDetail = sortedNewDetails.get(i);

            if (!Objects.equals(existing.getStartTime(), newDetail.getStartTime()) ||
                    !isBigDecimalEqual(existing.getElecPrice(), newDetail.getElecPrice()) ||
                    !isBigDecimalEqual(existing.getServicePrice(), newDetail.getServicePrice()) ||
                    !Objects.equals(existing.getPeriodFlag(), newDetail.getPeriodFlag())) {
                return false;
            }
        }

        return true;
    }

    /**
     * 比较 BigDecimal 是否相等（处理 null 情况）
     */
    private boolean isBigDecimalEqual(BigDecimal a, BigDecimal b) {
        if (a == null && b == null) {
            return true;
        }
        if (a == null || b == null) {
            return false;
        }
        return a.compareTo(b) == 0;
    }

    /**
     * 插入新的价格策略记录
     */
    private Long insertNewPricePolicy(ChargingPricePolicyVO pricePolicyVO) {
        ThirdPartyEquipmentPricePolicy entity = new ThirdPartyEquipmentPricePolicy();

        // 设置字段值
        entity.setEquipBizSeq(pricePolicyVO.getEquipBizSeq());
        entity.setConnectorId(pricePolicyVO.getConnectorID());
        entity.setSuccStat(pricePolicyVO.getSuccStat());
        entity.setFailReason(pricePolicyVO.getFailReason());
        entity.setSumPeriod(pricePolicyVO.getSumPeriod());
        entity.setCreateTime(LocalDateTime.now());

        // 插入新记录
        pricePolicyMapper.insert(entity);

        return entity.getId();
    }

    /**
     * 更新价格策略记录
     */
    private Long updatePricePolicy(ThirdPartyEquipmentPricePolicy existingPolicy, ChargingPricePolicyVO pricePolicyVO) {
        existingPolicy.setSuccStat(pricePolicyVO.getSuccStat());
        existingPolicy.setFailReason(pricePolicyVO.getFailReason());
        existingPolicy.setSumPeriod(pricePolicyVO.getSumPeriod());

        pricePolicyMapper.updateById(existingPolicy);

        return existingPolicy.getId();
    }

    /**
     * 保存价格策略明细（对比后更新或新增）
     */
    private void savePolicyInfoDetails(List<ChargingPricePolicyVO.PolicyInfo> policyInfos, Long policyId) {
        // 查询已存在的明细记录，以 startTime 为 key
        Map<String, ThirdPartyPolicyInfo> existingMap = policyInfoMapper.selectList(
                Wrappers.<ThirdPartyPolicyInfo>lambdaQuery()
                        .eq(ThirdPartyPolicyInfo::getPricePolicyId, policyId))
                .stream()
                .collect(Collectors.toMap(ThirdPartyPolicyInfo::getStartTime, info -> info, (v1, v2) -> v1));

        for (ChargingPricePolicyVO.PolicyInfo policyInfo : policyInfos) {
            ThirdPartyPolicyInfo existing = existingMap.get(policyInfo.getStartTime());
            
            if (existing == null) {
                // 不存在，执行新增
                savePolicyInfoDetail(policyInfo, policyId);
                log.debug("价格策略明细新增成功 - policyId: {}, startTime: {}", policyId, policyInfo.getStartTime());
            } else if (!isPolicyInfoSame(existing, policyInfo)) {
                // 存在且数据变化，执行更新
                updatePolicyInfoDetail(existing, policyInfo);
                log.debug("价格策略明细更新成功 - policyId: {}, startTime: {}", policyId, policyInfo.getStartTime());
            } else {
                log.debug("价格策略明细未变化，跳过保存 - policyId: {}, startTime: {}", policyId, policyInfo.getStartTime());
            }
        }
    }

    /**
     * 判断价格策略明细是否相同
     */
    private boolean isPolicyInfoSame(ThirdPartyPolicyInfo existing, ChargingPricePolicyVO.PolicyInfo newInfo) {
        return isBigDecimalEqual(existing.getElecPrice(), newInfo.getElecPrice()) &&
                isBigDecimalEqual(existing.getServicePrice(), newInfo.getServicePrice()) &&
                Objects.equals(existing.getPeriodFlag(), newInfo.getPeriodFlag());
    }

    /**
     * 更新价格策略明细
     */
    private void updatePolicyInfoDetail(ThirdPartyPolicyInfo existing, ChargingPricePolicyVO.PolicyInfo policyInfo) {
        existing.setElecPrice(policyInfo.getElecPrice());
        existing.setServicePrice(policyInfo.getServicePrice());
        existing.setPeriodFlag(policyInfo.getPeriodFlag());
        policyInfoMapper.updateById(existing);
    }

    /**
     * 保存价格策略明细
     */
    private void savePolicyInfoDetail(ChargingPricePolicyVO.PolicyInfo policyInfo, Long policyId) {
        ThirdPartyPolicyInfo entity = new ThirdPartyPolicyInfo();
        entity.setPricePolicyId(policyId);
        entity.setStartTime(policyInfo.getStartTime());
        entity.setElecPrice(policyInfo.getElecPrice());
        entity.setServicePrice(policyInfo.getServicePrice());
        entity.setPeriodFlag(policyInfo.getPeriodFlag());
        entity.setCreateTime(LocalDateTime.now());

        policyInfoMapper.insert(entity);
    }

    @Override
    public boolean updateStationTips(Long stationId, String stationTips) {
        return stationInfoMapper.update(null, Wrappers.<ThirdPartyStationInfo>lambdaUpdate()
                .eq(ThirdPartyStationInfo::getId, stationId)
                .set(ThirdPartyStationInfo::getStationTips, stationTips)) > 0;
    }
}