package com.steerinfo.dil.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.steerinfo.dil.mapper.WmspInboundScanResultMapper;
import com.steerinfo.dil.mapper.WmspInboundStackResultMapper;
import com.steerinfo.dil.model.WmspInboundScanResult;
import com.steerinfo.dil.model.WmspInboundStackResult;
import com.steerinfo.dil.service.IRmsMaterialSteelService;
import com.steerinfo.dil.service.IWmsInboundScanResultService;
import com.steerinfo.dil.service.IWmspInboundGroupService;
import com.steerinfo.dil.util.DataChange;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.xml.crypto.Data;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author luobang
 * @create 2021-09-07 15:12
 */
@Service
public class WmsInboundScanResultServiceImpl implements IWmsInboundScanResultService {

    @Autowired
    private WmspInboundScanResultMapper wmspInboundScanResultMapper;
    @Autowired
    private WmspInboundStackResultMapper wmspInboundStackResultMapper;
    @Autowired
    private IWmspInboundGroupService wmspInboundGroupService;
    @Autowired
    private IRmsMaterialSteelService rmsMaterialSteelService;


    //判断是否重复扫码
    @Override
    public Integer checkScanTag(Map<String,Object>map,BigDecimal loadId){
        //获取扫描吊牌实绩
        String resultMaterial = (String) map.get("resultMaterial");
        //获取物资扫描实绩
        String subResultMaterial = resultMaterial.substring(0,resultMaterial.length() - 1);

        Map<String,Object> checkScanMap = new HashMap<>();
        checkScanMap.put("resultMaterial",subResultMaterial);
        checkScanMap.put("loadId",loadId);
        //根据扫描实绩查询出扫描实绩个数
        Integer j=(checkScanResult(checkScanMap)).size();
        if (j!=0)
            return 0;

        return 1;
    }

    /**
     * 1.新增吊钢工扫描吊牌实绩
     * @param wmspInboundScanResult
     * @return
     */
    @Override
    public Integer insertWmsInboundScanResult(WmspInboundScanResult wmspInboundScanResult) {
            return wmspInboundScanResultMapper.insertSelective(wmspInboundScanResult);

    }

    /**
     * 2.获取最大ID
     * @return
     */
    @Override
    public BigDecimal count() {
        return wmspInboundScanResultMapper.getCount();
    }

    /**
     * 3.获取吊钢工最大扫描数
     * @param
     * @return
     */
    @Override
    public int scanNumber(Map<String, Object> map) {
        if (wmspInboundScanResultMapper.getScanNumber(map)==null){
            return 0;
        }
        return wmspInboundScanResultMapper.getScanNumber(map).intValue();
    }

    /**
     * 4.更新扫描吊牌实绩
     * @param wmspInboundScanResult
     * @return
     */
    @Override
    public Integer updateWmsInboundScanResult(WmspInboundScanResult wmspInboundScanResult) {
        return wmspInboundScanResultMapper.updateByPrimaryKeySelective(wmspInboundScanResult);
    }

    /**
     * 更新异常值
//     * @param wmspInboundScanResult
     * @return
     */
    @Override
    public Integer updateInboundAbnormal(Map<String,Object> map) {
        return wmspInboundScanResultMapper.updateInboundAbnormal(map);
    }

    @Override
    public Integer updateWmsInboundScanById(Map<String, Object> map) {
        return wmspInboundScanResultMapper.updateInboundScanResult(map);
    }


    /**
     * 获取扫描吊牌实绩
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getScanTagResult(Map<String, Object> map) {
        return wmspInboundScanResultMapper.selectScanTagResult(map);
    }

    /**
     * 获取正常入库
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getIssuedScanTagResult(Map<String, Object> map) {
        return wmspInboundScanResultMapper.selectIssuedScanTagResult(map);
    }

    /**
     * 获取异常入库
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getIssuedScanTagNoResult(Map<String, Object> map) {
        return wmspInboundScanResultMapper.selectIssuedScanTagNoResult(map);
    }

    /**
     * 判断是否重复插入
     * @param
     * @param
     * @return
     */
    @Override
    public List<Map<String, Object>> checkScanResult(Map<String,Object>map) {
        return wmspInboundScanResultMapper.checkScanResult(map);
    }

