package com.tashow.cloud.product.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.tashow.cloud.common.util.date.DateUtils;
import com.tashow.cloud.mybatis.mybatis.core.util.MyBatisUtils;
import com.tashow.cloud.productapi.api.product.dto.*;
import com.tashow.cloud.product.mapper.*;
import com.tashow.cloud.product.service.ProdExtendService;
import com.tashow.cloud.product.service.ProdPropService;
import com.tashow.cloud.product.service.ProdPropValueService;
import com.tashow.cloud.product.service.SkuService;
import com.tashow.cloud.productapi.api.product.vo.prodpropvalue.ProPageReqVO;
import com.tashow.cloud.productapi.api.product.vo.prodpropvalue.ProPropRecycleBinVO;
import com.tashow.cloud.productapi.api.product.vo.sku.*;
import com.tashow.cloud.productapi.enums.BaseEnum;
import com.tashow.cloud.productapi.enums.ErrorCodeConstants;
import com.tashow.cloud.productapi.enums.ServiceTypeEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.stereotype.Service;
import jakarta.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

import com.tashow.cloud.common.pojo.PageResult;
import com.tashow.cloud.common.pojo.PageParam;
import com.tashow.cloud.common.util.object.BeanUtils;


import static com.tashow.cloud.common.exception.util.ServiceExceptionUtil.exception;

/**
 * 单品SKU Service 实现类
 *
 * @author 芋道源码
 */
@Service
@Validated
@Slf4j
public class SkuServiceImpl implements SkuService {

    @Resource
    private SkuMapper skuMapper;
    @Resource
    private SkuServiceDetailsMapper skuServiceDetailsMapper;
    @Resource
    private SkuServicesFormMapper skuServicesFormMapper;
    @Resource
    private SkuServiceMaterialMapper skuServiceMaterialMapper;
    @Resource
    private SkuServiceTransportMapper skuServiceTransportMapper;
    @Resource
    private SkuServiceDeliverMapper skuServiceDeliverMapper;
    @Resource
    private ProdPropService prodPropService;
    @Resource
    private ProdExtendMapper prodExtendMapper;
    @Resource
    private ProdPropValueService prodPropValueService;
    @Resource
    private ProdExtendService prodExtendService;
    @Resource
    private ProdPropValueMapper prodPropValueMapper;
    @Resource
    private ProdPropMapper prodPropMapper;

    @Override
    public Long createSku(SkuSaveReqVO createReqVO) {
        // 插入
        SkuDO sku = BeanUtils.toBean(createReqVO, SkuDO.class);
        skuMapper.insert(sku);
        // 返回
        return sku.getSkuId();
    }

