package com.steerinfo.dil.controller;


import com.steerinfo.dil.mapper.BackgroundProcessingMapper;
import com.steerinfo.dil.mapper.OmstruckOrderMapper;
import com.steerinfo.dil.mapper.UniversalMapper;
import com.steerinfo.dil.service.impl.BackgroundProcessingServiceImpl;
import com.steerinfo.dil.util.BaseRESTfulController;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.framework.controller.RESTfulResult;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/*
 * 后台处理程序
 */

@RestController
@RequestMapping("${api.version}/bp")
public class BackgroundProcessingController extends BaseRESTfulController {

    @Autowired
    private BackgroundProcessingMapper backgroundProcessingMapper;

    @Autowired
    private BackgroundProcessingServiceImpl backgroundProcessingService;

    @Autowired
    private OmstruckOrderMapper omstruckOrderMapper;

    @Autowired
    private UniversalMapper universalMapper;


    @ApiOperation(value = "关闭一车多趟方法")
    @PostMapping("/closePurOrderMoreTrips")
    public RESTfulResult closePurOrderMoreTrips(String purchaseOrderNo, String deleteNoReceiveOrder) {
        int i = backgroundProcessingMapper.closePurOrderMoreTrips(purchaseOrderNo);
        if("yes".equals(deleteNoReceiveOrder)){
            //查询该采购订单下所有未接收的运输订单（5,6,7,8,17,18)
            ArrayList<Integer> orderIdList = backgroundProcessingMapper.getAllPurOrder(purchaseOrderNo);
            if(orderIdList != null && orderIdList.size() != 0){
                backgroundProcessingMapper.deleteOrders(orderIdList); //物理删除
                backgroundProcessingMapper.deleteOrderMaterials(orderIdList);//物理删除物资子表
                backgroundProcessingMapper.batchByOrderIdForTotalDelete(orderIdList);//总实绩表
            }
        }
        if(i != 1){
            return failed("关闭失败！没有此采购订单");
        }
        return success("关闭成功");
    }

    @ApiOperation(value = "更改所属厂区方法")
    @PostMapping("/updatePurOrgId")
    public RESTfulResult updatePurOrgId(@RequestBody(required = false) Map<String, Object> map){
        return success(backgroundProcessingService.updatePurOrgId(map));
    }

    @ApiOperation(value = "删除没用的表实绩 ")
    @PostMapping("/deleteErrorResult")
    public RESTfulResult deleteErrorResult(String orderNumber){
        return success(backgroundProcessingService.deleteErrorResult(orderNumber));
    }

    @ApiOperation(value = "手动允许放行-OK字段")
    @PostMapping("/allowEnfactory")
    public RESTfulResult allowEnfactory(String orderNumber){
        return success(backgroundProcessingMapper.allowEnfactory(orderNumber));
    }

    @ApiOperation(value = "获取cid和车牌号的关系")
    @PostMapping("/bindCidCapacityNo")
    public RESTfulResult bindCidCapacityNo(String cid,
                                           String capacityNo){
        if(cid == null || capacityNo == null || "null".equals(cid) || "null".equals(capacityNo)){
            return success(0);
        }
        int i = backgroundProcessingService.bindCidCapacityNo(cid,capacityNo);
        return success(i);
    }

    @ApiOperation(value = "更新运输订单canwork状态")
    @PostMapping("updateOrderCanWork")
    public RESTfulResult updateOrderCanWork(String orderNumber){
        if(orderNumber != null){
            int i = backgroundProcessingMapper.updateOrderCanWork(orderNumber);
            return success(i);
        }
        return success(0);
    }

    @ApiOperation(value = "更新运输订单状态接口")
    @PostMapping("updateOrderStatus")
    @Transactional(rollbackFor = Exception.class)
    public RESTfulResult updateOrderStatus(@RequestBody(required = false) Map<String,Object> map) throws Exception{
        if (map.get("orderNumber") != null) {
            //if (DataChange.dataToBigDecimal(map.get("orderStatus")).intValue() != 2) {
            if (DataChange.dataToBigDecimal(map.get("orderStatus")).intValue() > 0) {
                int i = backgroundProcessingMapper.updateOrderStatus(map);
                if(i > 1){
                    throw new Exception("该订单号有多个运单，不允许修改，请去数据库手动修改订单状态！");
                }
                return success(i);
            }
        }
        return failed(0);
    }

