package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.*;
import com.steerinfo.dil.mapper.TmstruckEnfactoryResultMapper;
import com.steerinfo.dil.mapper.TmstruckLeaveFactoryResultMapper;
import com.steerinfo.dil.mapper.UtilsMapper;
import com.steerinfo.dil.model.TmstruckLeaveFactoryResult;
import com.steerinfo.dil.service.ITmstruckLeaveFactoryResultService;
import com.steerinfo.dil.service.IUtilsService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.route.service.impl.RouteServiceImpl;
import com.steerinfo.framework.controller.RESTfulResult;
import org.apache.commons.lang3.builder.ToStringExclude;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * TmstruckLeaveFactoryResult服务实现：
 * @author generator
 * @version 1.0-SNAPSHORT 2021-09-11 10:32
 * 类描述
 * 修订历史：
 * 日期：2021-09-11
 * 作者：generator
 * 参考：
 * 描述：TmstruckLeaveFactoryResult服务实现
 * @see null
 * @Copyright 湖南视拓信息技术股份有限公司. All rights reserved.
 */
@Service(value = "tmstruckLeaveFactoryResultService")
public class TmstruckLeaveFactoryResultServiceImpl implements ITmstruckLeaveFactoryResultService {

    @Autowired
    private ITmstruckLeaveFactoryResultService tmstruckLeaveFactoryResultService;
    @Autowired
    private RouteServiceImpl routeService;
    @Autowired
    private TmstruckLeaveFactoryResultMapper tmstruckLeaveFactoryResultMapper;

    @Autowired
    private TmstruckEnfactoryResultMapper tmstruckEnfactoryResultMapper;

    @Autowired
    private UtilsServiceImpl utilsService;

    @Autowired
    private UtilsMapper utilsMapper;

    @Autowired
    private OtmsFeign otmsFeign;

    @Autowired
    private TmstruckEnfactoryResultServiceImpl tmstruckEnfactoryResultService;

    @Autowired
    OffSiteTransportationServiceImpl offSiteTransportationService;

    @Autowired
    TmstruckSmsRusultServiceImpl tmstruckSmsRusultService;

    @Autowired
    OmsFeign omsFeign;

    @Autowired
    BmsTruckFeign bmsTruckFeign;

    @Autowired
    AmsFeign amsFeign;

    /**
     * 查看运输线路是否为出厂
     * @param orderNumber
     * @return
     */
    @Override
    public Integer selectTransportRoute(String orderNumber) {
        return tmstruckLeaveFactoryResultMapper.selectTransportRoute(orderNumber);
    }


    /**
     * 派单后新增出厂实绩
     * 总实绩ID、线路终点
     * @param map
     * @return
     */
    @Override
    public int addLeaveFactory(Map<String, Object> map) {
        TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
        //添加主键
        tmstruckLeaveFactoryResult.setId(tmstruckLeaveFactoryResultMapper.selectMaxId());
        //添加总实绩ID
        BigDecimal resultTotalId = DataChange.dataToBigDecimal(map.get("resultTotalId"));
        tmstruckLeaveFactoryResult.setResultTotalId(resultTotalId);
        List<Integer> gatepostIdList = utilsMapper.getLineSegmentGateCalcId(map);
        gatepostIdList.remove(null);
        //随机取门岗值
        Integer gatepostId = utilsService.randomGetValue(gatepostIdList);
        //获取门岗ID
        tmstruckLeaveFactoryResult.setGatepostId(new BigDecimal(gatepostId));
        //添加路段顺序号
        tmstruckLeaveFactoryResult.setSegmentSqe(DataChange.dataToBigDecimal(map.get("segmentSqe")));
        //添加门岗ID 出厂门岗为线路的终点
        return tmstruckLeaveFactoryResultMapper.insertSelective(tmstruckLeaveFactoryResult);
    }

    @Override
    public Map<String, Object> getTruckFactoryResult(String nu) {
        return tmstruckLeaveFactoryResultMapper.getTruckFactoryResult(nu);
    }

    /**
     * APP查询出厂信息
     * @param orderNumber
     * @return
     */
    @Override
    public List<Map<String, Object>> getLeaveFactoryList(String orderNumber) {
        return tmstruckLeaveFactoryResultMapper.getLeaveFactoryList(orderNumber);
    }


