package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.mapper.*;
import com.steerinfo.dil.model.*;
import com.steerinfo.dil.service.IWmspRestackMakeResultService;
import com.steerinfo.dil.service.IWmspRestackScanResultService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.dil.model.WmspGridMaterial;
import com.steerinfo.dil.util.IDUtils;
import com.steerinfo.framework.mapper.IBaseMapper;
import com.steerinfo.framework.service.impl.BaseServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * WmspRestackMakeResult服务实现：
 * @author generator
 * @version 1.0-SNAPSHORT 2021-09-06 03:02
 * 类描述
 * 修订历史：
 * 日期：2021-09-06
 * 作者：generator
 * 参考：
 * 描述：WmspRestackMakeResult服务实现
 * @see null
 * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
 */
@Service
public class WmspRestackMakeResultServiceImpl  implements IWmspRestackMakeResultService {
    @Autowired
    private WmspRestackMakeResultMapper wmspRestackMakeResultMapper;
    @Autowired
    private WmspRestackMakeMaterialMapper wmspRestackMakeMaterialMapper;
    @Autowired
    private WmspRestackScanResultMapper wmspRestackScanResultMapper;
    @Autowired
    private WmspGridMaterialMapper wmspGridMaterialMapper;
    @Autowired
    private WmspRestackScanResultServiceImpl wmspRestackScanResultService;
    @Autowired
    private WmspRestackMakeTypeResultServiceImpl wmspRestackMakeTypeResultService;
    @Override
    public List<Map<String, Object>> selectRestackMakeResultList(Map<String, Object> mapval) {
        return wmspRestackMakeResultMapper.selectRestackMakeResultList(mapval);
    }

