package com.consum.base.service.core;

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

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import com.consum.base.core.WhBusinessEnum;
import com.consum.base.core.utils.IdUtil;
import com.consum.base.core.utils.LockManage;
import com.consum.base.service.BaseGoodsTemplateService;
import com.consum.base.service.GoodsBaseService;
import com.consum.base.service.LWarehouseFlowService;
import com.consum.base.service.LWhFormScrappedGoodsService;
import com.consum.base.service.LWhGoodsRecordService;
import com.consum.base.service.LWhGoodsService;
import com.consum.base.service.impl.LWhGoodsRecordDetailsService;
import com.consum.model.po.LWarehouseFlow;
import com.consum.model.po.LWhFormScrapped;
import com.consum.model.po.LWhFormScrappedGoods;
import com.consum.model.po.LWhGoodsRecord;
import com.iplatform.model.po.S_user_core;
import com.walker.infrastructure.utils.CollectionUtils;

import cn.hutool.core.convert.Convert;
import lombok.extern.slf4j.Slf4j;

/**
 * @ClassName LWhFormScrappedCoreService
 * @Date 2023/10/30
 * @Description
 * @Version 1.0
 **/
@Service
@Slf4j
@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
public class LWhFormScrappedCoreService {

    private GoodsBaseService goodsBaseService;
    private LWhFormScrappedGoodsService lWhFormScrappedGoodsService;
    private BaseGoodsTemplateService baseGoodsTemplateService;
    private LWhGoodsService lWhGoodsService;
    private LWhGoodsRecordDetailsService lWhGoodsRecordDetailsService;
    private LWhGoodsRecordService lWhGoodsRecordServiceImpl;
    private LWarehouseFlowService lWarehouseFlowServiceImpl;
    private LWhWarningCoreService lWhWarningCoreService;

    @Autowired
    public LWhFormScrappedCoreService(GoodsBaseService goodsBaseService,
        LWhFormScrappedGoodsService lWhFormScrappedGoodsService, BaseGoodsTemplateService baseGoodsTemplateService,
        LWhGoodsService lWhGoodsService, LWhGoodsRecordDetailsService lWhGoodsRecordDetailsService,
        LWhGoodsRecordService lWhGoodsRecordServiceImpl, LWarehouseFlowService lWarehouseFlowServiceImpl,
        LWhWarningCoreService lWhWarningCoreService) {
        this.lWhFormScrappedGoodsService = lWhFormScrappedGoodsService;
        this.baseGoodsTemplateService = baseGoodsTemplateService;
        this.lWhGoodsService = lWhGoodsService;
        this.lWhGoodsRecordDetailsService = lWhGoodsRecordDetailsService;
        this.lWhGoodsRecordServiceImpl = lWhGoodsRecordServiceImpl;
        this.lWarehouseFlowServiceImpl = lWarehouseFlowServiceImpl;
        this.goodsBaseService = goodsBaseService;
        this.lWhWarningCoreService = lWhWarningCoreService;
    }