    /**
     * 查询所有的出厂实绩
     * 1：销售订单；2：焦炭发运计划；3：水渣发运计划；4：内转到异地库；5：采购辅料订单；6：采购老区燃料订单；
     * 7：采购新区燃料订单；8：采购进口矿(万州-厂内)；9：采购内转(达州-厂内)；10：采购内转(老区-厂内)； 11：厂内内转
     * @param map
     * @return
     */
    @Override
    public List<Map<String, Object>> getLeaveFactoryResult(Map<String, Object> map) {
        Integer orderType = (Integer) map.get("orderTypee");
        switch (orderType){
            case 1:
            case 2:
            case 3:
                return tmstruckLeaveFactoryResultMapper.selectAllLeaveFacatoryForSale(map);
            case 4:
                return tmstruckLeaveFactoryResultMapper.selectSteelNzLeaveFactory(map);
            case 5:
            case 6:
            case 7:
            case 8:
            case 17:
            case 18:
                return tmstruckLeaveFactoryResultMapper.getCGLeaveFactoryResult(map); //apiId:110
            case 9:
                return tmstruckLeaveFactoryResultMapper.getImportedDomesticNzEnFactoryResult(map); //apiId:110
            case 10:
            case 20:
                return tmstruckEnfactoryResultMapper.getCgNzOutFactory(map);
            case 11:
                return tmstruckLeaveFactoryResultMapper.getInFactoryOutFactoryResult(map); //apiId:361
            case 12:
            case 13:
            case 14:
            case 19:
            case 100:
                 return tmstruckLeaveFactoryResultMapper.getSporadicLeaveFactory(map);//apiId:421
        }
        return null;
    }