    @Override
    @Transactional
    public void createSkuExtend(SkuExtendVO skuExtendVO) {
        //接运车辆配置
        if (Objects.equals(skuExtendVO.getTransportCarSwitch(), BaseEnum.YES_ONE.getKey())) {
            SkuServicesFormDO skuServicesFormDO = new SkuServicesFormDO();
            skuServicesFormDO.setServiceName(ServiceTypeEnum.TRANSPORT_CAR_CONFIG.getDescription());
            skuServicesFormDO.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesFormDO.setType(ServiceTypeEnum.TRANSPORT_CAR_CONFIG.getCode());
            skuServicesFormDO.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesFormDO);
            for (SkuServiceDetailsDO skuServiceDetailsDO : skuExtendVO.getTransportCarList()) {
                skuServiceDetailsDO.setServiceId(skuServicesFormDO.getId());
                skuServiceDetailsMapper.insert(skuServiceDetailsDO);
            }
            SkuServicesFormDO skuServicesForm = new SkuServicesFormDO();
            skuServicesForm.setServiceName(ServiceTypeEnum.TRANSPORT_CAR_MATERIAL.getDescription());
            skuServicesForm.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesForm.setType(ServiceTypeEnum.TRANSPORT_CAR_MATERIAL.getCode());
            skuServicesForm.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesForm);
            for (SkuServiceMaterialDO skuServiceMaterialDO : skuExtendVO.getTransportCarMaterialList()) {
                skuServiceMaterialDO.setServiceId(skuServicesForm.getId());
                skuServiceMaterialMapper.insert(skuServiceMaterialDO);
            }
        }
        //遗体运输目的地配置
        if (Objects.equals(skuExtendVO.getTrafficSwitch(), BaseEnum.YES_ONE.getKey())) {
            SkuServicesFormDO skuServicesFormDO = new SkuServicesFormDO();
            skuServicesFormDO.setServiceName(ServiceTypeEnum.BODY_TRANSPORT_CONFIG.getDescription());
            skuServicesFormDO.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesFormDO.setType(ServiceTypeEnum.BODY_TRANSPORT_CONFIG.getCode());
            skuServicesFormDO.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesFormDO);
            for (SkuServiceTransportDO skuServiceTransportDO : skuExtendVO.getTrafficList()) {
                skuServiceTransportDO.setServiceId(skuServicesFormDO.getId());
                skuServiceTransportMapper.insert(skuServiceTransportDO);
            }
            SkuServicesFormDO skuServicesForm = new SkuServicesFormDO();
            skuServicesForm.setServiceName(ServiceTypeEnum.BODY_TRANSPORT_MATERIAL.getDescription());
            skuServicesForm.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesForm.setType(ServiceTypeEnum.BODY_TRANSPORT_MATERIAL.getCode());
            skuServicesForm.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesForm);
            for (SkuServiceMaterialDO skuServiceMaterialDO : skuExtendVO.getTrafficMaterialList()) {
                skuServiceMaterialDO.setServiceId(skuServicesForm.getId());
                skuServiceMaterialMapper.insert(skuServiceMaterialDO);
            }
        }
        //遗体清洁配置
        if (Objects.equals(skuExtendVO.getCleanSwitch(), BaseEnum.YES_ONE.getKey())) {
            SkuServicesFormDO skuServicesFormDO = new SkuServicesFormDO();
            skuServicesFormDO.setServiceName(ServiceTypeEnum.BODY_CLEAN_CONFIG.getDescription());
            skuServicesFormDO.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesFormDO.setType(ServiceTypeEnum.BODY_CLEAN_CONFIG.getCode());
            skuServicesFormDO.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesFormDO);
            for (SkuServiceDetailsDO skuServiceDetails : skuExtendVO.getCleanList()) {
                skuServiceDetails.setServiceId(skuServicesFormDO.getId());
                skuServiceDetailsMapper.insert(skuServiceDetails);
            }
            SkuServicesFormDO skuServicesForm = new SkuServicesFormDO();
            skuServicesForm.setServiceName(ServiceTypeEnum.BODY_CLEAN_MATERIAL.getDescription());
            skuServicesForm.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesForm.setType(ServiceTypeEnum.BODY_CLEAN_MATERIAL.getCode());
            skuServicesForm.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesForm);
            for (SkuServiceMaterialDO skuServiceMaterialDO : skuExtendVO.getCleanMaterialList()) {
                skuServiceMaterialDO.setServiceId(skuServicesForm.getId());
                skuServiceMaterialMapper.insert(skuServiceMaterialDO);
            }
        }
        //追思告别配置
        if (Objects.equals(skuExtendVO.getReflectionSwitch(), BaseEnum.YES_ONE.getKey())) {
            SkuServicesFormDO skuServicesFormDO = new SkuServicesFormDO();
            skuServicesFormDO.setServiceName(ServiceTypeEnum.MEMORIAL_CONFIG.getDescription());
            skuServicesFormDO.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesFormDO.setType(ServiceTypeEnum.MEMORIAL_CONFIG.getCode());
            skuServicesFormDO.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesFormDO);
            for (SkuServiceDetailsDO skuServiceDetails : skuExtendVO.getReflectionList()) {
                skuServiceDetails.setServiceId(skuServicesFormDO.getId());
                skuServiceDetailsMapper.insert(skuServiceDetails);
            }
            SkuServicesFormDO skuServicesForm = new SkuServicesFormDO();
            skuServicesForm.setServiceName(ServiceTypeEnum.MEMORIAL_MATERIAL.getDescription());
            skuServicesForm.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesForm.setType(ServiceTypeEnum.MEMORIAL_MATERIAL.getCode());
            skuServicesForm.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesForm);
            for (SkuServiceMaterialDO skuServiceMaterialDO : skuExtendVO.getReflectionMaterialList()) {
                skuServiceMaterialDO.setServiceId(skuServicesForm.getId());
                skuServiceMaterialMapper.insert(skuServiceMaterialDO);
            }
        }

        //遗体火化配置
        if (Objects.equals(skuExtendVO.getCremationSwitch(), BaseEnum.YES_ONE.getKey())) {
            SkuServicesFormDO skuServicesFormDO = new SkuServicesFormDO();
            skuServicesFormDO.setServiceName(ServiceTypeEnum.CREMATION_CONFIG.getDescription());
            skuServicesFormDO.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesFormDO.setType(ServiceTypeEnum.CREMATION_CONFIG.getCode());
            skuServicesFormDO.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesFormDO);
            for (SkuServiceDetailsDO skuServiceDetails : skuExtendVO.getCremationList()) {
                skuServiceDetails.setServiceId(skuServicesFormDO.getId());
                skuServiceDetailsMapper.insert(skuServiceDetails);
            }
            SkuServicesFormDO skuServicesForm = new SkuServicesFormDO();
            skuServicesForm.setServiceName(ServiceTypeEnum.CREMATION_MATERIAL.getDescription());
            skuServicesForm.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesForm.setType(ServiceTypeEnum.CREMATION_MATERIAL.getCode());
            skuServicesForm.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesForm);
            for (SkuServiceMaterialDO skuServiceMaterialDO : skuExtendVO.getCremationMaterialList()) {
                skuServiceMaterialDO.setServiceId(skuServicesForm.getId());
                skuServiceMaterialMapper.insert(skuServiceMaterialDO);
            }
        }

        //骨灰处理配置
        if (Objects.equals(skuExtendVO.getAshProcessingSwitch(), BaseEnum.YES_ONE.getKey())) {
            SkuServicesFormDO skuServicesFormDO = new SkuServicesFormDO();
            skuServicesFormDO.setServiceName(ServiceTypeEnum.ASH_PROCESSING_CONFIG.getDescription());
            skuServicesFormDO.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesFormDO.setType(ServiceTypeEnum.ASH_PROCESSING_CONFIG.getCode());
            skuServicesFormDO.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesFormDO);
            for (SkuServiceDetailsDO skuServiceDetails : skuExtendVO.getAshProcessingList()) {
                skuServiceDetails.setServiceId(skuServicesFormDO.getId());
                skuServiceDetailsMapper.insert(skuServiceDetails);
            }
            SkuServicesFormDO skuForm = new SkuServicesFormDO();
            skuForm.setServiceName(ServiceTypeEnum.ASH_PROCESSING_DELIVERY.getDescription());
            skuForm.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuForm.setType(ServiceTypeEnum.ASH_PROCESSING_DELIVERY.getCode());
            skuForm.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuForm);
            for (SkuServiceDeliverDO skuServiceDeliverDO : skuExtendVO.getAshProcessingDeliverList()) {
                skuServiceDeliverDO.setServiceId(skuForm.getId());
                skuServiceDeliverMapper.insert(skuServiceDeliverDO);
            }
            SkuServicesFormDO skuServicesForm = new SkuServicesFormDO();
            skuServicesForm.setServiceName(ServiceTypeEnum.ASH_PROCESSING_MATERIAL.getDescription());
            skuServicesForm.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesForm.setType(ServiceTypeEnum.ASH_PROCESSING_MATERIAL.getCode());
            skuServicesForm.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesForm);
            for (SkuServiceMaterialDO skuServiceMaterialDO : skuExtendVO.getAshProcessingMaterialList()) {
                skuServiceMaterialDO.setServiceId(skuServicesForm.getId());
                skuServiceMaterialMapper.insert(skuServiceMaterialDO);
            }
        }

        //骨灰装殓配置
        if (Objects.equals(skuExtendVO.getBoneashSwitch(), BaseEnum.YES_ONE.getKey())) {
            SkuServicesFormDO skuServicesFormDO = new SkuServicesFormDO();
            skuServicesFormDO.setServiceName(ServiceTypeEnum.BONE_ASH_CONFIG.getDescription());
            skuServicesFormDO.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesFormDO.setType(ServiceTypeEnum.BONE_ASH_CONFIG.getCode());
            skuServicesFormDO.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesFormDO);
            for (SkuServiceDetailsDO skuServiceDetails : skuExtendVO.getBoneashList()) {
                skuServiceDetails.setServiceId(skuServicesFormDO.getId());
                skuServiceDetailsMapper.insert(skuServiceDetails);
            }
        }

        //纪念品配置
        if (Objects.equals(skuExtendVO.getSouvenirSwitch(), BaseEnum.YES_ONE.getKey())) {
            SkuServicesFormDO skuServicesFormDO = new SkuServicesFormDO();
            skuServicesFormDO.setServiceName(ServiceTypeEnum.SOUVENIR_CONFIG.getDescription());
            skuServicesFormDO.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuServicesFormDO.setType(ServiceTypeEnum.SOUVENIR_CONFIG.getCode());
            skuServicesFormDO.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuServicesFormDO);
            for (SkuServiceDetailsDO skuServiceDetails : skuExtendVO.getSouvenirList()) {
                skuServiceDetails.setServiceId(skuServicesFormDO.getId());
                skuServiceDetailsMapper.insert(skuServiceDetails);
            }
            SkuServicesFormDO skuForm = new SkuServicesFormDO();
            skuForm.setServiceName(ServiceTypeEnum.SOUVENIR_DELIVERY.getDescription());
            skuForm.setIsEnabled(BaseEnum.YES_ONE.getKey());
            skuForm.setType(ServiceTypeEnum.SOUVENIR_DELIVERY.getCode());
            skuForm.setName(skuExtendVO.getSkuFormName());
            skuServicesFormMapper.insert(skuForm);
            for (SkuServiceDeliverDO skuServiceDeliverDO : skuExtendVO.getSouvenirDeliverList()) {
                skuServiceDeliverDO.setServiceId(skuForm.getId());
                skuServiceDeliverMapper.insert(skuServiceDeliverDO);
            }
        }
    }

    @Override
    public SkuExtendVO getSkuExtend(Integer formId) {
        // 1. 查询所有与 formId 相关的扩展服务配置（已包含详情、物料等关联数据）
        List<SkuServiceExtendVO> skuServiceExtendVOList = skuServicesFormMapper.selectSkuServiceExtendWithDetails(formId);

        // 2. 创建返回对象
        SkuExtendVO skuExtendVO = new SkuExtendVO();
        // 可以设置 skuFormName，如果 formId 能关联到表单名称的话
        // skuExtendVO.setSkuFormName(...);

        // 3. 遍历查询结果，按类型分类赋值
        for (SkuServiceExtendVO skuServiceExtendVO : skuServiceExtendVOList) {
            // 注意：数据库中 type 是 tinyint，但 VO 中定义为 String，需要转换或比较字符串
            // 枚举中 code 是 int，所以最好将 VO 的 type 转为 Integer 进行比较
            Integer typeCode;
            try {
                typeCode = Integer.valueOf(skuServiceExtendVO.getType());
            } catch (NumberFormatException e) {
                // 如果 type 无法转为数字，跳过这条记录或记录日志
                continue;
            }

            // 使用 switch 或 if-else 根据 typeCode 赋值
            if (ServiceTypeEnum.TRANSPORT_CAR_CONFIG.getCode() == typeCode) {
                // 接运车辆配置
                skuExtendVO.setTransportCarSwitch(skuServiceExtendVO.getIsEnabled());
                skuExtendVO.setTransportCarList(skuServiceExtendVO.getSkuServiceDetailsDOList());

            } else if (ServiceTypeEnum.TRANSPORT_CAR_MATERIAL.getCode() == typeCode) {
                if (ObjectUtils.isEmpty(skuExtendVO.getTransportCarMaterialList())) {
                    skuExtendVO.setTransportCarMaterialList(skuServiceExtendVO.getSkuServiceMaterialDOList());
                }
            } else if (ServiceTypeEnum.BODY_TRANSPORT_CONFIG.getCode() == typeCode) {
                // 遗体运输目的地配置
                skuExtendVO.setTrafficSwitch(skuServiceExtendVO.getIsEnabled());
                skuExtendVO.setTrafficList(skuServiceExtendVO.getSkuServiceTransportDOList()); // 注意：这里用 TransportDO

            } else if (ServiceTypeEnum.BODY_TRANSPORT_MATERIAL.getCode() == typeCode) {
                // 遗体运输目的地物料
                if (ObjectUtils.isEmpty(skuExtendVO.getTrafficMaterialList())) {
                    skuExtendVO.setTrafficMaterialList(skuServiceExtendVO.getSkuServiceMaterialDOList());
                }

            } else if (ServiceTypeEnum.BODY_CLEAN_CONFIG.getCode() == typeCode) {
                // 遗体清洁配置
                skuExtendVO.setCleanSwitch(skuServiceExtendVO.getIsEnabled());
                skuExtendVO.setCleanList(skuServiceExtendVO.getSkuServiceDetailsDOList());

            } else if (ServiceTypeEnum.BODY_CLEAN_MATERIAL.getCode() == typeCode) {
                // 遗体清洁物料
                if (ObjectUtils.isEmpty(skuExtendVO.getCleanMaterialList())) {
                    skuExtendVO.setCleanMaterialList(skuServiceExtendVO.getSkuServiceMaterialDOList());
                }
            } else if (ServiceTypeEnum.MEMORIAL_CONFIG.getCode() == typeCode) {
                // 追思告别配置
                skuExtendVO.setReflectionSwitch(skuServiceExtendVO.getIsEnabled());
                skuExtendVO.setReflectionList(skuServiceExtendVO.getSkuServiceDetailsDOList());
            } else if (ServiceTypeEnum.MEMORIAL_MATERIAL.getCode() == typeCode) {
                // 追思告别物料
                if (ObjectUtils.isEmpty(skuExtendVO.getReflectionMaterialList())) {
                    skuExtendVO.setReflectionMaterialList(skuServiceExtendVO.getSkuServiceMaterialDOList());
                }
            } else if (ServiceTypeEnum.CREMATION_CONFIG.getCode() == typeCode) {
                // 遗体火化配置
                skuExtendVO.setCremationSwitch(skuServiceExtendVO.getIsEnabled());
                skuExtendVO.setCremationList(skuServiceExtendVO.getSkuServiceDetailsDOList());
            } else if (ServiceTypeEnum.CREMATION_MATERIAL.getCode() == typeCode) {
                // 遗体火化物料
                if (ObjectUtils.isEmpty(skuExtendVO.getCremationMaterialList())) {
                    skuExtendVO.setCremationMaterialList(skuServiceExtendVO.getSkuServiceMaterialDOList());
                }

            } else if (ServiceTypeEnum.ASH_PROCESSING_CONFIG.getCode() == typeCode) {
                // 骨灰处理配置
                skuExtendVO.setAshProcessingSwitch(skuServiceExtendVO.getIsEnabled());
                skuExtendVO.setAshProcessingList(skuServiceExtendVO.getSkuServiceDetailsDOList());

            } else if (ServiceTypeEnum.ASH_PROCESSING_DELIVERY.getCode() == typeCode) {
                // 骨灰处理配送方式 (补充)
                if (ObjectUtils.isEmpty(skuExtendVO.getAshProcessingDeliverList())) {
                    skuExtendVO.setAshProcessingDeliverList(skuServiceExtendVO.getSkuServiceDeliverDOList());
                }
            } else if (ServiceTypeEnum.ASH_PROCESSING_MATERIAL.getCode() == typeCode) {
                // 骨灰处理物料
                if (ObjectUtils.isEmpty(skuExtendVO.getAshProcessingMaterialList())) {
                    skuExtendVO.setAshProcessingMaterialList(skuServiceExtendVO.getSkuServiceMaterialDOList());
                }
            } else if (ServiceTypeEnum.BONE_ASH_CONFIG.getCode() == typeCode) {
                // 骨灰装殓配置
                skuExtendVO.setBoneashSwitch(skuServiceExtendVO.getIsEnabled());
                skuExtendVO.setBoneashList(skuServiceExtendVO.getSkuServiceDetailsDOList());
                // 注意：骨灰装殓是否有物料？根据你的 DO 列表，没有 material 字段

            } else if (ServiceTypeEnum.SOUVENIR_CONFIG.getCode() == typeCode) {
                // 纪念品配置
                skuExtendVO.setSouvenirSwitch(skuServiceExtendVO.getIsEnabled());
                skuExtendVO.setSouvenirList(skuServiceExtendVO.getSkuServiceDetailsDOList());
            } else if (ServiceTypeEnum.SOUVENIR_DELIVERY.getCode() == typeCode) {
                // 纪念品配送方式 (补充)
                if (ObjectUtils.isEmpty(skuExtendVO.getSouvenirDeliverList())) {
                    skuExtendVO.setSouvenirDeliverList(skuServiceExtendVO.getSkuServiceDeliverDOList());
                }
            }
            // 可以添加 default 处理未知类型
        }

        // 4. 返回组装好的对象
        return skuExtendVO;
    }

    @Override
    public void updateSku(SkuSaveReqVO updateReqVO) {
        // 校验存在
        validateSkuExists(updateReqVO.getSkuId());
        // 更新
        SkuDO updateObj = BeanUtils.toBean(updateReqVO, SkuDO.class);
        skuMapper.updateById(updateObj);
    }

    @Override
    @Transactional
    public void updateProp(SkuPropVO skuPropVO) {
        //保存sku
        if (CollectionUtil.isNotEmpty(skuPropVO.getSkuList())) {
            List<SkuDO> skuList = skuPropVO.getSkuList();
            List<SkuDO> skuListNew = new ArrayList<>();
            for (SkuDO sku : skuList) {
                if (Objects.equals(BaseEnum.YES_ONE.getKey(), sku.getIsExist())) {
                    sku.setProdId(skuPropVO.getProdId());
                    skuListNew.add(sku);
                }
            }
            if (CollUtil.isNotEmpty(skuListNew)) {
                skuMapper.insertBatch(skuListNew);
            }
        }
        prodExtendMapper.updateByProdId(skuPropVO.getProdId(), skuPropVO.getIsDisable(), skuPropVO.getIsExpire());
        //保存规格
        prodPropService.updateProdPropAndValues(skuPropVO);
    }


    @Override
    public void updatePropVal(Long id, String propValue) {
        ProdPropValueDO prodPropValueDO = prodPropValueMapper.selectById(id);
        ProdPropDO prodPropDO =prodPropMapper.selectById(prodPropValueDO.getPropId());
        List<SkuDO> skuDOList = skuMapper.getSkuListByName(prodPropDO.getProdId(),prodPropValueDO.getPropValue());
        for (SkuDO skuDO : skuDOList) {
            if (skuDO.getProperties() != null) {
                String[] split = skuDO.getProperties().split(",");
                for (String s : split) {
                    if (s.equals(prodPropValueDO.getPropValue())) {
                        skuDO.setProperties(propValue);
                        skuDO.setSkuName(propValue);
                        skuMapper.updateById(skuDO);
                    }
                }
            }
        }
        prodPropValueDO.setPropValue(propValue);
        prodPropValueMapper.updateById(prodPropValueDO);
    }


    @Override
    public void deleteProp(Long id) {
        ProdPropValueDO prodPropValueDO = prodPropValueService.getById(id);
        ProdPropDO prodPropDO =prodPropMapper.selectById(prodPropValueDO.getPropId());
        prodPropValueService.deleteProdPropValue(id);
        List<SkuDO> skuDOList = skuMapper.getSkuListByName(prodPropDO.getProdId(),prodPropValueDO.getPropValue());
        List<Long> skuids = new ArrayList<>();
        for (SkuDO skuDO : skuDOList) {
            if (skuDO.getProperties() != null) {
                String[] split = skuDO.getProperties().split(",");
                for (String s : split) {
                    if (s.equals(prodPropValueDO.getPropValue())) {
                        skuids.add(skuDO.getSkuId());
                    }
                }
            }
        }
        if (CollUtil.isNotEmpty(skuids)) {
            skuMapper.batchSkuDeleted(skuids);
        }
    }

    @Override
    public void disableProp(Long id, Integer state) {
        ProdPropValueDO prodPropValueDO = prodPropValueService.getById(id);
        prodPropValueDO.setState(state);
        prodPropValueService.updateById(prodPropValueDO);
        ProdPropDO prodPropDO =prodPropMapper.selectById(prodPropValueDO.getPropId());
        if (Objects.equals(BaseEnum.NO_ZERO.getKey(), state)) {
            List<SkuDO> skuDOList = skuMapper.getSkuListByName(prodPropDO.getProdId(),prodPropValueDO.getPropValue());
            List<SkuDO> skuDOList1 = new ArrayList<>();
            for (SkuDO skuDO : skuDOList) {
                if (skuDO.getProperties() != null) {
                    String[] split = skuDO.getProperties().split(",");
                    for (String s : split) {
                        if (s.equals(prodPropValueDO.getPropValue())) {
                            skuDO.setIsShelf(BaseEnum.NO_ZERO.getKey());
                            skuDOList1.add(skuDO);
                        }
                    }
                }
            }
            if (CollUtil.isNotEmpty(skuDOList1)) {
                skuMapper.updateBatch(skuDOList1);
            }
        }
    }


    @Override
    public SkuPropInfoVO getSKuPropList(Long prodId) {
        LambdaQueryWrapper<ProdPropDO> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ProdPropDO::getProdId, prodId);
        wrapper.eq(ProdPropDO::getState, BaseEnum.YES_ONE.getKey())
                .orderByAsc(ProdPropDO::getSort);
        List<ProdPropDO> list = prodPropService.list(wrapper);
        list.forEach(prop -> {
            List<ProdPropValueDO> values = prodPropValueService.list(
                    new LambdaQueryWrapper<ProdPropValueDO>()
                            .eq(ProdPropValueDO::getPropId, prop.getId())
                            .eq(ProdPropValueDO::getDeleted, BaseEnum.NO_ZERO.getKey())
                            .orderByAsc(ProdPropValueDO::getSort)
            );
            prop.setProdPropValues(values);
        });
        SkuPropInfoVO skuPropInfoVO = new SkuPropInfoVO();
        skuPropInfoVO.setProdId(prodId);
        skuPropInfoVO.setProdPropSaveReqVO(list);
        ProdExtendDO prodExtendDO = prodExtendService.getOne(new LambdaQueryWrapper<ProdExtendDO>().eq(ProdExtendDO::getProdId, prodId));
        skuPropInfoVO.setIsDisable(prodExtendDO.getIsDisable());
        skuPropInfoVO.setIsExpire(prodExtendDO.getIsExpire());
        return skuPropInfoVO;
    }

    @Override
    public PageResult<ProPropRecycleBinVO> getSKuPropRecycleBinList(ProPageReqVO proPageReqVO) {
        IPage<ProPropRecycleBinVO> prodPageList = prodPropValueMapper.getSKuPropRecycleBinList(MyBatisUtils.buildPage(proPageReqVO), proPageReqVO.getProdId(), proPageReqVO.getPropValue());
        for (ProPropRecycleBinVO prodPage : prodPageList.getRecords()) {
            if (prodPage.getDeleteTime() != null) {
                prodPage.setRemainingDays(DateUtils.getRemainingDays(prodPage.getDeleteTime()));
            }
        }
        return new PageResult<>(prodPageList.getRecords(), prodPageList.getTotal());
    }

