package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.mapper.RulesMapper;
import com.steerinfo.dil.mapper.TmstruckLeaveFactoryResultMapper;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.model.TmstruckLeaveFactoryResult;
import com.steerinfo.dil.service.IRulesService;
import com.steerinfo.dil.util.DataChange;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @ author    :TXF
 * @ time      :2021/11/16 14:30
 */

@Service(value = "rulesService")
public class RulesServiceImpl implements IRulesService {
    @Autowired
    private UtilsMapper utilsMapper;

    @Autowired
    private RulesMapper rulesMapper;

    @Autowired
    private TmstruckLeaveFactoryResultMapper tmstruckLeaveFactoryResultMapper;

    @Autowired

    /**
     * 通过运输订单号查询物资并根据门岗规则计算出厂门岗
     * @param map
     * @return
     */
    public int calculateGatepost(Map<String, Object> map){
        if(map != null){ //物资问题原因 计算不了门岗
            return 1;
        }
        BigDecimal materialId = utilsMapper.queryOrderMesByOrderId((String) map.get("orderNumber"));
        Map<String, Object> map1 = new HashMap<>();
        map1.put("materialId", materialId);
        //类型为出厂
        map1.put("type", 1);
        List<Map<String, Object>> list = rulesMapper.queryGatepostByMaterialId(map1);
        for (Map<String, Object> mes : list) {
            //从数据库中获取门岗开始时间结束时间 若当前时间满足该门岗进门时间 则下放 暂不考虑门岗优先级
            boolean judgeTime = judgeTime((String)mes.get("startTime"), (String)mes.get("endTime"));
            if(judgeTime){
                //更新出厂实绩门岗ID
                //通过运输订单号获取出厂实绩ID
                Map<String, Object> map2 = tmstruckLeaveFactoryResultMapper.selectResultId((String) map.get("orderNumber"));
                TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
                tmstruckLeaveFactoryResult.setResultId(DataChange.dataToBigDecimal(map2.get("resultId")));
                tmstruckLeaveFactoryResult.setGatepostId(DataChange.dataToBigDecimal(mes.get("gatepostId")));
                return tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
            }
        }
        return 1;
    }

    /**
     * 判断当前时间是否在时间区间范围内
     * @param startTime
     * @param endTime
     * @return
     */
    public boolean judgeTime(String startTime, String endTime){
        SimpleDateFormat sdf = new SimpleDateFormat("HHmmss");
        String format = sdf.format(new Date());
        int begin = Integer.parseInt(startTime);
        int end = Integer.parseInt(endTime);
        int now = Integer.parseInt(format);
        if(begin < end){
            return now < end && now >= begin;
        }else {
            return now < end || now >= begin;
        }
    }


    /**
     * 通过物资ID 和 计量类型 查找汽车衡
        materialId 物资Id
        nature 1: 进厂秤  2：出厂秤  3：中转
     * @return 汽车衡
     */
    public int calculateWeighbridge(Map<String, Object> map){
        //物资类型：无法计算汽车衡 返回所有1
        if(map != null){
            BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
            //生成随机数
            Random random = new Random();
            int randomNum = random.nextInt(10);
            //针对新厂区
            int orderType = DataChange.dataToBigDecimal(map.get("orderType")).intValue();

            if(orderType == 1 || orderType == 2){//销售
                //通过订单ID获取线路类型为哪种类型 钢材 焦炭 危化品
                Integer isSteel = rulesMapper.getLineIsSteel(orderId);
                if(isSteel == 3){
                    return 16; //化工厂
                }
                if(isSteel == 4){
                    if(randomNum < 5){
                        return 19;
                    }else {
                        return 20;
                    }
                }
            }
            if(orderType == 7 || orderType == 13){//采购燃料  零星进厂
                if(randomNum < 5){
                    return 17;
                }else{
                    return 18;
                }
            }
            if(orderType == 14){ // 零星出厂
                if(randomNum < 5){
                    return 19;
                }else {
                    return 20;
                }
            }
            if(orderType == 10){
                //查询还没有净重的实绩
                Integer resultCount = rulesMapper.getNoNetWeightResult(orderId);
                if(resultCount == 2){
                    return 15; //
                }else {
                    if(randomNum < 5){
                        return 17;
                    }else{
                        return 18;
                    }
                }
            }
            if(orderType == 17 || orderType == 18){ // 化工材料采购 现只考虑化工厂
                return 16;
            }
            return 0;
        }
//        List<Integer> calculateList = queryTruckCalculate(map);
//        //暂时不考虑优先级 随机进行取值
//        int size = calculateList.size();
//        if(size == 0){
//            return 13; //没有查询到汽车衡  则使用备用秤
//        }if(size == 1){
//            return calculateList.get(0);
//        }
//        return calculateList.get(new Random().nextInt(size));
        return 0;
    }