    /**
     * 通过 PDA 出厂
     * 1：销售订单；2：焦炭发运计划；3：水渣发运计划；4：内转到异地库；5：采购辅料订单；6：采购老区燃料订单；
     * 7：采购新区燃料订单；8：采购进口矿(万州-厂内)；9：采购内转(达州-厂内)；10：采购内转(老区-厂内)； 11：厂内内转
     * @param map
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public int leaveFactoryByPDA(Map<String, Object> map) throws Exception{
        int i = 0;
        String orderNumber = (String) map.get("orderNumber");
        orderNumber = orderNumber.substring(0, orderNumber.length() - 1);
        //通过订单号查询订单类型 及总实绩Id
        Map<String, Object> mesMap = utilsMapper.getOrderTypeByOrderNumber(orderNumber);
        int orderType = DataChange.dataToBigDecimal(mesMap.get("orderType")).intValue();
        String capacityNumber = (String) mesMap.get("capacityNumber");
        if(orderType == 11 || orderType == 15 || orderType == 16){
           return orderType11Use(map, mesMap,capacityNumber);
        }else if(orderType == 21){
            return tmstruckEnfactoryResultService.orderType21Use(map, orderNumber, DataChange.dataToBigDecimal(mesMap.get("orderId")));
        }
        Map<String, Object> selectMap = tmstruckLeaveFactoryResultMapper.selectResultId(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
        if(selectMap == null){
            throw new Exception("该车已出厂！！");
        }else{
            BigDecimal segmentSqe = DataChange.dataToBigDecimal(selectMap.get("segmentSqe"));
            BigDecimal orderSegmentSqe = DataChange.dataToBigDecimal(mesMap.get("orderSegmentSqe"));
            //如果当前路段顺序号 +1 不等于出厂路段顺序号 则不允许出厂
            if(segmentSqe.intValue() != (orderSegmentSqe.intValue() + 1)){
                throw  new Exception("该车作业环节未全部完成！");
            }
        }
        map.putAll(mesMap);
        map.putAll(selectMap);
        map.remove("Sqe");
        map.put("orderNumber", orderNumber);
        BigDecimal orderId = DataChange.dataToBigDecimal(map.get("orderId"));
        i += updateLeaveResultByPDA(map); //更新出厂实绩
        //更新路段顺序号
        i += utilsService.updateOrderLineSequence(map);
        switch (orderType){
            case 1:
                Integer driverConfirmationSteel = utilsMapper.getDriverConfirmation(orderId);
                if(driverConfirmationSteel == null){
                    throw new Exception("请提醒司机确认订单！");
                }
                try {
                    //发送短信
                    Map<String,Object>messageMap = tmstruckLeaveFactoryResultMapper.getMessageMap(orderId);
                    if(messageMap.get("saleOrderConsigneeTEL") != null){
                            String capacityNum = (String) messageMap.get("capacityNumber");
                            String mobile = (String)messageMap.get("saleOrderConsigneeTEL");
                            tmstruckSmsRusultService.generaSendMessage(mobile,capacityNum,orderId);
                    }
                    //销售厂外监控
                    Map<String, Object> parem=tmstruckLeaveFactoryResultService.getTruckFactoryResult(orderNumber);
                    parem.put("turnOf","0");
                    otmsFeign.createTotalResult(parem);
                }catch (Exception ex){

                }
                break;
            case 2:
            case 3:
                //查询司机是否已确认订单 如果订单未确认 则不允许出厂
                Integer driverConfirmation = utilsMapper.getDriverConfirmation(orderId);
                if(driverConfirmation == null){
                    throw new Exception("请提醒司机确认订单！");
                }
                i += utilsService.closeOrderNormally(map);
                // 判断是否要自动派单
                Map<String,Object> mapValue = omsFeign.getSaleAllMessages(orderId.intValue());
                Object closeStatus = mapValue.get("closeStatus");
                if (closeStatus != null && DataChange.dataToBigDecimal(closeStatus).intValue() == 0) {
                    amsFeign.dispatchTruckOrderByCarrier(mapValue);
                }
                bmsTruckFeign.addDetailsOrder(orderId);
                break;
            case 4:
                break;
            case 5:
            case 6:
            case 7:
            case 8:
                //判断出厂路段顺序号是否为最后一个 采购订单关闭订单
                i += utilsService.closeOrderNormally(map);
                //查询是否为一车多趟采购订单类型
                Integer isMoreTripsStatus = tmstruckLeaveFactoryResultMapper.getIsMoreTripsStatus(DataChange.dataToBigDecimal(map.get("orderId")));
                if(isMoreTripsStatus != null && isMoreTripsStatus == 1){
                    //如果是一车多趟 则重新下一个运输订单
                    omsFeign.addNewTransportOrder(orderId.intValue());
                }
                break;
            case 9:
            case 17:
            case 18:
                //判断出厂路段顺序号是否为最后一个 采购订单关闭订单
                i += utilsService.closeOrderNormally(map);
                break;
            case 10:
            case 20:
                //生成新的采购内转运输订单
                //判断出厂路段顺序号是否为最后一个 采购订单关闭订单
                i += utilsService.closeOrderNormally(map);
                //根据运输订单ID查询路段顺序号
                Integer seq = tmstruckLeaveFactoryResultMapper.getSeq(orderId);
                if(seq == 10){
                    //判断是否满足条件--计划是否被启用
                    Integer j = tmstruckLeaveFactoryResultMapper.getPlanEnable(orderId);
                    if(j == 1){
                        //生成新的运输订单
                        omsFeign.addPurInwardOrder(orderId);
                    }
                    try {
                        bmsTruckFeign.addInwardDetailsOrder(map);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                break;
            case 12:
            case 13:
            case 14:
                //关闭当前订单
                i += utilsService.closeOrderNormally(map);
                //生成新的零星订单
                omsFeign.pushMessageToDriver(map);
                break;
        }
        utilsService.pushMesToWebsocket((String) map.get("capacityNumber"), "出厂");
        return i;
    }



    /**
     * 内转订单类型
     * @Author TXF
     * @Date 2022/3/18 18:03
     * @param map
     * @param mesMap
     * @param capacityNumber
     * @return
     **/
    public int orderType11Use(Map<String, Object> map, Map<String, Object> mesMap, String capacityNumber){
        //内转订单类型 没有生成实绩 直接新增
        int sqe = DataChange.dataToBigDecimal(mesMap.get("Sqe")).intValue();
        sqe = sqe + 1;
        map.put("resultId",tmstruckLeaveFactoryResultMapper.selectMaxId());//出厂实绩ID
        map.put("Sqe",sqe);//查询路段顺序号+1
        map.put(("totalId"),mesMap.get("totalId"));
        tmstruckLeaveFactoryResultMapper.insertSelective(generateLeaveFactory(map));
        //更新路段顺序号
        mesMap.put("orderLineSequence",sqe);
        utilsService.updateOrderLineSqeByOrderNumber(mesMap);
        utilsService.pushMesToWebsocket(capacityNumber, "出厂");
        return 1;
    }


