package com.stylefeng.guns.modular.system.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.stylefeng.guns.core.util.ToolUtil;
import com.stylefeng.guns.modular.crossCity.model.OrderCrossCity;
import com.stylefeng.guns.modular.crossCity.server.IOrderCrossCityService;
import com.stylefeng.guns.modular.smallLogistics.model.OrderLogistics;
import com.stylefeng.guns.modular.smallLogistics.server.IOrderLogisticsService;
import com.stylefeng.guns.modular.specialTrain.model.OrderPrivateCar;
import com.stylefeng.guns.modular.specialTrain.server.IOrderPrivateCarService;
import com.stylefeng.guns.modular.system.dao.PhoneMapper;
import com.stylefeng.guns.modular.system.dao.RegionMapper;
import com.stylefeng.guns.modular.system.dao.SysReformistMapper;
import com.stylefeng.guns.modular.system.model.Driver;
import com.stylefeng.guns.modular.system.model.OrderPosition;
import com.stylefeng.guns.modular.system.model.Region;
import com.stylefeng.guns.modular.system.service.IDriverService;
import com.stylefeng.guns.modular.system.service.IOrderService;
import com.stylefeng.guns.modular.system.util.*;
import com.stylefeng.guns.modular.system.warpper.OrderListWarpper;
import com.stylefeng.guns.modular.taxi.model.OrderTaxi;
import com.stylefeng.guns.modular.taxi.service.IOrderTaxiService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;

/**
 * 订单相关逻辑类
 */
@Service
public class OrderServiceImpl implements IOrderService {

    @Resource
    private IOrderTaxiService orderTaxiService;

    @Resource
    private RegionMapper regionMapper;

    @Resource
    private SysReformistMapper sysReformistMapper;

    @Autowired
    private GDMapElectricFenceUtil gdMapElectricFenceUtil;

    @Autowired
    private GDMapGeocodingUtil gdMapGeocodingUtil;

    @Autowired
    private IDriverService driverService;

    @Autowired
    private TaskUtil taskUtil;

    @Autowired
    private ChinaMobileUtil chinaMobileUtil;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private PushUtil pushUtil;

    @Autowired
    private IOrderPrivateCarService orderPrivateCarService;

    @Autowired
    private IOrderCrossCityService orderCrossCityService;

    @Autowired
    private IOrderLogisticsService orderLogisticsService;

    @Autowired
    private ALiSendSms aLiSendSms;

    @Value("${pushMinistryOfTransport}")
    private boolean pushMinistryOfTransport;

    @Autowired
    private PushMinistryOfTransportUtil pushMinistryOfTransportUtil;