    /**
     * 通过物资Id、计量类型（进厂、出厂、中转） 可能会有多个
     * @param map
     * @return
     */
    @Override
    public List<Integer> queryTruckCalculate(Map<String, Object> map) {
        return rulesMapper.queryTruckCalculate(map);
    }

    /**
     * 查询未装车实绩
     * @param orderId
     * @return
     */
    @Override
    public List<Map<String, Object>> judgeLastMaterial(BigDecimal orderId) {
        return rulesMapper.judgeLastMaterial(orderId);
    }


    /*=========================仓库排队规则=========================*/

    /**
     *通过物资Id查询仓库是否有货 或者 是否有多个仓库有货
     * @param materialId 物资ID
     * @return
     */
    @Override
    public List<Integer> getWarehouseIdByMaterialId(Integer materialId) {
        return rulesMapper.getWarehouseIdByMaterialId(materialId);
    }

    /**
     * 通过仓库Id 和 物资Id 查询垛位 层次 月台 仓库
     * @param map MaterialId 物资ID warehouseId 仓库ID
     * @return
     */
    @Override
    public List<Map<String, Object>> getStackGradation(Map<String, Object> map) {
        return rulesMapper.getStackGradation(map);
    }

    /**
     * 通过月台Id 查询月台当前排队车辆数
     * @param platformId 月台ID
     * @return
     */
    @Override
    public BigDecimal queueCountByPlatformId(BigDecimal platformId) {
        return rulesMapper.queueCountByPlatformId(platformId);
    }


    /**
     * 获取月台Id 通过物资ID 根据排队规则 获取车辆该去哪个月台
     * 规则：不同物资在不同仓库 -->  遍历仓库通过物资Id和仓库Id查找对应的仓储网格表
     *       --> 找出多条数据 也就是说多个月台可以装  --> 遍历月台查看每个月台的排队车辆数 寻找最小的排队车辆数的月台
     *       --> 返回物资ID 和 月台ID
     * @param materialId 物资ID
     * @return 月台ID
     */
    public Map<String, Object> getPlatId(Integer materialId){
        Map<String, Object> map = new HashMap<>();
        Integer platId = null;
        //一种物资可能在多个仓库中
        List<Integer> warehouseList = getWarehouseIdByMaterialId(materialId);
        int countNum = 1000; //初始化比较值
        for (Integer warehouseId : warehouseList) {
            HashMap<String, Object> hashMap = new HashMap<>();
            hashMap.put("materialId", materialId);
            hashMap.put("warehouseId", warehouseId);
            //通过物资Id和仓库ID对仓储网格表 再次进行查询并筛选出层次号最高的几条数据
            List<Map<String, Object>> mesList = getStackGradation(hashMap);
            //遍历筛选出来的月台 查看当前月台排队车辆数
            for (Map<String, Object> mesMap : mesList) {
                BigDecimal platformId = DataChange.dataToBigDecimal(mesMap.get("platformId"));
                //通过月台ID 和 网格类型 查找当前网格Id
                hashMap.put("queueLocationId", platformId);
                hashMap.put("gridType", 1);
                BigDecimal gridId = rulesMapper.getGridIdByGatepostIdAndGridType(hashMap);
                //取得排队车辆数
                int count = queueCountByPlatformId(gridId).intValue();
                map.put("count", count);
                //如果当前月台排队车数为0 则直接选择这个月台
                if(count == 0){
                    platId = platformId.intValue();
                    map.put("loadingId", platId);
                    return map;
                }
                //如果排队车辆数小于上个月台排队车辆数
                if(count < countNum){
                    countNum = count; //取代比较数
                    platId = platformId.intValue(); //替换月台ID
                    map.put("loadingId", platId);
                }
            }
        }
        return map;
    }


