package com.yiqi.core.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.yiqi.common.enums.StatusType;
import com.yiqi.common.exception.ServiceException;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.yiqi.common.core.domain.AuthHolder;
import com.yiqi.common.core.domain.entity.SysUser;
import com.yiqi.common.enums.OrderSourceType;
import com.yiqi.common.enums.SourceType;
import com.yiqi.common.utils.DateUtils;
import com.yiqi.common.utils.SecurityUtils;
import com.yiqi.core.domain.GoodsSkuStore;
import com.yiqi.core.mapper.GoodsSkuStoreMapper;
import com.yiqi.core.service.IGoodsSkuStoreService;
import com.yiqi.order.domain.OrderGoods;
import com.yiqi.order.domain.OrderGoodsSku;
import com.yiqi.order.domain.OrderPurchaseGoods;
import com.yiqi.order.domain.OrderPurchaseGoodsSku;
import com.yiqi.system.domain.ManageFactory;
import com.yiqi.system.domain.SysStore;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 商品物料门店关联Service业务层处理
 *
 * @author ruoyi
 * @date 2023-09-05
 */
@Service
public class GoodsSkuStoreServiceImpl extends ServiceImpl<GoodsSkuStoreMapper, GoodsSkuStore> implements IGoodsSkuStoreService {

    /**
     * 查询商品物料门店关联
     *
     * @param id 商品物料门店关联主键
     * @return 商品物料门店关联
     */
    @Override
    public GoodsSkuStore selectGoodsSkuStoreById(Long id) {
        return baseMapper.selectGoodsSkuStoreById(id);
    }

    /**
     * 查询商品物料门店关联列表
     *
     * @param goodsSkuStore 商品物料门店关联
     * @return 商品物料门店关联
     */
    @Override
    public List<GoodsSkuStore> selectGoodsSkuStoreList(GoodsSkuStore goodsSkuStore) {
        return baseMapper.selectGoodsSkuStoreList(goodsSkuStore);
    }

    /**
     * 新增商品物料门店关联
     *
     * @param goodsSkuStore 商品物料门店关联
     * @return 结果
     */
    @Override
    public int insertGoodsSkuStore(GoodsSkuStore goodsSkuStore) {
        goodsSkuStore.setCreateTime(DateUtils.getNowDate());
        return baseMapper.insertGoodsSkuStore(goodsSkuStore);
    }

    /**
     * 修改商品物料门店关联
     *
     * @param goodsSkuStore 商品物料门店关联
     * @return 结果
     */
    @Override
    public int updateGoodsSkuStore(GoodsSkuStore goodsSkuStore) {
        goodsSkuStore.setUpdateTime(DateUtils.getNowDate());
        return baseMapper.updateGoodsSkuStore(goodsSkuStore);
    }

    /**
     * 批量删除商品物料门店关联
     *
     * @param ids 需要删除的商品物料门店关联主键
     * @return 结果
     */
    @Override
    public int deleteGoodsSkuStoreByIds(Long[] ids) {
        return baseMapper.deleteGoodsSkuStoreByIds(ids);
    }

    /**
     * 删除商品物料门店关联信息
     *
     * @param id 商品物料门店关联主键
     * @return 结果
     */
    @Override
    public int deleteGoodsSkuStoreById(Long id) {
        return baseMapper.deleteGoodsSkuStoreById(id);
    }

    /**
     * 修改商品物料门店关联状态
     *
     * @param goodsSkuStore 商品物料门店关联
     * @return 结果
     */
    @Override
    public int updateGoodsSkuStoreStatus(GoodsSkuStore goodsSkuStore) {
        goodsSkuStore.setUpdateBy(SecurityUtils.getUsername());
        goodsSkuStore.setUpdateById(SecurityUtils.getUserId());
        goodsSkuStore.setUpdateTime(DateUtils.getNowDate());
        return baseMapper.updateGoodsSkuStore(goodsSkuStore);
    }

    /**
     * 查询商品物料门店 通过物料id
     *
     * @param skuId 商品物料id
     * @return 商品规格集合
     */
    @Override
    public List<GoodsSkuStore> getSkuStoreListBySkuId(Long skuId) {
        if (skuId == null) {
            return null;
        }
        return baseMapper.getSkuStoreListBySkuId(skuId);
    }

    @Override
    public GoodsSkuStore getSkuStoreBySkuIdAndOrgId(Long skuId, String sourceType, Long orgId) {
        QueryWrapper<GoodsSkuStore> wrapper = new QueryWrapper<>();
        wrapper.eq("goods_sku_id", skuId);
        wrapper.eq("source_type", sourceType);
        if (!sourceType.equals(SourceType.MANAGER.getCode())) {
            wrapper.eq("target_id", orgId);
        }
        return baseMapper.selectOne(wrapper);
    }

    /**
     * 批量新增物料工厂关系
     *
     * @param goodsSkuStore 商品物料门店
     * @return 结果
     */
    @Override
    public int insertSkuToAllFactory(GoodsSkuStore goodsSkuStore) {
        return baseMapper.insertSkuToAllFactory(goodsSkuStore);
    }

    /**
     * 批量新增物料门店关系
     *
     * @param goodsSkuStore 商品物料门店
     * @return 结果
     */
    @Override
    public int insertSkuToAllStore(GoodsSkuStore goodsSkuStore) {
        return baseMapper.insertSkuToAllStore(goodsSkuStore);
    }