    @ApiOperation(value = "更新运输订单状态接口")
    @PostMapping("updateOrderStatusSell")
    @Transactional(rollbackFor = Exception.class)
    public RESTfulResult updateOrderStatusSell(@RequestBody(required = false) Map<String,Object> map) throws Exception{
        if (map.get("orderNumber") != null) {
            int i = backgroundProcessingMapper.updateOrderStatusSell(map);
            if(i > 1){
                throw new Exception("该订单号有多个运单，不允许修改，请去数据库手动修改订单状态！");
            }
            return success(i);
        }
        return failed(0);
    }

    @ApiOperation(value = "内转/采购新增上传金蝶表")
    @PostMapping("insertToUploadEas")
    public RESTfulResult insertToUploadEas(@RequestBody(required = false) Map<String,Object> map){
        try {
            Map<String,Object> purchaseOrder = (Map<String, Object>) map.get("purchaseOrder");
            List<Map<String,Object>> list= (List<Map<String, Object>>) map.get("list");
            for(Map<String,Object> item:list){
                item.put("purchaseOrderNo",purchaseOrder.get("purchaseOrderNo"));
                backgroundProcessingMapper.insertNotUpload(item);
            }
        }catch (NullPointerException e){
            e.printStackTrace();
            return failed("缺乏参数！");
        }catch (Exception e){
            e.printStackTrace();
            return failed("未知异常！");
        }
        return success("修改成功，稍后会自动上传金蝶！");
    }

    @ApiOperation(value = "重置钢材打印数量")
    @PostMapping("resetPrintNumber")
    public RESTfulResult resetPrintNumber(@RequestBody(required = false) Map<String,Object> map){
        return success(backgroundProcessingMapper.resetPrintNumber(map));
    }