/*    @Override
    public SkuPropInfoVO getSKuPropList(Long prodId, Integer isExpire, Integer state) {
        if (prodId == null) {
            throw new IllegalArgumentException("prodId 不能为空");
        }

        // 1. 查询商品扩展信息（用于默认值）
        ProdExtendDO extendDO = prodExtendService.getOne(
                new LambdaQueryWrapper<ProdExtendDO>().eq(ProdExtendDO::getProdId, prodId)
        );
        if (extendDO == null) {
            // 如果没有扩展信息，可返回空 VO 或抛异常，根据业务决定
            return buildEmptySkuPropInfoVO(prodId);
        }

        // 2. 设置默认值：isExpire 和 state
        Integer finalIsExpire = isExpire != null ? isExpire : extendDO.getIsExpire();
        Integer finalState = state != null ? state : extendDO.getIsDisable(); // 注意：这里你用的是 isDisable 当 state？需确认业务逻辑

        // 3. 查询有效属性列表
        LambdaQueryWrapper<ProdPropDO> propWrapper = new LambdaQueryWrapper<>();
        propWrapper.eq(ProdPropDO::getProdId, prodId)
                .eq(ProdPropDO::getState, BaseEnum.YES_ONE.getKey()) // 只查启用的属性
                .orderByAsc(ProdPropDO::getSort);

        List<ProdPropDO> propList = prodPropService.list(propWrapper);
        if (propList.isEmpty()) {
            return buildSkuPropInfoVO(prodId, propList, extendDO);
        }

        // 4. 提取所有属性 ID，用于批量查询属性值
        List<Long> propIds = propList.stream()
                .map(ProdPropDO::getId)
                .collect(Collectors.toList());

        // 5. 构建属性值查询条件（批量查询）
        LambdaQueryWrapper<ProdPropValueDO> valueWrapper = new LambdaQueryWrapper<>();
        valueWrapper.in(ProdPropValueDO::getPropId, propIds)
                .eq(ProdPropValueDO::getState, BaseEnum.YES_ONE.getKey()); // 启用状态

        // 根据 isExpire 过滤（注意字段是 getIsExpire）
        if (BaseEnum.NO_ZERO.getKey().equals(finalIsExpire)) {
            valueWrapper.eq(ProdPropValueDO::getIsExpire, BaseEnum.NO_ZERO.getKey());
        } else {
            valueWrapper.eq(ProdPropValueDO::getIsExpire, BaseEnum.YES_ONE.getKey());
        }

        // 根据 state 过滤（注意：这里你用的是 getState 字段）
        if (BaseEnum.NO_ZERO.getKey().equals(finalState)) {
            valueWrapper.eq(ProdPropValueDO::getState, BaseEnum.NO_ZERO.getKey());
        } else {
            valueWrapper.eq(ProdPropValueDO::getState, BaseEnum.YES_ONE.getKey());
        }

        valueWrapper.orderByDesc(ProdPropValueDO::getSort);

        List<ProdPropValueDO> valueList = prodPropValueService.list(valueWrapper);

        // 6. 按 propId 分组，便于后续关联
        Map<Long, List<ProdPropValueDO>> valueMap = valueList.stream()
                .collect(Collectors.groupingBy(ProdPropValueDO::getPropId));

        // 7. 关联属性与属性值
        propList.forEach(prop ->
                prop.setProdPropValues(valueMap.getOrDefault(prop.getId(), Collections.emptyList()))
        );

        // 8. 构建并返回 VO
        return buildSkuPropInfoVO(prodId, propList, extendDO);
    }*/

   /* @Override
    public SkuPropInfoVO getSKuPropList(Long prodId,Integer isExpire,Integer state) {
        LambdaQueryWrapper<ProdPropDO> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ProdPropDO::getProdId,prodId);
        wrapper.eq(ProdPropDO::getState, BaseEnum.YES_ONE.getKey())
                .orderByAsc(ProdPropDO::getSort);
        ProdExtendDO prodExtendDO = prodExtendService.getOne(new LambdaQueryWrapper<ProdExtendDO>().eq(ProdExtendDO::getProdId, prodId));
        if(isExpire==null){
            isExpire = prodExtendDO.getIsExpire();
        }
        if(state==null){
            state = prodExtendDO.getIsDisable();
        }
        List<ProdPropDO> list = prodPropService.list(wrapper);
        list.forEach(prop -> {
            LambdaQueryWrapper<ProdPropValueDO> wrapper1 = new LambdaQueryWrapper<>();
            wrapper1.eq(ProdPropValueDO::getPropId,prop.getId());
            wrapper1.eq(ProdPropValueDO::getState, BaseEnum.YES_ONE.getKey());
            if (isExpire!= null&& Objects.equals(BaseEnum.NO_ZERO.getKey(),isExpire) ) {
                wrapper1.eq(ProdPropValueDO::getIsExpire, BaseEnum.NO_ZERO.getKey());
            }else {
                wrapper1.eq(ProdPropValueDO::getIsExpire, BaseEnum.YES_ONE.getKey());
            }
            if (state!= null&& Objects.equals(BaseEnum.NO_ZERO.getKey(),state) ) {
                wrapper1.eq(ProdPropValueDO::getState, BaseEnum.NO_ZERO.getKey());
            }else {
                wrapper1.eq(ProdPropValueDO::getState, BaseEnum.YES_ONE.getKey());
            }
            wrapper1.orderByDesc(ProdPropValueDO::getSort);
            List<ProdPropValueDO> lists = prodPropValueService.list(wrapper1);
            prop.setProdPropValues(lists);
        });
        SkuPropInfoVO skuPropInfoVO = new SkuPropInfoVO();
        skuPropInfoVO.setProdId(prodId);
        skuPropInfoVO.setProdPropSaveReqVO(list);

        skuPropInfoVO.setIsDisable(prodExtendDO.getIsDisable());
        skuPropInfoVO.setIsExpire(prodExtendDO.getIsExpire());
        return skuPropInfoVO;
    }*/


    // 封装构建 VO 的逻辑，避免重复代码
    private SkuPropInfoVO buildSkuPropInfoVO(Long prodId, List<ProdPropDO> propList, ProdExtendDO extendDO) {
        SkuPropInfoVO vo = new SkuPropInfoVO();
        vo.setProdId(prodId);
        vo.setProdPropSaveReqVO(propList);
        vo.setIsDisable(extendDO.getIsDisable());
        vo.setIsExpire(extendDO.getIsExpire());
        return vo;
    }

    // 空情况处理
    private SkuPropInfoVO buildEmptySkuPropInfoVO(Long prodId) {
        SkuPropInfoVO vo = new SkuPropInfoVO();
        vo.setProdId(prodId);
        vo.setProdPropSaveReqVO(Collections.emptyList());
        vo.setIsDisable(BaseEnum.NO_ZERO.getKey()); // 默认值
        vo.setIsExpire(BaseEnum.NO_ZERO.getKey());
        return vo;
    }


    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteSku(Long id) {
        // 校验存在
        validateSkuExists(id);
        SkuDO prodSku = skuMapper.selectById(id);
        // Step 1: 获取该商品下所有未删除的 SKU 的 properties
        List<String> activeProperties = skuMapper.selectPropertiesByProdIdAndNotDeleted(prodSku.getProdId());

        // Step 2: 提取所有正在被使用的属性值（去重）
        Set<String> currentlyUsedValues = new HashSet<>();
        for (String props : activeProperties) {
            if (props != null && !props.trim().isEmpty()) {
                String[] values = props.split(",");
                for (String v : values) {
                    currentlyUsedValues.add(v.trim());
                }
            }
        }
        // 删除
        skuMapper.deleteBySkuId(id);
        // Step 3: 查询该商品下所有 rule=1 的属性值（销售属性）
        List<ProdPropValueDO> allPropValues = prodPropValueMapper.selectSalesValuesByProdId(prodSku.getProdId());
        // Step 4: 遍历每个属性值，检查是否还在被使用
        for (ProdPropValueDO pv : allPropValues) {
            String value = pv.getPropValue().trim();
            // 如果当前属性值不在“活跃使用”列表中，说明没有未删除的 SKU 使用它
            if (!currentlyUsedValues.contains(value)) {
                // 可以安全删除该属性值
                // 可以安全禁用该属性值
                ProdPropValueDO prodPropValueDO = new ProdPropValueDO();
                prodPropValueDO.setId(pv.getId());
                prodPropValueDO.setIsExpire(BaseEnum.YES_ONE.getKey());
                prodPropValueDO.setDeleteTime(new Date());
                prodPropValueMapper.updateById(prodPropValueDO);
            }
        }
    }


    @Transactional(rollbackFor = Exception.class)
    public void deleteSkus(List<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            return;
        }
        // Step 1: 查询这些 SKU 的基本信息（主要是 prod_id）
        List<SkuDO> skuList = skuMapper.selectByIds(ids);
        if (skuList.isEmpty()) {
            return;
        }
        Long prodId = skuList.get(0).getProdId();
        // 校验是否属于同一个商品（可选）
        boolean allSameProd = skuList.stream().allMatch(s -> s.getProdId().equals(prodId));
        if (!allSameProd) {
            throw new IllegalArgumentException("批量删除的 SKU 必须属于同一个商品");
        }
        // Step 3: 获取该商品下【当前仍然未删除】的 SKU 的 properties
        List<String> activeProperties = skuMapper.selectPropertiesByProdIdAndNotDeleted(prodId);
        for (Long id : ids) {
            // 删除
            skuMapper.deleteBySkuId(id);
        }
        // Step 4: 提取所有仍在使用的属性值（去重 + trim）
        Set<String> currentlyUsedValues = new HashSet<>();
        for (String props : activeProperties) {
            if (props != null && !props.trim().isEmpty()) {
                String[] values = props.split(",");
                for (String v : values) {
                    currentlyUsedValues.add(v.trim());
                }
            }
        }
        // Step 5: 查询该商品下所有 rule=1 的销售属性值（未删除的）
        List<ProdPropValueDO> allPropValues = prodPropValueMapper.selectSalesValuesByProdId(prodId);

        // Step 6: 收集需要删除的属性值 ID
        List<Long> valueIdsToDelete = new ArrayList<>();
        for (ProdPropValueDO pv : allPropValues) {
            String value = pv.getPropValue().trim();
            if (!currentlyUsedValues.contains(value)) {
                valueIdsToDelete.add(pv.getId());
            }
        }
        // Step 7: 批量删除无用的属性值
        if (!valueIdsToDelete.isEmpty()) {
            prodPropValueMapper.batchMarkDeleted(valueIdsToDelete);
        }
    }

    //恢复SKU
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void restoreSkuList(List<Long> ids) {
        List<SkuDO> skuList = skuMapper.getskuListBySkuIds(ids);
        if (skuList.isEmpty()) {
            return;
        }

        // 获取商品下所有被删除的SKU（除了当前要恢复的 ids）
        List<SkuDO> skuAllDeletedList = skuMapper.getskuListByDeleted(skuList.get(0).getProdId(), ids);

        Set<String> allDeletedValues = new HashSet<>();
        for (SkuDO sku : skuAllDeletedList) {
            if (sku.getProperties() != null && !sku.getProperties().trim().isEmpty()) {
                String[] values = sku.getProperties().split(",");
                for (String v : values) {
                    allDeletedValues.add(v.trim());
                }
            }
        }

        Set<String> currentlyUsedValues = new HashSet<>();
        for (SkuDO sku : skuList) {
            skuMapper.updateSkuDeleted(sku.getSkuId());
            if (sku.getProperties() != null && !sku.getProperties().trim().isEmpty()) {
                String[] values = sku.getProperties().split(",");
                for (String v : values) {
                    currentlyUsedValues.add(v.trim());
                }
            }
        }

        // === 核心修改点：提取 currentlyUsedValues 中不在 allDeletedValues 的值（即新增启用的规格值）===
        Set<String> valuesToRestore = new HashSet<>(currentlyUsedValues);
        valuesToRestore.removeAll(allDeletedValues); // 只保留“之前被删掉过”的规格值

        // 如果没有需要恢复的规格值，直接返回
        if (valuesToRestore.isEmpty()) {
            return;
        }

        // 查询商品下所有属性值
        Long prodId = skuList.get(0).getProdId();
        List<ProdPropValueDO> allPropValues = prodPropValueMapper.selectRestoreProp(prodId);

        if (!allPropValues.isEmpty()) {
            for (ProdPropValueDO pv : allPropValues) {
                // 仅当该属性值是“当前使用”且“之前被删除”的（即在 valuesToRestore 中），才恢复
                if (valuesToRestore.contains(pv.getPropValue())) {
                    pv.setIsExpire(BaseEnum.NO_ZERO.getKey()); // 标记为未过期
                    prodPropValueMapper.updateById(pv);
                }
            }
        }
    }

    @Override
    public void restorePropList(List<Long> ids) {
        prodPropValueMapper.restorePropValue(ids);
        List<ProdPropValueDO> prodPropValueDOList = prodPropValueMapper.getskuListByPropValueIds(ids);
        for (ProdPropValueDO prodPropValueDO : prodPropValueDOList) {
            int maxPropValue =prodPropValueMapper.getMaxPropValue(prodPropValueDO.getPropId());
            prodPropValueDO.setSort(maxPropValue+1);
            prodPropValueService.updateById(prodPropValueDO);
        }
    }


    @Override
    public void updatSkuIsShelf(Long id, Integer isShelf) {
        // 校验存在
        validateSkuExists(id);

        SkuDO prodSku = skuMapper.selectById(id);
        // Step 1: 获取该商品下所有未禁用的 SKU 的 properties
        List<String> activeProperties = skuMapper.selectPropertiesByProdIdShelf(prodSku.getProdId());
        prodSku.setIsShelf(isShelf);
        skuMapper.updateById(prodSku);
        // Step 2: 提取所有正在被使用的属性值（去重）
        Set<String> currentlyUsedValues = new HashSet<>();
        for (String props : activeProperties) {
            if (props != null && !props.trim().isEmpty()) {
                String[] values = props.split(",");
                for (String v : values) {
                    currentlyUsedValues.add(v.trim());
                }
            }
        }
        // Step 3: 查询该商品下所有 rule=1 的属性值（销售属性）
        List<ProdPropValueDO> allPropValues = prodPropValueMapper.selectSalesValuesByState(prodSku.getProdId());
        // Step 4: 遍历每个属性值，检查是否还在被使用
        for (ProdPropValueDO pv : allPropValues) {
            String value = pv.getPropValue().trim();
            // 如果当前属性值不在“活跃使用”列表中，说明没有未删除的 SKU 使用它
            if (!currentlyUsedValues.contains(value)) {
                // 可以安全禁用该属性值
                ProdPropValueDO prodPropValueDO = new ProdPropValueDO();
                prodPropValueDO.setId(pv.getId());
                prodPropValueDO.setState(BaseEnum.NO_ZERO.getKey());
                prodPropValueMapper.updateById(prodPropValueDO);
            }
        }
    }

    @Override
    public void updatSkuIsShelfs(List<Long> ids, Integer isShelf) {
        if (ids == null || ids.isEmpty()) {
            return;
        }

        // Step 1: 查询这些 SKU 的基本信息（主要是 prod_id）
        List<SkuDO> skuList = skuMapper.selectByIds(ids);
        if (skuList.isEmpty()) {
            return;
        }

        Long prodId = skuList.get(0).getProdId();
        // 校验是否属于同一个商品（可选）
        boolean allSameProd = skuList.stream().allMatch(s -> s.getProdId().equals(prodId));
        if (!allSameProd) {
            throw new IllegalArgumentException("批量删除的 SKU 必须属于同一个商品");
        }
        for (Long id : ids) {
            SkuDO sku = new SkuDO();
            sku.setSkuId(id);
            sku.setIsShelf(isShelf);
            skuMapper.updateById(sku);
        }
        // ================================
        //新增逻辑：判断商品整体上下架状态，并更新 tz_prod_prop_value.state
        // ================================
        // 查询该商品下所有未删除的 SKU 的 is_shelf 状态
        List<Integer> allSkuShelfStatus = skuMapper.selectShelfStatusByProdId(prodId);

        if (allSkuShelfStatus.isEmpty()) {
            return; // 没有 SKU，无需处理
        }

        boolean allShelf = allSkuShelfStatus.stream().allMatch(status -> status == 1); // 全部上架
        boolean allOffShelf = allSkuShelfStatus.stream().allMatch(status -> status == 0); // 全部下架

        Integer targetState = null;
        if (allShelf) {
            targetState = 1; // 启用
        } else if (allOffShelf) {
            targetState = 0; // 禁用
        }
        // 混合状态：不修改 state
        // 如果需要更新状态，则批量更新 tz_prod_prop_value 的 state 字段
        if (targetState != null) {
            prodPropValueMapper.updateStateByProdId(prodId, targetState);
        }
    }


    private void validateSkuExists(Long id) {
        if (skuMapper.selectById(id) == null) {
            throw exception(ErrorCodeConstants.SKU_NOT_EXISTS);
        }
    }

    @Override
    public SkuDO getSku(Long id) {
        return skuMapper.selectById(id);
    }

    @Override
    public PageResult<SkuRecycleBinVO> getSkuRecycleBinPageList(SkuPageReqVO pageReqVO) {
        IPage<SkuRecycleBinVO> prodPageList = skuMapper.getSkuRecycleBinPageList(MyBatisUtils.buildPage(pageReqVO), pageReqVO.getProdId(), pageReqVO.getProperties());
        for (SkuRecycleBinVO prodPage : prodPageList.getRecords()) {
            if (prodPage.getDeleteTime() != null) {
                prodPage.setRemainingDays(DateUtils.getRemainingDays(prodPage.getDeleteTime()));
            }
        }
        return new PageResult<>(prodPageList.getRecords(), prodPageList.getTotal());
    }

    @Override
    public PageResult<SkuDO> getSkuPageList(SkuPageReqVO pageReqVO) {
        IPage<SkuDO> prodPageList = skuMapper.getSkuPageList(MyBatisUtils.buildPage(pageReqVO), pageReqVO.getProdId(), pageReqVO.getSkuId(), pageReqVO.getProperties());

        return new PageResult<>(prodPageList.getRecords(), prodPageList.getTotal());
    }


    @Override
    public PageResult<SkuDO> getSkuPage(SkuPageReqVO pageReqVO) {
        return null;
    }

    @Override
    @Transactional
    public void updateServiceDetails(List<SkuServiceDetailsDO> skuServiceDetailsList) {
        if (ObjectUtils.isNotEmpty(skuServiceDetailsList)) {
            skuServiceDetailsMapper.delete(SkuServiceDetailsDO::getServiceId, skuServiceDetailsList.get(0).getServiceId());
            skuServiceDetailsMapper.insertBatch(skuServiceDetailsList);
        }
    }

    @Override
    @Transactional
    public void updateMaterial(List<SkuServiceMaterialDO> skuServiceMaterialList) {
        if (ObjectUtils.isNotEmpty(skuServiceMaterialList)) {
            skuServiceMaterialMapper.delete(SkuServiceMaterialDO::getServiceId, skuServiceMaterialList.get(0).getServiceId());
            skuServiceMaterialMapper.insertBatch(skuServiceMaterialList);
        }
    }

    @Override
    @Transactional
    public void updateTransportAdress(List<SkuServiceTransportDO> skuServiceTransportDOList) {
        if (ObjectUtils.isNotEmpty(skuServiceTransportDOList)) {
            skuServiceTransportMapper.delete(SkuServiceTransportDO::getServiceId, skuServiceTransportDOList.get(0).getServiceId());
            skuServiceTransportMapper.insertBatch(skuServiceTransportDOList);
        }
    }

    @Override
    public void updateDeliver(List<SkuServiceDeliverDO> skuServiceDeliverList) {
        if (ObjectUtils.isNotEmpty(skuServiceDeliverList)) {
            skuServiceDeliverMapper.delete(SkuServiceDeliverDO::getServiceId, skuServiceDeliverList.get(0).getServiceId());
            skuServiceDeliverMapper.insertBatch(skuServiceDeliverList);
        }
    }
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void reduceStocks(Long skuId, Integer stocksNum) {
        if (stocksNum == null || stocksNum <= 0) {
            stocksNum=1;
        }
        // 查询SKU信息
        SkuDO sku = skuMapper.selectById(skuId);
        if (sku == null) {
            //商品不存在
            throw exception(ErrorCodeConstants.SKU_DOES_NOT_EXIST);
        }
        if (sku.getDeleted() == 1) {
            //商品已删除
            throw exception(ErrorCodeConstants.SKU_DELETE);
        }
        if (sku.getStatus() == 0) {
            //商品已禁用
            throw exception(ErrorCodeConstants.SKU_DISABLE);
        }
        // 检查无限库存标志
        if (sku.getStocksFlg() != null && sku.getStocksFlg() == 1) {
            log.info("SKU {} 为无限库存，无需扣减", skuId);
            return;
        }

        // 检查库存是否充足
        if (sku.getStocks() < stocksNum) {
            throw new IllegalArgumentException("库存不足，当前库存：" + sku.getStocks() + "，需要：" + stocksNum);
        }

        // 扣减库存
        int updateRows = skuMapper.reduceStocks(skuId, stocksNum, sku.getVersion());

        if (updateRows == 0) {
            // 可能是版本号冲突或库存不足
            SkuDO currentSku = skuMapper.selectById(skuId);
            if (currentSku.getStocks() < stocksNum) {
                throw new IllegalArgumentException("库存不足，当前库存：" + sku.getStocks() + "，需要：" + stocksNum);
            } else {
                throw new IllegalArgumentException("扣减库存失败，请重试");
            }
        }
        log.info("扣减库存成功 - SKU: {}, 扣减数量: {}, 剩余库存: {}",skuId, stocksNum, sku.getStocks() - stocksNum);
    }

    @Override
    public void increaseStocks(Long skuId, Integer stocksNum) {
        // 查询SKU信息
        SkuDO sku = skuMapper.selectById(skuId);
        // 检查无限库存标志
        if (sku.getStocksFlg() != null && sku.getStocksFlg() == 1) {
            log.info("SKU {} 为无限库存，无需增加", skuId);
            return;
        }
        skuMapper.increaseStocks(skuId, stocksNum);
    }

}