    /**
     * 获取司机首页的订单列表
     * @param pageNum
     * @param size
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public List<Map<String, Object>> queryOrderList(Integer state, Integer pageNum, Integer size, Integer uid) throws Exception {
        Integer page = pageNum;
        pageNum = (pageNum - 1) * size;
        List<Map<String, Object>> datas = new ArrayList<>();
        //出租车
        List<Map<String, Object>> list = orderTaxiService.queryOrderList(state, uid);
        datas.addAll(list);
        //专车
        List<Map<String, Object>> list1 = orderPrivateCarService.queryOrderList(state, uid);
        datas.addAll(list1);
        //跨城
        List<Map<String, Object>> list2 = orderCrossCityService.queryOrderList(state, uid);
        datas.addAll(list2);
        //小件物流
        List<Map<String, Object>> list3 = orderLogisticsService.queryOrderList(uid);
        datas.addAll(list3);

        //分页
        if(datas.size() >= page * size){
            datas = datas.subList(pageNum, pageNum + size);
        }else if(pageNum < datas.size() && datas.size() < page * size){
            datas = datas.subList(pageNum, datas.size());
        }else{
            datas = new ArrayList<>();
        }
        return datas;
    }




    /**
     * 获取司机首页的订单列表
     * @param pageNum
     * @param size
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public List<Map<String, Object>> queryOrderList1(Integer state, Integer type, Integer pageNum, Integer size, Integer uid) throws Exception {
        Integer page = pageNum;
        pageNum = (pageNum - 1) * size;
        List<Map<String, Object>> datas = new ArrayList<>();
        if(type == 1){
            //出租车
            List<Map<String, Object>> list = orderTaxiService.queryOrderList(state, uid);
            datas.addAll(list);
            //专车
            List<Map<String, Object>> list1 = orderPrivateCarService.queryOrderList(state, uid);
            datas.addAll(list1);
            //跨城
            List<Map<String, Object>> list2 = orderCrossCityService.queryOrderList(state, uid);
            datas.addAll(list2);
        }else{//小件物流
            List<Map<String, Object>> list3 = orderLogisticsService.queryOrderList(uid);
            datas.addAll(list3);
        }

        //分页
        if(datas.size() >= page * size){
            datas = datas.subList(pageNum, pageNum + size);
        }else if(pageNum < datas.size() && datas.size() < page * size){
            datas = datas.subList(pageNum, datas.size());
        }else{
            datas = new ArrayList<>();
        }
        return datas;
    }




    /**
     * 获取司机端我的订单列表
     * @param state     1=全部，2=待支付，3=已取消，4=已完成
     * @param pageNum
     * @param size
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public List<OrderListWarpper> queryMyAllOrder(Integer state, Integer pageNum, Integer size, Integer uid) throws Exception {
        Integer page = pageNum;
        pageNum = (pageNum - 1) * size;
        List<Map<String, Object>> datas = new ArrayList<>();
        //出租车
        List<Map<String, Object>> list = orderTaxiService.queryMyAllOrder(state, uid);
        datas.addAll(list);
        //专车
        List<Map<String, Object>> list1 = orderPrivateCarService.queryMyAllOrder(state, uid);
        datas.addAll(list1);
        //跨城
        List<Map<String, Object>> list2 = orderCrossCityService.queryMyAllOrder(state, uid);
        datas.addAll(list2);
        //小件物流
        List<Map<String, Object>> list3 = orderLogisticsService.queryMyAllOrder(state, uid);
        datas.addAll(list3);

        List<OrderListWarpper> orderListWarpper = OrderListWarpper.getOrderListWarpper(datas);

        //分页
        if(orderListWarpper.size() >= page * size){
            orderListWarpper = orderListWarpper.subList(pageNum, pageNum + size);
        }else if(pageNum < orderListWarpper.size() && orderListWarpper.size() < page * size){
            orderListWarpper = orderListWarpper.subList(pageNum, orderListWarpper.size());
        }else{
            orderListWarpper = new ArrayList<>();
        }
        return orderListWarpper;
    }




    /**
     * 获取司机端我的订单列表
     * @param state     1=全部，2=待支付，3=已取消，4=已完成
     * @param pageNum
     * @param size
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public List<OrderListWarpper> queryMyAllOrder1(Integer pageNum, Integer size, Integer uid) throws Exception {
        Integer page = pageNum;
        pageNum = (pageNum - 1) * size;
        List<Map<String, Object>> datas = new ArrayList<>();
        //出租车
        List<Map<String, Object>> list = orderTaxiService.queryMyAllOrder(1, uid);
        datas.addAll(list);
//        //专车
//        List<Map<String, Object>> list1 = orderPrivateCarService.queryMyAllOrder(state, uid);
//        datas.addAll(list1);
//        //跨城
//        List<Map<String, Object>> list2 = orderCrossCityService.queryMyAllOrder(state, uid);
//        datas.addAll(list2);
//        //小件物流
//        List<Map<String, Object>> list3 = orderLogisticsService.queryMyAllOrder(state, uid);
//        datas.addAll(list3);

        List<OrderListWarpper> orderListWarpper = OrderListWarpper.getOrderListWarpper(datas);

        //分页
        if(orderListWarpper.size() >= page * size){
            orderListWarpper = orderListWarpper.subList(pageNum, pageNum + size);
        }else if(pageNum < orderListWarpper.size() && orderListWarpper.size() < page * size){
            orderListWarpper = orderListWarpper.subList(pageNum, orderListWarpper.size());
        }else{
            orderListWarpper = new ArrayList<>();
        }
        return orderListWarpper;
    }




    /**
     * 用户下单成功后司机主动去获取推送的订单详情
     * @param orderId
     * @param orderType
     * @return
     */
    @Override
    public Map<String, Object> queryPushOrder(Integer orderId, Integer orderType, String lon, String lat) throws Exception{
        Map<String, Object> map = null;
        switch (orderType){
            case 1://专车
                map = orderPrivateCarService.queryPushOrder(orderId);
                String order = String.valueOf(map.get("startLon")) + "," + String.valueOf(map.get("startLat"));
                String distance = gdMapElectricFenceUtil.getDistance(lon + "," + lat, order, 1).get("distance");
                map.put("startDistance", ToolUtil.isNotEmpty(distance) ? Double.valueOf(distance) / 1000 : 0);

                //总距离
                String end = String.valueOf(map.get("endLon")) + "," + String.valueOf(map.get("endLat"));
                distance = gdMapElectricFenceUtil.getDistance(end, order, 1).get("distance");
                map.put("totalDistance", ToolUtil.isNotEmpty(distance) ? Double.valueOf(distance) / 1000 : 0);

                Integer orderSource = Integer.valueOf(String.valueOf(map.get("orderSource")));
                if(orderSource == 1 || orderSource == 2 || orderSource == 3){
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 1 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "乘客下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 1 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 2 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "预约");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 2 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                if(orderSource == 5){
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 1 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "调度下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 1 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 2 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "预约");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 2 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                break;
            case 2://出租
                map = orderTaxiService.queryPushOrder(orderId);
                String order1 = String.valueOf(map.get("startLon")) + "," + String.valueOf(map.get("startLat"));
                String distance1 = gdMapElectricFenceUtil.getDistance(lon + "," + lat, order1, 1).get("distance");
                map.put("startDistance", ToolUtil.isNotEmpty(distance1) ? Double.valueOf(distance1) / 1000 : 0);

                //总距离

                String end1 = String.valueOf(map.get("endLon")) + "," + String.valueOf(map.get("endLat"));
                if(end1.equals(",")){
                    map.put("totalDistance", 0);
                }else{
                    Map<String, String> disMap = gdMapElectricFenceUtil.getDistance(end1, order1, 1);
                    if(ToolUtil.isEmpty(disMap)){
                        map.put("totalDistance", 0);
                    }else{
                        distance = disMap.get("distance");
                        map.put("totalDistance", ToolUtil.isNotEmpty(distance) ? Double.valueOf(distance) / 1000 : 0);
                    }

                }


                Integer orderSource1 = Integer.valueOf(String.valueOf(map.get("orderSource")));
                if(orderSource1 == 1 || orderSource1 == 2 || orderSource1 == 3){
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 1 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "乘客下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 1 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 2 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "预约");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 2 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                if(orderSource1 == 5){
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 1 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "调度下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 1 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 2 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "预约");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("orderType"))) == 2 && Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                break;
            case 3://城际
                map = orderCrossCityService.queryPushOrder(orderId);
                String order2 = String.valueOf(map.get("startLon")) + "," + String.valueOf(map.get("startLat"));
                String distance2 = gdMapElectricFenceUtil.getDistance(lon + "," + lat, order2, 1).get("distance");
                map.put("startDistance", ToolUtil.isNotEmpty(distance2) ? Double.valueOf(distance2) / 1000 : 0);

                //总距离
                String end2 = String.valueOf(map.get("endLon")) + "," + String.valueOf(map.get("endLat"));
                distance = gdMapElectricFenceUtil.getDistance(end2, order2, 1).get("distance");
                map.put("totalDistance", ToolUtil.isNotEmpty(distance) ? Double.valueOf(distance) / 1000 : 0);

                Integer orderSource2 = Integer.valueOf(String.valueOf(map.get("orderSource")));
                if(orderSource2 == 1 || orderSource2 == 2 || orderSource2 == 3){
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "乘客下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                if(orderSource2 == 5){
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "调度下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                break;
            case 4://同城小件物流
                map = orderLogisticsService.queryPushOrder(orderId);
                String order3 = String.valueOf(map.get("startLon")) + "," + String.valueOf(map.get("startLat"));
                String distance3 = gdMapElectricFenceUtil.getDistance(lon + "," + lat, order3, 1).get("distance");
                map.put("startDistance", ToolUtil.isNotEmpty(distance3) ? Double.valueOf(distance3) / 1000 : 0);

                //总距离
                String end3 = String.valueOf(map.get("endLon")) + "," + String.valueOf(map.get("endLat"));
                distance = gdMapElectricFenceUtil.getDistance(end3, order3, 1).get("distance");
                map.put("totalDistance", ToolUtil.isNotEmpty(distance) ? Double.valueOf(distance) / 1000 : 0);

                Integer orderSource3 = Integer.valueOf(String.valueOf(map.get("orderSource")));
                if(orderSource3 == 1 || orderSource3 == 2 || orderSource3 == 3){
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "乘客下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                if(orderSource3 == 5){
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "调度下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                break;
            case 5://跨城小件物流
                map = orderLogisticsService.queryPushOrder(orderId);
                String order4 = String.valueOf(map.get("startLon")) + "," + String.valueOf(map.get("startLat"));
                String distance4 = gdMapElectricFenceUtil.getDistance(lon + "," + lat, order4, 1).get("distance");
                map.put("startDistance", ToolUtil.isNotEmpty(distance4) ? Double.valueOf(distance4) / 1000 : 0);

                //总距离
                String end4 = String.valueOf(map.get("endLon")) + "," + String.valueOf(map.get("endLat"));
                distance = gdMapElectricFenceUtil.getDistance(end4, order4, 1).get("distance");
                map.put("totalDistance", ToolUtil.isNotEmpty(distance) ? Double.valueOf(distance) / 1000 : 0);

                Integer orderSource4 = Integer.valueOf(String.valueOf(map.get("orderSource")));
                if(orderSource4 == 1 || orderSource4 == 2 || orderSource4 == 3){
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "乘客下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                if(orderSource4 == 5){
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 1){
                        map.put("type", "调度下单");
                    }
                    if(Integer.valueOf(String.valueOf(map.get("isReassign"))) == 2){
                        map.put("type", "改派");
                    }
                }
                break;
            case 6:
                break;
        }
        return map;
    }


    /**
     * 司机执行抢单操作
     * @param orderId
     * @param orderType
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public synchronized ResultUtil grabOrder(Integer orderId, Integer orderType, Integer uid) throws Exception {
        switch (orderType){
            case 1://专车
                return orderPrivateCarService.grabOrder(orderId, uid);
            case 2://出租
                return orderTaxiService.grabOrder(orderId, uid);
            case 3://城际
                return ResultUtil.success();//不作任何操作，跨城默认选择的司机
            case 4://同城小件
                return orderLogisticsService.grabOrder(orderId, uid);
            case 5://跨城小件
                return orderLogisticsService.grabOrder(orderId, uid);
            case 6:
                break;
        }
        return null;
    }


    /**
     * 司机抢单（车载端）
     * @param orderId
     * @param orderType
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public synchronized ResultUtil grabOrder_(Integer orderId, Integer orderType, Integer uid) throws Exception {
        switch (orderType){
            case 1://专车
                break;
            case 2://出租
                return orderTaxiService.grabOrder_(orderId, uid);
            case 3://城际
                break;
            case 4://同城小件
                return orderLogisticsService.grabOrder_(orderId, uid);
            case 5://跨城小件
                return orderLogisticsService.grabOrder_(orderId, uid);
            case 6:
                break;
        }
        return null;
    }



    /**
     * 获取订单详情页（服务中的页面）
     * @param orderId
     * @param orderType
     * @return
     * @throws Exception
     */
    @Override
    public Map<String, Object> queryOrderInfo(Integer orderId, Integer orderType) throws Exception {
        Map<String, Object> map = null;
        switch (orderType){
            case 1://专车
                map = orderPrivateCarService.queryOrderInfo(orderId);
                break;
            case 2://出租
                map = orderTaxiService.queryOrderInfo(orderId);
                break;
            case 3://城际
                map = orderCrossCityService.queryOrderCrossCityInfo(orderId);
                break;
            case 4://同城小件
                map = orderLogisticsService.queryOrderInfo(orderId);
                break;
            case 5://跨城小件
                map = orderLogisticsService.queryOrderInfo(orderId);
                break;
            case 6:
                break;
        }
        if(null != map.get("telX")){
            map.put("phone", map.get("telX"));
        }
        return map;
    }


    /**
     * 获取改派订单收费金额
     * @param orderId
     * @return
     * @throws Exception
     */
    @Override
    public Double queryReassignMoney(Integer orderId, Integer orderType) throws Exception {
        Integer companyId = null;
        switch (orderType){
            case 1://专车
                companyId = orderPrivateCarService.selectById(orderId).getCompanyId();
                break;
            case 2://出租
                companyId = orderTaxiService.selectById(orderId).getCompanyId();
                break;
            case 3://城际
                companyId = orderCrossCityService.selectById(orderId).getCompanyId();
                break;
            case 4://同城小件
                companyId = orderLogisticsService.selectById(orderId).getCompanyId();
                break;
            case 5://跨城小件
                companyId = orderLogisticsService.selectById(orderId).getCompanyId();
                break;
            case 6:
                break;
        }
        return sysReformistMapper.queryMoney(companyId);
    }


    /**
     * 走订单流程操作
     * @param orderId
     * @param orderType
     * @param state
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil process(Integer orderId, Integer orderType, Integer state, Integer uid, Double lon, Double lat) throws Exception {
        Map<String, String> geocode = gdMapGeocodingUtil.geocode(String.valueOf(lon), String.valueOf(lat));
        String address = geocode.get("address");
        switch (orderType){
            case 1://专车
                return orderPrivateCarService.process(orderId, state, lon, lat, address);
            case 2://出租
                return orderTaxiService.process(orderId, state, lon, lat, address);
            case 3://城际
                return orderCrossCityService.process(orderId, state, lon, lat, address);
            case 4://同城小件
                return orderLogisticsService.process(orderId, state, lon, lat, address);
            case 5://跨城小件
                return orderLogisticsService.process(orderId, state, lon, lat, address);
            case 6:
                break;
        }
        return null;
    }


    /**
     * 确认费用操作
     * @param orderId
     * @param orderType
     * @param type
     * @param travelFee
     * @param parkingFee
     * @param crossingFee
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil confirmFees(Integer orderId, Integer orderType, Integer type, Double travelFee, Double parkingFee, Double crossingFee) throws Exception {
        switch (orderType){
            case 1://专车
                return orderPrivateCarService.confirmFees(orderId, type, parkingFee, crossingFee);
            case 2://出租
                return orderTaxiService.confirmFees(orderId, type, travelFee, parkingFee, crossingFee);
            case 3://城际（没有此流程）
                break;
            case 4://
                break;
            case 5:
                break;
            case 6:
                break;
        }
        return null;
    }

    /**
     * 确认费用（车载端）
     * @param orderId
     * @param orderType
     * @param type
     * @param travelFee
     * @param lon
     * @param lat
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil confirmFees_(Integer orderId, Integer orderType, Integer type, Double travelFee, Double lon, Double lat) throws Exception {
        Map<String, String> geocode = gdMapGeocodingUtil.geocode(String.valueOf(lon), String.valueOf(lat));
        String address = geocode.get("address");
        switch (orderType){
            case 1://专车
                break;
            case 2://出租
                return orderTaxiService.confirmFees_(orderId, type, travelFee, lon, lat, address);
            case 3://城际
                break;
            case 4://
                break;
            case 5:
                break;
            case 6:
                break;
        }
        return null;
    }


    /**
     * 司机确认费用（车载端）不管之前数据状态直接修改到待支付（流程断网情况的处理流程）
     * @param orderId
     * @param orderType
     * @param type
     * @param travelFee
     * @param lon
     * @param lat
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil confirmFees$(Integer orderId, Integer orderType, Integer type, Double travelFee, Double lon, Double lat) throws Exception {
        Map<String, String> geocode = gdMapGeocodingUtil.geocode(String.valueOf(lon), String.valueOf(lat));
        String address = geocode.get("address");
        switch (orderType){
            case 1://专车
                break;
            case 2://出租
                return orderTaxiService.confirmFees$(orderId, type, travelFee, lon, lat, address);
            case 3://城际
                break;
            case 4://
                break;
            case 5:
                break;
            case 6:
                break;
        }
        return null;
    }


    /**
     * 获取司机端待支付页面详情
     * @param orderId
     * @param orderType
     * @return
     */
    @Override
    public Map<String, Object> queryToBePaidPage(Integer orderId, Integer orderType) throws Exception{
        switch (orderType){
            case 1://专车
                return orderPrivateCarService.queryOrderInfo(orderId);
            case 2://出租
                return orderTaxiService.queryOrderInfo(orderId);
            case 3://城际（没有此流程）
                return null;
            case 4://
                break;
            case 5:
                break;
            case 6:
                break;
        }
        return null;
    }



    /**
     * 计算实时里程
     * @throws Exception
     */
    @Override
    public boolean calculateMileage(OrderPosition orderPosition) throws Exception {
        switch (orderPosition.getOrderType()){
            case 1://专车
                return orderPrivateCarService.calculateMileage(orderPosition.getOrderId(), orderPosition.getLon(), orderPosition.getLat());
            case 2://出租
                return orderTaxiService.calculateMileage(orderPosition.getOrderId(), orderPosition.getLon(), orderPosition.getLat());
            case 3://城际
                return orderCrossCityService.calculateMileage(orderPosition);
            case 4://
                break;
            case 5:
                break;
            case 6:
                break;
        }
        return false;
    }


    /**
     * 获取完成的订单数量
     * @param driverId
     * @param start
     * @param end
     * @return
     * @throws Exception
     */
    @Override
    public Integer queryOrderNum(Integer driverId, Date start, Date end) throws Exception {
        //出租车
        Integer[] state = new Integer[]{6, 7, 8, 9};
        int i = orderTaxiService.selectCount(new EntityWrapper<OrderTaxi>().eq("driverId", driverId).between("insertTime", start, end).in("state", state));
        return i;
    }


    /**
     * 处理预约单快到出行时间（30分钟内），将司机调整为服务中
     * @throws Exception
     */
    @Override
    public void reservationOrder() throws Exception {
        //出租车
        List<OrderTaxi> list = orderTaxiService.queryMaturity();//获取所有快到期的预约单（出行时间在10分钟内）
        List<Driver> drivers = new ArrayList<>();
        for(OrderTaxi orderTaxi : list){
            Driver driver = driverService.selectById(orderTaxi.getDriverId());
            driver.setState(3);//修改司机为服务中
            drivers.add(driver);
//            taskUtil.driverIds.add(driver.getId());//添加需要推送提醒的司机

            Integer muoth = Long.valueOf((orderTaxi.getTravelTime().getTime() - System.currentTimeMillis()) / (1000 * 60)).intValue();
            //发送短信提醒
//            HuaWeiSMSUtil.sendSms("[\"" + orderTaxi.getStartAddress() + "\",\"" + orderTaxi.getEndAddress() + "\",\"" + muoth + "\"]", driver.getPhone(), "8822072510762", "d1585000f09b40b784c9e22c8c34a24a");
            aLiSendSms.sendSms(driver.getPhone(), "SMS_485290170", "{\"data\":\"" + orderTaxi.getStartAddress() + "\",\"data1\":\"" + orderTaxi.getEndAddress() + "\",\"data2\":\"" + muoth + "\"}");
        }
        //专车
        List<OrderPrivateCar> list1 = orderPrivateCarService.queryMaturity();
        for(OrderPrivateCar orderPrivateCar : list1){
            Driver driver = driverService.selectById(orderPrivateCar.getDriverId());
            driver.setState(3);//修改司机为服务中
            drivers.add(driver);
//            taskUtil.driverIds.add(driver.getId());//添加需要推送提醒的司机

            Integer muoth = Long.valueOf((orderPrivateCar.getTravelTime().getTime() - System.currentTimeMillis()) / (1000 * 60)).intValue();
            //发送短信提醒
//            HuaWeiSMSUtil.sendSms("[\"" + orderPrivateCar.getStartAddress() + "\",\"" + orderPrivateCar.getEndAddress() + "\",\"" + muoth + "\"]", driver.getPhone(), "8822072510762", "d1585000f09b40b784c9e22c8c34a24a");
            aLiSendSms.sendSms(driver.getPhone(), "SMS_485290170", "{\"data\":\"" + orderPrivateCar.getStartAddress() + "\",\"data1\":\"" + orderPrivateCar.getEndAddress() + "\",\"data2\":\"" + muoth + "\"}");
        }
        //跨城
        List<OrderCrossCity> orderCrossCities = orderCrossCityService.queryMaturity();
        for(OrderCrossCity orderCrossCity : orderCrossCities){
            Driver driver = driverService.selectById(orderCrossCity.getDriverId());
            driver.setState(3);//修改司机为服务中
            drivers.add(driver);
//            taskUtil.driverIds.add(driver.getId());//添加需要推送提醒的司机

            Integer muoth = Long.valueOf((orderCrossCity.getTravelTime().getTime() - System.currentTimeMillis()) / (1000 * 60)).intValue();
            //发送短信提醒
//            HuaWeiSMSUtil.sendSms("[\"" + orderCrossCity.getStartAddress() + "\",\"" + orderCrossCity.getEndAddress() + "\",\"" + muoth + "\"]", driver.getPhone(), "8822072510762", "d1585000f09b40b784c9e22c8c34a24a");
            aLiSendSms.sendSms(driver.getPhone(), "SMS_485290170", "{\"data\":\"" + orderCrossCity.getStartAddress() + "\",\"data1\":\"" + orderCrossCity.getEndAddress() + "\",\"data2\":\"" + muoth + "\"}");
        }
        //小件物流
        List<OrderLogistics> orderLogistics = orderLogisticsService.queryMaturity();
        for(OrderLogistics orderLogistics1 : orderLogistics){
            Driver driver = driverService.selectById(orderLogistics1.getDriverId());
//            taskUtil.driverIds.add(driver.getId());//添加需要推送提醒的司机

            Integer muoth = Long.valueOf((orderLogistics1.getTravelTime().getTime() - System.currentTimeMillis()) / (1000 * 60)).intValue();
            //发送短信提醒
//            HuaWeiSMSUtil.sendSms("[\"" + orderLogistics1.getStartAddress() + "\",\"" + orderLogistics1.getEndAddress() + "\",\"" + muoth + "\"]", driver.getPhone(), "8822072510762", "d1585000f09b40b784c9e22c8c34a24a");
            aLiSendSms.sendSms(driver.getPhone(), "SMS_485290170", "{\"data\":\"" + orderLogistics1.getStartAddress() + "\",\"data1\":\"" + orderLogistics1.getEndAddress() + "\",\"data2\":\"" + muoth + "\"}");
        }
        if(drivers.size() > 0){
            driverService.updateBatchById(drivers);//批量修改状态为服务中
        }
    }


    /**
     * 定时任务处理结束订单后30分钟解绑小号功能
     * @throws Exception
     */
    @Override
    public void taskMidAxbUnBindSend() throws Exception {
        List<OrderTaxi> list = orderTaxiService.taskMidAxbUnBindSend();
        for(OrderTaxi orderTaxi : list){
            Map<String, String> map = chinaMobileUtil.midAxbUnBindSend(orderTaxi.getBindId());
            if(!String.valueOf(map.get("code")).equals("200")){
                System.err.println(String.valueOf(map.get("msg")));
            }
            orderTaxi.setTelX("");
            orderTaxi.setBindId("");
        }
        if(list.size() > 0){
            orderTaxiService.updateBatchById(list);
        }
    }


    /**
     * 更新绑定关系
     * @param orderId
     * @param orderType
     * @throws Exception
     */
    @Override
    public void RebindMidAxbBindSend(Integer orderId, Integer orderType) throws Exception {
        switch (orderType){
            case 1:
                OrderPrivateCar orderPrivateCar = orderPrivateCarService.selectById(orderId);
                if(ToolUtil.isNotEmpty(orderPrivateCar.getBindId())){
                    Map<String, String> map1 = chinaMobileUtil.midAxbUnBindSend(orderPrivateCar.getBindId());
                    if(!String.valueOf(map1.get("code")).equals("200")){
                        System.err.println(String.valueOf(map1.get("msg")));
                    }
                    //调用移动的小号接口
                    Map<String, String> geocode = gdMapGeocodingUtil.geocode(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
                    Region region = regionMapper.query(geocode.get("districtCode"));
                    Driver driver = driverService.selectById(orderPrivateCar.getDriverId());
                    Map<String, String> map = chinaMobileUtil.midAxbBindSend(orderPrivateCar.getPassengersPhone(), driver.getPhone(), Integer.valueOf(region.getCitycode().substring(1)));
                    if(String.valueOf(map.get("code")).equals("200")){
                        orderPrivateCar.setTelX(map.get("telX"));
                        orderPrivateCar.setBindId(map.get("bindId"));
                    }
                    orderPrivateCarService.updateById(orderPrivateCar);
                }
                break;
            case 2:
                OrderTaxi orderTaxi = orderTaxiService.selectById(orderId);
                if(ToolUtil.isNotEmpty(orderTaxi.getBindId())){
                    Map<String, String> map1 = chinaMobileUtil.midAxbUnBindSend(orderTaxi.getBindId());
                    if(!String.valueOf(map1.get("code")).equals("200")){
                        System.err.println(String.valueOf(map1.get("msg")));
                    }
                    //调用移动的小号接口
                    Map<String, String> geocode = gdMapGeocodingUtil.geocode(orderTaxi.getStartLon().toString(), orderTaxi.getStartLat().toString());
                    Region region = regionMapper.query(geocode.get("districtCode"));
                    Driver driver = driverService.selectById(orderTaxi.getDriverId());
                    Map<String, String> map = chinaMobileUtil.midAxbBindSend(orderTaxi.getPassengersPhone(), driver.getPhone(), Integer.valueOf(region.getCitycode().substring(1)));
                    if(String.valueOf(map.get("code")).equals("200")){
                        orderTaxi.setTelX(map.get("telX"));
                        orderTaxi.setBindId(map.get("bindId"));
                    }
                    orderTaxiService.updateById(orderTaxi);
                }
                break;
            case 3:
                OrderCrossCity orderCrossCity = orderCrossCityService.selectById(orderId);
                if(ToolUtil.isNotEmpty(orderCrossCity.getBindId())){
                    Map<String, String> map1 = chinaMobileUtil.midAxbUnBindSend(orderCrossCity.getBindId());
                    if(!String.valueOf(map1.get("code")).equals("200")){
                        System.err.println(String.valueOf(map1.get("msg")));
                    }
                    //调用移动的小号接口
                    Map<String, String> geocode = gdMapGeocodingUtil.geocode(orderCrossCity.getStartLon().toString(), orderCrossCity.getStartLat().toString());
                    Region region = regionMapper.query(geocode.get("districtCode"));
                    Driver driver = driverService.selectById(orderCrossCity.getDriverId());
                    Map<String, String> map = chinaMobileUtil.midAxbBindSend(orderCrossCity.getPassengersPhone(), driver.getPhone(), Integer.valueOf(region.getCitycode().substring(1)));
                    if(String.valueOf(map.get("code")).equals("200")){
                        orderCrossCity.setTelX(map.get("telX"));
                        orderCrossCity.setBindId(map.get("bindId"));
                    }
                    orderCrossCityService.updateById(orderCrossCity);
                }
                break;
        }
    }

    /**
     * 获取接单后的语音播报
     * @param orderId
     * @param orderType
     * @return
     * @throws Exception
     */
    @Override
    public String queryVoiceBroadcast(Integer orderId, Integer orderType, String lon, String lat) throws Exception {
        String content = "";
        switch (orderType){
            case 1:
                OrderPrivateCar orderPrivateCar = orderPrivateCarService.selectById(orderId);
                Map<String, String> distance = gdMapElectricFenceUtil.getDistance(lon + "," + lat, orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), 1);
                Double d = null != distance ? (Double.valueOf(String.valueOf(distance.get("distance"))) / 1000) : 0;
                Map<String, String> distance_ = gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), 1);
                Double d_ = null != distance_ ? (Double.valueOf(String.valueOf(distance_.get("distance"))) / 1000) : 0;
                content = (orderPrivateCar.getOrderType() == 1 ? "实时单" : "预约单") + "，距您约" + d + "公里，从" + orderPrivateCar.getStartAddress() + "到" + orderPrivateCar.getEndAddress() + "，全程" + d_ + "公里。";
                break;
            case 2:
                OrderTaxi orderTaxi = orderTaxiService.selectById(orderId);
                Map<String, String> distance1 = gdMapElectricFenceUtil.getDistance(lon + "," + lat, orderTaxi.getStartLon() + "," + orderTaxi.getStartLat(), 1);
                Double d1 = null != distance1 ? (Double.valueOf(String.valueOf(distance1.get("distance"))) / 1000) : 0;
                if(ToolUtil.isEmpty(orderTaxi.getEndLon())){
                    /*Map<String, String> distance1_ = gdMapElectricFenceUtil.getDistance(orderTaxi.getStartLon() + "," + orderTaxi.getStartLat(), orderTaxi.getEndLon() + "," + orderTaxi.getEndLat(), 1);
                    Double d1_ = null != distance1_ ? (Double.valueOf(String.valueOf(distance1_.get("distance"))) / 1000) : 0;*/
                    content = (orderTaxi.getOrderType() == 1 ? "实时单" : "预约单") + "，距您约" + d1 + "公里。";
                }else{
                    Map<String, String> distance1_ = gdMapElectricFenceUtil.getDistance(orderTaxi.getStartLon() + "," + orderTaxi.getStartLat(), orderTaxi.getEndLon() + "," + orderTaxi.getEndLat(), 1);
                    Double d1_ = null != distance1_ ? (Double.valueOf(String.valueOf(distance1_.get("distance"))) / 1000) : 0;
                    content = (orderTaxi.getOrderType() == 1 ? "实时单" : "预约单") + "，距您约" + d1 + "公里，从" + orderTaxi.getStartAddress() + "到" + orderTaxi.getEndAddress() + "，全程" + d1_ + "公里。";
                }
                break;
            case 3:
                OrderCrossCity orderCrossCity = orderCrossCityService.selectById(orderId);
                Map<String, String> distance2 = gdMapElectricFenceUtil.getDistance(lon + "," + lat, orderCrossCity.getStartLon() + "," + orderCrossCity.getStartLat(), 1);
                Double d2 = null != distance2 ? (Double.valueOf(String.valueOf(distance2.get("distance"))) / 1000) : 0;
                Map<String, String> distance2_ = gdMapElectricFenceUtil.getDistance(orderCrossCity.getStartLon() + "," + orderCrossCity.getStartLat(), orderCrossCity.getEndLon() + "," + orderCrossCity.getEndLat(), 1);
                Double d2_ = null != distance2_ ? (Double.valueOf(String.valueOf(distance2_.get("distance"))) / 1000) : 0;
                content = "实时单，距您约" + d2 + "公里，从" + orderCrossCity.getStartAddress() + "到" + orderCrossCity.getEndAddress() + "，全程" + d2_ + "公里。";
                break;
            case 4:
                OrderLogistics orderLogistics = orderLogisticsService.selectById(orderId);
                Map<String, String> distance3 = gdMapElectricFenceUtil.getDistance(lon + "," + lat, orderLogistics.getStartLon() + "," + orderLogistics.getStartLat(), 1);
                Double d3 = null != distance3 ? (Double.valueOf(String.valueOf(distance3.get("distance"))) / 1000) : 0;
                Map<String, String> distance3_ = gdMapElectricFenceUtil.getDistance(orderLogistics.getStartLon() + "," + orderLogistics.getStartLat(), orderLogistics.getEndLon() + "," + orderLogistics.getEndLat(), 1);
                Double d3_ = null != distance3_ ? (Double.valueOf(String.valueOf(distance3_.get("distance"))) / 1000) : 0;
                content = "实时单，距您约" + d3 + "公里，从" + orderLogistics.getStartAddress() + "到" + orderLogistics.getEndAddress() + "，全程" + d3_ + "公里。";
                break;
            case 5:
                OrderLogistics orderLogistics1 = orderLogisticsService.selectById(orderId);
                Map<String, String> distance4 = gdMapElectricFenceUtil.getDistance(lon + "," + lat, orderLogistics1.getStartLon() + "," + orderLogistics1.getStartLat(), 1);
                Double d4 = null != distance4 ? (Double.valueOf(String.valueOf(distance4.get("distance"))) / 1000) : 0;
                Map<String, String> distance4_ = gdMapElectricFenceUtil.getDistance(orderLogistics1.getStartLon() + "," + orderLogistics1.getStartLat(), orderLogistics1.getEndLon() + "," + orderLogistics1.getEndLat(), 1);
                Double d4_ = null != distance4_ ? (Double.valueOf(String.valueOf(distance4_.get("distance"))) / 1000) : 0;
                content = "实时单，距您约" + d4 + "公里，从" + orderLogistics1.getStartAddress() + "到" + orderLogistics1.getEndAddress() + "，全程" + d4_ + "公里。";
                break;
        }
        return content;
    }




    /**
     * 手动完成订单操作
     * @param orderId
     * @param orderType
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil completeOrder(Integer orderId, Integer orderType) throws Exception {
        Integer userId = 0;
        Integer driverId = 0;
        Integer state = 0;
        switch (orderType){
            case 1:
                OrderPrivateCar orderPrivateCar = orderPrivateCarService.selectById(orderId);
                if(orderPrivateCar.getState() == 8 || orderPrivateCar.getState() == 9){
                    return ResultUtil.error("订单已完成支付，不允许重复支付");
                }
                if(orderPrivateCar.getState() != 7){
                    return ResultUtil.error("订单不在待支付，无法完成订单");
                }
                orderPrivateCar.setPayManner(2);//其他方式支付
                orderPrivateCar.setRedPacketMoney(0D);
                orderPrivateCar.setCouponMoney(0D);
                orderPrivateCar.setDiscount(0D);
                orderPrivateCar.setDiscountMoney(0D);
                orderPrivateCar.setPayMoney(orderPrivateCar.getOrderMoney());
                orderPrivateCar.setState(8);
                orderPrivateCarService.updateById(orderPrivateCar);
                userId = orderPrivateCar.getUserId();
                driverId = orderPrivateCar.getDriverId();
                state = orderPrivateCar.getState();

                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        if(pushMinistryOfTransport){//上传数据
                            pushMinistryOfTransportUtil.operatePay(orderId);
                        }
                    }
                }).start();
                break;
            case 2:
                OrderTaxi orderTaxi = orderTaxiService.selectById(orderId);
                if(orderTaxi.getState() == 8 || orderTaxi.getState() == 9){
                    return ResultUtil.error("订单已完成支付，不允许重复支付");
                }
                if(orderTaxi.getState() != 7){
                    return ResultUtil.error("订单不在待支付，无法完成订单");
                }
                orderTaxi.setPayManner(2);//其他方式支付
                orderTaxi.setRedPacketMoney(0D);
                orderTaxi.setCouponMoney(0D);
                orderTaxi.setDiscount(0D);
                orderTaxi.setDiscountMoney(0D);
                orderTaxi.setPayMoney(orderTaxi.getOrderMoney());
                orderTaxi.setState(8);
                orderTaxiService.updateById(orderTaxi);
                userId = orderTaxi.getUserId();
                driverId = orderTaxi.getDriverId();
                state = orderTaxi.getState();

                //司机手动确认收款，删除限制司机6分钟不能接单的标识
                String vehicle = redisUtil.getValue("VEHICLE");
                if(ToolUtil.isNotEmpty(vehicle)){
                    JSONArray jsonArray = JSON.parseArray(vehicle);
                    for(int i = 0; i < jsonArray.size(); i++){
                        if(jsonArray.getInteger(i).compareTo(driverId) == 0){
                            jsonArray.remove(i);
                            break;
                        }
                    }
                    redisUtil.setStrValue("VEHICLE", jsonArray.toJSONString());
                }
                break;
        }


        Integer finalDriverId = driverId;
        Integer finalUserId = userId;
        Integer finalState = state;
        new Thread(new Runnable() {
            @Override
            public void run() {
                pushUtil.pushOrderState(1, finalUserId, orderId, orderType, finalState);
                pushUtil.pushOrderState(2, finalDriverId, orderId, orderType, finalState);
            }
        }).start();
        return ResultUtil.success();
    }


    /**
     * 获取订单费用明细
     * @param orderId
     * @param orderType
     * @return
     * @throws Exception
     */
    @Override
    public Map<String, Object> queryMoneyInfo(Integer orderId, Integer orderType) throws Exception {
        switch (orderType){
            case 1:
                return orderPrivateCarService.queryMoneyInfo(orderId);
            case 2:
                break;
        }
        return null;
    }




}