    //内转订单类型新增出厂实绩
    private TmstruckLeaveFactoryResult generateLeaveFactory(Map<String, Object> map) {
        TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
        //获取出厂实绩ID
        tmstruckLeaveFactoryResult.setResultId(DataChange.dataToBigDecimal(map.get("resultId")));
        //添加门岗
        tmstruckLeaveFactoryResult.setGatepostId(DataChange.dataToBigDecimal(map.get("gatepostId")));
        //添加路段顺序号
        tmstruckLeaveFactoryResult.setSegmentSqe(DataChange.dataToBigDecimal(map.get("Sqe")));
        //添加出厂时间
        tmstruckLeaveFactoryResult.setResultOutGateTime(new Date());
        tmstruckLeaveFactoryResult.setInsertTime(new Date());
        tmstruckLeaveFactoryResult.setResultOutMode("手动抬杆");
        tmstruckLeaveFactoryResult.setInsertUsername("admin");
        if(map.get("Sqe") !=null){
            tmstruckLeaveFactoryResult.setSegmentSqe(DataChange.dataToBigDecimal(map.get("Sqe")));
        }
        if(map.get("totalId") !=null){
            tmstruckLeaveFactoryResult.setResultTotalId(DataChange.dataToBigDecimal(map.get("totalId")));
        }
        return tmstruckLeaveFactoryResult;
    }

    /**
     * 更新出厂实绩
     * @param mapValue {运输订单号:orderNumber 门岗名称:gatepostName}
     * @return
     */
    public int updateLeaveResultByPDA(Map<String, Object> mapValue){
        TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
        tmstruckLeaveFactoryResult.setResultId(DataChange.dataToBigDecimal(mapValue.get("resultId")));
        //通过门岗名称获取门岗ID
        if(mapValue.get("gatepostId") == null){
            Integer gatepostId = tmstruckEnfactoryResultMapper.selectGatepostIdByGatepostName((String) mapValue.get("gatepostName"));
            if(gatepostId != null){
                tmstruckLeaveFactoryResult.setGatepostId(new BigDecimal(gatepostId));
            }
        }else {
            tmstruckLeaveFactoryResult.setGatepostId(DataChange.dataToBigDecimal(mapValue.get("gatepostId")));
        }
        //设置常规字段 添加 出厂时间 和 出厂方式
        tmstruckLeaveFactoryResult.setResultOutGateTime(new Date());
        tmstruckLeaveFactoryResult.setResultOutMode("手动抬杠");
        tmstruckLeaveFactoryResult.setInsertUsername("admin");
        tmstruckLeaveFactoryResult.setInsertTime(new Date());
        return tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
    }

    /**
     * 通过总实绩Id修改出厂实绩出厂门岗
     * @param resultTotalId
     * @param gatepostId
     * @return
     */
    public int updateLeaveFactoryGatepostId(Integer resultTotalId, Integer gatepostId){
        TmstruckLeaveFactoryResult tmstruckLeaveFactoryResult = new TmstruckLeaveFactoryResult();
        //通过总实绩ID查询出产实绩
        BigDecimal resultId = tmstruckLeaveFactoryResultMapper.getResultIdByTotalId(resultTotalId);
        tmstruckLeaveFactoryResult.setResultId(resultId);
        tmstruckLeaveFactoryResult.setGatepostId(new BigDecimal(gatepostId));
        return tmstruckLeaveFactoryResultMapper.updateByPrimaryKeySelective(tmstruckLeaveFactoryResult);
    }

    /**
     * 查询零星物资出厂列表
     * @param mapValue
     * @return
     */
    @Override
    public List<Map<String, Object>> getSporadicLeaveFactory(Map<String, Object> mapValue) {
        return tmstruckLeaveFactoryResultMapper.getSporadicLeaveFactory(mapValue);
    }


}