    /*
    更新退库扫描实绩
     */
    @Override
    public Integer updateWmsReboundScanById(Map<String, Object> map5) {
        return wmspInboundScanResultMapper.updateReboundScanResult(map5);
    }

    /*
    展示已下发退库实绩
     */
    @Override
    public List<Map<String, Object>> getIssuedScanResult(Map<String, Object> map) {
        return wmspInboundScanResultMapper.selectReIssuedScanResult(map);
    }

    /*
    展示未下发退库实绩
     */
    @Override
    public List<Map<String, Object>> getReScanTagResult(Map<String, Object> map) {
        return wmspInboundScanResultMapper.selectReScanTagResult(map);
    }

    /*
    展示已下发退库实绩
   */
    @Override
    public List<Map<String, Object>> getIssuedScanIvResult(Map<String, Object> map) {
        return wmspInboundScanResultMapper.selectIvIssuedScanResult(map);
    }

    /*
    展示未下发退库实绩
     */
    @Override
    public List<Map<String, Object>> getIvScanTagResult(Map<String, Object> map) {
        return wmspInboundScanResultMapper.selectIvScanTagResult(map);
    }


    @Override
    public List<Map<String, Object>>getScanResult(BigDecimal loadId) {
        return wmspInboundScanResultMapper.getScanResult(loadId);
    }

    @Override
    public BigDecimal getLoadId(Map<String, Object> map) {
        return wmspInboundScanResultMapper.getLoadId(map);
    }

    /**
     * 得到另外一个扫描实绩ID
     * @param otherLoadMap
     * @return
     */
    @Override
    public List<Map<String,Object>> getOntherLoadId(Map<String, Object> otherLoadMap) {
        return wmspInboundScanResultMapper.getOtherScanResultId(otherLoadMap);
    }

    @Override
    public BigDecimal getOtherLoadId(Map<String, Object> map) {
        return wmspInboundScanResultMapper.getOtherLoadId(map);
    }

    @Override
    public Integer getOtherMaterialSteelId(Map<String, Object> map) {
        return wmspInboundScanResultMapper.getOtherMaterialSteelId(map);
    }

    @Override
    public List<Map<String, Object>> selectStacking(Map<String, Object> map) {
        return wmspInboundScanResultMapper.selectStackNo(map);
    }

    @Override
    public Integer updateStatus(Map<String, Object> map) {
       return wmspInboundScanResultMapper.updataStatus(map);
    }

    /**
     * 判断物资是否为线材
     * @param materialId
     * @return
     */
    @Override
    public BigDecimal selectMaterialTypeByMaterialId(BigDecimal materialId) {
        return wmspInboundScanResultMapper.selectMaterialTypeByMaterialId(materialId);
    }

    /**
     * 判断物质是否已经被扫
     * @param userName
     * @param resultMaterial
     * @return
     */
    @Override
    public int isExist(String userName, String resultMaterial) {
        return wmspInboundScanResultMapper.isExist(userName,resultMaterial);
    }

    /**
     * 查询扫描没有下发的物质
     * @param userName
     * @return
     */
    @Override
    public List<Map<String, Object>> noIssueScanResult(String userName) {
        return wmspInboundScanResultMapper.noIssueScanResult(userName);
    }