    /**
     * 新增库管员填写倒垛单实绩
     * @param mapval
     * @return
     */
    @Override
    public int addMakeResult(Map<String, Object> mapval) {
        int i=0;
        //接收前端传过来的list
        //编写倒垛实绩
        Map<String,Object> map2= (Map<String, Object>) mapval.get("wmspRestackMakeResult");
        //获取倒垛后的垛位id
        Integer stackingId1 =(Integer) map2.get("stackingId1");
        //获取仓库id
        Integer warehouseid=(Integer) map2.get("warehouseid");
        WmspRestackMakeResult wmspRestackMakeResult=new WmspRestackMakeResult();
        BigDecimal makeresultid = wmspRestackMakeResultMapper.selectMaxId();
        wmspRestackMakeResult.setResultId(makeresultid);
        wmspRestackMakeResult.setResultStatus(new BigDecimal(0));
        wmspRestackMakeResult.setDistributionstatus(new BigDecimal(0));
        wmspRestackMakeResult.setResultStackNumber(DataChange.generateEightDigitsNumber("WDD",makeresultid.intValue()));
        wmspRestackMakeResult.setInsertUsername("admin");
        wmspRestackMakeResult.setInsertTime(new Date());
        wmspRestackMakeResult.setAfterWarehouseId(DataChange.dataToBigDecimal(warehouseid));
        wmspRestackMakeResult.setAfterStackingId(DataChange.dataToBigDecimal(stackingId1));
        wmspRestackMakeResult.setKeeperId(new BigDecimal(1));
        wmspRestackMakeResult.setDeleted(new BigDecimal(0));
        i=wmspRestackMakeResultMapper.insertSelective(wmspRestackMakeResult);
        List<Map<String,Object>> maplist= (List<Map<String, Object>>) mapval.get("maplist");
        for (Map<String,Object> map:maplist){
            //新增倒垛和物资中间表
            WmspRestackMakeMaterial wmspRestackMakeMaterial=new WmspRestackMakeMaterial();
            //设置主键
            Integer materialId =(Integer) map.get("materialId");
            wmspRestackMakeMaterial.setMakeMaterialId(wmspRestackMakeMaterialMapper.selectMaxId());
            wmspRestackMakeMaterial.setMakeResultId(wmspRestackMakeResult.getResultId());
            wmspRestackMakeMaterial.setMaterialId(DataChange.dataToBigDecimal(materialId));
            wmspRestackMakeMaterial.setMakeMaterialNumber(DataChange.dataToBigDecimal(map.get("makeMaterialNumber")));
            //根据仓库，垛位，层次，层序，查找仓储网格id
            //获取垛位已堆放物资数量
            int number1 = wmspRestackScanResultMapper.selectNumber(stackingId1);
            //计算层次
            int gradtionNumber2 = number1 / 24;
            //如果算出数据为0，则放置1号层次
            if (gradtionNumber2 <= 0) {
                gradtionNumber2 = gradtionNumber2 + 1;
            }
            //获取层序号
            int nu1=number1%24;
            //根据仓库，垛位，层次，层序，查找仓储网格id
            Map map1=new HashMap();
            map1.put("sequenceNumber",nu1);
            map1.put("warehouseId",warehouseid);
            map1.put("stackingId",stackingId1);
            map1.put("gradationNumber",gradtionNumber2);
            BigDecimal girdId1 = wmspRestackMakeResultMapper.selectGridIdByWarehouseAndSatcking(map1);
            //设置倒垛前仓储网格id
            Integer gridId =(Integer) map2.get("GridId");
            wmspRestackMakeMaterial.setBeforeGridId(DataChange.dataToBigDecimal(map2.get("GridId")));
            //根据倒垛前端的仓储网格锁定实时库存数据
            //根据倒垛前的物资和仓储网格进行查找实时库存主键id
            Integer gmId = wmspRestackScanResultService.selectGmIdByGridIdAndMaterialId(gridId, materialId);
            //进行实时库存的更新
            WmspGridMaterial wmspGridMaterial=new WmspGridMaterial();
            wmspGridMaterial.setGmId(new BigDecimal(gmId));
            wmspGridMaterial.setStatus(new BigDecimal(1));
            wmspGridMaterialMapper.updateByPrimaryKeySelective(wmspGridMaterial);
            //设置倒垛后仓储网格id
            wmspRestackMakeMaterial.setAfterGridId(DataChange.dataToBigDecimal(girdId1));
            wmspRestackMakeMaterial.setInsertTime(new Date());
            wmspRestackMakeMaterial.setInsertUsername("admin");
            i+=wmspRestackMakeMaterialMapper.insertSelective(wmspRestackMakeMaterial);
        }

        return i;
    }