    @ApiOperation(value = "删除进厂和排队")
    @PostMapping("clearEnAndQue")
    public RESTfulResult clearEnAndQue(@RequestBody(required = false) Map<String,Object> map){
        try {
            Map<String,Object> mesMap = backgroundProcessingMapper.getDetailsForEnAndQue(map);
            if(mesMap == null){
                return failed("没有符合条件的运单，请确认该运单是否已有净重！");
            }
            //清空进厂信息
            backgroundProcessingMapper.clearEnDetails(mesMap);
            //删除排队
            int materialMesCount = omstruckOrderMapper.getMaterialNumByOrderId(mesMap);
            if (materialMesCount == 1) {
                //如果是单拼,则删除排队实绩
                omstruckOrderMapper.deleteQueueList(DataChange.dataToBigDecimal(mesMap.get("capacityId")));
                omstruckOrderMapper.deleteQueueResult(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
            }else{
                omstruckOrderMapper.deleteQueueSpellList(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
                omstruckOrderMapper.deleteQueueResult(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
            }
            //将总实绩里面的部分信息去掉,并改路段顺序号为null
            omstruckOrderMapper.updateTotalResultNull(DataChange.dataToBigDecimal(mesMap.get("resultTotalId")));
            universalMapper.updateLineSqe(mesMap);
        } catch (Exception e) {
            e.printStackTrace();
            return failed("未知异常!",e.getMessage());
        }
        return success("修改成功！");
    }

    @ApiOperation(value = "关联OA")
    @PostMapping("oaRelevancy")
    public RESTfulResult oaRelevancy(@RequestBody(required = false) Map<String,Object> map) {
        if(map.get("orderNumber") == null) {
            return failed("修改失败");
        }
        map.put("orderNumber",map.get("orderNumber") + "");
        backgroundProcessingMapper.updateOaRelevancy(map);
        return success();
    }


    @ApiOperation(value = "手动放行接口")
    @PostMapping("passThroughOrder")
    @Transactional(rollbackFor = Exception.class)
    public RESTfulResult passThroughOrder(@RequestBody(required = false) Map<String,Object> map) throws Exception{
        if (map.get("orderNumber") != null) {
            try {
                int i = backgroundProcessingMapper.updatePassthrough(map);
                if(i != 1){
                    throw new Exception("数据不准确，请去数据库手动修改订单状态！");
                }
                return success(i);
            } catch (Exception e) {
                return failed("修改失败：" + e.getMessage());
            }
        }
        return failed("orderNumber为空");
    }

    @ApiOperation(value = "钢材同车同物资接错单交换接口")
    @PostMapping("interchangeOrder")
    @Transactional(rollbackFor = Exception.class)
    public RESTfulResult interchangeOrder(@RequestBody(required = false) Map<String,Object> map) throws Exception{
        if (map.get("orderNumber1") != null && map.get("orderNumber2") != null) {
            Map<String, Object> map1= backgroundProcessingMapper.getOrderInfoByOrderNumber(map.get("orderNumber1").toString());
            Map<String, Object> map2= backgroundProcessingMapper.getOrderInfoByOrderNumber(map.get("orderNumber2").toString());
            if(map1 == null || map2 == null
                || map1.get("orderId") == null || map2.get("orderId") == null
                    || map1.get("orderPlanId") == null || map2.get("orderPlanId") == null
                        || map1.get("capacityId") == null || map2.get("capacityId") == null
                            || !map1.get("capacityId").equals(map2.get("capacityId"))
            ){
                return failed("数据不准确，请去数据库手动修改！");
            }
            map1.put("newOrderPlanId", map2.get("orderPlanId"));
            map1.put("remark", "交换订单:"+map.get("orderNumber2")+";原车序号:"+map1.get("orderPlanId")+";新车序号:"+map2.get("orderPlanId"));
            map2.put("newOrderPlanId", map1.get("orderPlanId"));
            map2.put("remark", "交换订单:"+map.get("orderNumber1")+";原车序号:"+map2.get("orderPlanId")+";新车序号:"+map1.get("orderPlanId"));
            backgroundProcessingMapper.updateInterchangeOrder(map1);
            backgroundProcessingMapper.updateInterchangeOrder(map2);
        }
        return success(1);
    }

    @ApiOperation(value = "强制修改运输订单状态接口")
    @PostMapping("modifyOrderStatus")
    @Transactional(rollbackFor = Exception.class)
    public RESTfulResult modifyOrderStatus(@RequestBody(required = false) Map<String,Object> map) throws Exception{
        if (map.get("orderNumber") != null && map.get("orderStatus") != null && map.get("toOrderStatus") != null) {
            Map<String,Object> oMap;
            if(map.get("orderNumber").toString().length() < 8){
                return failed("修改失败：输入订单编号不能低于8位！");
            }
            try {
                oMap = backgroundProcessingMapper.getOrderInfoByOrderStatus(map);
            } catch (Exception e) {
                return failed("修改失败：订单编号不唯一！");
            }
            if(oMap == null || oMap.get("orderId") == null){
                return failed("修改失败：未找到运输订单！");
            }
            oMap.put("toOrderStatus", map.get("toOrderStatus"));
            oMap.put("remark","修改运输订单状态为" + map.get("toOrderStatus") + ";原订单状态为" + map.get("orderStatus"));
            backgroundProcessingMapper.modifyOrderStatus(oMap);
            return success(1);
        }
        return failed("修改失败：存在空值！");
    }

    @ApiOperation(value = "强制重置密码接口")
    @PostMapping("resetPassword")
    @Transactional(rollbackFor = Exception.class)
    public RESTfulResult resetPassword(@RequestBody(required = false) Map<String,Object> map) throws Exception{
        if (map.get("userNameCode") != null) {
            backgroundProcessingMapper.updateSysUser(map);
            backgroundProcessingMapper.updateSysUserLogin(map);
        }
        return success(1);
    }
}