    /**
     * 批量新增工厂和全部商品物料关系
     *
     * @param manageFactory 工厂实例
     * @return 结果
     */
    @Override
    public int insertFactoryToAllSku(ManageFactory manageFactory) {
        return baseMapper.insertFactoryToAllSku(manageFactory);
    }

    /**
     * 批量新增门店和全部商品物料关系
     *
     * @param sysStore 门店实例
     * @return 结果
     */
    @Override
    public int insertStoreToAllSku(SysStore sysStore) {
        return baseMapper.insertStoreToAllSku(sysStore);
    }

    /**
     * 更新商品物料库存
     *
     * @param goodsSkuStoreList 更新商品物料库存
     * @return 结果
     */
    @Override
    public int addGoodsSkuStockByOrderItems(List<GoodsSkuStore> goodsSkuStoreList) {
        return baseMapper.addGoodsSkuStockByOrderItems(goodsSkuStoreList);
    }

    /**
     * 减去商品物料库存
     *
     * @param goodsSkuStoreList 父级对象， 需要减去商品物料库存的对象，也就是父级
     * @return 结果
     */
    @Override
    public int minusGoodsSkuStockByOrder(List<GoodsSkuStore> goodsSkuStoreList) {
        GoodsSkuStore store = goodsSkuStoreList.get(0);
        List<Long> goodsSkuIdList = goodsSkuStoreList.stream().map(GoodsSkuStore::getGoodsSkuId).collect(Collectors.toList());
        // 查询父级当前库存
        List<GoodsSkuStore> skuStockByNow = baseMapper.getSkuStockByNow(goodsSkuIdList, store.getSourceType(), store.getTargetId());
        // 比较本次订单需要扣掉的数量，和当前库存
        List<Long> skuIdList = this.compareStock(goodsSkuStoreList, skuStockByNow);
        if (skuIdList.size() > 0) {
            throw new ServiceException("该商品库存不存");
        }
        return baseMapper.minusGoodsSkuStockByOrder(goodsSkuStoreList);
    }

    @Override
    public int addOrMinusGoodsSkuStockByGoods(Integer addOrMinus, OrderGoods orderGoods, List<OrderGoodsSku> orderGoodsSkuList) {
        if (CollUtil.isNotEmpty(orderGoodsSkuList)) {
            if (addOrMinus == 0) {
                orderGoodsSkuList.forEach(orderGoodsSku -> {
                    //扣减库存，如果库存不足，则扣减失败
                    int result = baseMapper.minusGoodsSkuStockNotCheckByStore(orderGoods.getSourceType(), orderGoods.getOrgId(), orderGoodsSku.getSkuId(), orderGoodsSku.getBuyNum());
                    if (result == 0) {
                        log.error(String.format("%s门店零售库存不足或者已下架", orderGoodsSku.getGoodsName()));
                    }
                });
            } else {
                orderGoodsSkuList.forEach(orderGoodsSku -> {
                    //扣减库存，如果库存不足，则扣减失败
                    int result = baseMapper.addGoodsSkuStockNotCheckByStore(orderGoods.getSourceType(), orderGoods.getOrgId(), orderGoodsSku.getSkuId(), orderGoodsSku.getBuyNum());
                    if (result == 0) {
                        log.error(String.format("%s门店零售库存不足或者已下架", orderGoodsSku.getGoodsName()));
                    }
                });
            }
            return 1;
        }
        return 0;
    }


    /**
     * 比较库存
     *
     * @param goodsSkuStoreList
     * @param skuStockByNow
     * @return
     */
    private List<Long> compareStock(List<GoodsSkuStore> goodsSkuStoreList, List<GoodsSkuStore> skuStockByNow) {
        List<Long> skuIdList = new ArrayList<>();
        // 订单数量
        Map<Long, Integer> stockMap = goodsSkuStoreList.stream().collect(Collectors.toMap(GoodsSkuStore::getGoodsSkuId, GoodsSkuStore::getStock));
        // 现有库存数量
        Map<Long, Integer> stockMapNow = skuStockByNow.stream().filter(nowStore -> nowStore.getStock() != null).collect(Collectors.toMap(GoodsSkuStore::getGoodsSkuId, GoodsSkuStore::getStock));
        if (CollUtil.isEmpty(stockMapNow)) {
            throw new ServiceException("库存数量不足");
        }
        // 循环比较
        for (Map.Entry<Long, Integer> entry : stockMap.entrySet()) {
            if (stockMapNow.get(entry.getKey()) < entry.getValue()) {
                skuIdList.add(entry.getKey());
            }
        }
        return skuIdList;
    }


    /**
     * 组装进货加库存的VO
     *
     * @param orderPurchaseGoodsSkus
     * @return
     */
    @Override
    public List<GoodsSkuStore> buildGoodsSkuStockVOByPurchase2AddStock(List<OrderPurchaseGoodsSku> orderPurchaseGoodsSkus, OrderPurchaseGoods orderPurchaseGoods) {
        List<GoodsSkuStore> goodsSkuStoreList = new ArrayList<>();
        for (OrderPurchaseGoodsSku goodsSkus : orderPurchaseGoodsSkus) {
            GoodsSkuStore goodsSkuStore = getSkuStoreBySkuIdAndOrgId(goodsSkus.getSkuId(), orderPurchaseGoods.getSourceType(), orderPurchaseGoods.getOrgId());
            if (goodsSkuStore == null) {
                throw new ServiceException("该商品库存不存在");
            }
            goodsSkuStore.setStock(goodsSkus.getBuyNum());
            goodsSkuStore.buildUpdateData();
            goodsSkuStoreList.add(goodsSkuStore);
        }
        return goodsSkuStoreList;
    }
}