    //根据主键进行更新
    @Override
    public int update(Map<String,Object> mapval) {
        int i=0;
        //接收前端传过来的list
        //编写倒垛实绩
        Map<String,Object> map2= (Map<String, Object>) mapval.get("wmspRestackMakeResult");
        //获取倒垛后的垛位id
        Integer stackingId1 =(Integer) map2.get("stackingId1");
        //获取仓库id
        Integer warehouseid=(Integer) map2.get("warehouseid");
        WmspRestackMakeResult wmspRestackMakeResult=new WmspRestackMakeResult();
        Integer resultId =(Integer) map2.get("resultId");
        wmspRestackMakeResult.setResultId(DataChange.dataToBigDecimal(resultId));
        wmspRestackMakeResult.setResultStatus(new BigDecimal(0));
        wmspRestackMakeResult.setAfterWarehouseId(DataChange.dataToBigDecimal(warehouseid));
        wmspRestackMakeResult.setAfterStackingId(DataChange.dataToBigDecimal(stackingId1));
        i=wmspRestackMakeResultMapper.updateByPrimaryKeySelective(wmspRestackMakeResult);
        List<Map<String,Object>> maplist= (List<Map<String, Object>>) mapval.get("maplist");
        for (Map<String,Object> map:maplist) {
            //新增倒垛和物资中间表
            WmspRestackMakeMaterial wmspRestackMakeMaterial = new WmspRestackMakeMaterial();
            //根据实绩id查找中间表id
            List<Map<String, Object>> maps = wmspRestackMakeResultMapper.selectMakeMaterialIdByResultId(resultId);
            for (Map<String, Object> map1 : maps) {
                Integer makeMaterialId =(Integer) map1.get("makeMaterialId");
                //设置主键
                wmspRestackMakeMaterial.setMakeMaterialId(DataChange.dataToBigDecimal(makeMaterialId));
                wmspRestackMakeMaterial.setMakeResultId(DataChange.dataToBigDecimal(resultId));
                wmspRestackMakeMaterial.setMaterialId(DataChange.dataToBigDecimal(map.get("materialId")));
                wmspRestackMakeMaterial.setMakeMaterialNumber(DataChange.dataToBigDecimal(map.get("makeMaterialNumber")));
                //根据仓库，垛位，层次，层序，查找仓储网格id
                //获取垛位已堆放物资数量
                int number1 = wmspRestackScanResultMapper.selectNumber(stackingId1);
                //计算层次
                int gradtionNumber2 = number1 / 24;
                //如果算出数据为0，则放置1号层次
                if (gradtionNumber2 <= 0) {
                    gradtionNumber2 = gradtionNumber2 + 1;
                }
                //获取层序号
                int nu1 = number1 % 24;
                //根据仓库，垛位，层次，层序，查找仓储网格id
                Map map4 = new HashMap();
                map4.put("sequenceNumber", nu1);
                map4.put("warehouseId", warehouseid);
                map4.put("stackingId", stackingId1);
                map4.put("gradationNumber", gradtionNumber2);
                BigDecimal girdId1 = wmspRestackMakeResultMapper.selectGridIdByWarehouseAndSatcking(map4);
                //设置倒垛前仓储网格id
                wmspRestackMakeMaterial.setBeforeGridId(DataChange.dataToBigDecimal(map2.get("GridId")));
                //设置倒垛后仓储网格id
                wmspRestackMakeMaterial.setAfterGridId(DataChange.dataToBigDecimal(girdId1));
                wmspRestackMakeMaterial.setInsertTime(new Date());
                wmspRestackMakeMaterial.setInsertUsername("admin");
                i += wmspRestackMakeMaterialMapper.updateByPrimaryKeySelective(wmspRestackMakeMaterial);
            }

        }

        return i;
    }

    @Override
    public int updateByPrimaryKeySelective(WmspRestackMakeResult wmspRestackMakeResult) {
        return wmspRestackMakeResultMapper.updateByPrimaryKeySelective(wmspRestackMakeResult);
    }

    //查询层次号
    @Override
    public List<Map<String, Object>> selectGardationNumber(Integer warehouseid,Integer stackingId) {
        return wmspRestackMakeResultMapper.selectGardationNumber(warehouseid,stackingId);
    }
    //查询垛位id
    @Override
    public List<Map<String, Object>> selectStackingId(Integer warehouseid) {
        return wmspRestackMakeResultMapper.selectStackingId(warehouseid);
    }
    //查询仓库名称
    @Override
    public List<Map<String, Object>> selectWarehouse() {
        return wmspRestackMakeResultMapper.selectWarehouse();
    }
    //获取仓库id
    @Override
    public BigDecimal getWarehouseId() {
        return wmspRestackMakeResultMapper.getWarehouseId();
    }
    //查询倒垛单
    @Override
    public List<Map<String, Object>> selectRestack(Map<String, Object> mapval) {
        return wmspRestackMakeResultMapper.selectRestack(mapval);
    }

    //根据实绩id查找倒垛后的仓库
    @Override
    public List<Map<String, Object>> selectAfterWarehouseByResultId(Integer resultId) {
        return wmspRestackMakeResultMapper.selectAfterWarehouseByResultId(resultId);
    }