    /**
     * 根据 报废单【L_WH_FORM_SCRAPPED】 报废物品
     *
     * @param formScrappedId 报废单Id
     * @return 流水记录总表ID
     */
    @Transactional(rollbackFor = Exception.class)
    public Long outFormByTransId(Long formScrappedId, S_user_core currentUser, Long dealTime) {
        if (formScrappedId == null) {
            return null;
        }
        LWhFormScrapped lWhFormScrapped = new LWhFormScrapped(formScrappedId);
        lWhFormScrapped = goodsBaseService.get(lWhFormScrapped);
        if (lWhFormScrapped != null && lWhFormScrapped.getStates() != 0) {
            log.error("报废失败！请检查报废单状态");
            return null;
        }

        Long userId = currentUser.getId();
        String nickName = currentUser.getNick_name();

        Integer warehouseType = lWhFormScrapped.getWarehouseType();
        Long warehouseId = lWhFormScrapped.getWarehouseId();
        String warehouseName = lWhFormScrapped.getWarehouseName();
        // 流水记录总表ID
        long lWarehouseFlowId = IdUtil.generateId();

        // 要报废的物品
        LWhFormScrappedGoods goods = new LWhFormScrappedGoods();
        goods.setFormScrappedId(formScrappedId);
        List<LWhFormScrappedGoods> formScrappedGoods = lWhFormScrappedGoodsService.select(goods);
        if (CollectionUtils.isEmpty(formScrappedGoods)) {
            log.error("没有要报废的物品");
            return null;
        }

        // 按型号分组
        ArrayList<Long> allChangModelList = new ArrayList<>();

        Map<Long, List<LWhFormScrappedGoods>> modelGroup =
            formScrappedGoods.stream().collect(Collectors.groupingBy(LWhFormScrappedGoods::getBaseGoodsModelsId));
        for (Map.Entry<Long, List<LWhFormScrappedGoods>> entry : modelGroup.entrySet()) {
            // 规格型号编号
            Long baseGoodsModelsId = entry.getKey();
            allChangModelList.add(baseGoodsModelsId);
            // 对每组中要报废的数量求和
            List<LWhFormScrappedGoods> modelGoodsList = entry.getValue();
            // 查询型号信息
            Map<String, Object> tempGoodsInfo = baseGoodsTemplateService.queryGoodsInfoByModelId(baseGoodsModelsId);
            // 要报废的总数量
            int modelTotalNum = modelGoodsList.stream().mapToInt(LWhFormScrappedGoods::getCounts).sum();
            Long tempGoodsId = (Long)tempGoodsInfo.get("goodsid");
            String goodsName = (String)tempGoodsInfo.get("goodsname");
            String modelName = (String)tempGoodsInfo.get("modelname");
            // 插入 各规格物品的进出库记录 L_WH_GOODS_RECORD
            long whGoodsRecordId = IdUtil.generateId();
            LWhGoodsRecord whGoodsRecord = new LWhGoodsRecord();
            whGoodsRecord.setId(whGoodsRecordId);
            whGoodsRecord.setWarehouseType(warehouseType);
            whGoodsRecord.setWarehouseId(warehouseId);
            whGoodsRecord.setWarehouseFlowId(lWarehouseFlowId);
            whGoodsRecord.setBaseGoodsTemplateId(tempGoodsId);
            whGoodsRecord.setGoodsTemplateName(goodsName);
            whGoodsRecord.setBaseGoodsModelsId(baseGoodsModelsId);
            whGoodsRecord.setBaseGoodsModelsName(modelName);
            whGoodsRecord.setDealTime(dealTime);
            // 本次调整类型 1=调增；2=调减
            whGoodsRecord.setThisType(2);
            whGoodsRecord.setThisCount(modelTotalNum);

            // 通过LockManage获得锁
            Object warehouseModelLockObj = LockManage.acquireLock(warehouseType, warehouseId, baseGoodsModelsId);
            synchronized (warehouseModelLockObj) {
                for (LWhFormScrappedGoods formScrappedGood : modelGoodsList) {
                    // 报废数量
                    Integer counts = formScrappedGood.getCounts();
                    // 报废单编号
                    Long transBusinessId = formScrappedGood.getTransBusinessId();

                    // 获得锁后查询该型号的期初数量
                    int goodsModelNum = 0;
                    List<Long> srappedGoodsIds = null;
                    if (warehouseType == null || warehouseType == 0) {
                        List<Long> warehouseIds = new ArrayList<>(Arrays.asList(warehouseId));
                        goodsModelNum =
                            lWhGoodsService.queryGoodsModelNum(warehouseType, warehouseIds, baseGoodsModelsId, 1, null);
                        srappedGoodsIds = lWhGoodsService.queryScrappedGoodsIds(warehouseType, warehouseId, null, null,
                            baseGoodsModelsId, (short)1, counts);
                    } else {
                        // 使用人员名称
                        String userName = formScrappedGood.getUserName();
                        // 根据分发单、规格型号编号、使用人员名称，进行报废
                        srappedGoodsIds = lWhGoodsService.queryScrappedGoodsIds(warehouseType, warehouseId,
                            transBusinessId, userName, baseGoodsModelsId, (short)2, counts);
                        List<Long> warehouseIds = new ArrayList<>(Arrays.asList(warehouseId));
                        goodsModelNum =
                            lWhGoodsService.queryGoodsModelNum(warehouseType, warehouseIds, baseGoodsModelsId, 2, null);
                    }

                    if (goodsModelNum < counts) {
                        log.error("要报废的物品数量不足");
                        // 手动回滚
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        throw new RuntimeException("出库失败!型号数量不足");
                    }

                    if (CollectionUtils.isEmpty(srappedGoodsIds) || srappedGoodsIds.size() < counts) {
                        log.error("要报废的物品数量不足！");
                        // 手动回滚
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        throw new RuntimeException("报废失败!型号数量不足");
                    }
                    // 通过物品id查询所有商品的总金额
                    long amount = lWhGoodsService.queryGoodsPriceById(srappedGoodsIds);
                    LWhFormScrappedGoods lWhFormScrappedGoods = new LWhFormScrappedGoods(formScrappedGood.getId());
                    lWhFormScrappedGoods.setTotalAmount((int)amount);
                    lWhFormScrappedGoodsService.update(lWhFormScrappedGoods);

                    whGoodsRecord.setInitialCount(goodsModelNum);
                    whGoodsRecord.setEndCount(goodsModelNum - counts);

                    // 设置物品为报废状态
                    lWhGoodsService.modGoodsTransfering(srappedGoodsIds, null, null, null, 3);
                    // 批量插入 进出库流水明细[L_WH_GOODS_RECORD_DETAILS]
                    lWhGoodsRecordDetailsService.sameGoodsInsertMore(srappedGoodsIds, whGoodsRecordId, (short)2);
                }
                lWhGoodsRecordServiceImpl.insert(whGoodsRecord);
            }

        }
        LWarehouseFlow warehouseFlow = new LWarehouseFlow();
        warehouseFlow.setId(lWarehouseFlowId);
        warehouseFlow.setWarehouseType(warehouseType);
        warehouseFlow.setWarehouseId(warehouseId);
        warehouseFlow.setWarehouseName(warehouseName);
        warehouseFlow.setThisType(2);
        warehouseFlow.setBusinessType(WhBusinessEnum.BAOFEI.getValue() + 0);
        warehouseFlow.setBusinessFormId(formScrappedId);
        warehouseFlow.setOperatorId(userId);
        warehouseFlow.setOperatorName(nickName);
        warehouseFlow.setDealTime(dealTime);
        // 插入流水总表
        int flowInsertFlag = lWarehouseFlowServiceImpl.insert(warehouseFlow);
        if (flowInsertFlag == 0) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return null;
        }
        // 更新报废单
        lWhFormScrapped = new LWhFormScrapped(formScrappedId);
        lWhFormScrapped.setLWarehouseFlowId(lWarehouseFlowId);
        lWhFormScrapped.setStates(1);
        lWhFormScrapped.setOperatorId(userId);
        lWhFormScrapped.setOperatorName(nickName);
        lWhFormScrapped.setDealTime(dealTime);
        goodsBaseService.update(lWhFormScrapped);

        // 当库存变动时调用该方法
        lWhWarningCoreService.updateKuCun(Convert.toShort(warehouseType, (short)0), warehouseId, allChangModelList,
            null, dealTime);
        return lWarehouseFlowId;
    }

}