    /**
     * 计算物资优先级顺序 并计算装车点  传入多个物资ID
     * @param mapList
     */
    public Map<String, Object> calculateMaterialPriority (List<Map<String, Object>> mapList){
        int compareNum = 100; //优先级比较基准数初始值
        int compareNum2 = 0; //车辆排队序号
        Map<String, Object> map = new HashMap<>();
        for (Map<String, Object> mesMap : mapList) {
            int materialOrder = DataChange.dataToBigDecimal(mesMap.get("materialOrder")).intValue();
            if(materialOrder < compareNum){
                //通过当前物资Id查找装车点
                Map<String, Object> loadingIdMap = getPlatId(DataChange.dataToBigDecimal(map.get("materialId")).intValue());
                mesMap.put("loadingId", loadingIdMap.get("loadingId"));
                compareNum = materialOrder; //替换比较数
                compareNum2 = (int) loadingIdMap.get("count"); //添加车辆排队比较数
                map = mesMap;
            }
            if(materialOrder == compareNum){//如果优先级相同 计算当前月台排队车辆数
                //通过当前物资Id查找装车点
                Map<String, Object> loadingIdMap = getPlatId(DataChange.dataToBigDecimal(map.get("materialId")).intValue());
                int count = (int) loadingIdMap.get("count");
                mesMap.put("loadingId", loadingIdMap.get("loadingId"));
                //如果当前排队车辆数小于上一排队车辆数
                if(count < compareNum2){
                    map = mesMap;//更换要返回的map
                    compareNum2 = count;//替换排队比较数
                }
            }
        }
        return map;
    }

    /**
     * 计算装车顺序
     * @return
     */
    public Map<String, Object> calculateMaterial(List<Map<String, Object>> mapList){
        int compareNum = 100; //比较基准数
        //传入多个未装车的装车物资ID以及装车顺序
        Map<String, Object> map = null;
        for (Map<String, Object> mesMap : mapList) {
            //获取装车顺序 顺序小的先装
            BigDecimal loadingSequence = DataChange.dataToBigDecimal(mesMap.get("loadingSequence"));
            if(loadingSequence.intValue() < compareNum){
                map = mesMap;
            }
        }
        return map;
    }

    /**
     * 计算门岗
     * @param map
     * @return
     */
    public int calculateDxGatepostId(Map<String, Object> map){
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        //针对新厂区
        int orderType = DataChange.dataToBigDecimal(map.get("orderType")).intValue();
        if(orderType == 1 || orderType == 2){ //销售
            //通过订单ID获取线路类型为哪种类型 钢材 焦炭 危化品
            Integer isSteel = rulesMapper.getLineIsSteel(orderId);
            if(isSteel == 3){
                return 12; //化工厂  化工厂二号门
            }
            if(isSteel == 4){
                return 9; //焦化厂  达兴二号门
                }
            }
        if(orderType == 7){
            return 10; // 采购燃料
        }
        if (orderType == 12 || orderType == 13){
            return 9; //内转  达兴二号门
        }
        if(orderType == 10){
            //查询还没有出厂门岗ID的实绩
            Integer resultCount = rulesMapper.getNoGatepostIdResult(orderId);
            if(resultCount == 0){
                return 13;
            }else {
                return 10;
            }
        }
        if(orderType == 17 || orderType == 18){ // 化工材料采购 现只考虑化工厂
            return 12;
        }
        return 0;
    }
}