    //根据实绩id查找倒垛后的垛位
    @Override
    public List<Map<String, Object>> selectAfterstackingByResultId(Integer resultId) {
        return wmspRestackMakeResultMapper.selectAfterstackingByResultId(resultId);
    }

    //根据实绩id查找物资信息
    @Override
    public List<Map<String, Object>> selectMaterialInfoByResultId(Integer resultId) {
        return wmspRestackMakeResultMapper.selectMaterialInfoByResultId(resultId);
    }

    @Override
    public List<Map<String, Object>> selectRestackByWarehouseId(Map<String, Object> map) {
        return wmspRestackMakeResultMapper.selectRestackByWarehouseId(map);
    }

    @Override
    public Integer selectGridIdByMaterialId(BigDecimal materialSteelId) {
        return wmspRestackMakeResultMapper.selectGridIdByMaterialId(materialSteelId);
    }

    @Override
    public List<Map<String, Object>> selectRestackInfoByResultId(Integer resultId) {
        return wmspRestackMakeResultMapper.selectRestackInfoByResultId(resultId);
    }

    @Override
    public List<Map<String, Object>> selectRestackForPc(Map<String, Object> map) {
        return wmspRestackMakeResultMapper.selectRestackForPc(map);
    }

    /**
     * //创建倒垛单和倒垛单类型
     * @param keeperId
     * @param resultStackNumber
     * @param afterStackingId
     * @param afterWarehouseId
     * @param afterBeforeStackingId
     * @param resultRemark
     * @param maps
     * @return
     */
    @Transactional
    @Override
    public WmspRestackMakeResult createRestackMakeResult(
            BigDecimal keeperId, String resultStackNumber, BigDecimal afterStackingId,
              BigDecimal afterWarehouseId, BigDecimal afterBeforeStackingId, String resultRemark, List<Map<String, Object>> maps) {
        //初始化倒垛单
        WmspRestackMakeResult wmspRestackMakeResult=new WmspRestackMakeResult();
        //获得序号
        BigDecimal makeresultid =IDUtils.createIDYMDHMS( wmspRestackMakeResultMapper.selectMaxId());

        //主键赋值
        wmspRestackMakeResult.setResultId(makeresultid);
        //倒垛单编号
        wmspRestackMakeResult.setResultStackNumber(resultStackNumber);
        //倒垛后垛位id
        wmspRestackMakeResult.setAfterStackingId(afterStackingId);
        //倒垛日期
        wmspRestackMakeResult.setResultMovelistTime(new Date());
        //库管员ID
        wmspRestackMakeResult.setKeeperId(keeperId);
        //创建人
        wmspRestackMakeResult.setInsertTime(new Date());
        wmspRestackMakeResult.setInsertUsername(keeperId.toString());
        //删除状态:0为未删除，1删除
        wmspRestackMakeResult.setDeleted(new BigDecimal(0));
        //下发状态
        wmspRestackMakeResult.setDistributionstatus(new BigDecimal(0));
        //倒垛后仓库id
        wmspRestackMakeResult.setAfterWarehouseId(afterWarehouseId);
        //倒垛完成状态倒垛完成状态（0：未完成；1：已完成
        wmspRestackMakeResult.setResultStatus(new BigDecimal((0)));
        //倒垛单备注
        wmspRestackMakeResult.setResultRemark(resultRemark);
        //倒垛前的垛位
        wmspRestackMakeResult.setAfterBeforeStackingId(afterBeforeStackingId);

        //首先创建倒垛类型,再创建倒垛单 makeresultid
        Integer totalCount= wmspRestackMakeTypeResultService.createMakeTypeList(makeresultid,maps);

        //添加总是
        wmspRestackMakeResult.setQuantity(new BigDecimal(totalCount));
        //添加
        wmspRestackMakeResultMapper.insertSelective(wmspRestackMakeResult);
        return wmspRestackMakeResult;
    }

}