    @Override
    public Map<String, Object> createInboundScanResultByResultMaterial(Integer scanedCount, String userName,String resultMaterial,String hookNo) throws ParseException {
        //创建入库扫描实绩、并且给对象赋值
        WmspInboundScanResult wmspInboundScanResult=new WmspInboundScanResult();
        //设置主键自增，这里需要修改
        wmspInboundScanResult.setId(count());
        //获取班次次序的吊牌信息
        String[] result = resultMaterial.split("-");
        if(result.length == 10){
            String shiftOrder = result[9];
            wmspInboundScanResult.setShiftOrder(shiftOrder);
        }
        //分组
        //根据用户名和分组状态查询到分组信息
        BigDecimal groupId= wmspInboundGroupService.getGroupIdByUserName(userName);
        wmspInboundScanResult.setInboundGroupId(groupId);
        //吊钢工扫描吊牌结果
        wmspInboundScanResult.setResultMaterial(resultMaterial);
        //扫描吊牌信息
        wmspInboundScanResult.setResultLoadTime(new Date());
        //新增钢材物资ID
        Map<String,Object> materialSteel = rmsMaterialSteelService.insertRmsMaterialSteel2(resultMaterial,hookNo);
        wmspInboundScanResult.setMaterialId(new BigDecimal(materialSteel.get("materialSteelId").toString()));
        //创建用户
        //insertUsername
        wmspInboundScanResult.setInboundAbnormalis(new BigDecimal(0));
        //设置入库物资件数，默认一件
        wmspInboundScanResult.setInboundMaterialNumber(new BigDecimal(1));
        // 状态：0：未下发；1：已下发
        wmspInboundScanResult.setResultStatus(new BigDecimal(0));
        //吊钢工已扫物资次数 ,目前已扫描为没有下发的物质
        //BigDecimal scanCount= wmspInboundScanResultMapper.getScanedNumber(userId);
        wmspInboundScanResult.setResultNumber(new BigDecimal(scanedCount));
        //逻辑删除：1：删除，0：未删除
        wmspInboundScanResult.setResultDeleted(new BigDecimal(0));
        //扫码用户
        wmspInboundScanResult.setInsertUsername(userName);
        //创建时间
        wmspInboundScanResult.setInsertTime(new Date());
        int status = wmspInboundScanResultMapper.insertSelective(wmspInboundScanResult);
        //判断是否创建成功
        if (status>0){
            materialSteel.putAll(JSON.parseObject(JSON.toJSONString(wmspInboundScanResult),new TypeReference<Map<String,Object>>(){}));
            return materialSteel;
        }
        return null;

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public int createInboundScanResultByFind(List<Map<String, Object>> list, Map<String, Object> map) throws Exception {
        List<WmspInboundScanResult> results=new ArrayList<>();
        String userName=map.get("userName").toString();
        int i=0;
        for(Map<String,Object> temp:list){
            if(temp==null || temp.get("resultMaterial")==null){
                throw new Exception("查询结果存在空值，终止新增扫码实绩，并回滚");
            }
            //创建入库扫描实绩、并且给对象赋值
            WmspInboundScanResult wmspInboundScanResult=new WmspInboundScanResult();
            //设置自增主键
            wmspInboundScanResult.setId(wmspInboundScanResultMapper.getCount());
            //获取班次次序的吊牌信息
            String resultMaterial=temp.get("resultMaterial").toString();
            String[] result = resultMaterial.split("-");
            if(result.length == 10){
                String shiftOrder = result[9];
                wmspInboundScanResult.setShiftOrder(shiftOrder);
            }
            //分组
            //根据用户名和分组状态查询到分组信息
            BigDecimal groupId= wmspInboundGroupService.getGroupIdByUserName(userName);
            wmspInboundScanResult.setInboundGroupId(groupId);
            //吊钢工扫描吊牌结果
            wmspInboundScanResult.setResultMaterial(resultMaterial);
            //扫描吊牌信息
            wmspInboundScanResult.setResultLoadTime(new Date());
            //新增钢材物资ID
            Map<String,Object> materialSteel = rmsMaterialSteelService.insertRmsMaterialSteel2(resultMaterial,""+map.get("hookNo"));
            wmspInboundScanResult.setMaterialId(new BigDecimal(materialSteel.get("materialSteelId").toString()));
            //创建用户
            //insertUsername
            wmspInboundScanResult.setInboundAbnormalis(new BigDecimal(0));
            //设置入库物资件数，默认一件
            wmspInboundScanResult.setInboundMaterialNumber(new BigDecimal(1));
            // 状态：0：未下发；1：已下发
            wmspInboundScanResult.setResultStatus(new BigDecimal(0));
            //吊钢工已扫物资次数 ,目前已扫描为没有下发的物资
            wmspInboundScanResult.setResultNumber(new BigDecimal(list.size()));
            //逻辑删除：1：删除，0：未删除
            wmspInboundScanResult.setResultDeleted(new BigDecimal(0));
            //扫码用户
            wmspInboundScanResult.setInsertUsername(userName);
            //创建时间
            wmspInboundScanResult.setInsertTime(new Date());
            //插入
            i+=wmspInboundScanResultMapper.insertSelective(wmspInboundScanResult);
        }
        return i;
    }

    @Override
    public List<Map<String, Object>> noIssueScanResultList(String userName) {
        return wmspInboundScanResultMapper.noIssueScanResultList(userName);
    }

    @Override
    public int changeInboundIscomplete(BigDecimal stackResultId) {
//        根据stackResultId找到对应的成品并修改其状态
        WmspInboundStackResult wmspInboundStackResult =new WmspInboundStackResult();
        wmspInboundStackResult.setResultId(stackResultId);
        wmspInboundStackResult.setStackingStatus(new BigDecimal(1));
        return wmspInboundStackResultMapper.updateByPrimaryKeySelective(wmspInboundStackResult);
    }

    public int updateInboundScanStatus(BigDecimal resultId,BigDecimal inboundId) {
        return wmspInboundScanResultMapper.updataStatusByResultId(resultId,inboundId);
    }

    @Override
    public Integer getResultStatusByResultId(String resultId) {
        return wmspInboundScanResultMapper.getResultStatusByResultId(resultId);
    }

    @Override
    public int isExist2(String userName, String resultMaterial) {
        return wmspInboundScanResultMapper.isExist2(userName,resultMaterial);
    }

    @Override
    public Map<String, Object> createInboundScanResultByResultMaterial2(int scanedCount, String userName, String resultMaterial,String hookNo) throws ParseException {
        //创建入库扫描实绩、并且给对象赋值
        WmspInboundScanResult wmspInboundScanResult=new WmspInboundScanResult();
        //设置主键自增，这里需要修改
        wmspInboundScanResult.setId(count());


        //分组 只需要扫一次没有分组信息
        //根据用户名和分组状态查询到分组信息
//        BigDecimal groupId= wmspInboundGroupService.getGroupIdByUserName(userName);
//        wmspInboundScanResult.setInboundGroupId(groupId);
        //吊钢工扫描吊牌结果
        wmspInboundScanResult.setResultMaterial(resultMaterial);
        //扫描吊牌信息
        wmspInboundScanResult.setResultLoadTime(new Date());
        //新增钢材物资ID
        Map<String,Object> materialSteel = rmsMaterialSteelService.insertRmsMaterialSteel2(resultMaterial,hookNo);
        wmspInboundScanResult.setMaterialId(new BigDecimal(materialSteel.get("materialSteelId").toString()));
        //创建用户
        //insertUsername
        wmspInboundScanResult.setInboundAbnormalis(new BigDecimal(0));
        //设置入库物资件数，默认一件
        wmspInboundScanResult.setInboundMaterialNumber(new BigDecimal(1));
        // 状态：0：未下发；1：已下发
        wmspInboundScanResult.setResultStatus(new BigDecimal(0));
        //吊钢工已扫物资次数 ,目前已扫描为没有下发的物质
        //BigDecimal scanCount= wmspInboundScanResultMapper.getScanedNumber(userId);
        wmspInboundScanResult.setResultNumber(new BigDecimal(scanedCount));
        //逻辑删除：1：删除，0：未删除
        wmspInboundScanResult.setResultDeleted(new BigDecimal(0));
        //扫码用户
        wmspInboundScanResult.setInsertUsername(userName);
        //创建时间
        wmspInboundScanResult.setInsertTime(new Date());
        int status = wmspInboundScanResultMapper.insertSelective(wmspInboundScanResult);
        //判断是否创建成功
        if (status>0){
            materialSteel.putAll(JSON.parseObject(JSON.toJSONString(wmspInboundScanResult),new TypeReference<Map<String,Object>>(){}));
            return materialSteel;
        }
        return null;
    }

    @Override
    public int isExistInboundScanResult(String resultMaterial) {
        int isExist = wmspInboundScanResultMapper.isExistInboundScanResult(resultMaterial);
        return isExist;
    }

    @Override
    public List<Map<String, Object>> noIssueScanResultList2(String userName) {
        return wmspInboundScanResultMapper.noIssueScanResultList2(userName);
    }

    @Override
    public Map<String, Object> getOrderTypeByNum(String orderNumber) {
        return wmspInboundScanResultMapper.getOrderTypeByNum(orderNumber);
    }

    @Override
    public Map<String, Object> getOrderTypeByInboundId(String resultId) {
        return wmspInboundScanResultMapper.getOrderTypeByInboundId(resultId);
    }

    @Override
    public List<Map<String, Object>> findInboundScanResult(String orderNumber) {
        return wmspInboundScanResultMapper.findInboundScanResult(orderNumber);
    }

    @Override
    public Integer isExistLoad(String orderNumber) {
        return wmspInboundScanResultMapper.isExistLoad(orderNumber);
    }

    @Override
    public List<Map<String,Object>> createResultMaterials(Map<String,Object> map){
        List<Map<String,Object>> resultMaterials=new ArrayList<>();
        String today = null;
        if(map.get("productDate") != null) {
            today = (String) map.get("productDate");
        }else{
            SimpleDateFormat format=new SimpleDateFormat("yyyyMMdd");
            //把今天作为生产日期
            today=format.format(new Date());
        }
        String materialOnlyCode = null;
        if(map.get("materialOnlyCode") != null) {
            materialOnlyCode = map.get("materialOnlyCode").toString();
        }else{
            materialOnlyCode = "wuliuxitongbulu"+System.currentTimeMillis();
        }
        //总数量
        Integer number=Integer.parseInt(map.get("number").toString());
        String materialCount = "";
        if(DataChange.dataToBigDecimal(map.get("materialCount")).compareTo(new BigDecimal(0)) != 0) {
            materialCount = map.get("materialCount").toString();
        }
        //物资编码
        String materialCode=map.get("materialCode").toString();
        //炉号
        String furnaceNumber=map.get("furnaceNumber").toString();
        //理重
        BigDecimal theoreticalWeight= DataChange.dataToBigDecimal(map.get("theoreticalWeight"));
        //实重
        BigDecimal actualWeight = DataChange.dataToBigDecimal(map.get("actualWeight"));
        Map<String,Object> materialDetails=wmspInboundScanResultMapper.findMaterialDetails(materialCode);
        if(materialDetails==null || materialDetails.get("materialModel")==null || materialDetails.get("materialSpecification")==null)
            return null;
        //物资型号
        String materialModel=materialDetails.get("materialModel").toString();
        //物资规格
        String materialSpecification=materialDetails.get("materialSpecification").toString();
        String arr[]=materialSpecification.split("Φ");
        if(arr.length>1){
            materialSpecification=arr[1];
        }
        for(int i=0;i<number;i++){
            Map<String,Object> temp=new HashMap<>();
            String resultMaterial="";
            resultMaterial=materialModel+"-"
                    +materialSpecification+"-"
                    +furnaceNumber+"-"
                    +"-"
                    +theoreticalWeight+"-"
                    +materialCount + "-"
                    +today+"-"
                    +i+materialOnlyCode+"-"//唯一编码
                    +materialCode+"-"
                    +"A1024A" + actualWeight;
            temp.put("resultMaterial",resultMaterial);
            System.out.println(resultMaterial);
            resultMaterials.add(temp);
        }
        return resultMaterials;
    }

    @Override
    public int deleteMaterialSteelMes(Map<String, Object> map) {
        BigDecimal materialSteelId = wmspInboundScanResultMapper.getMaterialSteelId(map);
        if(materialSteelId == null) {
            return 0;
        }
        //删除入库实绩,实时库存
        wmspInboundScanResultMapper.deleteMaterialSteel(materialSteelId);
        wmspInboundScanResultMapper.deleteInboundResult(materialSteelId);
        wmspInboundScanResultMapper.deleteInboundScanResult(materialSteelId);
        return 1;
    }
}