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

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.stylefeng.guns.core.util.ToolUtil;
import com.stylefeng.guns.modular.specialTrain.model.OrderPrivateCar;
import com.stylefeng.guns.modular.specialTrain.server.IOrderPrivateCarService;
import com.stylefeng.guns.modular.system.dao.UserInfoMapper;
import com.stylefeng.guns.modular.system.model.*;
import com.stylefeng.guns.modular.system.service.*;
import com.stylefeng.guns.modular.system.util.*;
import com.stylefeng.guns.modular.taxi.dao.OrderTaxiMapper;
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.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class OrderTaxiServiceImpl extends ServiceImpl<OrderTaxiMapper, OrderTaxi> implements IOrderTaxiService {

    @Resource
    private OrderTaxiMapper orderTaxiMapper;
    
    @Autowired
    private IDriverService driverService;
    
    @Autowired
    private PushUtil pushUtil;
    
    @Autowired
    private GDFalconUtil gdFalconUtil;
    
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    
    @Autowired
    private IOrderPositionService orderPositionService;
    
    @Autowired
    private ISystemNoticeService systemNoticeService;
    
    @Autowired
    private ChinaMobileUtil chinaMobileUtil;
    
    @Autowired
    private GeodesyUtil geodesyUtil;

    @Autowired
    private GDMapGeocodingUtil gdMapGeocodingUtil;

    @Autowired
    private IOrderPrivateCarService orderPrivateCarService;

    @Autowired
    private ICompanyService companyService;

    @Autowired
    private IOrderAdditionalFeeService orderAdditionalFeeService;

    @Resource
    private UserInfoMapper userInfoMapper;


    @Autowired
    private TDriverPromotionActivityService driverPromotionActivityService;
    
    @Resource
    private IOpenCityService openCityService;

    @Autowired
    private IPaymentRecordService paymentRecordService;

    @Autowired
    private ITransactionDetailsService transactionDetailsService;

    @Autowired
    private IIncomeService incomeService;

    @Autowired
    private PayMoneyUtil payMoneyUtil;





    /**
     * 获取司机端首页订单列表
     * @param state     1=服务中，2=待服务（30分钟定义预约）
     * @param driverId
     * @return
     * @throws Exception
     */
    @Override
    public List<Map<String, Object>> queryOrderList(Integer state, Integer driverId) throws Exception {
        return orderTaxiMapper.queryOrderList(state, driverId);
    }


    /**
     * 获取司机端我的订单列表
     * @param state     1=全部，2=待支付，3=已取消
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public List<Map<String, Object>> queryMyAllOrder(Integer state, Integer uid) throws Exception {
        return orderTaxiMapper.queryMyAllOrder(state, uid);
    }


    /**
     * 获取订单数据
     * @param state
     * @param driverId
     * @return
     * @throws Exception
     */
    @Override
    public List<OrderTaxi> query(Integer driverId, Integer...state) throws Exception {
        List<Integer> integers = Arrays.asList(state);
        return orderTaxiMapper.query(integers, driverId);
    }


    /**
     * 获取司机抢单页面的订单详情
     * @param orderId
     * @return
     * @throws Exception
     */
    @Override
    public Map<String, Object> queryPushOrder(Integer orderId) throws Exception {
        return orderTaxiMapper.queryPushOrder(orderId);
    }


    /**
     * 抢单操作
     * @param orderId
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil grabOrder(Integer orderId, Integer uid) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        if(null != orderTaxi && orderTaxi.getType() == 2){
            if(orderTaxi.getState() != 1){
                return ResultUtil.error("订单已被抢了");
            }
        }else{
            OrderPrivateCar orderPrivateCar1 = orderPrivateCarService.selectById(orderId);
            if(null != orderPrivateCar1 && orderPrivateCar1.getType() == 3 && orderPrivateCar1.getState() != 1&& orderPrivateCar1.getState() != 11){
                return ResultUtil.error("订单已被抢了");
            }
            orderTaxi = null;
            if(null != orderPrivateCar1 && orderPrivateCar1.getType() == 3 && (orderPrivateCar1.getState() == 1||  orderPrivateCar1.getState() == 11)){
                orderPrivateCarService.deleteById(orderId);
                OrderTaxi orderTaxi1 = setOrderTaxi(orderPrivateCar1);
                this.insert(orderTaxi1);
                orderTaxi = orderTaxi1;
            }
        }
        if(null == orderTaxi){
            return ResultUtil.error("订单已被抢了");
        }

        //处理摆渡车的情况
        if(orderTaxi.getType() == 2){
            //查看用户下的摆渡车是否已被人抢了
            List<OrderTaxi> list = this.selectList(
                    new EntityWrapper<OrderTaxi>()
                            .eq("type", 2)
                            .eq("userId", orderTaxi.getUserId())
                            .ne("state", 1)
                            .eq("crossCityOrderId", orderTaxi.getCrossCityOrderId())
                            .eq("place", orderTaxi.getPlace())
            );
            List<OrderPrivateCar> list1 = orderPrivateCarService.selectList(
                    new EntityWrapper<OrderPrivateCar>()
                            .eq("type", 2)
                            .eq("userId", orderTaxi.getUserId())
                            .ne("state", 1)
                            .eq("crossCityOrderId", orderTaxi.getCrossCityOrderId())
                            .eq("place", orderTaxi.getPlace())
            );
            if(list.size() > 0 || list1.size() > 0){
                return ResultUtil.error("手速有点慢哦，订单已被抢啦！");
            }
        }

        if(orderTaxi.getState() == 10){
            return ResultUtil.error("订单已取消");
        }
        if(orderTaxi.getState() != 1 && orderTaxi.getState() != 11 ){
            return ResultUtil.error("手速有点慢哦，订单已被抢啦！");
        }

        Integer oldDriverId = null;
        if(orderTaxi.getState()==11){
            oldDriverId= orderTaxi.getDriverId();
        }
        Driver driver = driverService.selectById(uid);
        orderTaxi.setDriverId(uid);
        orderTaxi.setCarId(driver.getCarId());
        orderTaxi.setCompanyId(driver.getFranchiseeId() != null && driver.getFranchiseeId() != 0 ? driver.getFranchiseeId() : (
                driver.getCompanyId() != null && driver.getCompanyId() != 0 ? driver.getCompanyId() : 1));
        orderTaxi.setState(2);
        orderTaxi.setSnatchOrderTime(new Date());

        //调用高德创建轨迹
//        String s = gdFalconUtil.selectTerminal(driver.getPhone());
//        String track = gdFalconUtil.createTrack(s);
//        orderTaxi.setTrackId(track);
//
//        //调用移动的小号接口
//        Map<String, String> map = chinaMobileUtil.midAxbBindSend(orderTaxi.getPassengersPhone(), driver.getPhone(), (System.currentTimeMillis() + 86400000));
//        if(String.valueOf(map.get("code")).equals("200")){
//            orderTaxi.setTelX(map.get("telX"));
//            orderTaxi.setBindId(map.get("bindId"));
//        }

        // 是否推广订单
        Integer promotion = isPromotion(orderTaxi.getUserId(), driver.getPlaceOfEmployment());
        if(promotion!=null){
            orderTaxi.setPromotion(2);
            Driver driver1 = driverService.selectById(promotion);
            orderTaxi.setPromotionUser(driver1.getName());
            orderTaxi.setPromotionPhone(driver1.getPhone());
            orderTaxi.setPromotionDriverId(promotion);
        }else{
            orderTaxi.setPromotion(1);
        }
        
        this.updateById(orderTaxi);

        if(orderTaxi.getType() == 2){
            List<OrderTaxi> list = this.selectList(
                    new EntityWrapper<OrderTaxi>()
                            .eq("type", 2)
                            .eq("userId", orderTaxi.getUserId())
                            .ne("state", 1)
                            .eq("crossCityOrderId", orderTaxi.getCrossCityOrderId())
                            .eq("place", orderTaxi.getPlace()).ne("id", orderTaxi.getId())
            );
            List<OrderPrivateCar> list1 = orderPrivateCarService.selectList(
                    new EntityWrapper<OrderPrivateCar>()
                            .eq("type", 2)
                            .eq("userId", orderTaxi.getUserId())
                            .ne("state", 1)
                            .eq("crossCityOrderId", orderTaxi.getCrossCityOrderId())
                            .eq("place", orderTaxi.getPlace())
            );
            for(OrderTaxi orderTaxi1 : list){
                orderTaxi1.setState(10);
                this.updateById(orderTaxi1);
            }
            for(OrderPrivateCar orderPrivateCar : list1){
                orderPrivateCar.setState(10);
                orderPrivateCarService.updateById(orderPrivateCar);
            }
        }

        //如果是预约单，则不修改司机为服务中
        if(orderTaxi.getOrderType() != 2 || (orderTaxi.getOrderType() == 2 && orderTaxi.getTravelTime().getTime() < System.currentTimeMillis() + 600000)){
            //修改司机为服务中
            driver.setState(3);
            driverService.updateById(driver);
        }

        //推送相关代码------------------start----------------
        OrderTaxi finalOrderTaxi = orderTaxi;
        Integer finalOldDriverId = oldDriverId;
        new Thread(new Runnable() {
            @Override
            public void run() {
                if(finalOldDriverId !=null){
                    // 推送3个 1推送原司机 2推送新司机 3推送用户
                    pushUtil.pushOrderState(2, finalOrderTaxi.getDriverId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
                    pushUtil.pushOrderReassign(finalOrderTaxi.getUserId(),1 , finalOrderTaxi.getId(), 2);
                    pushUtil.pushOrderReassign(finalOldDriverId,2, finalOrderTaxi.getId(), 2);

                }else {
                    pushUtil.pushOrderState(1, finalOrderTaxi.getUserId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
                    pushUtil.pushOrderState(2, finalOrderTaxi.getDriverId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
                    if(finalOrderTaxi.getType() == 2){
                        pushUtil.pushFerryOrderState(1, finalOrderTaxi.getUserId(), finalOrderTaxi.getId(), 2, 2);
                        System.err.println("----------------------------------推送摆渡订单-----------------------------");
                    }
                }

            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                pushUtil.pushDriverPosition(orderId, 2);
            }
        }).start();

        systemNoticeService.addSystemNotice(2, "您已成功抢得出租车订单，请及时联系客户！", orderTaxi.getDriverId(), 1);
        systemNoticeService.addSystemNotice(1, "您的订单已指派给" + driver.getName().substring(0, 1) + "师傅，请保持电话畅通！", orderTaxi.getUserId(), 1);

        return ResultUtil.success(orderTaxi.getId());
    }
    private Integer isPromotion(Integer userId, String code){
        UserInfo userInfo = userInfoMapper.selectById(userId);
        if(userInfo.getBindDriverId()!=null && userInfo.getBindExpireDate().getTime()<=System.currentTimeMillis()){
            TDriverPromotionActivity tDriverPromotionActivity = driverPromotionActivityService.selectOne(new EntityWrapper<TDriverPromotionActivity>().eq("state",1)
                    .eq("districtCode", code).le("startTime", new Date()).ge("endTime", new Date()).last("AND FIND_IN_SET(" + 2 + ", bizType) limit 1"));
            if(tDriverPromotionActivity!=null){
                return userInfo.getBindDriverId();
            }
        }
        return null;

    }


    public OrderTaxi setOrderTaxi(OrderPrivateCar orderPrivateCar){
        OrderTaxi orderTaxi = new OrderTaxi();
        orderTaxi.setType(1);
        orderTaxi.setUserId(orderPrivateCar.getUserId());
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
        try {
            orderTaxi.setOrderNum("TA" + sdf.format(new Date()) + UUIDUtil.getRandomCode(5));
        } catch (Exception e) {
            e.printStackTrace();
        }
        orderTaxi.setPlacementLon(orderPrivateCar.getPlacementLon());
        orderTaxi.setPlacementLat(orderPrivateCar.getPlacementLat());
        orderTaxi.setPlacementAddress(orderPrivateCar.getPlacementAddress());
        orderTaxi.setStartLon(orderPrivateCar.getStartLon());
        orderTaxi.setStartLat(orderPrivateCar.getStartLat());
        orderTaxi.setStartAddress(orderPrivateCar.getStartAddress());
        orderTaxi.setEndAddress(orderPrivateCar.getEndAddress());
        orderTaxi.setEndLat(orderPrivateCar.getEndLat());
        orderTaxi.setEndLon(orderPrivateCar.getEndLon());
        orderTaxi.setCompanyId(orderPrivateCar.getCompanyId());
        orderTaxi.setSubstitute(orderPrivateCar.getSubstitute());
        orderTaxi.setPassengers(orderPrivateCar.getPassengers());
        orderTaxi.setPassengersPhone(orderPrivateCar.getPassengersPhone());
        orderTaxi.setState(1);
        orderTaxi.setInsertTime(orderPrivateCar.getInsertTime());
        orderTaxi.setTravelTime(orderPrivateCar.getTravelTime());
        orderTaxi.setOrderType(orderPrivateCar.getOrderType());
        orderTaxi.setOrderSource(orderPrivateCar.getOrderSource());
        orderTaxi.setIsDelete(1);
        orderTaxi.setIsReassign(1);
        return orderTaxi;
    }




    /**
     * 抢单操作（车载端）
     * @param orderId
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public synchronized ResultUtil grabOrder_(Integer orderId, Integer uid) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        if(orderTaxi.getState() == 9){
            return ResultUtil.error("订单已取消");
        }
        if(orderTaxi.getState() != 1){
            return ResultUtil.error("手速有点慢哦，订单已被抢啦！");
        }
        Driver driver = driverService.selectById(uid);
        orderTaxi.setDriverId(uid);
        orderTaxi.setCarId(driver.getCarId());
        orderTaxi.setCompanyId(driver.getFranchiseeId() != null && driver.getFranchiseeId() != 0 ? driver.getFranchiseeId() : (
                driver.getCompanyId() != null && driver.getCompanyId() != 0 ? driver.getCompanyId() : 1));
        orderTaxi.setState(2);
        Date date = new Date();
        orderTaxi.setSnatchOrderTime(date);
        orderTaxi.setSetOutTime(date);
        orderTaxi.setArriveTime(date);
        orderTaxi.setStartServiceTime(date);
        orderTaxi.setBoardingTime(date);
    
        String value = (String) redisTemplate.opsForValue().get("dache:DRIVER" + uid);
        if (ToolUtil.isNotEmpty(value)) {
            String[] split = value.split(",");
            Map<String, String> geocode1 = gdMapGeocodingUtil.geocode(split[0], split[1]);
            orderTaxi.setBoardingAddress(geocode1.get("address"));
            orderTaxi.setBoardingLon(Double.valueOf(split[0]));
            orderTaxi.setBoardingLat(Double.valueOf(split[1]));
        }
    
        //调用高德创建轨迹
//        String s = gdFalconUtil.selectTerminal(driver.getPhone());
//        String track = gdFalconUtil.createTrack(s);
//        orderTaxi.setTrackId(track);

        //调用移动的小号接口 TODO 车载端使用真实号码
//        Map<String, String> geocode = gdMapGeocodingUtil.geocode(orderTaxi.getStartLon().toString(), orderTaxi.getStartLat().toString());
//        Region region = regionMapper.query(geocode.get("districtCode"));
//        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"));
////        }

        this.updateById(orderTaxi);

        //如果是预约单，则不修改司机为服务中
        if(orderTaxi.getOrderType() != 2 || (orderTaxi.getOrderType() == 2 && orderTaxi.getTravelTime().getTime() < System.currentTimeMillis() + 600000)){
            //修改司机为服务中
            driver.setState(3);
            driverService.updateById(driver);
        }

        //推送相关代码------------------start----------------
        new Thread(new Runnable() {
            @Override
            public void run() {
                pushUtil.pushOrderState(1, orderTaxi.getUserId(), orderTaxi.getId(), 2, orderTaxi.getState());
                pushUtil.pushOrderState(2, orderTaxi.getDriverId(), orderTaxi.getId(), 2, orderTaxi.getState());
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                pushUtil.pushDriverPosition(orderId, 2);
            }
        }).start();

        systemNoticeService.addSystemNotice(2, "您已成功抢得出租车订单，请及时联系客户！", orderTaxi.getDriverId(), 1);
        systemNoticeService.addSystemNotice(1, "您的订单已指派给" + driver.getName().substring(0, 1) + "师傅，请保持电话畅通！", orderTaxi.getUserId(), 1);

        return ResultUtil.success();
    }





    /**
     * 获取订单详情页（服务中的页面）
     * @param orderId
     * @return
     * @throws Exception
     */
    @Override
    public Map<String, Object> queryOrderInfo(Integer orderId) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        OpenCity openCity = openCityService.openCity1(orderTaxi.getStartLon().toString(), orderTaxi.getStartLat().toString());
        return orderTaxiMapper.queryOrderInfo(orderId, openCity.getId());
    }


    /**
     * 走订单流程操作
     * @param orderId
     * @param state
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil process(Integer orderId, Integer state, Double lon, Double lat, String address) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        if(10 == orderTaxi.getState()){
            return ResultUtil.error("订单已被取消，不能继续操作");
        }
        switch (state){
            case 3://出发前往预约点
                orderTaxi.setState(3);
                orderTaxi.setSetOutTime(new Date());
                systemNoticeService.addSystemNotice(1, "司机已出发，请耐心等待", orderTaxi.getUserId(), 1);
                break;
            case 4://到达预约点，等待客户上车
                orderTaxi.setState(4);
                orderTaxi.setArriveTime(new Date());
                systemNoticeService.addSystemNotice(1, "司机已到达您设置的预约地点，请及时上车", orderTaxi.getUserId(), 1);
                break;
            case 5://开始服务
                orderTaxi.setBoardingLon(lon);
                orderTaxi.setBoardingLat(lat);
                orderTaxi.setBoardingAddress(address);
                orderTaxi.setBoardingTime(new Date());
                orderTaxi.setState(5);
                orderTaxi.setStartServiceTime(new Date());

                pushUtil.pushDriverPosition(orderTaxi.getId(), 2);//主动推送司机定位
                break;
            case 6://结束服务
                orderTaxi.setGetoffLon(lon);
                orderTaxi.setGetoffLat(lat);
                orderTaxi.setGetoffAddress(address);
                orderTaxi.setGetoffTime(new Date());
                orderTaxi.setState(6);
                orderTaxi.setEndServiceTime(new Date());

                pushUtil.removeTask(orderId, 2);//删除定时任务，结束推送数据
                systemNoticeService.addSystemNotice(1, "司机已结束本次行程，谢谢使用", orderTaxi.getUserId(), 1);
                break;
        }
        this.updateById(orderTaxi);
    
        // TODO: 2020/6/5 推送状态
        new Thread(new Runnable() {
            @Override
            public void run() {
                pushUtil.pushOrderState(1, orderTaxi.getUserId(), orderTaxi.getId(), 2, orderTaxi.getState());
                pushUtil.pushOrderState(2, orderTaxi.getDriverId(), orderTaxi.getId(), 2, orderTaxi.getState());
            }
        }).start();
        return ResultUtil.success();
    }


    /**
     * 确认费用操作
     * @param orderId
     * @param type
     * @param travelFee
     * @param parkingFee
     * @param crossingFee
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil confirmFees(Integer orderId, Integer type, Double travelFee, Double parkingFee, Double crossingFee) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        orderTaxi.setPayManner(type);
        if(type == 2){//其他支付，不需要操作，直接完成订单
            orderTaxi.setOrderMoney(0D);
            orderTaxi.setTravelMoney(0D);
            orderTaxi.setParkMoney(0D);
            orderTaxi.setRoadTollMoney(0D);
            orderTaxi.setRedPacketMoney(0D);
            orderTaxi.setCouponMoney(0D);
            orderTaxi.setDiscount(0D);
            orderTaxi.setDiscountMoney(0D);
            orderTaxi.setPayMoney(0D);
            orderTaxi.setState(8);
        }else{
            orderTaxi = this.setMoney(orderTaxi, travelFee, parkingFee, crossingFee);
            orderTaxi.setState(7);
        }
        this.updateById(orderTaxi);
    
        Driver driver = driverService.selectById(orderTaxi.getDriverId());

        //回滚司机状态为空闲
        driver.setState(2);
        driverService.updateById(driver);

        OrderTaxi finalOrderTaxi = orderTaxi;
        new Thread(new Runnable() {
            @Override
            public void run() {
                pushUtil.pushOrderState(1, finalOrderTaxi.getUserId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
                pushUtil.pushOrderState(2, finalOrderTaxi.getDriverId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
            }
        }).start();
        return ResultUtil.success();
    }



    @Override
    public ResultUtil confirmFees1(Integer orderId, Integer type, Double travelFee, String additionalFee) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        orderTaxi.setPayManner(type);
        if(type == 2){//其他支付，不需要操作，直接完成订单
            orderTaxi.setOrderMoney(0D);
            orderTaxi.setTravelMoney(0D);
            orderTaxi.setParkMoney(0D);
            orderTaxi.setRoadTollMoney(0D);
            orderTaxi.setHolidayFee(0D);
            orderTaxi.setRedPacketMoney(0D);
            orderTaxi.setCouponMoney(0D);
            orderTaxi.setDiscount(0D);
            orderTaxi.setDiscountMoney(0D);
            orderTaxi.setPayMoney(0D);
            orderTaxi.setState(8);
        }else{
            orderTaxi = this.setMoney1(orderTaxi, travelFee, additionalFee);
            if (Integer.valueOf(1).equals(orderTaxi.getPaymentMode())) {
                double estimateAmount = orderTaxi.getEstimateAmount() == null ? 0D : orderTaxi.getEstimateAmount();
                int compareResult = BigDecimal.valueOf(estimateAmount).compareTo(BigDecimal.valueOf(orderTaxi.getOrderMoney()));
                if (compareResult > 0) {
                    orderTaxi.setState(7);
                    orderTaxi.setPrepayStage(4);
                    handlePrepaidRefund(orderTaxi, estimateAmount - orderTaxi.getOrderMoney());
                } else if (compareResult < 0) {
                    orderTaxi.setState(7);
                    orderTaxi.setPrepayStage(3);
                } else {
                    finishPrepaidOrder(orderTaxi);
                }
            } else {
                orderTaxi.setState(7);
            }
        }
        this.updateById(orderTaxi);
    
        Driver driver = driverService.selectById(orderTaxi.getDriverId());

        //回滚司机状态为空闲
        driver.setState(2);
        driverService.updateById(driver);

        OrderTaxi finalOrderTaxi = orderTaxi;
        new Thread(new Runnable() {
            @Override
            public void run() {
                pushUtil.pushOrderState(1, finalOrderTaxi.getUserId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
                pushUtil.pushOrderState(2, finalOrderTaxi.getDriverId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
            }
        }).start();
        return ResultUtil.success();
    }

    /**
     * 处理预支付多退退款
     */
    private void handlePrepaidRefund(OrderTaxi orderTaxi, Double refundAmount) throws Exception {
        if (refundAmount == null || refundAmount <= 0) {
            return;
        }
        Double refundMoney = formatMoney(refundAmount);
        String refundNo = buildPrepayRefundNo(2, orderTaxi.getId());
        orderTaxi.setPrepayRefundNo(refundNo);
        orderTaxi.setPrepayRefundAmount(refundMoney);

        if (Integer.valueOf(3).equals(orderTaxi.getPayType())) {
            UserInfo userInfo = userInfoMapper.selectById(orderTaxi.getUserId());
            if (userInfo != null) {
                userInfo.setBalance(formatMoney((userInfo.getBalance() == null ? 0D : userInfo.getBalance()) + refundMoney));
                userInfoMapper.updateById(userInfo);
                finishPrepaidOrder(orderTaxi);
            }
            return;
        }

        PaymentRecord paymentRecord = paymentRecordService.query(1, orderTaxi.getUserId(), 1, orderTaxi.getId(), 2, orderTaxi.getPayType(), 2);
        if (paymentRecord == null || ToolUtil.isEmpty(paymentRecord.getCode())) {
            System.err.println("预支付退款数据异常（taxiOrderId = " + orderTaxi.getId() + "）");
            return;
        }

        if (Integer.valueOf(1).equals(orderTaxi.getPayType())) {
            Map<String, String> map = payMoneyUtil.wxRefund(paymentRecord.getCode(), refundNo, paymentRecord.getAmount().toString(), refundMoney.toString(), "/base/prepayRefundWXPay");
            if (!"SUCCESS".equals(map.get("return_code"))) {
                System.err.println("出租车预支付退款申请失败：" + map.get("return_msg"));
            }
            return;
        }

        if (Integer.valueOf(2).equals(orderTaxi.getPayType())) {
            try {
                Map<String, String> map = payMoneyUtil.aliRefund(paymentRecord.getCode(), refundMoney.toString());
                if ("10000".equals(map.get("code"))) {
                    finishPrepaidOrder(orderTaxi);
                } else {
                    System.err.println("出租车预支付退款申请失败：" + map.get("msg"));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void finishPrepaidOrder(OrderTaxi orderTaxi) throws Exception {
        boolean refunded = Integer.valueOf(4).equals(orderTaxi.getPrepayStage())
                && orderTaxi.getPrepayRefundAmount() != null
                && orderTaxi.getPrepayRefundAmount() > 0;
        if (refunded && orderTaxi.getPrepayRefundTime() == null) {
            transactionDetailsService.saveData(orderTaxi.getUserId(), "出租车预支付退款", orderTaxi.getPrepayRefundAmount(), 1, 1, 1, 2, orderTaxi.getId());
            orderTaxi.setPrepayRefundTime(new Date());
        }
        orderTaxi.setState(8);
        orderTaxi.setPrepayStage(5);
        orderTaxi.setPayMoney(formatMoney(orderTaxi.getOrderMoney()));

        if (orderTaxi.getRecoveryOrder() == null || orderTaxi.getRecoveryOrder() == 0) {
            Double orderMoney = (2 == orderTaxi.getAbnormal() && 2 == orderTaxi.getAbnormalStatus()
                    ? orderTaxi.getResponsibilityMoney().doubleValue() : orderTaxi.getOrderMoney());
            Map<String, Object> map = incomeService.saveIncome(orderTaxi.getId(), 2, orderMoney);
            orderTaxi.setSplitAllocation(JSON.toJSONString(map));
        }

        if (2 == orderTaxi.getAbnormal() && 1 == orderTaxi.getAbnormalStatus()) {
            orderTaxi.setAbnormalStatus(3);
            orderTaxi.setResponsibilityMoney(new BigDecimal(orderTaxi.getOrderMoney()));
            orderTaxi.setResponsibilityType(3);
            orderTaxi.setAbnormalRemark("乘客已完成预支付订单结算，申诉已自动关闭");
        }
    }

    private String buildPrepayRefundNo(Integer orderType, Integer orderId) {
        return "PRF_" + orderType + "_" + orderId + "_" + System.currentTimeMillis();
    }

    private Double formatMoney(Double money) {
        return new BigDecimal(money == null ? 0D : money).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue();
    }

    @Override
    public void payPrepaidRefundCallback(Integer orderId, String refundNo, String refundId) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        if (orderTaxi == null || !Integer.valueOf(4).equals(orderTaxi.getPrepayStage())) {
            return;
        }
        if (ToolUtil.isNotEmpty(orderTaxi.getPrepayRefundTime())) {
            return;
        }
        if (ToolUtil.isNotEmpty(orderTaxi.getPrepayRefundNo()) && !orderTaxi.getPrepayRefundNo().equals(refundNo)) {
            return;
        }
        finishPrepaidOrder(orderTaxi);
        this.updateById(orderTaxi);
        pushUtil.pushOrderState(1, orderTaxi.getUserId(), orderTaxi.getId(), 2, orderTaxi.getState());
        pushUtil.pushOrderState(2, orderTaxi.getDriverId(), orderTaxi.getId(), 2, orderTaxi.getState());
    }


    /**
     * 确认费用（车载端）
     * @param orderId
     * @param type
     * @param travelFee
     * @param lon
     * @param lat
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil confirmFees_(Integer orderId, Integer type, Double travelFee, Double lon, Double lat, String address) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        if(orderTaxi.getState() == 5){//服务中才能确认费用
            orderTaxi.setPayManner(type);
            orderTaxi = this.setMoney(orderTaxi, travelFee, 0D, 0D);
            orderTaxi.setState(7);
            orderTaxi.setGetoffLon(lon);
            orderTaxi.setGetoffLat(lat);
            orderTaxi.setGetoffAddress(address);
            orderTaxi.setGetoffTime(new Date());
            orderTaxi.setEndServiceTime(new Date());

            this.updateById(orderTaxi);

            pushUtil.removeTask(orderId, 2);//删除定时任务，结束推送数据
            systemNoticeService.addSystemNotice(1, "司机已结束本次行程，谢谢使用", orderTaxi.getUserId(), 1);

            //回滚司机状态为空闲
            Driver driver = driverService.selectById(orderTaxi.getDriverId());
            driver.setState(2);
            driverService.updateById(driver);

            OrderTaxi finalOrderTaxi = orderTaxi;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    pushUtil.pushOrderState(1, finalOrderTaxi.getUserId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
                    pushUtil.pushOrderState(2, finalOrderTaxi.getDriverId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
                }
            }).start();
            //添加定时任务6分钟司机不确认收款自动完成支付（仅车载端），6分钟之内司机无法接单
            String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
            JSONArray jsonArray = new JSONArray();
            if(ToolUtil.isNotEmpty(vehicle)){
                jsonArray = JSON.parseArray(vehicle);
            }
            jsonArray.add(orderTaxi.getDriverId());
            redisTemplate.opsForValue().set("VEHICLE", jsonArray.toJSONString());//添加司机不能接单标识

            TimerTask timerTask = new TimerTask() {
                @Override
                public void run() {
                    OrderTaxi orderTaxi1 = OrderTaxiServiceImpl.this.selectById(orderId);
                    if(orderTaxi1.getState() == 7){//如果是待支付
                        orderTaxi1.setPayManner(2);//其他方式支付
                        orderTaxi1.setRedPacketMoney(0D);
                        orderTaxi1.setCouponMoney(0D);
                        orderTaxi1.setDiscount(0D);
                        orderTaxi1.setDiscountMoney(0D);
                        orderTaxi1.setPayMoney(orderTaxi1.getOrderMoney());
                        orderTaxi1.setState(8);
                        OrderTaxiServiceImpl.this.updateById(orderTaxi1);
    
                        String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
                        if(ToolUtil.isNotEmpty(vehicle)){
                            JSONArray jsonArray = JSON.parseArray(vehicle);
                            for(int i = 0; i < jsonArray.size(); i++){
                                if(jsonArray.getInteger(i).compareTo(orderTaxi1.getDriverId()) == 0){
                                    jsonArray.remove(i);
                                    break;
                                }
                            }
                            redisTemplate.opsForValue().set("VEHICLE", jsonArray.toJSONString());
                        }

                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                pushUtil.pushOrderState(1, orderTaxi1.getUserId(), orderId, 2, 8);
                                pushUtil.pushOrderState(2, orderTaxi1.getDriverId(), orderId, 2, 8);
                            }
                        }).start();
                    }
                }
            };
            Timer timer = new Timer();
            timer.schedule(timerTask, 6 * 60 * 1000);
        }
        return ResultUtil.success();
    }


    /**
     * 司机确认费用（车载端）不管之前数据状态直接修改到待支付（流程断网情况的处理流程）
     * @param orderId
     * @param type
     * @param travelFee
     * @param lon
     * @param lat
     * @param address
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil confirmFees$(Integer orderId, Integer type, Double travelFee, Double lon, Double lat, String address) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        orderTaxi.setPayManner(type);
        orderTaxi = this.setMoney(orderTaxi, travelFee, 0D, 0D);
        orderTaxi.setState(7);
        orderTaxi.setGetoffLon(lon);
        orderTaxi.setGetoffLat(lat);
        orderTaxi.setGetoffAddress(address);
        orderTaxi.setGetoffTime(new Date());
        orderTaxi.setEndServiceTime(new Date());

        this.updateById(orderTaxi);

        pushUtil.removeTask(orderId, 2);//删除定时任务，结束推送数据
        systemNoticeService.addSystemNotice(1, "司机已结束本次行程，谢谢使用", orderTaxi.getUserId(), 1);

        //回滚司机状态为空闲
        Driver driver = driverService.selectById(orderTaxi.getDriverId());
        driver.setState(2);
        driverService.updateById(driver);

        OrderTaxi finalOrderTaxi = orderTaxi;
        new Thread(new Runnable() {
            @Override
            public void run() {
                pushUtil.pushOrderState(1, finalOrderTaxi.getUserId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
                pushUtil.pushOrderState(2, finalOrderTaxi.getDriverId(), finalOrderTaxi.getId(), 2, finalOrderTaxi.getState());
            }
        }).start();

        //添加定时任务6分钟司机不确认收款自动完成支付（仅车载端），6分钟之内司机无法接单
        String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
        JSONArray jsonArray = new JSONArray();
        if(ToolUtil.isNotEmpty(vehicle)){
            jsonArray = JSON.parseArray(vehicle);
        }
        jsonArray.add(orderTaxi.getDriverId());
        redisTemplate.opsForValue().set("VEHICLE", jsonArray.toJSONString());//添加司机不能接单标识

        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                OrderTaxi orderTaxi1 = OrderTaxiServiceImpl.this.selectById(orderId);
                if(orderTaxi1.getState() == 7){//如果是待支付
                    orderTaxi1.setPayManner(2);//其他方式支付
                    orderTaxi1.setRedPacketMoney(0D);
                    orderTaxi1.setCouponMoney(0D);
                    orderTaxi1.setDiscount(0D);
                    orderTaxi1.setDiscountMoney(0D);
                    orderTaxi1.setPayMoney(orderTaxi1.getOrderMoney());
                    orderTaxi1.setState(8);
                    OrderTaxiServiceImpl.this.updateById(orderTaxi1);
    
                    String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
                    if(ToolUtil.isNotEmpty(vehicle)){
                        JSONArray jsonArray = JSON.parseArray(vehicle);
                        for(int i = 0; i < jsonArray.size(); i++){
                            if(jsonArray.getInteger(i).compareTo(orderTaxi1.getDriverId()) == 0){
                                jsonArray.remove(i);
                                break;
                            }
                        }
                        redisTemplate.opsForValue().set("VEHICLE", jsonArray.toJSONString());
                    }

                    new Thread(new Runnable() {
                        @Override
                        public void run() {
                            pushUtil.pushOrderState(1, orderTaxi1.getUserId(), orderId, 2, 8);
                            pushUtil.pushOrderState(2, orderTaxi1.getDriverId(), orderId, 2, 8);
                        }
                    }).start();
                }
            }
        };
        Timer timer = new Timer();
        timer.schedule(timerTask, 6 * 60 * 1000);
        return ResultUtil.success();
    }


    /**
     * 计算已服务的实时里程
     * @param orderId
     * @param lon
     * @param lat
     */
    @Override
    public boolean calculateMileage(Integer orderId, String lon, String lat) throws Exception {
        OrderTaxi orderTaxi = this.selectById(orderId);
        if(null == orderTaxi){
            System.err.println("订单数据异常：" + orderId);
            return false;
        }
        OrderPosition orderPosition = orderPositionService.queryNew(orderId, 2);
        String now = lon + "," + lat;
        String old = null;
        if(null != orderPosition){
            old = orderPosition.getLon() + "," + orderPosition.getLat();
        }else{
            orderTaxi.setMileage(0D);
            this.updateById(orderTaxi);
            return true;//第一条数据不作处理，直接存储
        }
        Map<String, Double> distance = geodesyUtil.getDistance(now, old);
        if(null != distance){
            Double distance1 = distance.get("WGS84");
            if(distance1 < 50){
                return false;
            }
            if(orderTaxi.getState() == 5){//大于50米表示在移动,且正在服务中的时候存入里程
                orderTaxi.setMileage(new BigDecimal(orderTaxi.getMileage()).add(new BigDecimal(distance1)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
                this.updateById(orderTaxi);
                return true;
            }
        }
        return false;
    }


    /**
     * 获取所有快到期的预约单（出行时间在30分钟内）
     * @return
     * @throws Exception
     */
    @Override
    public List<OrderTaxi> queryMaturity() throws Exception {
        return orderTaxiMapper.queryMaturity();
    }


    /**
     * 获取订单完成后30分钟的数据
     * @return
     * @throws Exception
     */
    @Override
    public List<OrderTaxi> taskMidAxbUnBindSend() throws Exception {
        return orderTaxiMapper.taskMidAxbUnBindSend();
    }


    /**
     * 计算费用
     * @param orderTaxi
     * @param travelFee
     * @param parkingFee
     * @param crossingFee
     * @return
     */
    public OrderTaxi setMoney(OrderTaxi orderTaxi, Double travelFee, Double parkingFee, Double crossingFee) throws Exception{

        if (travelFee!=null){
            String s = travelFee.toString();
            BigDecimal trave = new BigDecimal(s);
            orderTaxi.setTravelMoney(trave.setScale(2, BigDecimal.ROUND_DOWN).doubleValue());
        }else{
            orderTaxi.setTravelMoney(0.0);

        }
        if (parkingFee!=null){
            String s1 = parkingFee.toString();
            BigDecimal parking = new BigDecimal(s1);
            orderTaxi.setParkMoney(parking.setScale(2, BigDecimal.ROUND_DOWN).doubleValue());
        }else{
            orderTaxi.setParkMoney(0.0);

        }
        if (crossingFee!=null){
            String s2 = crossingFee.toString();

            BigDecimal crossing = new BigDecimal(s2);
            orderTaxi.setRoadTollMoney(crossing.setScale(2, BigDecimal.ROUND_DOWN).doubleValue());
        }else{
            orderTaxi.setRoadTollMoney(0.0);
        }
        BigDecimal sum = new BigDecimal(null == travelFee ? 0 : travelFee).add(new BigDecimal(null == parkingFee ? 0 : parkingFee))
                .add(new BigDecimal(null == crossingFee ? 0 : crossingFee)).add(new BigDecimal(null == orderTaxi.getTipMoney() ? 0 : orderTaxi.getTipMoney()));
        orderTaxi.setOrderMoney(sum.setScale(2, BigDecimal.ROUND_DOWN).doubleValue());
        return orderTaxi;
    }


    public OrderTaxi setMoney1(OrderTaxi orderTaxi, Double travelFee, String additionalFee) throws Exception{
        if (travelFee!=null){
            String s = travelFee.toString();
            BigDecimal trave = new BigDecimal(s);
            orderTaxi.setTravelMoney(trave.setScale(2, BigDecimal.ROUND_DOWN).doubleValue());
        }else{
            orderTaxi.setTravelMoney(0.0);
        }
        orderTaxi.setParkMoney(0D);
        orderTaxi.setRoadTollMoney(0D);
        Company company = companyService.selectById(orderTaxi.getCompanyId());
        BigDecimal t = new BigDecimal(0);
        if(ToolUtil.isNotEmpty(additionalFee)){//附加费
            JSONArray jsonArray = JSON.parseArray(additionalFee);
            for(int i = 0; i < jsonArray.size(); i++){
                JSONObject jsonObject = jsonArray.getJSONObject(i);
                Integer id = jsonObject.getInteger("id");
                Double amount = jsonObject.getDouble("amount");
                OrderAdditionalFee orderAdditionalFee = new OrderAdditionalFee();
                orderAdditionalFee.setOrderType(2);
                orderAdditionalFee.setOrderId(orderTaxi.getId());
                orderAdditionalFee.setAdditionalFeeId(id);
                orderAdditionalFee.setAmount(amount);
                orderAdditionalFeeService.insert(orderAdditionalFee);
                t = t.add(new BigDecimal(amount));
            }
        }

        orderTaxi.setHolidayFee(null == company.getHolidayFee() ? 0D : company.getHolidayFee());
        BigDecimal sum = new BigDecimal(null == travelFee ? 0 : travelFee).add(new BigDecimal(0))
                .add(new BigDecimal(0)).add(new BigDecimal(orderTaxi.getHolidayFee()))
                .add(new BigDecimal(null == orderTaxi.getTipMoney() ? 0 : orderTaxi.getTipMoney())).add(t);
        orderTaxi.setOrderMoney(sum.setScale(2, BigDecimal.ROUND_DOWN).doubleValue());
        return orderTaxi;
    }
}