package com.stylefeng.guns.modular.specialTrain.server.impl;

import cn.hutool.core.util.StrUtil;
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.account.controller.AppOrderController;
import com.stylefeng.guns.modular.crossCity.dao.OrderCrossCityMapper;
import com.stylefeng.guns.modular.crossCity.model.OrderCrossCity;
import com.stylefeng.guns.modular.crossCity.server.IOrderCrossCityService;
import com.stylefeng.guns.modular.crossCity.server.impl.OrderCrossCityServiceImpl;
import com.stylefeng.guns.modular.specialTrain.dao.OrderPrivateCarMapper;
import com.stylefeng.guns.modular.specialTrain.model.OrderPrivateCar;
import com.stylefeng.guns.modular.specialTrain.server.IOrderPrivateCarService;
import com.stylefeng.guns.modular.system.dao.*;
import com.stylefeng.guns.modular.system.model.*;
import com.stylefeng.guns.modular.system.model.vo.UnPayOrderVO;
import com.stylefeng.guns.modular.system.service.*;
import com.stylefeng.guns.modular.system.util.*;
import com.stylefeng.guns.modular.system.warpper.*;
import com.stylefeng.guns.modular.taxi.dao.OrderTaxiMapper;
import com.stylefeng.guns.modular.taxi.model.OrderTaxi;
import com.stylefeng.guns.modular.taxi.model.PaymentRecord;
import com.stylefeng.guns.modular.taxi.service.IOrderTaxiService;
import com.stylefeng.guns.modular.taxi.service.IPaymentRecordService;
import com.stylefeng.guns.modular.taxi.service.ITransactionDetailsService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;


@Service
public class OrderPrivateCarServiceImpl extends ServiceImpl<OrderPrivateCarMapper, OrderPrivateCar> implements IOrderPrivateCarService {
	
	public static Set<Integer> orderIds = ConcurrentHashMap.newKeySet();;
	@Resource
	private OrderPrivateCarMapper orderPrivateCarMapper;
	@Resource
	private CarServiceMapper carServiceMapper;
	@Resource
	private OrderTaxiMapper orderTaxiMapper;
	@Resource
	private SensitiveWordsMapper sensitiveWordsMapper;
	@Resource
	private UserActivityDiscount1Mapper userActivityDiscount1Mapper;
	@Resource
	private SysIntegralMapper sysIntegralMapper;
	@Resource
	private OrderCrossCityMapper orderCrossCityMapper;
	@Resource
	private RegionMapper regionMapper;
	@Autowired
	private DateUtil dateUtil;
	@Autowired
	private IUserInfoService userInfoService;
	@Autowired
	private IDriverService driverService;
	@Autowired
	private IDriverServiceService driverServiceService;
	@Autowired
	private PushUtil pushUtil;
	@Autowired
	private ICompanyCityService companyCityService;
	@Autowired
	private IPushOrderService pushOrderService;
	@Autowired
	private ISystemNoticeService systemNoticeService;
	@Autowired
	private ICancleOrderService cancleOrderService;
	@Autowired
	private IOrderCancelService orderCancelService;
	@Autowired
	private RestTemplate internalRestTemplate;
	@Autowired
	private IPaymentRecordService paymentRecordService;
	@Autowired
	private ITransactionDetailsService transactionDetailsService;
	@Autowired
	private ChinaMobileUtil chinaMobileUtil;
	@Autowired
	private IIncomeService incomeService;
	@Autowired
	private IUserCouponRecordService userCouponRecordService;
	@Autowired
	private IUserRedPacketRecordService userRedPacketRecordService;
	@Autowired
	private ICompanyService companyService;
	@Autowired
	private IUserActivityRedenvelopeService userActivityRedenvelopeService;
	@Resource
	private RedisTemplate<String, Object> redisTemplate;
	@Autowired
	private GDFalconUtil gdFalconUtil;
	@Autowired
	private GDMapGeocodingUtil gdMapGeocodingUtil;
	@Autowired
	private GDMapElectricFenceUtil gdMapElectricFenceUtil;
	@Autowired
	private IOrderPositionService orderPositionService;
	@Autowired
	private PushMinistryOfTransportUtil pushMinistryOfTransportUtil;
	@Autowired
	private IOrderCrossCityService orderCrossCityService;
	@Autowired
	private IOrderTaxiService orderTaxiService;
	@Autowired
	private PayMoneyUtil payMoneyUtil;

	@Autowired
	private CbyzxOrderPayHelper cbyzxOrderPayHelper;
	@Autowired
	private TAbnormalPayOrderMapper abnormalPayOrderMapper;
	@Autowired
	private ITaxiCardPaymentService taxiCardPaymentService;
	@Autowired
	private ITaxiCardService taxiCardService;
	@Autowired
	private IOpenCityService openCityService;
	@Autowired
	private IUserUserService userUserService;
	@Autowired
	private IUserTaxiCardService userTaxiCardService;
	@Autowired
	private IRegionService regionService;
	@Autowired
	private ITSysPushTypeService tSysPushTypeService;

	@Value("${callbackPath}")
	private String callbackPath;
	
	@Value("${pushMinistryOfTransport}")
	private boolean pushMinistryOfTransport;
	
	@Autowired
	private ITbSpellOrderRuleService spellOrderRuleService;
	
	@Autowired
	private GeodesyUtil geodesyUtil;
	
	private Lock lock = new ReentrantLock();
	@Autowired
	private AppOrderController appOrderController;

	@Autowired
	private TDriverPromotionActivityService driverPromotionActivityService;
	private CarMapper carMapper;

	@Autowired
	private ITSysPaymentModeService tSysPaymentModeService;

	@Autowired
	private IServerCarModelService serverCarModelService;

	/**
	 * 专车下单操作
	 *
	 * @param serverCarModelId 服务车型id
	 * @param travelTime       出行时间
	 * @param reservation      是否预约（1=否，2=是）
	 * @param instead          是否代下单（0=否，1=是）
	 * @param startLon         起点经度
	 * @param startLat         起点纬度
	 * @param startAddress     起点详细地址
	 * @param endLon           终点经度
	 * @param endLat           终点纬度
	 * @param endAddress       终点详细地址
	 * @param name             乘客姓名
	 * @param phone            乘客电话
	 * @return
	 * @throws Exception
	 */
	@Override
	public synchronized ResultUtil<BaseWarpper> saveOrderPrivateCar(Integer serverCarModelId, Date travelTime, Integer reservation, Integer instead, String placementLon, String placementLat, String startLon, String startLat,
	                                                                String startAddress, String endLon, String endLat, String endAddress, String name, String phone, Integer orderSource, Integer driverId, Integer type, Integer uid, Integer peopleNum, Integer rideType) throws Exception {
		BaseWarpper baseWarpper = new BaseWarpper();
		if (lock.tryLock()) {
			try {
				//如果出行时间大于当前10分钟则默认为预约单
				if (travelTime.getTime() > (System.currentTimeMillis() + 600000)) {
					reservation = 2;
				}
				/**
				 * 1.出租车、专车、跨城有待支付的订单不能叫车
				 * 2.小件物流有未完成的订单可以下跨城、专车、出租车
				 * 3.出租车、专车、跨城有预约单可以下即时单
				 */
				List<OrderPrivateCar> orderPrivateCars = orderPrivateCarMapper.queryByState(uid, null, 1, 7, 12);
				if (orderPrivateCars.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				List<OrderTaxi> list = orderTaxiMapper.queryByState_(uid, null, 1, 7, 12);
				if (list.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				List<OrderCrossCity> orderCrossCities1 = orderCrossCityMapper.queryByState(uid, 7, 12);
				if (orderCrossCities1.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				if (reservation == 1) {
					orderPrivateCars = orderPrivateCarMapper.queryByState(uid, 1, 1, 1, 2, 3, 4, 5, 6, 7, 11, 12);
					if (orderPrivateCars.size() > 0) {
						return ResultUtil.error("有未完成的订单");
					}
					list = orderTaxiMapper.queryByState_(uid, 1, 1, 1, 2, 3, 4, 5, 6, 7, 11, 12);
					if (list.size() > 0) {
						return ResultUtil.error("有未完成的订单");
					}
				}
				
				List<OrderPrivateCar> orderPrivateCars1 = orderPrivateCarMapper.queryByState(uid, null, 3, 7, 12);
				if (orderPrivateCars1.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				List<OrderTaxi> list1 = orderTaxiMapper.queryByState_(uid, null, 3, 7, 12);
				if (list1.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				List<OrderCrossCity> orderCrossCities11 = orderCrossCityMapper.queryByState(uid, 7, 12);
				if (orderCrossCities11.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				if (reservation == 1) {
					orderPrivateCars1 = orderPrivateCarMapper.queryByState(uid, 1, 3, 1, 2, 3, 4, 5, 6, 7, 11, 12);
					if (orderPrivateCars1.size() > 0) {
						return ResultUtil.error("有未完成的订单");
					}
					list1 = orderTaxiMapper.queryByState_(uid, 1, 3, 1, 2, 3, 4, 5, 6, 7, 11, 12);
					if (list1.size() > 0) {
						return ResultUtil.error("有未完成的订单");
					}
				}
				String serverCarModel = "";
				if(2 == orderSource){
					Driver driver = driverService.selectById(driverId);
					CarService carService = new CarService();
					carService.setType(1);
					carService.setCarId(driver.getCarId());
					CarService carService1 = carServiceMapper.selectOne(carService);
					serverCarModel = "[{\"serverCarModelId\":" + carService1.getServerCarModelId() + ",\"rideType\":1}]";
				}
				
				startAddress = startAddress.replaceAll("& #40;", "(");
				startAddress = startAddress.replaceAll("& #41;", ")");
				endAddress = endAddress.replaceAll("& #40;", "(");
				endAddress = endAddress.replaceAll("& #41;", ")");
				if ((orderSource == 1 || orderSource == 3) && null == serverCarModelId) {
					return ResultUtil.error("请选择服务车型");
				}
				
				OrderPrivateCar orderPrivateCar = new OrderPrivateCar();
				orderPrivateCar.setPeopleNum(peopleNum);
				orderPrivateCar.setRideType(rideType);
				orderPrivateCar.setType(type);
				orderPrivateCar.setUserId(uid);
				orderPrivateCar.setServerCarModelId(serverCarModelId);
				orderPrivateCar.setServerCarModel(serverCarModel);
				orderPrivateCar.setOrderNum(this.getOrderNum());
				orderPrivateCar.setPlacementLon(Double.valueOf(placementLon));
				orderPrivateCar.setPlacementLat(Double.valueOf(placementLat));
				Map<String, String> geocode = gdMapGeocodingUtil.geocode(placementLon, placementLat);
				orderPrivateCar.setPlacementAddress(geocode.get("address"));
				orderPrivateCar.setStartLon(Double.valueOf(startLon));
				orderPrivateCar.setStartLat(Double.valueOf(startLat));
				orderPrivateCar.setStartAddress(startAddress);
				orderPrivateCar.setEndLon(Double.valueOf(endLon));
				orderPrivateCar.setEndLat(Double.valueOf(endLat));
				orderPrivateCar.setEndAddress(endAddress);
				orderPrivateCar.setSubstitute(instead);
				orderPrivateCar.setPassengers(name);
				orderPrivateCar.setPassengersPhone(phone);
				// TODO: 2023/11/4 无法修改
				Map<String, String> distanceMap = gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), 1);
				orderPrivateCar.setEstimateMileage(Double.valueOf(distanceMap.get("distance")));
				orderPrivateCar.setEstimateTime(Double.valueOf(distanceMap.get("duration")) / 60);
				if (instead == 0 || ToolUtil.isEmpty(orderPrivateCar.getPassengers())) {
					UserInfo userInfo = userInfoService.selectById(uid);
					if (ToolUtil.isEmpty(userInfo.getPhone())) {
						return ResultUtil.error("请先绑定手机号码");
					}
					orderPrivateCar.setPassengers(userInfo.getName());
					orderPrivateCar.setPassengersPhone(userInfo.getPhone());
				}
				orderPrivateCar.setState(1);
				// ===== 先付/后付模式判断 =====
				if (orderSource != 2) { // 扫码下单跳过先付判断（扫码下单已有固定司机）
					TSysPaymentMode paymentMode = tSysPaymentModeService.selectOne(
							new EntityWrapper<TSysPaymentMode>().last("LIMIT 1"));
					if (paymentMode != null && paymentMode.getPrivateType() != null) {
						baseWarpper.setPaymentMode(paymentMode.getPrivateType());
					}
					if (paymentMode != null && Integer.valueOf(1).equals(paymentMode.getPrivateType())) {
						// 先付模式：计算预估金额，订单状态改为7（待支付）
						Company payCompany = companyCityService.query(geocode.get("districtCode"));
						if (payCompany != null) {
							try {
								// 复用已获取的预估距离(米)和预估时间(分钟)，还原为 getPrice 所需单位
								double distanceMeters = orderPrivateCar.getEstimateMileage() != null
										? orderPrivateCar.getEstimateMileage() : 0;
								long durationSeconds = orderPrivateCar.getEstimateTime() != null
										? (long) (orderPrivateCar.getEstimateTime() * 60) : 0;
								List<ServerCarModelWarpper> priceList = serverCarModelService.getPrice(
										payCompany.getId(), distanceMeters, durationSeconds, 0L, 1, geocode);
								if (priceList != null && !priceList.isEmpty()) {
									// 按 serverCarModelId 精确匹配，找不到则取第一条
									ServerCarModelWarpper matched = priceList.stream()
											.filter(w -> w.getId() != null && w.getId().equals(serverCarModelId))
											.findFirst()
											.orElse(priceList.get(0));
									// 根据 rideType 取对应金额 Map（key="zongfeiyong"）
									Map<String, Object> amountMap = null;
									if (Integer.valueOf(2).equals(rideType)) {
										amountMap = matched.getBuyNowAmount();         // 一口价
									} else if (Integer.valueOf(3).equals(rideType)) {
										amountMap = matched.getPutTogetherOneAmount(); // 拼车（1人拼成）
									} else {
										amountMap = matched.getAmount();               // 独享（默认）
									}
									if (amountMap != null && amountMap.get("zongfeiyong") != null) {
										Double estimateMoney = Double.valueOf(amountMap.get("zongfeiyong").toString());
										orderPrivateCar.setEstimateAmount(estimateMoney);
										orderPrivateCar.setOrderMoney(estimateMoney);
										baseWarpper.setEstimateAmount(estimateMoney);
									}
								}
								// 先付模式：覆盖状态为7（待支付），不进行派单
								orderPrivateCar.setState(7);
								orderPrivateCar.setCompanyId(payCompany.getId());
								orderPrivateCar.setPaymentMode(1); // 记录先付模式
							} catch (Exception e) {
								e.printStackTrace();
								// 降级：计算失败时保持后付逻辑（state=1，正常派单）
								orderPrivateCar.setPaymentMode(2); // 降级记录后付
							}
						} else {
							orderPrivateCar.setPaymentMode(1); // 公司未找到，仍记录配置为先付
						}
					} else {
						// 后付模式（无配置 或 privateType=2）
						orderPrivateCar.setPaymentMode(
								(paymentMode != null && paymentMode.getPrivateType() != null)
										? paymentMode.getPrivateType()
										: 2
						);
					}
				}
				// ===== 先付/后付判断结束 =====
				orderPrivateCar.setInsertTime(new Date());
				orderPrivateCar.setTravelTime(travelTime);
				orderPrivateCar.setOrderType(reservation);
				orderPrivateCar.setOrderSource(orderSource);
				if (orderSource == 2) {//扫码下单
					Driver driver = driverService.selectById(driverId);
					if (null == driver) {
						return ResultUtil.error("司机信息有误，无法完成下单");
					}
					if (driver.getAuthState() == 1) {
						return ResultUtil.error("司机信息还未完成审核，无法完成下单");
					}
					if (driver.getAuthState() == 3) {
						return ResultUtil.error("司机账户已被冻结，无法提供服务");
					}
					if (driver.getAuthState() == 4) {
						return ResultUtil.error("司机信息未通过审核，无法提供服务");
					}
					if (driver.getState() == 1) {
						return ResultUtil.error("司机还未上线，无法提供服务");
					}
					if (driver.getState() == 3) {
						return ResultUtil.error("司机正在服务中，无法提供服务");
					}
					//            Integer orderType = orderPrivateCar.getRideType()==1?1:orderPrivateCar.getRideType()==2?9:8;
					Integer orderType = 1;
					Integer integer = driverServiceService.query_(driverId, orderType);
					if (null == integer) {
						return ResultUtil.error("该司机不能服务此业务");
					}
					
					orderPrivateCar.setDriverId(driverId);
					orderPrivateCar.setCompanyId(driver.getFranchiseeId() != null && driver.getFranchiseeId() != 0 ? driver.getFranchiseeId() : (
							driver.getCompanyId() != null && driver.getCompanyId() != 0 ? driver.getCompanyId() : 1));
					orderPrivateCar.setState(2);
					orderPrivateCar.setCarId(driver.getCarId());
					CarService query1 = carServiceMapper.query(1, driver.getCarId());
					orderPrivateCar.setServerCarModelId(query1.getServerCarModelId());
					orderPrivateCar.setSnatchOrderTime(new Date());
					
					//            //调用高德创建轨迹
					//            String s = gdFalconUtil.selectTerminal(driver.getPhone());
					//            String track = gdFalconUtil.createTrack(s);
					//            orderPrivateCar.setTrackId(track);
					//
					//调用移动的小号接口
//					Map<String, String> map = chinaMobileUtil.midAxbBindSend(orderPrivateCar.getPassengersPhone(), driver.getPhone(), (System.currentTimeMillis() + 86400000));
//					if (String.valueOf(map.get("code")).equals("200")) {
//						orderPrivateCar.setTelX(map.get("telX"));
//						orderPrivateCar.setBindId(map.get("bindId"));
//					}
					
					driver.setState(3);
					driverService.updateById(driver);
				}







				//判断独享，一口价，拼车
				if (orderPrivateCar.getRideType() != 3) {
					orderPrivateCar.setTotalPeopleNum(peopleNum);
					orderPrivateCar.setIsReassign(1);
					orderPrivateCar.setIsDelete(1);
					orderPrivateCar.setPrepayStage(Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode()) ? 1 : 0);
					this.insert(orderPrivateCar);
					
					if (orderSource == 2) {//扫码下单
						new Thread(new Runnable() {
							@Override
							public void run() {
								pushUtil.pushOrderState(1, uid, orderPrivateCar.getId(), 1, 2, 0);
								pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, 2, 0);
								pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
							}
						}).start();
					}
					
					//推单操作-独享
					if (orderPrivateCar.getState() == 1) {
						this.pushOrder(orderPrivateCar);
					}

				} else {


					// 拼车逻辑
					OrderPrivateCar orderPrivateCar1 = null;
					OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
					//判断是否有相同线路的拼车-有直接拼成功，或者推送拼车订单
					List<OrderPrivateCar> orderList = orderPrivateCarMapper.selectList(new EntityWrapper<OrderPrivateCar>().eq("rideType", 3).in("state", "2,3,4").le("totalPeopleNum", 4 - peopleNum));
					for (OrderPrivateCar order : orderList) {
						
						TbSpellOrderRule spellOrderRule = spellOrderRuleService.selectOne(new EntityWrapper<TbSpellOrderRule>().eq("openCityId", openCity.getId()));
						if (spellOrderRule != null) {
							JSONObject jsonObject = JSONObject.parseObject(spellOrderRule.getContent());
							//判断时间
							
							if (travelTime.getTime() >= order.getTravelTime().getTime() - jsonObject.getInteger("num5") * 60000L && travelTime.getTime() <= order.getTravelTime().getTime() + jsonObject.getInteger("num6") * 60000L) {
								//                        Double dis1 = Double.valueOf(gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), order.getStartLon() + "," + order.getStartLat(), 1).get("distance").toString());
								//                        Double dis2 = Double.valueOf(gdMapElectricFenceUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat(), 1).get("distance").toString());
								// TODO: 2023/11/4  已改成计算直线距离
								Double dis1 = geodesyUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), order.getStartLon() + "," + order.getStartLat()).get("WGS84");
								Double dis2 = geodesyUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat()).get("WGS84");
								//判断距离
								if (dis1 <= jsonObject.getInteger("num1") * 1000 && dis2 <= jsonObject.getInteger("num2") * 1000) {
									orderPrivateCar1 = order;
									break;
								}
							}
						}
					}
					if (orderPrivateCar1 == null) {
						orderList = orderPrivateCarMapper.selectList(new EntityWrapper<OrderPrivateCar>().eq("rideType", 3).eq("state", 5).le("totalPeopleNum", 4 - peopleNum));
						for (OrderPrivateCar order : orderList) {
							TbSpellOrderRule spellOrderRule = spellOrderRuleService.selectOne(new EntityWrapper<TbSpellOrderRule>().eq("openCityId", openCity.getId()));
							if (spellOrderRule != null) {
								JSONObject jsonObject = JSONObject.parseObject(spellOrderRule.getContent());
								//判断时间
								if (travelTime.getTime() >= order.getTravelTime().getTime() - jsonObject.getInteger("num5") * 60000L && travelTime.getTime() <= order.getTravelTime().getTime() + jsonObject.getInteger("num6") * 60000L) {
									String value = (String) redisTemplate.opsForValue().get("dache:DRIVER" + String.valueOf(order.getDriverId()));
									//                            Double dis1 = Double.valueOf(gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), value, 1).get("distance").toString());
									//                            Double dis2 = Double.valueOf(gdMapElectricFenceUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat(), 1).get("distance").toString());
									
									// TODO: 2023/11/4  已改成计算直线距离
									Double dis1 = geodesyUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), value).get("WGS84");
									Double dis2 = geodesyUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat()).get("WGS84");
									//判断距离
									if (dis1 <= jsonObject.getInteger("num3") * 1000 && dis2 <= jsonObject.getInteger("num4") * 1000) {
										orderPrivateCar1 = order;
										break;
									}
								}
							}
						}
					}
					if (orderPrivateCar1 == null) {
						orderPrivateCar.setTotalPeopleNum(peopleNum);
						orderPrivateCar.setIsReassign(1);
						orderPrivateCar.setIsDelete(1);
						orderPrivateCar.setPrepayStage(Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode()) ? 1 : 0);
						this.insert(orderPrivateCar);
						this.pushOrder(orderPrivateCar);
					} else {
						Driver driver = driverService.selectById(orderPrivateCar1.getDriverId());
						orderPrivateCar.setDriverId(driverId);
						orderPrivateCar.setCompanyId(driver.getFranchiseeId() != null && driver.getFranchiseeId() != 0 ? driver.getFranchiseeId() : (
								driver.getCompanyId() != null && driver.getCompanyId() != 0 ? driver.getCompanyId() : 1));
						orderPrivateCar.setState(2);
						orderPrivateCar.setDriverId(driver.getId());
						orderPrivateCar.setCarId(driver.getCarId());
						CarService query1 = carServiceMapper.query(1, driver.getCarId());
						orderPrivateCar.setServerCarModelId(query1.getServerCarModelId());
						orderPrivateCar.setSnatchOrderTime(new Date());
						orderPrivateCar.setTotalPeopleNum(peopleNum + orderPrivateCar1.getTotalPeopleNum());
						orderPrivateCar.setIsReassign(1);
						orderPrivateCar.setIsDelete(1);
						orderPrivateCar.setPid(orderPrivateCar1.getPid() == null ? orderPrivateCar1.getId() : orderPrivateCar1.getPid());
						orderPrivateCar.setPrepayStage(Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode()) ? 1 : 0);
						this.insert(orderPrivateCar);
						//修改总订单人数
						OrderPrivateCar orderPrivateCar2 = new OrderPrivateCar();
						orderPrivateCar2.setSpellSuccess(1);
						orderPrivateCar2.setTotalPeopleNum(peopleNum + orderPrivateCar1.getTotalPeopleNum());
						this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("pid", orderPrivateCar1.getPid() == null ? orderPrivateCar1.getId() : orderPrivateCar1.getPid()).lt("state", 6));
						this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("id", orderPrivateCar1.getPid() == null ? orderPrivateCar1.getId() : orderPrivateCar1.getPid()).lt("state", 6));
						//
						//调用移动的小号接口
//						Map<String, String> map = chinaMobileUtil.midAxbBindSend(orderPrivateCar.getPassengersPhone(), driver.getPhone(), (System.currentTimeMillis() + 86400000));
//						if (String.valueOf(map.get("code")).equals("200")) {
//							orderPrivateCar.setTelX(map.get("telX"));
//							orderPrivateCar.setBindId(map.get("bindId"));
//						}
						new Thread(new Runnable() {
							@Override
							public void run() {
								pushUtil.pushOrderState(1, uid, orderPrivateCar.getId(), 1, 2, 0);
								pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, 100, 0);
								pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
								
							}
						}).start();
						List<OrderPrivateCar> orderList1 = this.selectList(new EntityWrapper<OrderPrivateCar>().eq("pid", orderPrivateCar.getPid()));
						for (OrderPrivateCar orderPrivateCar3 : orderList1) {
							pushUtil.pushOrderState(1, orderPrivateCar3.getUserId(), orderPrivateCar3.getId(), 1, 13, 0);
						}
						OrderPrivateCar orderPrivateCar3 = this.selectById(orderPrivateCar.getPid());
						pushUtil.pushOrderState(1, orderPrivateCar3.getUserId(), orderPrivateCar3.getId(), 1, 13, 0);
					}
					
				}
				
				
				//添加消息
				systemNoticeService.addSystemNotice(1, "您的快车订单已下单成功，我们正在为您指派司机，请稍后！", orderPrivateCar.getUserId(), 1);
				baseWarpper.setId(orderPrivateCar.getId());

			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				lock.unlock();
			}
		} else {
			return ResultUtil.error("系统繁忙，请稍后再试！");
		}
		return ResultUtil.success(baseWarpper);
	}
	
	/**
	 * 批量订单
	 *
	 * @throws Exception
	 */
	@Override
	public ResultUtil<BaseWarpper> saveOrderPrivateCars(String serverCarModel, Date travelTime, Integer reservation, Integer instead, String placementLon, String placementLat, String startLon, String startLat, String startAddress, String endLon,
	                                                    String endLat, String endAddress, String name, String phone, Integer orderSource, Integer driverId, Integer uid, Integer peopleNum) throws Exception {
		BaseWarpper baseWarpper = new BaseWarpper();
		String key = "saveOrderPrivateCar:" + uid;
		Boolean hasKey = redisTemplate.hasKey(key);
		if (!hasKey) {
			redisTemplate.opsForValue().set(key, uid, 30, TimeUnit.SECONDS);
			try {
				//如果出行时间大于当前10分钟则默认为预约单
				if (travelTime.getTime() > (System.currentTimeMillis() + 600000)) {
					reservation = 2;
				}
				
				/**
				 * 1.出租车、专车、跨城有待支付的订单不能叫车
				 * 2.小件物流有未完成的订单可以下跨城、专车、出租车
				 * 3.出租车、专车、跨城有预约单可以下即时单
				 */
				List<OrderPrivateCar> orderPrivateCars = orderPrivateCarMapper.queryByState(uid, null, 1, 7, 12);
				if (orderPrivateCars.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				List<OrderTaxi> list = orderTaxiMapper.queryByState_(uid, null, 1, 7, 12);
				if (list.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				List<OrderCrossCity> orderCrossCities1 = orderCrossCityMapper.queryByState(uid, 7, 12);
				if (orderCrossCities1.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				if (reservation == 1) {
					orderPrivateCars = orderPrivateCarMapper.queryByState(uid, 1, 1, 1, 2, 3, 4, 5, 6, 7, 11, 12);
					if (orderPrivateCars.size() > 0) {
						return ResultUtil.error("有未完成的订单");
					}
					list = orderTaxiMapper.queryByState_(uid, 1, 1, 1, 2, 3, 4, 5, 6, 7, 11, 12);
					if (list.size() > 0) {
						return ResultUtil.error("有未完成的订单");
					}
				}
				
				
				List<OrderPrivateCar> orderPrivateCars1 = orderPrivateCarMapper.queryByState(uid, null, 3, 7, 12);
				if (orderPrivateCars1.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				List<OrderTaxi> list1 = orderTaxiMapper.queryByState_(uid, null, 3, 7, 12);
				if (list1.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				List<OrderCrossCity> orderCrossCities11 = orderCrossCityMapper.queryByState(uid, 7, 12);
				if (orderCrossCities11.size() > 0) {
					return ResultUtil.error("有未完成的订单");
				}
				if (reservation == 1) {
					orderPrivateCars1 = orderPrivateCarMapper.queryByState(uid, 1, 3, 1, 2, 3, 4, 5, 6, 7, 11, 12);
					if (orderPrivateCars1.size() > 0) {
						return ResultUtil.error("有未完成的订单");
					}
					list1 = orderTaxiMapper.queryByState_(uid, 1, 3, 1, 2, 3, 4, 5, 6, 7, 11, 12);
					if (list1.size() > 0) {
						return ResultUtil.error("有未完成的订单");
					}
				}

				if(2 == orderSource){
					Driver driver = driverService.selectById(driverId);
					CarService carService = new CarService();
					carService.setType(1);
					carService.setCarId(driver.getCarId());
					CarService carService1 = carServiceMapper.selectOne(carService);
					serverCarModel = "[{\"serverCarModelId\":" + carService1.getServerCarModelId() + ",\"rideType\":1}]";
				}
				
				startAddress = startAddress.replaceAll("& #40;", "(");
				startAddress = startAddress.replaceAll("& #41;", ")");
				endAddress = endAddress.replaceAll("& #40;", "(");
				endAddress = endAddress.replaceAll("& #41;", ")");
				if (ToolUtil.isEmpty(serverCarModel)) {
					return ResultUtil.error("请选择服务车型");
				}

				OrderPrivateCar orderPrivateCar = new OrderPrivateCar();
				orderPrivateCar.setPeopleNum(peopleNum);
				orderPrivateCar.setType(3);
				orderPrivateCar.setUserId(uid);
				orderPrivateCar.setServerCarModel(serverCarModel);
				orderPrivateCar.setOrderNum(this.getOrderNum());
				orderPrivateCar.setPlacementLon(Double.valueOf(placementLon));
				orderPrivateCar.setPlacementLat(Double.valueOf(placementLat));
				Map<String, String> geocode = gdMapGeocodingUtil.geocode(placementLon, placementLat);
				orderPrivateCar.setPlacementAddress(geocode.get("address"));
				orderPrivateCar.setStartLon(Double.valueOf(startLon));
				orderPrivateCar.setStartLat(Double.valueOf(startLat));
				orderPrivateCar.setStartAddress(startAddress);
				orderPrivateCar.setEndLon(Double.valueOf(endLon));
				orderPrivateCar.setEndLat(Double.valueOf(endLat));
				orderPrivateCar.setEndAddress(endAddress);
				orderPrivateCar.setSubstitute(instead);
				orderPrivateCar.setPassengers(name);
				orderPrivateCar.setPassengersPhone(phone);
				// TODO: 2023/11/4 无法修改
				Map<String, String> distanceMap = gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), 1);
				orderPrivateCar.setEstimateMileage(Double.valueOf(distanceMap.get("distance")));
				orderPrivateCar.setEstimateTime(Double.valueOf(distanceMap.get("duration")) / 60);
				UserInfo userInfo = userInfoService.selectById(uid);
				if (instead == 0 || ToolUtil.isEmpty(orderPrivateCar.getPassengers())) {

					if (ToolUtil.isEmpty(userInfo.getPhone())) {
						return ResultUtil.error("请先绑定手机号码");
					}
					orderPrivateCar.setPassengers(userInfo.getName());
					orderPrivateCar.setPassengersPhone(userInfo.getPhone());
				}
				orderPrivateCar.setState(1);
				if (orderSource != 2) {
					TSysPaymentMode paymentMode = tSysPaymentModeService.selectOne(
							new EntityWrapper<TSysPaymentMode>().last("LIMIT 1"));
					if (paymentMode != null && paymentMode.getPrivateType() != null) {
						baseWarpper.setPaymentMode(paymentMode.getPrivateType());
					}
					if (paymentMode != null && Integer.valueOf(1).equals(paymentMode.getPrivateType())) {
						Company payCompany = companyCityService.query(geocode.get("districtCode"));
						if (payCompany != null) {
							try {
								double distanceMeters = orderPrivateCar.getEstimateMileage() != null
										? orderPrivateCar.getEstimateMileage() : 0;
								long durationSeconds = orderPrivateCar.getEstimateTime() != null
										? (long) (orderPrivateCar.getEstimateTime() * 60) : 0;
								List<ServerCarModelWarpper> priceList = serverCarModelService.getPrice(
										payCompany.getId(), distanceMeters, durationSeconds, 0L, 1, geocode);
								Double estimateMoney = getBatchEstimateAmount(serverCarModel, priceList);
								if (estimateMoney != null) {
									orderPrivateCar.setEstimateAmount(estimateMoney);
									orderPrivateCar.setOrderMoney(estimateMoney);
									orderPrivateCar.setState(7);
									orderPrivateCar.setCompanyId(payCompany.getId());
									orderPrivateCar.setPaymentMode(1);
									baseWarpper.setEstimateAmount(estimateMoney);
								} else {
									orderPrivateCar.setPaymentMode(2);
								}
							} catch (Exception e) {
								e.printStackTrace();
								orderPrivateCar.setPaymentMode(2);
								orderPrivateCar.setState(1);
							}
						} else {
							orderPrivateCar.setPaymentMode(1);
						}
					} else {
						orderPrivateCar.setPaymentMode(
								(paymentMode != null && paymentMode.getPrivateType() != null)
										? paymentMode.getPrivateType()
										: 2
						);
					}
				}
				orderPrivateCar.setInsertTime(new Date());
				orderPrivateCar.setTravelTime(travelTime);
				orderPrivateCar.setOrderType(reservation);
				orderPrivateCar.setOrderSource(orderSource);
				orderPrivateCar.setTotalPeopleNum(peopleNum);
				orderPrivateCar.setIsReassign(1);
				orderPrivateCar.setIsDelete(1);
				orderPrivateCar.setPrepayStage(Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode()) ? 1 : 0);

				//判断独享，一口价，拼车
				JSONArray jsonArray = JSON.parseArray(serverCarModel);
				this.insert(orderPrivateCar);

				if (orderPrivateCar.getState() != 7) {
					for (int i = 0; i < jsonArray.size(); i++) {
						JSONObject jsonObject1 = jsonArray.getJSONObject(i);
						Integer serverCarModelId = jsonObject1.getInteger("serverCarModelId");
						Integer rideType = jsonObject1.getInteger("rideType");
						if (0 == serverCarModelId) {
							OrderTaxi orderTaxi = new OrderTaxi();
							orderTaxi.setId(orderPrivateCar.getId());
							orderTaxi.setState(1);
							orderTaxi.setUserId(orderPrivateCar.getUserId());
							orderTaxi.setStartLon(orderPrivateCar.getStartLon());
							orderTaxi.setStartLat(orderPrivateCar.getStartLat());
							orderTaxiService.pushOrder(orderTaxi, 3);
						}
						
						if (rideType != 3) {
							//推单操作-独享
							this.pushOrder(orderPrivateCar.getId(), rideType, serverCarModelId, orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat());
						} else {
							OrderPrivateCar orderPrivateCar1 = null;
							OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
							TbSpellOrderRule spellOrderRule = spellOrderRuleService.selectOne(new EntityWrapper<TbSpellOrderRule>().eq("openCityId", openCity.getId()));
							//判断是否有相同线路的拼车-有直接拼成功，或者推送拼车订单
							List<OrderPrivateCar> orderList = orderPrivateCarMapper.selectList(new EntityWrapper<OrderPrivateCar>().eq("rideType", 3).in("state", "2,3,4").le("totalPeopleNum", 4 - peopleNum));
							for (OrderPrivateCar order : orderList) {
								if (spellOrderRule != null) {
									JSONObject jsonObject = JSONObject.parseObject(spellOrderRule.getContent());
									//判断时间
									if (travelTime.getTime() >= order.getTravelTime().getTime() - jsonObject.getInteger("num5") * 60000L && travelTime.getTime() <= order.getTravelTime().getTime() + jsonObject.getInteger("num6") * 60000L) {
										Double dis1 = geodesyUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), order.getStartLon() + "," + order.getStartLat()).get("WGS84");
										Double dis2 = geodesyUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat()).get("WGS84");
										if (dis1 <= jsonObject.getInteger("num1") * 1000 && dis2 <= jsonObject.getInteger("num2") * 1000) {
											orderPrivateCar1 = order;
											break;
										}
									}
								}
							}
							if (orderPrivateCar1 == null) {
								orderList = orderPrivateCarMapper.selectList(new EntityWrapper<OrderPrivateCar>().eq("rideType", 3).eq("state", 5).le("totalPeopleNum", 4 - peopleNum));
								for (OrderPrivateCar order : orderList) {
									if (spellOrderRule != null) {
										JSONObject jsonObject = JSONObject.parseObject(spellOrderRule.getContent());
										if (travelTime.getTime() >= order.getTravelTime().getTime() - jsonObject.getInteger("num5") * 60000L && travelTime.getTime() <= order.getTravelTime().getTime() + jsonObject.getInteger("num6") * 60000L) {
											String value = (String) redisTemplate.opsForValue().get("dache:DRIVER" + String.valueOf(order.getDriverId()));
											Double dis1 = geodesyUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), value).get("WGS84");
											Double dis2 = geodesyUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat()).get("WGS84");
											if (dis1 <= jsonObject.getInteger("num3") * 1000 && dis2 <= jsonObject.getInteger("num4") * 1000) {
												orderPrivateCar1 = order;
												break;
											}
										}
									}
								}
							}
							if (orderPrivateCar1 == null) {
								this.pushOrder(orderPrivateCar.getId(), rideType, serverCarModelId, orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat());
							} else {
								Driver driver = driverService.selectById(orderPrivateCar1.getDriverId());
								orderPrivateCar.setDriverId(driverId);
								orderPrivateCar.setCompanyId(driver.getFranchiseeId() != null && driver.getFranchiseeId() != 0 ? driver.getFranchiseeId() : (
										driver.getCompanyId() != null && driver.getCompanyId() != 0 ? driver.getCompanyId() : 1));
								orderPrivateCar.setState(2);
								orderPrivateCar.setDriverId(driver.getId());
								orderPrivateCar.setCarId(driver.getCarId());
								CarService query1 = carServiceMapper.query(1, driver.getCarId());
								orderPrivateCar.setServerCarModelId(query1.getServerCarModelId());
								orderPrivateCar.setRideType(3);
								orderPrivateCar.setSnatchOrderTime(new Date());
								orderPrivateCar.setTotalPeopleNum(peopleNum + orderPrivateCar1.getTotalPeopleNum());
								orderPrivateCar.setIsReassign(1);
								orderPrivateCar.setIsDelete(1);
								orderPrivateCar.setPid(orderPrivateCar1.getPid() == null ? orderPrivateCar1.getId() : orderPrivateCar1.getPid());

								Integer promotion1 = isPromotion(orderPrivateCar.getUserId(), driver.getPlaceOfEmployment());
								if(promotion1!=null){
									orderPrivateCar.setPromotion(2);
									Driver driver1 = driverService.selectById(promotion1);
									orderPrivateCar.setPromotionUser(driver1.getName());
									orderPrivateCar.setPromotionPhone(driver1.getPhone());
									orderPrivateCar.setPromotionDriverId(promotion1);
								}

								OrderPrivateCar orderPrivateCar2 = new OrderPrivateCar();
								orderPrivateCar2.setSpellSuccess(1);
								orderPrivateCar2.setTotalPeopleNum(peopleNum + orderPrivateCar1.getTotalPeopleNum());
								this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("pid", orderPrivateCar1.getPid() == null ? orderPrivateCar1.getId() : orderPrivateCar1.getPid()).lt("state", 6));
								this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("id", orderPrivateCar1.getPid() == null ? orderPrivateCar1.getId() : orderPrivateCar1.getPid()).lt("state", 6));
								new Thread(new Runnable() {
									@Override
									public void run() {
										pushUtil.pushOrderState(1, uid, orderPrivateCar.getId(), 1, 2, 0);
										pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, 100, 0);
										pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
										
									}
								}).start();
								List<OrderPrivateCar> orderList1 = this.selectList(new EntityWrapper<OrderPrivateCar>().eq("pid", orderPrivateCar.getPid()));
								for (OrderPrivateCar orderPrivateCar3 : orderList1) {
									pushUtil.pushOrderState(1, orderPrivateCar3.getUserId(), orderPrivateCar3.getId(), 1, 13, 0);
								}
								OrderPrivateCar orderPrivateCar3 = this.selectById(orderPrivateCar.getPid());
								pushUtil.pushOrderState(1, orderPrivateCar3.getUserId(), orderPrivateCar3.getId(), 1, 13, 0);
							}
						}
					}
				}
				
				//添加消息
				if (orderPrivateCar.getState() == 7) {
					systemNoticeService.addSystemNotice(1, "您的快车订单已生成，请先完成支付。", orderPrivateCar.getUserId(), 1);
				} else {
					systemNoticeService.addSystemNotice(1, "您的快车订单已下单成功，我们正在为您指派司机，请稍后！", orderPrivateCar.getUserId(), 1);
				}
				baseWarpper.setId(orderPrivateCar.getId());
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				redisTemplate.delete(key);
			}
		} else {
			return ResultUtil.error("系统繁忙，请稍后再试！");
		}
		return ResultUtil.success(baseWarpper);
	}

	private Double getBatchEstimateAmount(String serverCarModel, List<ServerCarModelWarpper> priceList) {
		if (ToolUtil.isEmpty(serverCarModel) || priceList == null || priceList.isEmpty()) {
			return null;
		}
		JSONArray jsonArray = JSON.parseArray(serverCarModel);
		Double minEstimateAmount = null;
		for (int i = 0; i < jsonArray.size(); i++) {
			JSONObject jsonObject = jsonArray.getJSONObject(i);
			Integer serverCarModelId = jsonObject.getInteger("serverCarModelId");
			Integer rideType = jsonObject.getInteger("rideType");
			if (serverCarModelId == null || serverCarModelId == 0) {
				continue;
			}
			ServerCarModelWarpper matched = priceList.stream()
					.filter(item -> item.getId() != null && item.getId().equals(serverCarModelId))
					.findFirst()
					.orElse(null);
			if (matched == null) {
				continue;
			}
			Map<String, Object> amountMap;
			if (Integer.valueOf(2).equals(rideType)) {
				amountMap = matched.getBuyNowAmount();
			} else if (Integer.valueOf(3).equals(rideType)) {
				amountMap = matched.getPutTogetherOneAmount();
			} else {
				amountMap = matched.getAmount();
			}
			if (amountMap == null || amountMap.get("zongfeiyong") == null) {
				continue;
			}
			Double estimateAmount = Double.valueOf(amountMap.get("zongfeiyong").toString());
			if (minEstimateAmount == null || estimateAmount < minEstimateAmount) {
				minEstimateAmount = estimateAmount;
			}
		}
		return minEstimateAmount;
	}


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

	}


	/**
	 * 下单后继续等待
	 *
	 * @param id
	 * @return
	 * @throws Exception
	 */
	@Override
	public ResultUtil pushOrderPrivateCar(Integer id) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(id);
		if (null == orderPrivateCar) {
			return ResultUtil.error("推送订单失败，订单信息有误");
		}
		if (orderPrivateCar.getState() != 1) {
			return ResultUtil.error("订单已被司机接单，不能重复推送");
		}
		//处理摆渡订单的继续推单操作
		if (orderPrivateCar.getType() == 2) {
			OrderCrossCityServiceImpl.pushEndMap.put(orderPrivateCar.getCrossCityOrderId(), false);//还原标识数据
			List<OrderPrivateCar> list = this.selectList(new EntityWrapper<OrderPrivateCar>().eq("type", 2).eq("crossCityOrderId", orderPrivateCar.getCrossCityOrderId()).eq("place", orderPrivateCar.getPlace()));
			List<Map<String, Integer>> orders = new ArrayList<>();
			for (OrderPrivateCar orderPrivateCar1 : list) {
				if (orderPrivateCar1.getState() != 1) {
					return ResultUtil.error("订单已被司机接单，推单取消");
				}
				Map<String, Integer> map = new HashMap<>();
				map.put("orderType", 1);
				map.put("orderId", orderPrivateCar1.getId());
				orders.add(map);
			}
			List<OrderTaxi> list1 = orderTaxiService.selectList(new EntityWrapper<OrderTaxi>().eq("type", 2).eq("crossCityOrderId", orderPrivateCar.getCrossCityOrderId()).eq("place", orderPrivateCar.getPlace()));
			for (OrderTaxi orderTaxi : list1) {
				if (orderTaxi.getState() != 1) {
					return ResultUtil.error("订单已被司机接单，推单取消");
				}
				Map<String, Integer> map = new HashMap<>();
				map.put("orderType", 2);
				map.put("orderId", orderTaxi.getId());
				orders.add(map);
			}
			//开始重新推单
			orderCrossCityService.pushOrder(orders);
			
		} else {
			//判断独享，一口价，拼车
			if (orderPrivateCar.getRideType() != 3) {
				this.pushOrder(orderPrivateCar);
			} else {
				OrderPrivateCar orderPrivateCar1 = null;
				OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
				//判断是否有相同线路的拼车-有直接拼成功，或者推送拼车订单
				List<OrderPrivateCar> orderList = orderPrivateCarMapper.selectList(new EntityWrapper<OrderPrivateCar>().eq("rideType", 3).in("state", "2,3,4").le("totalPeopleNum", 4 - orderPrivateCar.getPeopleNum()));
				for (OrderPrivateCar order : orderList) {
					TbSpellOrderRule spellOrderRule = spellOrderRuleService.selectOne(new EntityWrapper<TbSpellOrderRule>().eq("openCityId", openCity.getId()));
					if (spellOrderRule != null) {
						JSONObject jsonObject = JSONObject.parseObject(spellOrderRule.getContent());
						//判断时间
						if (orderPrivateCar.getTravelTime().getTime() >= order.getTravelTime().getTime() - jsonObject.getInteger("num5") * 60000L && orderPrivateCar.getTravelTime().getTime() <= order.getTravelTime().getTime() + jsonObject.getInteger("num6") * 60000L) {
//                            Double dis1 = Double.valueOf(gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), order.getStartLon() + "," + order.getStartLat(), 1).get("distance").toString());
//                            Double dis2 = Double.valueOf(gdMapElectricFenceUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat(), 1).get("distance").toString());
							// TODO: 2023/11/4 已改成计算直线距离
							Double dis1 = geodesyUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), order.getStartLon() + "," + order.getStartLat()).get("WGS84");
							Double dis2 = geodesyUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat()).get("WGS84");
							//判断距离
							if (dis1 <= jsonObject.getInteger("num1") * 1000 && dis2 <= jsonObject.getInteger("num2") * 1000) {
								orderPrivateCar1 = orderPrivateCar;
								break;
							}
						}
					}
				}
				if (orderPrivateCar1 == null) {
					orderList = orderPrivateCarMapper.selectList(new EntityWrapper<OrderPrivateCar>().eq("rideType", 3).eq("state", 5).le("totalPeopleNum", 4 - orderPrivateCar.getPeopleNum()));
					for (OrderPrivateCar order : orderList) {
						TbSpellOrderRule spellOrderRule = spellOrderRuleService.selectOne(new EntityWrapper<TbSpellOrderRule>().eq("openCityId", openCity.getId()));
						if (spellOrderRule != null) {
							JSONObject jsonObject = JSONObject.parseObject(spellOrderRule.getContent());
							//判断时间
							if (orderPrivateCar.getTravelTime().getTime() >= order.getTravelTime().getTime() - jsonObject.getInteger("num5") * 60000L && orderPrivateCar.getTravelTime().getTime() <= order.getTravelTime().getTime() + jsonObject.getInteger("num6") * 60000L) {
								String value = (String) redisTemplate.opsForValue().get("dache:DRIVER" + String.valueOf(order.getDriverId()));
//                                Double dis1 = Double.valueOf(gdMapElectricFenceUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), value, 1).get("distance").toString());
//                                Double dis2 = Double.valueOf(gdMapElectricFenceUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat(), 1).get("distance").toString());
								// TODO: 2023/11/4 已改成计算直线距离
								Double dis1 = geodesyUtil.getDistance(orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), value).get("WGS84");
								Double dis2 = geodesyUtil.getDistance(orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), order.getEndLon() + "," + order.getEndLat()).get("WGS84");
								//判断距离
								if (dis1 <= jsonObject.getInteger("num3") * 1000 && dis2 <= jsonObject.getInteger("num4") * 1000) {
									orderPrivateCar1 = order;
									break;
								}
							}
						}
					}
				}
				if (orderPrivateCar1 == null) {
					this.pushOrder(orderPrivateCar);
				} else {
					Driver driver = driverService.selectById(orderPrivateCar1.getDriverId());
					orderPrivateCar.setDriverId(orderPrivateCar1.getDriverId());
					orderPrivateCar.setCompanyId(driver.getFranchiseeId() != null && driver.getFranchiseeId() != 0 ? driver.getFranchiseeId() : (
							driver.getCompanyId() != null && driver.getCompanyId() != 0 ? driver.getCompanyId() : 1));
					orderPrivateCar.setState(2);
					orderPrivateCar.setCarId(driver.getCarId());
					orderPrivateCar.setDriverId(driver.getId());
					CarService query1 = carServiceMapper.query(1, driver.getCarId());
					orderPrivateCar.setServerCarModelId(query1.getServerCarModelId());
					orderPrivateCar.setSnatchOrderTime(new Date());
					
					orderPrivateCar.setTotalPeopleNum(orderPrivateCar.getPeopleNum() + orderPrivateCar1.getTotalPeopleNum());
					orderPrivateCar.setPid(orderPrivateCar1.getPid() == null ? orderPrivateCar1.getId() : orderPrivateCar1.getPid());
					orderPrivateCar.setIsReassign(1);
					orderPrivateCar.setIsDelete(1);
					this.updateById(orderPrivateCar);
					//修改总订单人数
					OrderPrivateCar orderPrivateCar2 = new OrderPrivateCar();
					orderPrivateCar2.setTotalPeopleNum(orderPrivateCar.getPeopleNum() + orderPrivateCar1.getTotalPeopleNum());
					this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("pid", orderPrivateCar1.getPid() == null ? orderPrivateCar1.getId() : orderPrivateCar1.getPid()).lt("state", 6));
					this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("id", orderPrivateCar1.getPid() == null ? orderPrivateCar1.getId() : orderPrivateCar1.getPid()).lt("state", 6));
					//调用移动的小号接口
//					Map<String, String> map = chinaMobileUtil.midAxbBindSend(orderPrivateCar.getPassengersPhone(), driver.getPhone(), (System.currentTimeMillis() + 86400000));
//					if (String.valueOf(map.get("code")).equals("200")) {
//						orderPrivateCar.setTelX(map.get("telX"));
//						orderPrivateCar.setBindId(map.get("bindId"));
//					}
					new Thread(new Runnable() {
						@Override
						public void run() {
							pushUtil.pushOrderState(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, 2, 0);
							pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, 100, 0);
							pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
						}
					}).start();
					List<OrderPrivateCar> orderList1 = this.selectList(new EntityWrapper<OrderPrivateCar>().eq("pid", orderPrivateCar.getPid()));
					for (OrderPrivateCar orderPrivateCar3 : orderList1) {
						pushUtil.pushOrderState(1, orderPrivateCar3.getUserId(), orderPrivateCar3.getId(), 1, 13, 0);
					}
					OrderPrivateCar orderPrivateCar3 = this.selectById(orderPrivateCar.getPid());
					pushUtil.pushOrderState(1, orderPrivateCar3.getUserId(), orderPrivateCar3.getId(), 1, 13, 0);
				}
			}
			
		}
		return ResultUtil.success();
	}
	
	@Override
	public ResultUtil<BaseWarpper> queryCancleAmount(Integer id) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(id);
		if (null == orderPrivateCar) {
			return ResultUtil.error("获取数据失败，订单信息有误");
		}
		if (orderPrivateCar.getState() == 5) {
			return ResultUtil.error("订单已开始服务，不能取消订单");
		}
		if (orderPrivateCar.getState() == 6 || orderPrivateCar.getState() == 7 || orderPrivateCar.getState() == 8 || orderPrivateCar.getState() == 9) {
			return ResultUtil.error("订单已完成，不能取消订单");
		}
		if (orderPrivateCar.getState() == 10) {
			return ResultUtil.error("订单已被取消，不能重复操作");
		}
		OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
		double amount = 0;
		CancleOrder query = cancleOrderService.query(orderPrivateCar.getOrderType(), 1, openCity.getId());
		if (null != orderPrivateCar.getDriverId() &&
				(orderPrivateCar.getSnatchOrderTime().getTime() + query.getMinuteNum() * 60 * 1000) < new Date().getTime()) {//收费的情况
			if (null != query) {
				amount += query.getMoney();
			}
		}
		BaseWarpper baseWarpper = new BaseWarpper();
		baseWarpper.setAmount(amount);
		return ResultUtil.success(baseWarpper);
	}
	
	@Override
	public ResultUtil addCancle(Integer id, String reason, String remark, Integer uid) throws Exception {
		if (ToolUtil.isNotEmpty(remark)) {
			if (ToolUtil.isNotEmpty(remark)) {
				List<SensitiveWords> sensitiveWords = sensitiveWordsMapper.selectList(null);
				for (SensitiveWords s : sensitiveWords) {
					remark = remark.replaceAll(s.getContent(), "***");
				}
			}
		}
		
		OrderPrivateCar orderPrivateCar = this.selectById(id);
		Integer integer = null;
		if (null == orderPrivateCar) {
			return ResultUtil.error("取消订单失败，订单信息有误");
		}
//        if(orderPrivateCar.getState() == 4){
//            return ResultUtil.error("司机已到达预约点，取消会产生一定的费用");
//        }
		if (orderPrivateCar.getState() >= 5 && orderPrivateCar.getState() != 11 && orderPrivateCar.getCancelType() ==2) {
			return ResultUtil.error("订单已取消，请刷新页面");
		}
		if (!Integer.valueOf(2).equals(orderPrivateCar.getPaymentMode())) {
			handlePrivateCarPrepayCancelRefund(orderPrivateCar,reason);
		}
		Integer number1 = this.selectCount(new EntityWrapper<OrderPrivateCar>().eq("pid", orderPrivateCar.getPid() == null ? orderPrivateCar.getId() : orderPrivateCar.getPid()).lt("state", 6));
		Integer number2 = this.selectCount(new EntityWrapper<OrderPrivateCar>().eq("id", orderPrivateCar.getPid() == null ? orderPrivateCar.getId() : orderPrivateCar.getPid()).lt("state", 6));
		if (number1 + number2 == 1) {
			OrderPrivateCar orderPrivateCar2 = new OrderPrivateCar();
			orderPrivateCar2.setTotalPeopleNum(orderPrivateCar.getTotalPeopleNum() - orderPrivateCar.getPeopleNum());
			orderPrivateCar2.setSpellSuccess(0);
			this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("pid", orderPrivateCar.getPid() == null ? orderPrivateCar.getId() : orderPrivateCar.getPid()).lt("state", 6));
			this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("id", orderPrivateCar.getPid() == null ? orderPrivateCar.getId() : orderPrivateCar.getPid()).lt("state", 6));
			
		} else {
			OrderPrivateCar orderPrivateCar2 = new OrderPrivateCar();
			orderPrivateCar2.setTotalPeopleNum(orderPrivateCar.getTotalPeopleNum() - orderPrivateCar.getPeopleNum());
			this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("pid", orderPrivateCar.getPid() == null ? orderPrivateCar.getId() : orderPrivateCar.getPid()).lt("state", 6));
			this.update(orderPrivateCar2, new EntityWrapper<OrderPrivateCar>().eq("id", orderPrivateCar.getPid() == null ? orderPrivateCar.getId() : orderPrivateCar.getPid()).lt("state", 6));
		}
		if (null == orderPrivateCar.getDriverId()) {//没有接单的情况
			if (orderPrivateCar.getType() == 2) {//摆渡车
				OrderCrossCityServiceImpl.pushEndMap.remove(orderPrivateCar.getCrossCityOrderId());//删除标识数据
				List<OrderPrivateCar> list = this.selectList(new EntityWrapper<OrderPrivateCar>().eq("type", 2).eq("crossCityOrderId", orderPrivateCar.getCrossCityOrderId()).eq("place", orderPrivateCar.getPlace()));
				for (OrderPrivateCar orderPrivateCar1 : list) {
					orderCancelService.saveData(orderPrivateCar1.getId(), 1, "无司机接单", "无司机接单", null, null, 2, 1, uid);
					orderPrivateCar1.setState(10);
					this.updateById(orderPrivateCar1);
				}
				List<OrderTaxi> list1 = orderTaxiService.selectList(new EntityWrapper<OrderTaxi>().eq("type", 2).eq("crossCityOrderId", orderPrivateCar.getCrossCityOrderId()).eq("place", orderPrivateCar.getPlace()));
				for (OrderTaxi orderTaxi : list1) {
					orderCancelService.saveData(orderTaxi.getId(), 2, "无司机接单", "无司机接单", null, null, 2, 1, uid);
					orderTaxi.setState(10);
					orderTaxiService.updateById(orderTaxi);
				}
			} else {
				integer = orderCancelService.saveData(id, 1, "无司机接单", "无司机接单", null, null, 2, 1, uid);
				orderPrivateCar.setState(10);
				this.updateById(orderPrivateCar);
			}
		} else {
			OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
			CancleOrder query = cancleOrderService.query(orderPrivateCar.getOrderType(), 1, openCity.getId());
			if (null != query) {
				if ((orderPrivateCar.getSnatchOrderTime().getTime() + query.getMinuteNum() * 60 * 1000) < System.currentTimeMillis() && query.getMoney().compareTo(0D) > 0) {//收费的情况
					orderPrivateCar.setState(12);
					this.updateById(orderPrivateCar);
					integer = orderCancelService.saveData(id, 1, reason, remark, null, query.getMoney(), 1, 1, uid);
				} else {
					integer = orderCancelService.saveData(id, 1, reason, remark, null, null, 2, 1, uid);
					
					orderPrivateCar.setState(10);
					this.updateById(orderPrivateCar);
				}
				this.deleteTask(id);//删除定时任务
				
				new Thread(new Runnable() {
					@Override
					public void run() {
						pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
						System.err.println("推送取消操作---------------------");
					}
				}).start();
				
				//修改司机为空闲
				Driver driver = driverService.selectById(orderPrivateCar.getDriverId());
				driver.setState(2);
				driverService.updateById(driver);
				
				// 解绑手机
				
				//解除小号绑定
				if (orderPrivateCar.getBindId() != null) {
					Map<String, String> map = chinaMobileUtil.midAxbUnBindSend(orderPrivateCar.getBindId(), orderPrivateCar.getTelX(), (System.currentTimeMillis() + 86400000));
				}
			} else {
				return ResultUtil.error("请完善后台取消规则设置");
			}
			
		}
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				if (pushMinistryOfTransport) {
					//上传数据
					pushMinistryOfTransportUtil.orderCancel(orderPrivateCar.getId());
				}
			}
		}).start();
		
		//添加消息
		systemNoticeService.addSystemNotice(1, "您已成功取消出行订单，谢谢使用！", orderPrivateCar.getUserId(), 1);
		Map<String, Object> map = new HashMap<>();
		map.put("id", integer);
		return ResultUtil.success(map);
	}
	
	/**
	 * 取消订单操作
	 *
	 * @param id
	 * @return
	 * @throws Exception
	 */
	@Override
	@Transactional(propagation = Propagation.REQUIRES_NEW)
	public ResultUtil cancleOrderPrivateCar(Integer id, Integer payType, Integer cancleId, Integer type) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(id);
		Integer uid = orderPrivateCar.getUserId();
		UserInfo userInfo = userInfoService.selectById(uid);
		ResultUtil resultUtil = ResultUtil.success(new Object());
		
		if (null == orderPrivateCar) {
			return ResultUtil.error("取消订单失败，订单信息有误", "");
		}
		if (orderPrivateCar.getState() != 12) {
			return ResultUtil.error("订单已取消，请刷新页面", "");
		}
		OrderCancel orderCancel = null;
		if (null == cancleId) {
			orderCancel = orderCancelService.query(id, 1, null, null, 1);
		} else {
			orderCancel = orderCancelService.selectById(cancleId);
		}
		OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
		CancleOrder query = cancleOrderService.query(orderPrivateCar.getOrderType(), 1, openCity.getId());
		if (null != query) {
			if (payType == 1) {//微信支付
				orderCancel.setPayType(1);
				orderCancelService.updateById(orderCancel);
				String outTradeNo = "CANCEL_" + id + "_1_" + UUIDUtil.getRandomCode(5);
				JSONObject response = cbyzxOrderPayHelper.createOrder(orderPrivateCar.getUserId(), userInfo.getAppletsOpenId(), outTradeNo, query.getMoney());
				if (!cbyzxOrderPayHelper.isCreateSuccess(response)) {
					return ResultUtil.error(cbyzxOrderPayHelper.extractMessage(response), response);
				}
				String paymentCode = ToolUtil.isNotEmpty(cbyzxOrderPayHelper.extractRecordCode(response)) ? cbyzxOrderPayHelper.extractRecordCode(response) : outTradeNo;
				resultUtil = ResultUtil.success(response);
				paymentRecordService.saveData(1, orderPrivateCar.getUserId(), 1, id, 1, 1, query.getMoney(), paymentCode, 1);//添加预支付数据
			}
			if (payType == 2) {//支付宝支付
				orderCancel.setPayType(2);
				orderCancelService.updateById(orderCancel);
				
				resultUtil = payMoneyUtil.alipay("订单取消", "订单取消", "", id + "_1_" + UUIDUtil.getRandomCode(5), query.getMoney().toString(), "/base/aliCancelOrderTaxi");
				paymentRecordService.saveData(1, orderPrivateCar.getUserId(), 1, id, 1, 2, query.getMoney(), "", 1);//添加预支付数据
			}
			if (payType == 3) {//余额支付
				if (userInfo.getBalance() != null && userInfo.getBalance() < query.getMoney()) {
					return ResultUtil.error("余额不足，无法完成支付");
				}
//                resultUtil= appOrderController.moneyPay(id,userInfo.getId(),query.getMoney());
//                if(resultUtil.getCode()==500){
//                    return ResultUtil.error("电子余额不足，无法完成支付");
//                }
				userInfo.setBalance(new BigDecimal(userInfo.getBalance()).subtract(new BigDecimal(query.getMoney())).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
				//添加交易明细
				transactionDetailsService.saveData(uid, "快车取消订单", query.getMoney(), 2, 1, 1, 1, id);
				userInfoService.updateById(userInfo);
				
				//解除小号绑定
				if (orderPrivateCar.getBindId() != null) {
					chinaMobileUtil.midAxbUnBindSend(orderPrivateCar.getBindId(), orderPrivateCar.getTelX(), (System.currentTimeMillis() + 600000));
				}
				
				orderPrivateCar.setState(10);
				orderPrivateCar.setTelX("");
				orderPrivateCar.setBindId("");
				this.updateById(orderPrivateCar);

				orderCancel.setState(2);
				orderCancel.setPayType(3);
				orderCancelService.updateById(orderCancel);
				
				//添加已收入明细
				incomeService.saveData(1, orderPrivateCar.getCompanyId(), 3, orderPrivateCar.getId(), 1, query.getMoney());
				
				this.deleteTask(id);//删除定时任务
				
				//添加消息
				systemNoticeService.addSystemNotice(1, "您已使用余额成功支付取消订单费用，谢谢使用！", orderPrivateCar.getUserId(), 1);
				
			} else if (payType == 4) {
				Double payMoney = orderPrivateCar.getOrderMoney();
				Integer integer = paymentRecordService.saveData(1, orderPrivateCar.getUserId(), 1, id, 1, 4, query.getMoney(), "", 1);
				resultUtil = appOrderController.placeAnOrder(new BigDecimal(query.getMoney()), 4, id, 1, integer);
				
			}
		}
		return resultUtil;
	}
	
	
	@Override
	public Map<String, Object> queryOrderInfo(Integer uid, Integer orderId) throws Exception {
		Map<String, Object> map = orderPrivateCarMapper.queryOrderInfo(orderId);
		if(null == map){
			OrderTaxi orderTaxi = orderTaxiService.selectOne(new EntityWrapper<OrderTaxi>()
					.eq("userId", uid)
					.eq("isDelete", 1)
					.in("state", Arrays.asList(2, 3, 4, 5, 6, 7))
			);
			if(null == orderId){
				return new HashMap<>();
			}
			return orderTaxiService.queryOrderInfo(orderTaxi.getId());
		}
		if(null != map.get("reassignNotice") && Integer.valueOf(String.valueOf(map.get("reassignNotice"))) == 2){//改派完成，重新获取了新的司机数据，开始修改数据防止继续调用
			OrderPrivateCar orderPrivateCar = this.selectById(orderId);
			orderPrivateCar.setReassignNotice(0);
			this.updateById(orderPrivateCar);
		}
		if(Integer.valueOf(String.valueOf(map.get("state"))) == 11){
			map.put("state", map.get("oldState"));
		}
		if(map.get("abnormalIntro")!=null){
			map.put("appealStatus", 1);
		}

		if(Integer.valueOf(String.valueOf(map.get("state"))) != 8 && Integer.valueOf(String.valueOf(map.get("state"))) != 9){
			map.put("redPacketMoney", null);
			map.put("couponMoney", null);
		}
		
		String driverId = (String) redisTemplate.opsForValue().get("DEVICE_" + map.get("driverId"));
		map.put("device", ToolUtil.isNotEmpty(driverId) ? 2 : 1);
		map.put("orderType", 1);
		fillPrivateCarPrepayDisplayMoney(this.selectById(orderId), map);
		return map;
	}
	
	/**
	 * 获取服务中的订单数据
	 * @param uid
	 * @return
	 * @throws Exception
	 */
	@Override
	public OrderServerWarpper queryOrderServer(Integer orderId, Integer uid) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		if(null == orderPrivateCar){
			return orderTaxiService.queryOrderServer(orderId, uid);
		}
		//计算预计距离和剩余时间
		String value = (String) redisTemplate.opsForValue().get("dache:DRIVER" + String.valueOf(orderPrivateCar.getDriverId()));
		if(null == value || "".equals(value)){
			System.err.println("司机没有上传位置信息");
			
			//调用获取轨迹中的数据
			List<Map<String, Object>> list = orderPositionService.queryTrack(orderId, 2);
			if(list.size() > 0){
				Map<String, Object> map = list.get(list.size() - 1);
				value = map.get("lon") + "," + map.get("lat");
			}
			
		}
		
		OrderServerWarpper orderServerWarpper = new OrderServerWarpper();
		orderServerWarpper.setOrderId(orderPrivateCar.getId());
		orderServerWarpper.setOrderType(1);
		orderServerWarpper.setState(orderPrivateCar.getState());
		orderServerWarpper.setLon(null != value ? value.split(",")[0] : "0.0");
		orderServerWarpper.setLat(null != value ? value.split(",")[1] : "0.0");
		orderServerWarpper.setReassignNotice(orderPrivateCar.getReassignNotice());
		if(orderPrivateCar.getState() == 2 || orderPrivateCar.getState() == 3){//前往预约地
			// TODO: 2023/11/4 无法修改
			Map<String, String> distance = gdMapElectricFenceUtil.getDistance(value, orderPrivateCar.getStartLon() + "," + orderPrivateCar.getStartLat(), 1);
			String d = "0";
			String t = "0";
			if(null == distance){
				System.err.println("查询距离出错了");
			}else{
				d = new BigDecimal(distance.get("distance")).divide(new BigDecimal(1000), new MathContext(2, RoundingMode.HALF_EVEN)).toString();
				t = new BigDecimal(distance.get("duration")).divide(new BigDecimal(60), new MathContext(2, RoundingMode.HALF_EVEN)).intValue() + "";
			}
			orderServerWarpper.setReservationMileage(d);
			orderServerWarpper.setReservationTime(t);
			orderServerWarpper.setServedMileage("0");
			orderServerWarpper.setServedTime("0");
			orderServerWarpper.setLaveMileage("0");
			orderServerWarpper.setLaveTime("0");
		}
		if(orderPrivateCar.getState() == 5 || orderPrivateCar.getState() == 6){//服务中
			// TODO: 2023/11/4 无法修改
			Map<String, String> distance = gdMapElectricFenceUtil.getDistance(value, orderPrivateCar.getEndLon() + "," + orderPrivateCar.getEndLat(), 1);
			String d = "0";
			String t = "0";
			if(null == distance){
				System.err.println("查询距离出错了");
			}else{
				d = new BigDecimal(distance.get("distance")).divide(new BigDecimal(1000), new MathContext(2, RoundingMode.HALF_EVEN)).toString();
				t = new BigDecimal(distance.get("duration")).divide(new BigDecimal(60), new MathContext(2, RoundingMode.HALF_EVEN)).intValue() + "";
			}
			orderServerWarpper.setReservationMileage("0");
			orderServerWarpper.setReservationTime("0");
			orderServerWarpper.setServedMileage(String.valueOf((null == orderPrivateCar.getMileage() ? 0 : orderPrivateCar.getMileage()) / 1000));
			orderServerWarpper.setServedTime(Long.valueOf((new Date().getTime() - orderPrivateCar.getStartServiceTime().getTime()) / 60000).intValue() + "");
			orderServerWarpper.setLaveMileage(d);
			orderServerWarpper.setLaveTime(t);
		}
		
		return orderServerWarpper;
	}
	
	
	@Override
	public synchronized String getOrderNum() throws Exception {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		return "PR" + sdf.format(new Date()) + UUIDUtil.getRandomCode(5);
	}
	
	/**
	 * 删除定时任务
	 *
	 * @param orderId
	 */
	@Override
	public void deleteTask(Integer orderId) {
		//发送验证码短信
		HttpHeaders headers = new HttpHeaders();
		// 以表单的方式提交
		headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
		//将请求头部和参数合成一个请求
		MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
		params.add("orderId", orderId + "");
		params.add("orderType", "1");
		HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(params, headers);
		String s = internalRestTemplate.postForObject("http://driver-server/base/netty/deleteTask", requestEntity, String.class);
		JSONObject jsonObject = JSON.parseObject(s, JSONObject.class);
		if (jsonObject.getIntValue("code") != 200) {
			System.err.println("调用driver-server出错了");
		}
	}
	
	@Override
	public Map<String, Object> queryBalance(Integer orderId, Integer uid) throws Exception {
		Map<String, Object> map = new HashMap<>();
		UserInfo userInfo = userInfoService.selectById(uid);
		map.put("balance", userInfo.getBalance());
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		int i = userCouponRecordService.queryAvailable(uid, orderPrivateCar.getCompanyId(), 1, 1, orderPrivateCar.getOrderMoney());
		i = i + userCouponRecordService.queryAvailable(uid, orderPrivateCar.getCompanyId(), 1, 0, orderPrivateCar.getOrderMoney());
		map.put("coupon", i);
		return map;
	}
	
	@Override
	public PreferentialDataVo queryBalance1(Integer orderId, Integer uid) throws Exception {
		UserInfo userInfo = userInfoService.selectById(uid);
		PreferentialDataVo preferentialDataVo = new PreferentialDataVo();
		preferentialDataVo.setBalance(userInfo.getBalance());
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		Integer ids = userInfoService.getDiscount();
		if (ids != null) {
			List<UserActivityDiscount1> userActivityId = userActivityDiscount1Mapper.selectList(new EntityWrapper<UserActivityDiscount1>().eq("userActivityId", ids));
			if (userActivityId.size() > 0) {
				
				preferentialDataVo.setDiscount(userActivityId.get(0).getSpecial());
			}
		}
		// 查出当前用户的红包 并将订单的修改
		List<UserRedPacketRecord> userRedPacketRecords = userRedPacketRecordService.selectList(new EntityWrapper<UserRedPacketRecord>().eq("userId", uid).eq("state", 1).gt("expirationTime", new Date()).gt("endTime", new Date()));
		if (userRedPacketRecords.size() > 0) {
			
			preferentialDataVo.setRedPacket(userRedPacketRecords.get(0).getMoney());
			orderPrivateCar.setRedPacketId(userRedPacketRecords.get(0).getId());
			orderPrivateCar.setRedPacketMoney(userRedPacketRecords.get(0).getMoney());
			this.updateById(orderPrivateCar);
		}
		
		
		//获取优惠券中最优数据
		List<UserCouponRecord> list = userCouponRecordService.selectList(new EntityWrapper<UserCouponRecord>().eq("companyId", orderPrivateCar.getCompanyId()).eq("state", 1).le("money", orderPrivateCar.getOrderMoney()).in("couponUseType", Arrays.asList(0, 1)).eq("userId", uid).where("now() < expirationTime"));
		Integer id = null;
		Double price = 0d;
		Integer type = 0;
		for (UserCouponRecord userCouponRecord : list) {
			if (userCouponRecord.getCouponType() == 1) {//抵扣券
				if (price.compareTo(userCouponRecord.getMoney()) < 0) {
					price = userCouponRecord.getMoney();
					id = userCouponRecord.getId();
					type = 1;
				}
			} else {//满减券
				if (orderPrivateCar.getOrderMoney().compareTo(userCouponRecord.getFullMoney()) >= 0 && price.compareTo(userCouponRecord.getMoney()) < 0) {
					price = userCouponRecord.getMoney();
					id = userCouponRecord.getId();
					type = 1;
				}
			}
		}
		
		//获取打车卡中最优数
		Map<String, String> geocode = gdMapGeocodingUtil.geocode(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
		CompanyCity companyCity = companyCityService.selectOne(new EntityWrapper<CompanyCity>().eq("companyId", orderPrivateCar.getCompanyId()).eq("areaCode", geocode.get("districtCode")).eq("state", 1));
		if (null == companyCity) {
			companyCity = companyCityService.selectOne(new EntityWrapper<CompanyCity>().eq("companyId", orderPrivateCar.getCompanyId()).eq("cityCode", geocode.get("cityCode")).eq("state", 1));
		}
		if (null == companyCity) {
			companyCity = companyCityService.selectOne(new EntityWrapper<CompanyCity>().eq("companyId", orderPrivateCar.getCompanyId()).eq("provinceCode", geocode.get("provinceCode")).eq("state", 1));
		}
		List<UserTaxiCard> userTaxiCards = new ArrayList<>();
		if (companyCity != null) {
			userTaxiCards = userTaxiCardService.selectList(new EntityWrapper<UserTaxiCard>().like("companyCityId", "%" + companyCity.getId() + "%")
					.in("type", Arrays.asList(1, 2, 3, 4)).eq("userId", uid).where("now() between startTime and endTime"));
		}
		//全国卡
		List<TaxiCard> taxiCards = taxiCardService.selectList(new EntityWrapper<TaxiCard>().eq("taxiCardType", 2).in("type", Arrays.asList(1, 2, 3, 4)).eq("state", 1));
		if (taxiCards.size() > 0) {
			List<UserTaxiCard> userTaxiCards2 = userTaxiCardService.selectList(new EntityWrapper<UserTaxiCard>().eq("userId", uid)
					.in("type", Arrays.asList(1, 2, 3, 4)).in("taxiCardId", taxiCards.stream().map(TaxiCard::getId).collect(Collectors.toList())).where("now() between startTime and endTime"));
			userTaxiCards.addAll(userTaxiCards2);
		}
		//亲密账户中有相同的卡优先使用自己的
		// 因为比对中只有优惠金额最高的才会被替换，所以先查找自己的数据再查找亲密账户的数据
		Map<String, Object> map = getOptimalTaxiCards(orderPrivateCar, price, id, type, userTaxiCards);
		price = Double.valueOf(map.get("price").toString());
		id = null != map.get("id") ? Integer.valueOf(map.get("id").toString()) : null;
		type = Integer.valueOf(map.get("type").toString());
		
		//亲密账户
		List<UserTaxiCard> userTaxiCards_ = new ArrayList<>();
		List<UserUser> bindUserId = userUserService.selectList(new EntityWrapper<UserUser>().eq("bindUserId", uid));
		CompanyCity finalCompanyCity = companyCity;
		bindUserId.forEach(userUser -> {
			if (finalCompanyCity != null) {
				List<UserTaxiCard> userTaxiCards1 = userTaxiCardService.selectList(new EntityWrapper<UserTaxiCard>().in("type", Arrays.asList(1, 2, 3, 4))
						.like("companyCityId", "%" + finalCompanyCity.getId() + "%").eq("userId", userUser.getUserId()).where("now() between startTime and endTime"));
				userTaxiCards_.addAll(userTaxiCards1);
			}
			
			//全国卡
			if (taxiCards.size() > 0) {
				List<UserTaxiCard> userTaxiCards2 = userTaxiCardService.selectList(new EntityWrapper<UserTaxiCard>().eq("userId", userUser.getUserId())
						.in("type", Arrays.asList(1, 2, 3, 4)).in("taxiCardId", taxiCards.stream().map(TaxiCard::getId).collect(Collectors.toList())).where("now() between startTime and endTime"));
				userTaxiCards_.addAll(userTaxiCards2);
			}
		});
		map = getOptimalTaxiCards(orderPrivateCar, price, id, type, userTaxiCards_);
		price = Double.valueOf(map.get("price").toString());
		id = null != map.get("id") ? Integer.valueOf(map.get("id").toString()) : null;
		type = Integer.valueOf(map.get("type").toString());
		System.out.println(price);
		System.out.println(orderPrivateCar.getOrderMoney());
		System.out.println(type);
		
		if (orderPrivateCar.getOrderMoney() != null && price <= orderPrivateCar.getOrderMoney() || type == 2) {
			preferentialDataVo.setDiscountAmount(price);
			preferentialDataVo.setType(type);
			preferentialDataVo.setObjectId(id);
		}
		return preferentialDataVo;
	}
	
	/**
	 * 获取最优打车卡数据
	 *
	 * @param orderPrivateCar
	 * @param price
	 * @param id
	 * @param type
	 * @param userTaxiCards
	 * @throws Exception
	 */
	public Map<String, Object> getOptimalTaxiCards(OrderPrivateCar orderPrivateCar, Double price, Integer id, Integer type, List<UserTaxiCard> userTaxiCards) throws Exception {
		Map<String, Object> map = new HashMap<>();
		for (UserTaxiCard t : userTaxiCards) {
			JSONObject jsonObject = JSON.parseObject(t.getContent());
			List<Integer> integers = jsonObject.getJSONArray("businessTypes").toJavaList(Integer.class);
			if (!integers.contains(1)) {
				continue;
			}
			if (t.getType() == 1) {//打折次数卡{"businessTypes":[1,2,3],"time":5,"timeQuantum":["08:00:00 - 09:00:00","17:00:00 - 18:00:00"],"discount":5}
				Integer time = jsonObject.getInteger("time");
				if (time == 0) {
					continue;
				}
				JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
				Double discount = jsonObject.getDouble("discount");
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				Date date = new Date();
				for (int i = 0; i < timeQuantum.size(); i++) {
					String[] split = timeQuantum.getString(i).split(" - ");
					Date s = sdf1.parse(sdf.format(date) + " " + split[0]);
					Date e = sdf1.parse(sdf.format(date) + " " + split[1]);
					if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
						double v = new BigDecimal(orderPrivateCar.getOrderMoney()).multiply(new BigDecimal((10 - discount) / 10)).setScale(2, RoundingMode.HALF_EVEN).doubleValue();
						if (price.compareTo(v) < 0) {
							price = v;
							id = t.getId();
							type = 2;
						}
						if (price.compareTo(v) < 0) {
							price = v;
							id = t.getId();
							type = 2;
						}
					}
				}
				
			}
			if (t.getType() == 2) {//优惠卡{"businessTypes":[1,2,3],"timeQuantum":["08:00:00 - 09:00:00","17:00:00 - 18:00:00"],"fullReduction":[[50,3],[100,5],[150,10]]}
				JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
				JSONArray fullReduction = jsonObject.getJSONArray("fullReduction");
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				Date date = new Date();
				for (int i = 0; i < timeQuantum.size(); i++) {
					String[] split = timeQuantum.getString(i).split(" - ");
					Date s = sdf1.parse(sdf.format(date) + " " + split[0]);
					Date e = sdf1.parse(sdf.format(date) + " " + split[1]);
					if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
						for (int j = fullReduction.size() - 1; j >= 0; j--) {
							JSONArray jsonArray = fullReduction.getJSONArray(j);
							Double p = jsonArray.getDouble(0);//满金额
							Double y = jsonArray.getDouble(1);//优惠金额
							if (orderPrivateCar.getOrderMoney().compareTo(p) >= 0 && price.compareTo(y) < 0) {
								price = y;
								id = t.getId();
								type = 2;
							}
						}
					}
				}
			}
			if (t.getType() == 3) {//次数卡{"businessTypes":[1,2,3],"timeQuantum":["08:00:00 - 09:00:00","17:00:00 - 18:00:00"],"time":1,"discountAmount":10}
				Integer time = jsonObject.getInteger("time");
				if (time == 0) {
					continue;
				}
				JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
				Double discountAmount = jsonObject.getDouble("discountAmount");
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				Date date = new Date();
				for (int i = 0; i < timeQuantum.size(); i++) {
					String[] split = timeQuantum.getString(i).split(" - ");
					Date s = sdf1.parse(sdf.format(date) + " " + split[0]);
					Date e = sdf1.parse(sdf.format(date) + " " + split[1]);
					if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
						if (price.compareTo(discountAmount) < 0) {
							price = discountAmount;
							id = t.getId();
							type = 2;
						}
					}
				}
			}
			if (t.getType() == 4) {//打折天数卡{"businessTypes":[1,2,3],"discount":5,"timeQuantum":["08:00:00 - 09:00:00","17:00:00 - 18:00:00"]}
				Double discount = jsonObject.getDouble("discount");//折扣
				JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");//使用时间段
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				Date date = new Date();
				for (int i = 0; i < timeQuantum.size(); i++) {
					String[] split = timeQuantum.getString(i).split(" - ");
					Date s = sdf1.parse(sdf.format(date) + " " + split[0]);
					Date e = sdf1.parse(sdf.format(date) + " " + split[1]);
					if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
						double v = new BigDecimal(orderPrivateCar.getOrderMoney()).multiply(new BigDecimal((10 - discount) / 10)).setScale(2, RoundingMode.HALF_EVEN).doubleValue();
						if (price.compareTo(v) < 0) {
							price = v;
							id = t.getId();
							type = 2;
						}
					}
				}
			}
		}
		map.put("price", price);
		map.put("id", id);
		map.put("type", type);
		return map;
	}
	
	@Override
	public List<Map<String, Object>> queryCoupon(Integer orderId, Integer uid, Integer pageNum, Integer size) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		List<Map<String, Object>> list = userCouponRecordService.queryCoupon(uid, orderPrivateCar.getCompanyId(), 1, 1, orderPrivateCar.getOrderMoney(), pageNum, size);
		List<Map<String, Object>> list1 = userCouponRecordService.queryCoupon(uid, orderPrivateCar.getCompanyId(), 1, 0, orderPrivateCar.getOrderMoney(), pageNum, size);
		list.addAll(list1);
		return list;
	}
	
	@Override
	public List<CouponsListVo> queryCouponList(Integer orderId, Integer uid, Integer pageNum, Integer size) throws Exception {
		pageNum = (pageNum - 1) * size;
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		List<CouponsListVo> rows = new ArrayList<>();
		List<UserCouponRecord> list = userCouponRecordService.selectList(new EntityWrapper<UserCouponRecord>().eq("companyId", orderPrivateCar.getCompanyId())
				.eq("state", 1).in("couponUseType", Arrays.asList(0, 1)).eq("userId", uid).where("expirationTime >= now()"));
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		for (UserCouponRecord userCouponRecord : list) {
			if (userCouponRecord.getCouponType() == 2) {//满减券
				if (orderPrivateCar.getOrderMoney().compareTo(userCouponRecord.getFullMoney()) < 0) {
					continue;
				}
			}
			CouponsListVo couponsListVo = new CouponsListVo();
			couponsListVo.setId(userCouponRecord.getId());
			couponsListVo.setDataType(1);
			couponsListVo.setMoney(userCouponRecord.getMoney());
			couponsListVo.setUserType(userCouponRecord.getCouponUseType());
			couponsListVo.setTime(sdf.format(userCouponRecord.getExpirationTime()));
			couponsListVo.setType(userCouponRecord.getCouponType());
			couponsListVo.setFullMoney(userCouponRecord.getFullMoney());
			couponsListVo.setState(userCouponRecord.getState());
			Company company = companyService.selectById(userCouponRecord.getCompanyId());
			couponsListVo.setCompany(company.getName());
			rows.add(couponsListVo);
		}
		
		Map<String, String> geocode = gdMapGeocodingUtil.geocode(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
		CompanyCity companyCity = companyCityService.selectOne(new EntityWrapper<CompanyCity>().eq("companyId", orderPrivateCar.getCompanyId()).eq("areaCode", geocode.get("districtCode")).eq("state", 1));
		if (null == companyCity) {
			companyCity = companyCityService.selectOne(new EntityWrapper<CompanyCity>().eq("companyId", orderPrivateCar.getCompanyId()).eq("cityCode", geocode.get("cityCode")).eq("state", 1));
		}
		if (null == companyCity) {
			companyCity = companyCityService.selectOne(new EntityWrapper<CompanyCity>().eq("companyId", orderPrivateCar.getCompanyId()).eq("provinceCode", geocode.get("provinceCode")).eq("state", 1));
		}
		List<UserTaxiCard> userTaxiCards;
		if (companyCity != null) {
			userTaxiCards = userTaxiCardService.selectList(new EntityWrapper<UserTaxiCard>().eq("userId", uid)
					.in("type", Arrays.asList(1, 2, 3, 4)).like("companyCityId", "%" + companyCity.getId() + "%").where("now() between startTime and endTime"));
		} else {
			userTaxiCards = new ArrayList<>();
		}
		
		//全国卡
		List<TaxiCard> taxiCards = taxiCardService.selectList(new EntityWrapper<TaxiCard>().eq("taxiCardType", 2).in("type", Arrays.asList(1, 2, 3, 4)).eq("state", 1));
		if (taxiCards.size() > 0) {
			List<UserTaxiCard> userTaxiCards1 = userTaxiCardService.selectList(new EntityWrapper<UserTaxiCard>().eq("userId", uid)
					.in("type", Arrays.asList(1, 2, 3, 4)).in("taxiCardId", taxiCards.stream().map(TaxiCard::getId).collect(Collectors.toList())).where("now() between startTime and endTime"));
			userTaxiCards.addAll(userTaxiCards1);
		}
		
		
		//亲密账户
		List<UserUser> bindUserId = userUserService.selectList(new EntityWrapper<UserUser>().eq("bindUserId", uid));
		CompanyCity finalCompanyCity = companyCity;
		bindUserId.forEach(userUser -> {
			if (finalCompanyCity != null) {
				List<UserTaxiCard> taxiCardPayments1 = userTaxiCardService.selectList(new EntityWrapper<UserTaxiCard>().in("type", Arrays.asList(1, 2, 3, 4))
						.like("companyCityId", "%" + finalCompanyCity.getId() + "%").eq("userId", userUser.getUserId()).where("now() between startTime and endTime"));
				userTaxiCards.addAll(taxiCardPayments1);
			}
			
			//全国卡
			if (taxiCards.size() > 0) {
				List<UserTaxiCard> userTaxiCards1 = userTaxiCardService.selectList(new EntityWrapper<UserTaxiCard>().eq("userId", userUser.getUserId())
						.in("type", Arrays.asList(1, 2, 3, 4)).in("taxiCardId", taxiCards.stream().map(TaxiCard::getId).collect(Collectors.toList())).where("now() between startTime and endTime"));
				userTaxiCards.addAll(userTaxiCards1);
			}
		});
		
		for (UserTaxiCard t : userTaxiCards) {
			try {
				CouponsListVo couponsListVo = new CouponsListVo();
				couponsListVo.setId(t.getId());
				couponsListVo.setDataType(2);
				couponsListVo.setUserType(1);
				couponsListVo.setTime(sdf.format(t.getEndTime()));
				couponsListVo.setState(1);
				couponsListVo.setTaxiCardType(t.getType());
				Company company = companyService.selectById(t.getCompanyId());
				couponsListVo.setCompany(company.getName());
				couponsListVo.setName(taxiCardService.selectById(t.getTaxiCardId()).getName());
				
				
				JSONObject jsonObject = JSON.parseObject(t.getContent());
				JSONArray businessTypes = jsonObject.getJSONArray("businessTypes");
				if (!businessTypes.toJavaList(Integer.class).contains(1)) {
					continue;
				}
				if (t.getType() == 1) {//{"businessTypes":[1,2,3],"time":5,"timeQuantum":["08:00:00 - 09:00:00","17:00:00 - 18:00:00"],"discount":5}
					Integer time = jsonObject.getInteger("time");
					if (time == 0) {
						continue;
					}
					JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
					SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
					boolean b = true;
					for (int i = 0; i < timeQuantum.size(); i++) {
						String[] split = timeQuantum.getString(i).split(" - ");
						Date s = sdf.parse(sdf1.format(new Date()) + " " + split[0]);
						Date e = sdf.parse(sdf1.format(new Date()) + " " + split[1]);
						if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
							b = false;
							break;
						}
					}
					if (b) {
						continue;
					}
					couponsListVo.setMoney(jsonObject.getDouble("discount"));
					couponsListVo.setType(1);
				}
				if (t.getType() == 2) {//{"businessTypes":[1,2,3],"fullReduction":[[50,3],[100,5],[150,10]]}
					JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
					SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
					boolean b = true;
					for (int i = 0; i < timeQuantum.size(); i++) {
						String[] split = timeQuantum.getString(i).split(" - ");
						Date s = sdf.parse(sdf1.format(new Date()) + " " + split[0]);
						Date e = sdf.parse(sdf1.format(new Date()) + " " + split[1]);
						if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
							b = false;
							break;
						}
					}
					if (b) {
						continue;
					}
					JSONArray fullReduction = jsonObject.getJSONArray("fullReduction");
					b = true;
					for (int i = fullReduction.size() - 1; i >= 0; i--) {
						JSONArray jsonArray = fullReduction.getJSONArray(i);
						Double m = jsonArray.getDouble(0);
						Double j = jsonArray.getDouble(1);
						if (orderPrivateCar.getOrderMoney().compareTo(m) >= 0) {
							couponsListVo.setFullMoney(m);
							couponsListVo.setMoney(j);
							b = false;
							break;
						}
					}
					if (b) {
						continue;
					}
					couponsListVo.setType(2);
				}
				if (t.getType() == 3) {//{"businessTypes":[1,2,3],"time":1,"discountAmount":10}
					Integer time = jsonObject.getInteger("time");
					if (time == 0) {
						continue;
					}
					JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
					SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
					boolean b = true;
					for (int i = 0; i < timeQuantum.size(); i++) {
						String[] split = timeQuantum.getString(i).split(" - ");
						Date s = sdf.parse(sdf1.format(new Date()) + " " + split[0]);
						Date e = sdf.parse(sdf1.format(new Date()) + " " + split[1]);
						if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
							b = false;
							break;
						}
					}
					if (b) {
						continue;
					}
					couponsListVo.setFullMoney(0D);
					couponsListVo.setMoney(jsonObject.getDouble("discountAmount"));
					couponsListVo.setType(2);
				}
				if (t.getType() == 4) {//{"businessTypes":[1,2,3],"discount":5,"timeQuantum":["08:00:00 - 09:00:00","17:00:00 - 18:00:00"]}
					JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
					SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
					boolean b = true;
					for (int i = 0; i < timeQuantum.size(); i++) {
						String[] split = timeQuantum.getString(i).split(" - ");
						Date s = sdf.parse(sdf1.format(new Date()) + " " + split[0]);
						Date e = sdf.parse(sdf1.format(new Date()) + " " + split[1]);
						if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
							b = false;
							break;
						}
					}
					if (b) {
						continue;
					}
					couponsListVo.setMoney(jsonObject.getDouble("discount"));
					couponsListVo.setType(1);
				}
				
				
				String str = "";
				TaxiCard taxiCard = taxiCardService.selectById(t.getTaxiCardId());
				if (taxiCard.getTaxiCardType() == 1) {
					String[] split = taxiCard.getCompanyCityId().split(";");
					for (String c : split) {
						CompanyCity companyCity1 = companyCityService.selectById(c);
						if (ToolUtil.isNotEmpty(companyCity1.getAreaCode())) {
							Region region = regionService.selectOne(new EntityWrapper<Region>().eq("code", companyCity1.getAreaCode()));
							str += region.getName() + ";";
							continue;
						}
						if (ToolUtil.isNotEmpty(companyCity1.getCityCode())) {
							Region region = regionService.selectOne(new EntityWrapper<Region>().eq("code", companyCity1.getCityCode()));
							str += region.getName() + ";";
							continue;
						}
						if (ToolUtil.isNotEmpty(companyCity1.getProvinceCode())) {
							Region region = regionService.selectOne(new EntityWrapper<Region>().eq("code", companyCity1.getProvinceCode()));
							str += region.getName() + ";";
							continue;
						}
					}
				} else {
					str = "全国;";
				}
				couponsListVo.setCity(str.substring(0, str.length() - 1));
				
				
				rows.add(couponsListVo);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		Collections.sort(rows, new Comparator<CouponsListVo>() {
			public int compare(CouponsListVo s1, CouponsListVo s2) {
				return Integer.compare(s1.getId(), s2.getId());
			}
		});
		
		if (rows.size() >= (pageNum + 1) * size) {
			rows = rows.subList(pageNum, pageNum + size);
		} else if (pageNum < rows.size() && rows.size() < (pageNum + 1) * size) {
			rows = rows.subList(pageNum, rows.size());
		} else {
			rows = new ArrayList<>();
		}
		System.out.println(rows);
		System.out.println(orderPrivateCar.getOrderMoney());
		rows = rows.stream().filter(e -> e.getMoney() <= orderPrivateCar.getOrderMoney() || e.getDataType() == 2).collect(Collectors.toList());
		System.out.println(rows);
		return rows;
	}
	
	@Override
	public ResultUtil payPrivateCarOrder(Integer payType, Integer orderId, Integer couponId, Integer type) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		if (orderPrivateCar.getState() == 8 || orderPrivateCar.getState() == 9) {
			return ResultUtil.error("订单已完成支付，不允许重复支付", "");
		}
		if (orderPrivateCar.getState() != 7) {
			return ResultUtil.error("订单不在待支付状态，不允许支付", "");
		}
		if (Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode()) && Integer.valueOf(4).equals(orderPrivateCar.getPrepayStage())) {
			return ResultUtil.error("订单退款处理中，请等待退款完成", "");
		}
		Integer uid = orderPrivateCar.getUserId();
		Double orderMoney = (2 == orderPrivateCar.getAbnormal() && 2 == orderPrivateCar.getAbnormalStatus() ? orderPrivateCar.getResponsibilityMoney().doubleValue() : orderPrivateCar.getOrderMoney());
		UserInfo userInfo = userInfoService.selectById(uid);
		ResultUtil resultUtil = ResultUtil.success(new Object());
		orderPrivateCar.setCouponMoney(0D);//初始化历史数据
		orderPrivateCar.setCouponId(null);
		
		//计算优惠券
		UserCouponRecord userCouponRecord = null;
		if (null != couponId) {
			userCouponRecord = userCouponRecordService.selectById(couponId);
			if (userCouponRecord.getCompanyId() != orderPrivateCar.getCompanyId()) {
				return ResultUtil.error("优惠券不能用于此订单", "");
			}
			if (userCouponRecord.getState() == 2) {
				return ResultUtil.error("优惠券已使用", "");
			}
			if (userCouponRecord.getState() == 3) {
				return ResultUtil.error("优惠券已过期", "");
			}
			if (userCouponRecord.getCouponUseType() != 0 && userCouponRecord.getCouponUseType() != 1) {
				return ResultUtil.error("优惠券不能用于此类型订单", "");
			}
			if (userCouponRecord.getCouponType() == 2 && orderMoney.compareTo(userCouponRecord.getFullMoney()) < 0) {
				return ResultUtil.error("优惠券不能用于此订单", "");
			}
			orderMoney = orderMoney - userCouponRecord.getMoney();
			orderPrivateCar.setCouponMoney(userCouponRecord.getMoney());
			orderPrivateCar.setCouponId(couponId);
		}
		
		
		//计算红包
		UserRedPacketRecord query = userRedPacketRecordService.query(uid, orderPrivateCar.getCompanyId(), 1, 1, orderMoney);
		if (null != query && query.getMoney().compareTo(orderMoney) < 0) {
			orderMoney = orderMoney - query.getMoney();
			orderPrivateCar.setRedPacketMoney(query.getMoney());
			orderPrivateCar.setRedPacketId(query.getId());
		}
		
		//计算折扣
		UserActivityDiscount1 query2 = userActivityDiscount1Mapper.query(orderPrivateCar.getCompanyId());
		if (null != query2) {
			Double special = query2.getSpecial();
			orderPrivateCar.setDiscount(special);
			double v = new BigDecimal(orderMoney).multiply(new BigDecimal(special / 10)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue();
			if (orderMoney.compareTo(v) > 0) {
				orderPrivateCar.setDiscountMoney(orderMoney - v);
				orderPrivateCar.setActivityId(query2.getId());
				orderMoney = v;
			}
		}
		orderMoney = orderMoney < 0 ? 0 : orderMoney;
		ResultUtil prepaySettleResult = settlePrivateCarPrepayIfNoSecondPay(orderPrivateCar, userInfo, orderMoney);
		if (prepaySettleResult != null) {
			return prepaySettleResult;
		}
		orderMoney = getPrivateCarPrepayFinalPayAmount(orderPrivateCar, orderMoney);
		if (payType == 1) {//微信支付
			String outTradeNo = orderId + "_1_" + UUIDUtil.getRandomCode(5);
			JSONObject response = cbyzxOrderPayHelper.createOrder(orderPrivateCar.getUserId(), userInfo.getAppletsOpenId(), outTradeNo, orderMoney);
			if (!cbyzxOrderPayHelper.isCreateSuccess(response)) {
				return ResultUtil.error(cbyzxOrderPayHelper.extractMessage(response), response);
			}
			String paymentCode = ToolUtil.isNotEmpty(cbyzxOrderPayHelper.extractRecordCode(response)) ? cbyzxOrderPayHelper.extractRecordCode(response) : outTradeNo;
			resultUtil = ResultUtil.success(response);
			paymentRecordService.saveData(1, orderPrivateCar.getUserId(), 1, orderId, 1, 1, orderMoney, paymentCode, 1);//添加预支付数据
		}
		if (payType == 2) {//支付宝支付
			String outTradeNo = orderId + "_1_" + UUIDUtil.getRandomCode(5);
			resultUtil = payMoneyUtil.alipay("完成订单", "完成订单", "", outTradeNo, orderMoney.toString(), "/base/aliPayOrderTaxi");
			paymentRecordService.saveData(1, orderPrivateCar.getUserId(), 1, orderId, 1, 2, orderMoney, outTradeNo, 1);//添加预支付数据
		}
		if (payType == 3) {//余额支付
			if (userInfo.getBalance() == null || userInfo.getBalance() < orderMoney) {
				return ResultUtil.error("余额不足，无法完成支付", "");
			}
			
			userInfo.setBalance(new BigDecimal(userInfo.getBalance()).subtract(new BigDecimal(orderMoney)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
			
			boolean isPrepayFirstStage = isPrivateCarPrepayFirstStage(orderPrivateCar);
			boolean isPrepaySpreadStage = isPrivateCarPrepaySpreadStage(orderPrivateCar);
			if (isPrepayFirstStage) {
				handlePrivateCarPrepayFirstPaid(orderPrivateCar, userInfo, orderMoney, 3);
				return resultUtil;
			}

			OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
			SysIntegral query1 = sysIntegralMapper.query(openCity.getId());
			userInfo.setIntegral(userInfo.getIntegral() + (orderMoney.intValue() * query1.getIntegral()));//积分

			//添加交易明细
			transactionDetailsService.saveData(uid, "快车订单", orderMoney, 2, 1, 1, 1, orderId);
			userInfoService.updateById(userInfo);

			orderPrivateCar.setState(8);
			orderPrivateCar.setPayType(3);
			orderPrivateCar.setPayMoney(isPrepaySpreadStage ? appendPayMoney(orderPrivateCar.getPayMoney(), orderMoney) : orderMoney);
			orderPrivateCar.setPayTime(new Date());
			if (isPrepaySpreadStage) {
				orderPrivateCar.setPrepayStage(5);
				orderPrivateCar.setPrepaySecondPayNo(buildBalancePayNo(1, orderId));
			}

			if (!isPrepaySpreadStage) {
				consumePrivateCarBenefits(orderPrivateCar);
			}
			//非追缴单才需要添加收入
			if(0 == orderPrivateCar.getRecoveryOrder()){
				//添加收入
				Double orderMoney1 = (2 == orderPrivateCar.getAbnormal() && 2 == orderPrivateCar.getAbnormalStatus() ? orderPrivateCar.getResponsibilityMoney().doubleValue() : orderPrivateCar.getOrderMoney());
				Map<String, Object> map = incomeService.saveIncome(orderPrivateCar.getId(), 1, orderMoney1);
				orderPrivateCar.setSplitAllocation(JSON.toJSONString(map));
			}
			
			// TODO: 2020/5/24 这里需要给司机和用户推送订单状态
			new Thread(new Runnable() {
				@Override
				public void run() {
					pushUtil.pushOrderState(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
					pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
				}
			}).start();
			
			systemNoticeService.addSystemNotice(1, "您已使用余额成功完成出行订单支付，谢谢使用！", uid, 1);
			
			new Thread(new Runnable() {
				@Override
				public void run() {
					if (pushMinistryOfTransport) {//上传数据
						pushMinistryOfTransportUtil.operatePay(orderId);
					}
				}
			}).start();
		}
		
		this.updateAllColumnById(orderPrivateCar);
		return resultUtil;
	}
	
	@Override
	@Transactional(propagation = Propagation.REQUIRES_NEW)
	public ResultUtil payPrivateCarOrder1(Integer payType, Integer orderId, Integer objectId, Integer objectType, Integer type, String path, String ip) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		if (orderPrivateCar.getState() == 8 || orderPrivateCar.getState() == 9) {
			return ResultUtil.error("订单已完成支付，不允许重复支付", new ArrayList<>());
		}
		if (orderPrivateCar.getState() != 7) {
			return ResultUtil.error("订单不在待支付状态，不允许支付", new ArrayList<>());
		}
		if (Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode()) && Integer.valueOf(4).equals(orderPrivateCar.getPrepayStage())) {
			return ResultUtil.error("订单退款处理中，请等待退款完成", new ArrayList<>());
		}

		Integer uid = orderPrivateCar.getUserId();
		Double orderMoney = (2 == orderPrivateCar.getAbnormal() && 2 == orderPrivateCar.getAbnormalStatus() ? orderPrivateCar.getResponsibilityMoney().doubleValue() : orderPrivateCar.getOrderMoney());
		UserInfo userInfo = userInfoService.selectById(uid);
		ResultUtil resultUtil = ResultUtil.success(new Object());
		orderPrivateCar.setCouponMoney(0D);//初始化历史数据
		orderPrivateCar.setCouponId(null);
		System.out.println("!!!" + orderMoney + "!!!!");
		//计算优惠券
		UserCouponRecord userCouponRecord = null;
		if (null != objectId && objectType == 1) {
			userCouponRecord = userCouponRecordService.selectById(objectId);
			if (userCouponRecord.getCompanyId().compareTo(orderPrivateCar.getCompanyId()) != 0) {
				return ResultUtil.error("优惠券不能用于此订单", new ArrayList<>());
			}
			if (userCouponRecord.getState() == 2) {
				return ResultUtil.error("优惠券已使用", new ArrayList<>());
			}
			if (userCouponRecord.getState() == 3) {
				return ResultUtil.error("优惠券已过期", new ArrayList<>());
			}
			if (userCouponRecord.getCouponUseType() != 0 && userCouponRecord.getCouponUseType() != 1) {
				return ResultUtil.error("优惠券不能用于此类型订单", new ArrayList<>());
			}
			if (userCouponRecord.getCouponType() == 2 && orderMoney.compareTo(userCouponRecord.getFullMoney()) < 0) {
				return ResultUtil.error("优惠券不能用于此订单", new ArrayList<>());
			}
			orderMoney = orderMoney - userCouponRecord.getMoney();
			orderPrivateCar.setCouponMoney(userCouponRecord.getMoney());
			orderPrivateCar.setCouponId(objectId);
			System.out.println("!!!" + orderMoney + "!!!!");
		}
		
		//打车卡
		UserTaxiCard userTaxiCard = null;
		if (null != objectId && objectType == 2) {
			userTaxiCard = userTaxiCardService.selectById(objectId);
			TaxiCard taxiCard = taxiCardService.selectById(userTaxiCard.getTaxiCardId());
			if (taxiCard.getTaxiCardType() == 1 && userTaxiCard.getCompanyId() != orderPrivateCar.getCompanyId()) {
				return ResultUtil.error("打车卡不能用于此订单", new ArrayList<>());
			}
			if (System.currentTimeMillis() > userTaxiCard.getEndTime().getTime()) {
				return ResultUtil.error("打车卡已过期", new ArrayList<>());
			}
			if (userTaxiCard.getType() == 1 || userTaxiCard.getType() == 3) {
				Integer time = JSON.parseObject(userTaxiCard.getContent()).getInteger("time");
				if (0 == time) {
					return ResultUtil.error("打车卡已使用完", new ArrayList<>());
				}
			}
			List<Integer> integers = JSON.parseObject(userTaxiCard.getContent()).getJSONArray("businessTypes").toJavaList(Integer.class);
			if (!integers.contains(1)) {
				return ResultUtil.error("打车卡不能用于此类型订单", new ArrayList<>());
			}
			
			Double yh = 0D;
			JSONObject jsonObject = JSON.parseObject(userTaxiCard.getContent());
			if (userTaxiCard.getType() == 1) {//打折次数卡{"businessTypes":[1,2,3],"time":5,"timeQuantum":["08:00:00 - 09:00:00","17:00:00 - 18:00:00"],"discount":5}
				JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
				Double discount = jsonObject.getDouble("discount");
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				Date date = new Date();
				for (int i = 0; i < timeQuantum.size(); i++) {
					String[] split = timeQuantum.getString(i).split(" - ");
					Date s = sdf1.parse(sdf.format(date) + " " + split[0]);
					Date e = sdf1.parse(sdf.format(date) + " " + split[1]);
					if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
						yh = new BigDecimal(orderPrivateCar.getOrderMoney()).multiply(new BigDecimal((10 - discount) / 10)).setScale(2, RoundingMode.HALF_EVEN).doubleValue();
						jsonObject.put("time", jsonObject.getInteger("time") - 1);
						userTaxiCard.setContent(jsonObject.toJSONString());
						break;
					}
				}
				
			}
			if (userTaxiCard.getType() == 2) {//优惠卡{"businessTypes":[1,2,3],"fullReduction":[[50,3],[100,5],[150,10]]}
				JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
				JSONArray fullReduction = jsonObject.getJSONArray("fullReduction");
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				Date date = new Date();
				for (int i = 0; i < timeQuantum.size(); i++) {
					String[] split = timeQuantum.getString(i).split(" - ");
					Date s = sdf1.parse(sdf.format(date) + " " + split[0]);
					Date e = sdf1.parse(sdf.format(date) + " " + split[1]);
					if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
						for (int j = fullReduction.size() - 1; j >= 0; j--) {
							JSONArray jsonArray = fullReduction.getJSONArray(j);
							Double p = jsonArray.getDouble(0);//满金额
							if (orderPrivateCar.getOrderMoney().compareTo(p) >= 0) {
								yh = jsonArray.getDouble(1);//优惠金额
								break;
							}
						}
					}
				}
				
			}
			if (userTaxiCard.getType() == 3) {//次数卡{"businessTypes":[1,2,3],"time":1,"discountAmount":10}
				JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				Date date = new Date();
				for (int i = 0; i < timeQuantum.size(); i++) {
					String[] split = timeQuantum.getString(i).split(" - ");
					Date s = sdf1.parse(sdf.format(date) + " " + split[0]);
					Date e = sdf1.parse(sdf.format(date) + " " + split[1]);
					if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
						yh = jsonObject.getDouble("discountAmount");
						jsonObject.put("time", jsonObject.getInteger("time") - 1);
						userTaxiCard.setContent(jsonObject.toJSONString());
					}
				}
				
			}
			if (userTaxiCard.getType() == 4) {//打折天数卡{"businessTypes":[1,2,3],"discount":5,"timeQuantum":["08:00:00 - 09:00:00","17:00:00 - 18:00:00"]}
				Double discount = jsonObject.getDouble("discount");//折扣
				JSONArray timeQuantum = jsonObject.getJSONArray("timeQuantum");//使用时间段
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
				SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				Date date = new Date();
				for (int i = 0; i < timeQuantum.size(); i++) {
					String[] split = timeQuantum.getString(i).split(" - ");
					Date s = sdf1.parse(sdf.format(date) + " " + split[0]);
					Date e = sdf1.parse(sdf.format(date) + " " + split[1]);
					if (s.getTime() <= System.currentTimeMillis() && System.currentTimeMillis() < e.getTime()) {
						yh = new BigDecimal(orderPrivateCar.getOrderMoney()).multiply(new BigDecimal((10 - discount) / 10)).setScale(2, RoundingMode.HALF_EVEN).doubleValue();
						break;
					}
				}
			}
			
			orderMoney = orderMoney - yh;
			orderPrivateCar.setTaxiCardId(userTaxiCard.getTaxiCardId());
			orderPrivateCar.setUserTaxiCardId(objectId);
			orderPrivateCar.setDiscountAmount(yh);
		}
		
		System.out.println("!!!" + orderMoney + "!!!!");
		
		//计算红包
		UserRedPacketRecord query = userRedPacketRecordService.query(uid, orderPrivateCar.getCompanyId(), 1, 1, orderMoney);
		if (null != query && query.getMoney().compareTo(orderMoney) < 0) {
			orderMoney = orderMoney - query.getMoney();
			orderPrivateCar.setRedPacketMoney(query.getMoney());
			orderPrivateCar.setRedPacketId(query.getId());
		}
		
		System.out.println("!!!" + orderMoney + "!!!!");
		//计算折扣
		UserActivityDiscount1 query2 = userActivityDiscount1Mapper.query(orderPrivateCar.getCompanyId());
		if (null != query2) {
			Double special = query2.getSpecial();
			orderPrivateCar.setDiscount(special);
			double v = new BigDecimal(orderMoney).multiply(new BigDecimal(special / 10)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue();
			if (orderMoney.compareTo(v) > 0) {
				orderPrivateCar.setDiscountMoney(orderMoney - v);
				orderPrivateCar.setActivityId(query2.getId());
				orderMoney = v;
			}
		}
		orderMoney = new BigDecimal(orderMoney).setScale(2, RoundingMode.HALF_UP).doubleValue();
		System.out.println("!!!" + orderMoney + "!!!!");
		orderMoney = orderMoney < 0 ? 0 : orderMoney;
		ResultUtil prepaySettleResult = settlePrivateCarPrepayIfNoSecondPay(orderPrivateCar, userInfo, orderMoney);
		if (prepaySettleResult != null) {
			return prepaySettleResult;
		}
		orderMoney = getPrivateCarPrepayFinalPayAmount(orderPrivateCar, orderMoney);
		if (!isPrivateCarPrepaySpreadStage(orderPrivateCar)) {
			orderPrivateCar.setPayMoney(orderMoney);
		}
		if (payType == 1) {//微信支付
			if (orderMoney == 0) {
				return ResultUtil.error("请使用余额支付");
			}
			String outTradeNo = orderId + "_1_" + UUIDUtil.getRandomCode(5);
			JSONObject response = cbyzxOrderPayHelper.createOrder(orderPrivateCar.getUserId(), userInfo.getAppletsOpenId(), outTradeNo, orderMoney);
			if (!cbyzxOrderPayHelper.isCreateSuccess(response)) {
				return ResultUtil.error(cbyzxOrderPayHelper.extractMessage(response), response);
			}
			String paymentCode = ToolUtil.isNotEmpty(cbyzxOrderPayHelper.extractRecordCode(response)) ? cbyzxOrderPayHelper.extractRecordCode(response) : outTradeNo;
			resultUtil = ResultUtil.success(response);
			paymentRecordService.saveData(1, orderPrivateCar.getUserId(), 1, orderId, 1, 1, orderMoney, paymentCode, 1);//添加预支付数据

			//创建定时任务查询订单支付状态
			ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
			threadPoolExecutor.execute(()->{
				try {
					int num = 1;
					int wait = 0;
					while (num <= 13) {
						int min = 5000;
						wait += (min * num);
						OrderPrivateCar orderPrivateCar1 = this.selectById(orderPrivateCar.getId());
						if (orderPrivateCar1.getState() != 7) {
							break;
						}
						Thread.sleep(wait);
						num++;
					}
				} catch (Exception e) {
					e.printStackTrace();
				}finally {
					threadPoolExecutor.shutdown();
				}
				
			});
			
		}
		if (payType == 2) {//支付宝支付
			if (orderMoney == 0) {
				return ResultUtil.error("请使用余额支付");
			}
			String outTradeNo = orderId + "_1_" + UUIDUtil.getRandomCode(5);
			resultUtil = payMoneyUtil.alipay("完成订单", "完成订单", "", outTradeNo, orderMoney.toString(), "/base/aliPayOrderTaxi");
			paymentRecordService.saveData(1, orderPrivateCar.getUserId(), 1, orderId, 1, 2, orderMoney, outTradeNo, 1);//添加预支付数据
		}
		if (payType == 3) {//余额支付
			if (userInfo.getBalance() == null || userInfo.getBalance() < orderMoney) {
				return ResultUtil.error("余额不足，无法完成支付");
			}

			userInfo.setBalance(new BigDecimal(userInfo.getBalance()).subtract(new BigDecimal(orderMoney)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());

			boolean isPrepayFirstStage = isPrivateCarPrepayFirstStage(orderPrivateCar);
			boolean isPrepaySpreadStage = isPrivateCarPrepaySpreadStage(orderPrivateCar);
			if (isPrepayFirstStage) {
				handlePrivateCarPrepayFirstPaid(orderPrivateCar, userInfo, orderMoney, 3);
				return resultUtil;
			}

			OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
			SysIntegral query1 = sysIntegralMapper.query(openCity.getId());
			if (null != query1) {
				userInfo.setIntegral(userInfo.getIntegral() + (orderMoney.intValue() * query1.getIntegral()));//积分
			}
			
			//添加交易明细
			transactionDetailsService.saveData(uid, "快车订单", orderMoney, 2, 1, 1, 1, orderId);
			userInfoService.updateById(userInfo);
			
			orderPrivateCar.setState(8);
			orderPrivateCar.setPayType(3);
			orderPrivateCar.setPayMoney(isPrepaySpreadStage ? appendPayMoney(orderPrivateCar.getPayMoney(), orderMoney) : orderMoney);
			orderPrivateCar.setPayTime(new Date());
			if (isPrepaySpreadStage) {
				orderPrivateCar.setPrepayStage(5);
				orderPrivateCar.setPrepaySecondPayNo(buildBalancePayNo(1, orderId));
			}

			if (!isPrepaySpreadStage) {
				consumePrivateCarBenefits(orderPrivateCar);
			}
			//非追缴单才添加收入记录
			if(0 == orderPrivateCar.getRecoveryOrder()){
				//添加收入
				Double orderMoney1 = (2 == orderPrivateCar.getAbnormal() && 2 == orderPrivateCar.getAbnormalStatus() ? orderPrivateCar.getResponsibilityMoney().doubleValue() : orderPrivateCar.getOrderMoney());
				Map<String, Object> map = incomeService.saveIncome(orderPrivateCar.getId(), 1, orderMoney1);
				orderPrivateCar.setSplitAllocation(JSON.toJSONString(map));
			}

			//待审核的异常单修改状态为已关闭
			if(2 == orderPrivateCar.getAbnormal() && 1 == orderPrivateCar.getAbnormalStatus()){
				orderPrivateCar.setAbnormalStatus(3);
				orderPrivateCar.setResponsibilityMoney(new BigDecimal(orderPrivateCar.getOrderMoney()));
				orderPrivateCar.setResponsibilityType(3);
				orderPrivateCar.setAbnormalRemark("乘客已支付订单，申诉已自动关闭");
			}
			this.updateAllColumnById(orderPrivateCar);
			promotion(orderPrivateCar.getId());


			// TODO: 2020/5/24 这里需要给司机和用户推送订单状态
			new Thread(new Runnable() {
				@Override
				public void run() {
					pushUtil.pushOrderState(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
					pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
				}
			}).start();
			
			systemNoticeService.addSystemNotice(1, "您已使用余额成功完成出行订单支付，谢谢使用！", uid, 1);
			
			new Thread(new Runnable() {
				@Override
				public void run() {
					if (pushMinistryOfTransport) {//上传数据
						pushMinistryOfTransportUtil.operatePay(orderId);
					}
				}
			}).start();
		} else if (payType == 4) {
			if (orderMoney == 0) {
				return ResultUtil.error("请使用余额支付");
			}
			orderPrivateCar.setPayTime(new Date());
			Integer integer = paymentRecordService.saveData(1, orderPrivateCar.getUserId(), 1, orderId, 1, 4, orderMoney, "", 1);
			resultUtil = appOrderController.placeAnOrder(new BigDecimal(orderMoney), 4, orderId, 6, integer);
			
		}

		if(payType != 3){
			this.updateAllColumnById(orderPrivateCar);
		}


		return resultUtil;
	}
	
	@Override
	public synchronized ResultUtil<BaseWarpper> queryRedMoney(Integer orderId) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		Integer companyId = orderPrivateCar.getCompanyId();
		
		Map<String, Object> query = userActivityRedenvelopeService.query(companyId, orderPrivateCar.getTravelTime());
		Double money = 0D;
		BaseWarpper baseWarpper = new BaseWarpper();
		if (null != query) {
			Integer type = Integer.valueOf(String.valueOf(query.get("type")));
			if (type == 1) {//固定金额
				money = Double.valueOf(String.valueOf(query.get("money")));
			} else {//随机金额
				Double startMoney = Double.valueOf(String.valueOf(query.get("startMoney")));
				Double endMoney = Double.valueOf(String.valueOf(query.get("endMoney")));
				int i = new BigDecimal(endMoney).subtract(new BigDecimal(startMoney)).intValue();
				Random random = new Random();
				int num = random.nextInt(i);
				money = new BigDecimal(startMoney).add(new BigDecimal(num)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue();
			}
			//判断当前红包是否大于剩余可领取总金额
			if (money.compareTo(Double.valueOf(query.get("lavePrice").toString())) > 0) {
				baseWarpper.setAmount(0D);
				return ResultUtil.success(baseWarpper);
			}
		}
		baseWarpper.setAmount(money);
		
		if (money > 0) {
			//添加临时红包数据
			UserRedPacketRecord userRedPacketRecord = new UserRedPacketRecord();
			userRedPacketRecord.setMoney(money);
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(new Date());
			calendar.set(Calendar.DAY_OF_MONTH, calendar.get(Calendar.DAY_OF_MONTH) + Integer.valueOf(String.valueOf(query.get("effective"))));
			userRedPacketRecord.setExpirationTime(calendar.getTime());
			userRedPacketRecord.setInsertTime(new Date());
			userRedPacketRecord.setCompanyId(Integer.valueOf(String.valueOf(query.get("companyId"))));
			userRedPacketRecord.setState(0);
			userRedPacketRecord.setOrderId(orderPrivateCar.getId());
			userRedPacketRecord.setOrderType(1);
			userRedPacketRecord.setUserId(orderPrivateCar.getUserId());
			userRedPacketRecordService.insert(userRedPacketRecord);
		}
		
		// 获取平台电子账簿   当前用户电子账簿
		appOrderController.moneyPay(orderPrivateCar.getId(), orderPrivateCar.getUserId(), money);
		
		return ResultUtil.success(baseWarpper);
	}
	
	@Override
	public synchronized ResultUtil shareRedEnvelope(Integer orderId) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		UserRedPacketRecord query = userRedPacketRecordService.query_(orderPrivateCar.getUserId(), orderPrivateCar.getCompanyId(), 0, 1, null);
		if (null != query) {
			Double money = query.getMoney();
			Map<String, Object> map = userActivityRedenvelopeService.query(orderPrivateCar.getCompanyId(), orderPrivateCar.getTravelTime());
			Double laveMoney = Double.valueOf(String.valueOf(map.get("laveMoney")));
			if (money.compareTo(laveMoney) > 0) {
				return ResultUtil.error("手速太慢了，红包已派发完啦！");
			}
			//判断当前红包是否大于剩余可领取总金额
			if (money.compareTo(Double.valueOf(map.get("lavePrice").toString())) > 0) {
				return ResultUtil.error("手速太慢了，红包已派发完啦！");
			}
			double v = new BigDecimal(laveMoney).subtract(new BigDecimal(money)).doubleValue();
			
			UserActivityRedenvelope id = userActivityRedenvelopeService.selectById(String.valueOf(map.get("id")));
			id.setLaveMoney(v);
			id.setLavePrice(new BigDecimal(id.getLavePrice() - money).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
			userActivityRedenvelopeService.updateById(id);
			
			query.setState(1);
			query.setRedPacketActivityId(id.getId());
			userRedPacketRecordService.updateById(query);
		}
		return ResultUtil.success();
	}
	
	/**
	 * 取消订单支付后的处理
	 *
	 * @param id       订单=id
	 * @param order_id 工行支付单号
	 * @param type     1=微信，2=支付宝
	 * @throws Exception
	 */
	@Override
	public void payCancelOrderPrivateCar(Integer id, String order_id, Integer type) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(id);
		PaymentRecord query = paymentRecordService.query(1, orderPrivateCar.getUserId(), 1, Integer.valueOf(id), 1, type, 1);
		if (null != query) {
			//添加交易明细
			transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车取消订单", query.getAmount(), 2, 1, 1, 1, query.getOrderId());
			orderPrivateCar.setState(10);
			//解除小号绑定
			if (orderPrivateCar.getBindId() != null) {
				chinaMobileUtil.midAxbUnBindSend(orderPrivateCar.getBindId(), orderPrivateCar.getTelX(), (System.currentTimeMillis() + 600000));
			}
			orderPrivateCar.setBindId("");
			orderPrivateCar.setTelX("");
			this.updateById(orderPrivateCar);
			
			query.setState(2);
			query.setCode(order_id);
			paymentRecordService.updateById(query);
			
			OrderCancel query1 = orderCancelService.query(query.getOrderId(), query.getOrderType(), query.getAmount(), query.getPayType(), 1);
			if (null != query1) {
				query1.setState(2);
				orderCancelService.updateById(query1);
			}
			
			//添加已收入明细
			incomeService.saveData(1, orderPrivateCar.getCompanyId(), 3, orderPrivateCar.getId(), 1, query.getAmount());
			
			this.deleteTask(orderPrivateCar.getId());//删除定时任务
			
			// TODO: 2020/5/24 这里需要给司机和用户推送订单状态
//            new Thread(new Runnable() {
//                @Override
//                public void run() {
//                    pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
//                }
//            }).start();
			
			//添加消息
			systemNoticeService.addSystemNotice(1, "您已使用" + (type == 1 ? "微信" : (type == 2 ? "支付宝" : "云闪付")) + "成功支付取消订单费用，谢谢使用！", orderPrivateCar.getUserId(), 1);
		} else {
			System.err.println("预支付数据异常（orderId = " + id + ")");
		}
	}

	private boolean isPrivateCarPrepayFirstStage(OrderPrivateCar orderPrivateCar) {
		return orderPrivateCar != null
				&& Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode())
				&& Integer.valueOf(1).equals(orderPrivateCar.getPrepayStage());
	}

	private boolean isPrivateCarPrepaySpreadStage(OrderPrivateCar orderPrivateCar) {
		return orderPrivateCar != null
				&& Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode())
				&& Integer.valueOf(3).equals(orderPrivateCar.getPrepayStage());
	}

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

	private Double appendPayMoney(Double source, Double amount) {
		return new BigDecimal(source == null ? 0D : source)
				.add(new BigDecimal(amount == null ? 0D : amount))
				.setScale(2, BigDecimal.ROUND_HALF_EVEN)
				.doubleValue();
	}

	private boolean isPrivateCarPrepayFinalStage(OrderPrivateCar orderPrivateCar) {
		return orderPrivateCar != null
				&& Integer.valueOf(7).equals(orderPrivateCar.getState());
	}

	private BigDecimal toMoney(Double amount) {
		return new BigDecimal(String.valueOf(amount == null ? 0D : amount)).setScale(2, RoundingMode.HALF_UP);
	}

	private PaymentRecord getPrivateCarPrepayPaidRecord(OrderPrivateCar orderPrivateCar) throws Exception {
		PaymentRecord paymentRecord = paymentRecordService.query(1, orderPrivateCar.getUserId(), 1, orderPrivateCar.getId(), 1, orderPrivateCar.getPayType(), 2);
		if (paymentRecord == null) {
			paymentRecord = paymentRecordService.query(1, orderPrivateCar.getUserId(), 1, orderPrivateCar.getId(), 1, null, 2);
		}
		if (paymentRecord == null) {
			paymentRecord = paymentRecordService.query(1, null, null, orderPrivateCar.getId(), 1, null, 2);
		}
		if (paymentRecord != null && orderPrivateCar.getPayType() == null) {
			orderPrivateCar.setPayType(paymentRecord.getPayType());
		}
		return paymentRecord;
	}

	private BigDecimal getPrivateCarPrepayPaidAmount(OrderPrivateCar orderPrivateCar) throws Exception {
		PaymentRecord paymentRecord = getPrivateCarPrepayPaidRecord(orderPrivateCar);
		if (paymentRecord != null && paymentRecord.getAmount() != null && paymentRecord.getAmount() > 0) {
			return toMoney(paymentRecord.getAmount());
		}
		if ((Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode()) || (orderPrivateCar.getPrepayStage() != null && orderPrivateCar.getPrepayStage() > 0))
				&& orderPrivateCar.getPayMoney() != null && orderPrivateCar.getPayMoney() > 0) {
			return toMoney(orderPrivateCar.getPayMoney());
		}
		return BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);
	}

	private Double getPrivateCarPrepayFinalPayAmount(OrderPrivateCar orderPrivateCar, Double finalAmount) throws Exception {
		if (!isPrivateCarPrepayFinalStage(orderPrivateCar)) {
			return toMoney(finalAmount).doubleValue();
		}
		BigDecimal paidAmount = getPrivateCarPrepayPaidAmount(orderPrivateCar);
		if (paidAmount.compareTo(BigDecimal.ZERO) <= 0) {
			return toMoney(finalAmount).doubleValue();
		}
		BigDecimal spreadAmount = toMoney(finalAmount).subtract(paidAmount).setScale(2, RoundingMode.HALF_UP);
		if (spreadAmount.compareTo(BigDecimal.ZERO) > 0) {
			orderPrivateCar.setPrepayStage(3);
			return spreadAmount.doubleValue();
		}
		return 0D;
	}

	private Double getPrivateCarPrepayDisplayPayAmount(OrderPrivateCar orderPrivateCar, Double finalAmount) {
		if (!isPrivateCarPrepayFinalStage(orderPrivateCar)) {
			return toMoney(finalAmount).doubleValue();
		}
		try {
			BigDecimal paidAmount = getPrivateCarPrepayPaidAmount(orderPrivateCar);
			if (paidAmount.compareTo(BigDecimal.ZERO) <= 0) {
				return toMoney(finalAmount).doubleValue();
			}
			BigDecimal displayAmount = toMoney(finalAmount).subtract(paidAmount).setScale(2, RoundingMode.HALF_UP);
			return displayAmount.compareTo(BigDecimal.ZERO) > 0 ? displayAmount.doubleValue() : 0D;
		} catch (Exception e) {
			e.printStackTrace();
			return toMoney(finalAmount).doubleValue();
		}
	}

	private void fillPrivateCarPrepayDisplayMoney(OrderPrivateCar orderPrivateCar, Map<String, Object> map) {
		if (map == null || orderPrivateCar == null || !isPrivateCarPrepayFinalStage(orderPrivateCar)) {
			return;
		}
		Double finalAmount = null != map.get("orderMoney") ? Double.valueOf(String.valueOf(map.get("orderMoney"))) : orderPrivateCar.getOrderMoney();
		Double displayAmount = getPrivateCarPrepayDisplayPayAmount(orderPrivateCar, finalAmount);
		map.put("orderMoney", displayAmount);
		map.put("payMoney", displayAmount);
	}

	private ResultUtil settlePrivateCarPrepayIfNoSecondPay(OrderPrivateCar orderPrivateCar, UserInfo userInfo, Double finalAmount) throws Exception {
		if (!isPrivateCarPrepayFinalStage(orderPrivateCar)) {
			return null;
		}
		BigDecimal paidAmount = getPrivateCarPrepayPaidAmount(orderPrivateCar);
		if (paidAmount.compareTo(BigDecimal.ZERO) <= 0) {
			return null;
		}
		BigDecimal settleAmount = toMoney(finalAmount);
		BigDecimal refundAmount = paidAmount.subtract(settleAmount).setScale(2, RoundingMode.HALF_UP);
		if (refundAmount.compareTo(BigDecimal.ZERO) < 0) {
			return null;
		}
		if (refundAmount.compareTo(BigDecimal.ZERO) > 0) {
			ResultUtil refundResult = refundPrivateCarPrepayDifference(orderPrivateCar, userInfo, refundAmount.doubleValue());
			if (!ResultUtil.SUCCESS.equals(refundResult.getCode())) {
				return refundResult;
			}
		}
		finishPrivateCarPrepayOrder(orderPrivateCar, settleAmount.doubleValue());
		return ResultUtil.success();
	}

	private ResultUtil refundPrivateCarPrepayDifference(OrderPrivateCar orderPrivateCar, UserInfo userInfo, Double refundAmount) throws Exception {
		if (Integer.valueOf(3).equals(orderPrivateCar.getPayType())) {
			userInfo.setBalance(new BigDecimal(null != userInfo.getBalance() ? userInfo.getBalance() : 0D)
					.add(toMoney(refundAmount)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
			userInfoService.updateById(userInfo);
			orderPrivateCar.setPrepayRefundNo("BALANCE_REFUND_1_" + orderPrivateCar.getId() + "_" + ToolUtil.getRandomString(5));
			orderPrivateCar.setPrepayRefundAmount(refundAmount);
			orderPrivateCar.setPrepayRefundTime(new Date());
			transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车先付订单退款", refundAmount, 1, 1, 1, 1, orderPrivateCar.getId());
			return ResultUtil.success();
		}

		PaymentRecord paymentRecord = getPrivateCarPrepayPaidRecord(orderPrivateCar);
		if (paymentRecord == null) {
			return ResultUtil.error("先付订单缺少已支付流水，无法退款");
		}
		if (Integer.valueOf(1).equals(orderPrivateCar.getPayType())) {
			CbyzxPayUtil.ClosePayOrderRequest request = new CbyzxPayUtil.ClosePayOrderRequest();
			request.setOutRequestNo(ToolUtil.isNotEmpty(orderPrivateCar.getPrepaySecondPayNo()) ? orderPrivateCar.getPrepaySecondPayNo() : paymentRecord.getCode());
			request.setRefundOutRequestNo("PREPAY_DIFF_REFUND_1_" + orderPrivateCar.getId() + ToolUtil.getRandomString(5));
			request.setRefundAmount(toFen(refundAmount));
			request.setRefundDesc("快车先付订单多退少补退款");
			JSONObject response = CbyzxPayUtil.closePayOrder(request);
			if (!isPrivateCarPrepayRefundSuccess(response)) {
				return ResultUtil.error(extractPrivateCarRefundMessage(response), response);
			}
			orderPrivateCar.setPrepayRefundNo(extractPrivateCarRefundNo(response));
			orderPrivateCar.setPrepayRefundAmount(refundAmount);
			orderPrivateCar.setPrepayRefundTime(new Date());
			transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车先付订单退款", refundAmount, 1, 1, 1, 1, orderPrivateCar.getId());
			return ResultUtil.success(response);
		}
		if (Integer.valueOf(2).equals(orderPrivateCar.getPayType())) {
			Map<String, String> map = payMoneyUtil.aliRefund(paymentRecord.getCode(), refundAmount.toString());
			if (!"10000".equals(map.get("code"))) {
				return ResultUtil.error(map.get("msg"));
			}
			orderPrivateCar.setPrepayRefundNo(map.get("trade_no"));
			orderPrivateCar.setPrepayRefundAmount(refundAmount);
			orderPrivateCar.setPrepayRefundTime(new Date());
			transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车先付订单退款", refundAmount, 1, 1, 1, 1, orderPrivateCar.getId());
			return ResultUtil.success(map);
		}
		return ResultUtil.error("先付订单支付方式不支持退款");
	}

	private void finishPrivateCarPrepayOrder(OrderPrivateCar orderPrivateCar, Double settleAmount) throws Exception {
		orderPrivateCar.setState(8);
		orderPrivateCar.setPayMoney(settleAmount);
		orderPrivateCar.setPayTime(new Date());
		orderPrivateCar.setPrepayStage(5);
		if (orderPrivateCar.getRecoveryOrder() != null && 0 == orderPrivateCar.getRecoveryOrder()) {
			Double incomeAmount = (2 == orderPrivateCar.getAbnormal() && 2 == orderPrivateCar.getAbnormalStatus()
					? orderPrivateCar.getResponsibilityMoney().doubleValue() : orderPrivateCar.getOrderMoney());
			Map<String, Object> map = incomeService.saveIncome(orderPrivateCar.getId(), 1, incomeAmount);
			orderPrivateCar.setSplitAllocation(JSON.toJSONString(map));
		}
		this.updateAllColumnById(orderPrivateCar);
		promotion(orderPrivateCar.getId());
		new Thread(new Runnable() {
			@Override
			public void run() {
				pushUtil.pushOrderState(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
				pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
			}
		}).start();
		systemNoticeService.addSystemNotice(1, "您的快车先付订单已完成结算，请注意查收。", orderPrivateCar.getUserId(), 1);
	}

	private void consumePrivateCarBenefits(OrderPrivateCar orderPrivateCar) throws Exception {
		if (null != orderPrivateCar.getCouponId()) {
			UserCouponRecord userCouponRecord = userCouponRecordService.selectById(orderPrivateCar.getCouponId());
			if (userCouponRecord != null) {
				userCouponRecord.setState(2);
				userCouponRecord.setEndTime(new Date());
				userCouponRecordService.updateById(userCouponRecord);
			}
		}
		if (null != orderPrivateCar.getUserTaxiCardId()) {
			UserTaxiCard userTaxiCard = userTaxiCardService.selectById(orderPrivateCar.getUserTaxiCardId());
			if (userTaxiCard != null && (userTaxiCard.getType() == 1 || userTaxiCard.getType() == 3)) {
				JSONObject jsonObject = JSON.parseObject(userTaxiCard.getContent());
				jsonObject.put("time", jsonObject.getInteger("time") - 1);
				userTaxiCard.setContent(jsonObject.toJSONString());
				userTaxiCardService.updateById(userTaxiCard);
			}
		}
		if (null != orderPrivateCar.getRedPacketId()) {
			UserRedPacketRecord userRedPacketRecord = userRedPacketRecordService.selectById(orderPrivateCar.getRedPacketId());
			if (userRedPacketRecord != null) {
				userRedPacketRecord.setState(2);
				userRedPacketRecord.setEndTime(new Date());
				userRedPacketRecordService.updateById(userRedPacketRecord);
			}
		}
	}

	private void restorePrivateCarBenefits(OrderPrivateCar orderPrivateCar) throws Exception {
		if (null != orderPrivateCar.getCouponId()) {
			UserCouponRecord userCouponRecord = userCouponRecordService.selectById(orderPrivateCar.getCouponId());
			if (userCouponRecord != null) {
				userCouponRecord.setState(1);
				userCouponRecord.setEndTime(null);
				userCouponRecordService.updateById(userCouponRecord);
			}
		}
		if (null != orderPrivateCar.getUserTaxiCardId()) {
			UserTaxiCard userTaxiCard = userTaxiCardService.selectById(orderPrivateCar.getUserTaxiCardId());
			if (userTaxiCard != null && (userTaxiCard.getType() == 1 || userTaxiCard.getType() == 3)) {
				JSONObject jsonObject = JSON.parseObject(userTaxiCard.getContent());
				Integer time = jsonObject.getInteger("time");
				jsonObject.put("time", (time == null ? 0 : time) + 1);
				userTaxiCard.setContent(jsonObject.toJSONString());
				userTaxiCardService.updateById(userTaxiCard);
			}
		}
		if (null != orderPrivateCar.getRedPacketId()) {
			UserRedPacketRecord userRedPacketRecord = userRedPacketRecordService.selectById(orderPrivateCar.getRedPacketId());
			if (userRedPacketRecord != null) {
				userRedPacketRecord.setState(1);
				userRedPacketRecord.setEndTime(null);
				userRedPacketRecordService.updateById(userRedPacketRecord);
			}
		}
	}

	private boolean isPrivateCarPrepayRefundSuccess(JSONObject response) {
		if (response == null) {
			return false;
		}
		Object code = response.get("code");
		if (code == null || !"0".equals(String.valueOf(code))) {
			return false;
		}
		JSONObject data = response.getJSONObject("data");
		return data != null && Boolean.TRUE.equals(data.getBoolean("isSuccess"));
	}

	private String extractPrivateCarRefundNo(JSONObject response) {
		if (response == null) {
			return null;
		}
		JSONObject data = response.getJSONObject("data");
		if (data == null) {
			return null;
		}
		String refundNo = data.getString("merchantRefundSerialNo");
		if (ToolUtil.isNotEmpty(refundNo)) {
			return refundNo;
		}
		refundNo = data.getString("refundId");
		if (ToolUtil.isNotEmpty(refundNo)) {
			return refundNo;
		}
		return data.getString("gatewaySerialNo");
	}

	private String extractPrivateCarRefundMessage(JSONObject response) {
		if (response == null) {
			return "微信先付退款失败";
		}
		JSONObject data = response.getJSONObject("data");
		if (data != null && ToolUtil.isNotEmpty(data.getString("failReason"))) {
			return data.getString("failReason");
		}
		String msg = response.getString("msg");
		return ToolUtil.isNotEmpty(msg) ? msg : "微信先付退款失败";
	}

	private Integer toFen(Double amount) {
		return new BigDecimal(String.valueOf(amount)).multiply(new BigDecimal("100")).setScale(0, RoundingMode.HALF_UP).intValue();
	}

	private String buildPrepayRefundOutNo(Integer orderId) {
		return "PREPAY_REFUND_1_" + orderId+ToolUtil.getRandomString(5);
	}

	private boolean isPrivateCarPrepayMode(OrderPrivateCar orderPrivateCar) {
		return orderPrivateCar != null && Integer.valueOf(1).equals(orderPrivateCar.getPaymentMode());
	}

	private void handlePrivateCarPrepayCancelRefund(OrderPrivateCar orderPrivateCar, String reason) throws Exception {
		if (!isPrivateCarPrepayMode(orderPrivateCar)) {
			return;
		}
		if (Integer.valueOf(3).equals(orderPrivateCar.getPayType())) {
			Double refundAmount = orderPrivateCar.getPayMoney();
			if (refundAmount == null || refundAmount <= 0) {
				throw new RuntimeException("余额先付订单退款金额异常");
			}
			UserInfo userInfo = userInfoService.selectById(orderPrivateCar.getUserId());
			if (userInfo == null) {
				throw new RuntimeException("用户信息不存在，无法退款");
			}
			userInfo.setBalance(new BigDecimal(null != userInfo.getBalance() ? userInfo.getBalance() : 0)
					.add(new BigDecimal(refundAmount)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
			userInfoService.updateById(userInfo);
			restorePrivateCarBenefits(orderPrivateCar);
			transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车取消订单退款", refundAmount, 1, 1, 1, 1, orderPrivateCar.getId());
			orderPrivateCar.setState(10);
			orderPrivateCar.setPrepayStage(5);
			orderPrivateCar.setPrepayRefundNo("BALANCE_REFUND_1_" + orderPrivateCar.getId() + "_" + ToolUtil.getRandomString(5));
			orderPrivateCar.setPrepayRefundAmount(refundAmount);
			orderPrivateCar.setPrepayRefundTime(new Date());
			this.updateById(orderPrivateCar);
			systemNoticeService.addSystemNotice(1, "您的快车余额先付订单已取消，退款已退回账户余额，请注意查收。", orderPrivateCar.getUserId(), 1);
		} else if (Integer.valueOf(1).equals(orderPrivateCar.getPayType())){
			String outRequestNo = orderPrivateCar.getPrepaySecondPayNo();
			if (ToolUtil.isEmpty(outRequestNo)) {
				throw new RuntimeException("微信先付订单缺少支付单号，无法关闭支付单");
			}
			Double refundAmount = orderPrivateCar.getPayMoney();
			if (refundAmount == null || refundAmount <= 0) {
				throw new RuntimeException("微信先付订单退款金额异常");
			}
			CbyzxPayUtil.ClosePayOrderRequest request = new CbyzxPayUtil.ClosePayOrderRequest();
			request.setOutRequestNo(outRequestNo);
			request.setRefundOutRequestNo(buildPrepayRefundOutNo(orderPrivateCar.getId()));
			request.setRefundAmount(toFen(refundAmount));
			request.setRefundDesc(ToolUtil.isNotEmpty(reason) ? reason : "快车订单取消退款");
			JSONObject response = CbyzxPayUtil.closePayOrder(request);
			if (!isPrivateCarPrepayRefundSuccess(response)) {
				throw new RuntimeException(extractPrivateCarRefundMessage(response));
			}
			restorePrivateCarBenefits(orderPrivateCar);
			transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车取消订单退款", refundAmount, 1, 1, 1, 1, orderPrivateCar.getId());
			systemNoticeService.addSystemNotice(1, "您的快车微信先付订单已取消，退款已原路退回，请注意查收。", orderPrivateCar.getUserId(), 1);
		}
	}

	private ResultUtil handlePrivateCarPrepayCancelRefund(OrderPrivateCar orderPrivateCar, String reason, String remark, Integer uid) throws Exception {
		System.out.println("快车退款！！！！");
		if (!isPrivateCarPrepayMode(orderPrivateCar)) {
			return null;
		}
		if (Integer.valueOf(3).equals(orderPrivateCar.getPayType())) {
			Double refundAmount = orderPrivateCar.getPayMoney();
			System.out.println("快车余额退款金额！！！！"+ refundAmount);
			if (refundAmount == null || refundAmount <= 0) {
				return ResultUtil.error("余额先付订单退款金额异常");
			}
			UserInfo userInfo = userInfoService.selectById(orderPrivateCar.getUserId());
			if (userInfo == null) {
				return ResultUtil.error("用户信息不存在，无法退款");
			}
			userInfo.setBalance(new BigDecimal(null != userInfo.getBalance() ? userInfo.getBalance() : 0)
					.add(new BigDecimal(refundAmount)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
			userInfoService.updateById(userInfo);
			restorePrivateCarBenefits(orderPrivateCar);
			transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车取消订单退款", refundAmount, 1, 1, 1, 1, orderPrivateCar.getId());
			orderCancelService.saveData(orderPrivateCar.getId(), 1,
					ToolUtil.isNotEmpty(reason) ? reason : "无司机接单",
					ToolUtil.isNotEmpty(remark) ? remark : (ToolUtil.isNotEmpty(reason) ? reason : "无司机接单"),
					1, refundAmount, 2, 1, uid);
			orderPrivateCar.setState(10);
			orderPrivateCar.setPrepayStage(5);
			orderPrivateCar.setPrepayRefundNo("BALANCE_REFUND_1_" + orderPrivateCar.getId() + "_" + ToolUtil.getRandomString(5));
			orderPrivateCar.setPrepayRefundAmount(refundAmount);
			orderPrivateCar.setPrepayRefundTime(new Date());
			this.updateById(orderPrivateCar);
			if (orderPrivateCar.getDriverId() != null) {
				this.deleteTask(orderPrivateCar.getId());
				pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
				Driver driver = driverService.selectById(orderPrivateCar.getDriverId());
				if (driver != null) {
					driver.setState(2);
					driverService.updateById(driver);
				}
				if (orderPrivateCar.getBindId() != null) {
					chinaMobileUtil.midAxbUnBindSend(orderPrivateCar.getBindId(), orderPrivateCar.getTelX(), (System.currentTimeMillis() + 600000));
				}
			}
			System.out.println("余额退款通知940");
			systemNoticeService.addSystemNotice(1, "您的快车余额先付订单已取消，退款已退回账户余额，请注意查收。", orderPrivateCar.getUserId(), 1);
			return ResultUtil.success();
		}
		String outRequestNo = orderPrivateCar.getPrepaySecondPayNo();
		if (ToolUtil.isEmpty(outRequestNo)) {
			return ResultUtil.error("微信先付订单缺少支付单号，无法关闭支付单");
		}
		Double refundAmount = orderPrivateCar.getPayMoney();
		if (refundAmount == null || refundAmount <= 0) {
			return ResultUtil.error("微信先付订单退款金额异常");
		}
		CbyzxPayUtil.ClosePayOrderRequest request = new CbyzxPayUtil.ClosePayOrderRequest();
		request.setOutRequestNo(outRequestNo);
		request.setRefundOutRequestNo(buildPrepayRefundOutNo(orderPrivateCar.getId()));
		request.setRefundAmount(toFen(refundAmount));
		request.setRefundDesc(ToolUtil.isNotEmpty(reason) ? reason : "快车订单取消退款");
		JSONObject response = CbyzxPayUtil.closePayOrder(request);
		if (!isPrivateCarPrepayRefundSuccess(response)) {
			return ResultUtil.error(extractPrivateCarRefundMessage(response), response);
		}

		restorePrivateCarBenefits(orderPrivateCar);
		transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车取消订单退款", refundAmount, 1, 1, 1, 1, orderPrivateCar.getId());
		orderCancelService.saveData(orderPrivateCar.getId(), 1,
				ToolUtil.isNotEmpty(reason) ? reason : "无司机接单",
				ToolUtil.isNotEmpty(remark) ? remark : (ToolUtil.isNotEmpty(reason) ? reason : "无司机接单"),
				1, refundAmount, 2, 1, uid);
		orderPrivateCar.setState(10);
		orderPrivateCar.setPrepayStage(5);
		orderPrivateCar.setPrepayRefundNo(extractPrivateCarRefundNo(response));
		orderPrivateCar.setPrepayRefundAmount(refundAmount);
		orderPrivateCar.setPrepayRefundTime(new Date());
		this.updateById(orderPrivateCar);
		if (orderPrivateCar.getDriverId() != null) {
			this.deleteTask(orderPrivateCar.getId());
			pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
			Driver driver = driverService.selectById(orderPrivateCar.getDriverId());
			if (driver != null) {
				driver.setState(2);
				driverService.updateById(driver);
			}
			if (orderPrivateCar.getBindId() != null) {
				chinaMobileUtil.midAxbUnBindSend(orderPrivateCar.getBindId(), orderPrivateCar.getTelX(), (System.currentTimeMillis() + 86400000));
			}
		}
		systemNoticeService.addSystemNotice(1, "您的快车微信先付订单已取消，退款已原路退回，请注意查收。", orderPrivateCar.getUserId(), 1);
		return ResultUtil.success(response);
	}

	private void dispatchPrepayPrivateCarOrder(OrderPrivateCar orderPrivateCar) throws Exception {
		if (Integer.valueOf(3).equals(orderPrivateCar.getType()) && ToolUtil.isNotEmpty(orderPrivateCar.getServerCarModel())) {
			JSONArray jsonArray = JSON.parseArray(orderPrivateCar.getServerCarModel());
			for (int i = 0; i < jsonArray.size(); i++) {
				JSONObject jsonObject = jsonArray.getJSONObject(i);
				Integer serverCarModelId = jsonObject.getInteger("serverCarModelId");
				Integer rideType = jsonObject.getInteger("rideType");
				if (serverCarModelId != null && serverCarModelId == 0) {
					OrderTaxi orderTaxi = new OrderTaxi();
					orderTaxi.setId(orderPrivateCar.getId());
					orderTaxi.setState(1);
					orderTaxi.setUserId(orderPrivateCar.getUserId());
					orderTaxi.setStartLon(orderPrivateCar.getStartLon());
					orderTaxi.setStartLat(orderPrivateCar.getStartLat());
					orderTaxiService.pushOrder(orderTaxi, 3);
					continue;
				}
				OrderPrivateCar pushOrder = new OrderPrivateCar();
				BeanUtils.copyProperties(orderPrivateCar, pushOrder);
				pushOrder.setRideType(rideType);
				pushOrder.setServerCarModelId(serverCarModelId);
				this.pushOrder(pushOrder);
			}
			return;
		}
		if (Integer.valueOf(3).equals(orderPrivateCar.getRideType())) {
			this.pushOrderPrivateCar(orderPrivateCar.getId());
			return;
		}
		this.pushOrder(orderPrivateCar);
	}

	private void handlePrivateCarPrepayFirstPaid(OrderPrivateCar orderPrivateCar, UserInfo userInfo, Double payAmount, Integer payType) throws Exception {
		OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
		SysIntegral query1 = sysIntegralMapper.query(openCity.getId());
		System.out.println("快车预付回调-------057,"+query1);
		if (null != query1) {
			userInfo.setIntegral(userInfo.getIntegral() + (payAmount.intValue() * query1.getIntegral()));
		}
		userInfoService.updateById(userInfo);

		consumePrivateCarBenefits(orderPrivateCar);
		transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车订单", payAmount, 2, 1, 1, 1, orderPrivateCar.getId());

		orderPrivateCar.setState(1);
		orderPrivateCar.setPayType(payType);
		orderPrivateCar.setPayMoney(payAmount);
		orderPrivateCar.setPayTime(new Date());
		orderPrivateCar.setPrepayStage(2);
		this.updateAllColumnById(orderPrivateCar);

		pushUtil.pushOrderState(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
		systemNoticeService.addSystemNotice(1, "您的快车订单已支付成功，我们正在为您指派司机，请稍后！", orderPrivateCar.getUserId(), 1);
		dispatchPrepayPrivateCarOrder(orderPrivateCar);
	}
	
	@Override
	public void payOrderPrivateCarCallback(Integer id, String order_id, Integer type, String outTradeNo) throws Exception {
		OrderPrivateCar orderPrivateCar = this.selectById(id);
		PaymentRecord query = ToolUtil.isNotEmpty(outTradeNo) ? paymentRecordService.queryByCode(outTradeNo, 1) : null;
		if (query == null) {
			query = paymentRecordService.query(1, orderPrivateCar.getUserId(), 1, Integer.valueOf(id), 1, type, 1);
		}
		System.out.println("快车预付回调-------084,"+query);
		if (null != query && query.getState() == 1) {
			UserInfo userInfo = userInfoService.selectById(orderPrivateCar.getUserId());
			query.setState(2);
			query.setCode(order_id);
			paymentRecordService.updateById(query);
			System.out.println("快车预付回调-------090");
			if (isPrivateCarPrepayFirstStage(orderPrivateCar)) {
				orderPrivateCar.setPrepaySecondPayNo(outTradeNo);
				handlePrivateCarPrepayFirstPaid(orderPrivateCar, userInfo, query.getAmount(), type);
				return;
			}

			//添加交易明细
			transactionDetailsService.saveData(orderPrivateCar.getUserId(), "快车订单", query.getAmount(), 2, 1, 1, 1, query.getOrderId());
			orderPrivateCar.setState(8);
			orderPrivateCar.setPayType(type);
			boolean isPrepaySpreadStage = isPrivateCarPrepaySpreadStage(orderPrivateCar);
			orderPrivateCar.setPayMoney(isPrepaySpreadStage ? appendPayMoney(orderPrivateCar.getPayMoney(), query.getAmount()) : query.getAmount());
			orderPrivateCar.setPayTime(new Date());
			if (isPrepaySpreadStage) {
				orderPrivateCar.setPrepayStage(5);
				orderPrivateCar.setPrepaySecondPayNo(order_id);
			}

			OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
			SysIntegral query1 = sysIntegralMapper.query(openCity.getId());
			if(null != query1){
				userInfo.setIntegral(userInfo.getIntegral() + (query.getAmount().intValue() * query1.getIntegral()));//积分
				userInfoService.updateById(userInfo);
			}

			if (!isPrepaySpreadStage) {
				consumePrivateCarBenefits(orderPrivateCar);
			}

			//非追缴单才需要记录收入
			if(null != orderPrivateCar.getRecoveryOrder() && 0 == orderPrivateCar.getRecoveryOrder()){
				//添加收入
				Double orderMoney = (2 == orderPrivateCar.getAbnormal() && 2 == orderPrivateCar.getAbnormalStatus() ? orderPrivateCar.getResponsibilityMoney().doubleValue() : orderPrivateCar.getOrderMoney());
				Map<String, Object> map = incomeService.saveIncome(orderPrivateCar.getId(), 1, orderMoney);
				orderPrivateCar.setSplitAllocation(JSON.toJSONString(map));
			}
			//待审核的异常单修改状态为已关闭
			if(null != orderPrivateCar.getAbnormal() && 2 == orderPrivateCar.getAbnormal() &&
					null != orderPrivateCar.getAbnormalStatus() && 1 == orderPrivateCar.getAbnormalStatus()){
				orderPrivateCar.setAbnormalStatus(3);
				orderPrivateCar.setResponsibilityMoney(new BigDecimal(orderPrivateCar.getOrderMoney()));
				orderPrivateCar.setResponsibilityType(3);
				orderPrivateCar.setAbnormalRemark("乘客已支付订单，申诉已自动关闭");
			}
			this.updateById(orderPrivateCar);
			promotion(orderPrivateCar.getId());
			
			// TODO: 2020/5/24 这里需要给司机和用户推送订单状态
			new Thread(new Runnable() {
				@Override
				public void run() {
					pushUtil.pushOrderState(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
					pushUtil.pushOrderState(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), 0);
				}
			}).start();
			
			systemNoticeService.addSystemNotice(1, "您已使用" + (type == 1 ? "微信" : (type == 2 ? "支付宝" : "云闪付")) + "成功完成出行订单支付，谢谢使用！", orderPrivateCar.getUserId(), 1);
			
			new Thread(new Runnable() {
				@Override
				public void run() {
					if (pushMinistryOfTransport) {//上传数据
						pushMinistryOfTransportUtil.operatePay(orderPrivateCar.getId());
					}
				}
			}).start();
			
		} else {
			System.err.println("预支付数据异常（orderId = " + id + ")");
		}
	}
	
	@Override
	public List<OrderPrivateCar> queryOrder(Integer uid, Integer... state) throws Exception {
		return orderPrivateCarMapper.queryByState_(uid, state);
	}
	
	@Override
	public List<Map<String, Object>> queryMyOrderList(Integer uid, Integer pageNum, Integer size) throws Exception {
		pageNum = (pageNum - 1) * size;
		List<Map<String, Object>> maps = orderPrivateCarMapper.queryMyOrderList(uid, pageNum, size);
		for (Map<String, Object> map : maps) {
			if (Integer.valueOf(String.valueOf(map.get("state"))) == 11) {
				map.put("state", map.get("oldState"));
			}
		}
		return maps;
	}
	
	@Override
	public List<Map<String, Object>> queryInvoiceOrder(Integer type, Date startTime, Date endTime, Double startMoney, Double endMoney, Integer uid) throws Exception {
		startTime = dateUtil.getStartOrEndDate(startTime, "start");
		endTime = dateUtil.getStartOrEndDate(endTime, "end");
		return orderPrivateCarMapper.queryInvoiceOrder(type, startTime, endTime, startMoney, endMoney, uid);
	}
	
	
	@Override
	public List<Map<String, Object>> queryMyTravelRecord(Integer uid) throws Exception {
		return orderPrivateCarMapper.queryMyTravelRecord(uid);
	}
	

	
	/**
	 * 获取下单推送完后没有司机接单的提醒
	 *
	 * @return
	 * @throws Exception
	 */
	@Override
	public EndPushWarpper queryEndPush(Integer uid) throws Exception {
		List<OrderPrivateCar> list = orderPrivateCarMapper.queryByState(uid, null, null, 1);
		EndPushWarpper endPushWarpper = new EndPushWarpper();
		if (list.size() > 0) {
			OrderPrivateCar orderPrivateCar = list.get(0);
			if (!orderIds.contains(orderPrivateCar.getId())) {
				endPushWarpper.setOrderId(orderPrivateCar.getId());
				endPushWarpper.setOrderType(1);
				endPushWarpper.setState(1);
				OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
				List<PushOrder> querys = pushOrderService.querys(null, 2, openCity.getId());//获取需要推送的次数
				int time = 0;
				for (int i = 1; i <= querys.size() + 15; i++) {
					int finalI = i;
					PushOrder pushOrder = querys.stream().filter(s -> s.getType() == (finalI <= 3 ? finalI : 3)).findFirst().orElse(null);
					time += pushOrder.getPushTime() * 1000;
				}
				//当前时间减去推单总时间大于下单时间
				if ((System.currentTimeMillis() - time) > orderPrivateCar.getInsertTime().getTime()) {
					endPushWarpper.setState(2);
				}
			}
		}
		return endPushWarpper;
	}
	
	/**
	 * 获取红包使用记录
	 *
	 * @param uid
	 * @return
	 * @throws Exception
	 */
	@Override
	public List<Map<String, Object>> queryRedEnvelope(Integer uid) throws Exception {
		return orderPrivateCarMapper.queryRedEnvelope(uid);
	}
	
	@Override
	@Transactional(propagation = Propagation.REQUIRES_NEW)
	public ResultUtil payThankYouFee(Integer uid, Integer orderId, Double money, Integer payType, Integer type) throws Exception {
		UserInfo userInfo = userInfoService.selectById(uid);
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		ResultUtil resultUtil = ResultUtil.success();
		if (payType == 1) {//微信支付
			String outTradeNo = "THANK_" + orderId + "_1_" + UUIDUtil.getRandomCode(5);
			JSONObject response = cbyzxOrderPayHelper.createOrder(orderPrivateCar.getUserId(), userInfo.getAppletsOpenId(), outTradeNo, money);
			if (!cbyzxOrderPayHelper.isCreateSuccess(response)) {
				return ResultUtil.error(cbyzxOrderPayHelper.extractMessage(response), response);
			}
			String paymentCode = ToolUtil.isNotEmpty(cbyzxOrderPayHelper.extractRecordCode(response)) ? cbyzxOrderPayHelper.extractRecordCode(response) : outTradeNo;
			resultUtil = ResultUtil.success(response);
			paymentRecordService.saveData(3, uid, 1, orderId, 1, 1, money, paymentCode, 1);//添加预支付数据
		}
		if (payType == 2) {//支付宝支付
			resultUtil = payMoneyUtil.alipay("感谢费", "感谢费", "", orderId + "_1_" + UUIDUtil.getRandomCode(5), money.toString(), "/base/aliPayThankYouFee");
			paymentRecordService.saveData(3, uid, 1, orderId, 1, 2, money, "", 1);//添加预支付数据
		}
		if (payType == 3) {//余额支付
			if (userInfo.getBalance() == null || userInfo.getBalance() < money) {
				return ResultUtil.error("余额不足，无法完成支付");
			}
//            resultUtil= appOrderController.moneyPay(orderId,userInfo.getId(),money);
//            if(resultUtil.getCode()==500){
//                return ResultUtil.error("电子余额不足，无法完成支付");
//            }
			userInfo.setBalance(new BigDecimal(userInfo.getBalance()).subtract(new BigDecimal(money)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
			
			OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
			SysIntegral query1 = sysIntegralMapper.query(openCity.getId());
			userInfo.setIntegral(userInfo.getIntegral() + (money.intValue() * query1.getIntegral()));//积分
			
			//添加交易明细
			transactionDetailsService.saveData(uid, "快车订单-感谢费", money, 2, 1, 1, 1, orderId);
			userInfoService.updateById(userInfo);
			
			orderPrivateCar.setThankYouFee(money);
			this.updateById(orderPrivateCar);
			
			//添加已收入明细
			incomeService.saveData(2, orderPrivateCar.getDriverId(), 6, orderPrivateCar.getId(), 1, money);
			Driver driver = driverService.selectById(orderPrivateCar.getDriverId());
			driver.setBusinessMoney(new BigDecimal(null != driver.getBusinessMoney() ? driver.getBusinessMoney() : 0).add(new BigDecimal(money)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
			driver.setLaveBusinessMoney(new BigDecimal(null != driver.getLaveBusinessMoney() ? driver.getLaveBusinessMoney() : 0).add(new BigDecimal(money)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
			driver.setBalance(new BigDecimal(null != driver.getBalance() ? driver.getBalance() : 0).add(new BigDecimal(money)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
			driverService.updateById(driver);
			systemNoticeService.addSystemNotice(1, "您已使用余额成功完成感谢费支付，谢谢使用！", uid, 1);
			
		}
		if (payType == 4) {
			Double payMoney = orderPrivateCar.getThankYouFee();
			Integer integer = paymentRecordService.saveData(3, uid, 1, orderId, 1, 4, money, "", 1);
			resultUtil = appOrderController.placeAnOrder(new BigDecimal(money), 4, orderId, 11, integer);
		}
		return resultUtil;
	}
	
	@Override
	public void payThankYouFeeCallback(Integer orderId, String order_id, Integer payType) throws Exception {
		System.out.println(orderId + "_" + order_id + "_" + payType);
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		UserInfo userInfo = userInfoService.selectById(orderPrivateCar.getUserId());
		System.out.println("用户" + userInfo);
		PaymentRecord query = paymentRecordService.query(3, userInfo.getId(), 1, orderId, 1, payType, 1);
		System.out.println("query:" + query);
		query.setState(2);
		query.setCode(order_id);
		paymentRecordService.updateById(query);
		OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());
		SysIntegral query1 = sysIntegralMapper.query(openCity.getId());
//		System.out.println("query1:" + query1);
		userInfo.setIntegral(userInfo.getIntegral() + (query.getAmount().intValue() * query1.getIntegral()));//积分
		
		//添加交易明细
		transactionDetailsService.saveData(userInfo.getId(), "快车订单-感谢费", query.getAmount(), 2, 1, 1, 1, orderId);
		userInfoService.updateById(userInfo);
		
		orderPrivateCar.setThankYouFee(query.getAmount());
		this.updateById(orderPrivateCar);
		
		//添加已收入明细
		incomeService.saveData(2, orderPrivateCar.getDriverId(), 6, orderPrivateCar.getId(), 1, query.getAmount());
		Driver driver = driverService.selectById(orderPrivateCar.getDriverId());
		driver.setBusinessMoney(new BigDecimal(null != driver.getBusinessMoney() ? driver.getBusinessMoney() : 0).add(new BigDecimal(query.getAmount())).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
		driver.setLaveBusinessMoney(new BigDecimal(null != driver.getLaveBusinessMoney() ? driver.getLaveBusinessMoney() : 0).add(new BigDecimal(query.getAmount())).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
		driver.setBalance(new BigDecimal(null != driver.getBalance() ? driver.getBalance() : 0).add(new BigDecimal(query.getAmount())).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
		driverService.updateById(driver);
		systemNoticeService.addSystemNotice(1, "您已使用" + (payType == 1 ? "微信" : (payType == 2 ? "支付宝" : "云闪付")) + "成功完成感谢费支付，谢谢使用！", userInfo.getId(), 1);
		System.out.println("出租车感谢费ok");
	}
	
	@Override
	public List<Map<String, Object>> queryOrderInfo2(Integer orderId, Integer state, String lon, String lat) {
		return this.baseMapper.queryOrderInfo2(orderId, state, lon, lat);
	}
	
	/**
	 * 获取专车未支付订单
	 *
	 * @param uid
	 * @return
	 */
	@Override
	public List<UnPayOrderVO> getUnpayPrivateOrders(Integer uid) {
		EntityWrapper<OrderPrivateCar> wrapper = new EntityWrapper<>();
		wrapper.eq("userId", uid);
		wrapper.eq("state", 7);
		//查出未支付订单
		List<OrderPrivateCar> orderPrivateCars = this.selectList(wrapper);
		List<UnPayOrderVO> unPayOrderVOList = new ArrayList<>();
		for (OrderPrivateCar order : orderPrivateCars) {
			UnPayOrderVO vo = new UnPayOrderVO();
			// 复制属性
			//添加司机信息
			DriverInfoWarpper driverInfoWarpper = new DriverInfoWarpper();
			Driver driver = driverService.selectById(order.getDriverId());
			BeanUtils.copyProperties(driver, driverInfoWarpper);
			vo.setDriverInfoWarpper(driverInfoWarpper);
			//其余信息
			BeanUtils.copyProperties(order, vo);
			vo.setPayMoney(getPrivateCarPrepayDisplayPayAmount(order, order.getOrderMoney()));
			unPayOrderVOList.add(vo);
		}
		
		return unPayOrderVOList;
	}
	
	public void pushOrder(Integer id, Integer rideType, Integer serverCarModelId, Double startLon, Double startLat) throws Exception {
		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					Integer orderType = rideType == 1 ? 1 : rideType == 2 ? 9 : 8;
					orderIds.add(id);//添加记录，防止调用接口重复提醒无人接单
					String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
					List<Integer> integers = new ArrayList<>();
					if (ToolUtil.isNotEmpty(vehicle)) {
						integers = JSON.parseArray(vehicle).toJavaList(Integer.class);
					}
					OpenCity openCity = openCityService.openCity1(startLon.toString(), startLat.toString());
					List<PushOrder> querys = pushOrderService.querys(null, 1, openCity.getId());//获取需要推送的次数
					//整轮派单结束，若无司机接单，系统自动增加派单5轮，若增加5轮后任无司机接单，则系统结束派单，乘客端显示无司机接单、是否再次打车
					int num = 0;
					for (int j = 0; j < 6; j++) {
						Boolean push = false;
						for (int i = 1; i <= querys.size(); i++) {
							num++;
							OrderPrivateCar orderPrivateCar = orderPrivateCarMapper.selectById(id);
							if (null == orderPrivateCar || orderPrivateCar.getState() > 1) {
								push = true;
								break;
							}
							int finalI = i;
							PushOrder pushOrder = querys.stream().filter(s -> s.getType() == (finalI <= 3 ? finalI : 3)).findFirst().orElse(null);
							System.out.println("pushOrder2:" + pushOrder);
							if (orderPrivateCar.getState() > 1) {
								push = true;
								break;
							}
							//获取空闲司机
							List<Driver> list = driverService.queryIdleDriver(orderType, serverCarModelId, startLon, startLat, pushOrder.getPushDistance(), null);//所有附近空闲司机
							//随机排序
							Collections.shuffle(list);
							if (list.size() > 0) {
								double driverProportion = pushOrder.getDriverProportion() / 100;//推送占比计算成小数
								int lastIndex = Double.valueOf(list.size() * driverProportion).intValue();//计算占比转成整数（下标截取）
								lastIndex = lastIndex == 0 ? list.size() : lastIndex;
								list = list.subList(0, lastIndex);//获取空闲司机中占比数据
								for (Driver driver : list) {//开始进行推送
									boolean bo = false;
									for (Integer integer : integers) {
										if (integer.compareTo(driver.getId()) == 0) {
											bo = true;
											break;
										}
									}
									if (bo) {
										continue;
									}
									pushUtil.pushOrderState(2, driver.getId(), id, 1, 1, pushOrder.getPushTime());
								}
							}
							Thread.sleep(pushOrder.getPushTime() * 1000);//设置等待时间
							OrderPrivateCar orderPrivateCar1 = orderPrivateCarMapper.selectById(orderPrivateCar.getId());
							if(null == orderPrivateCar1){
								break;
							}
							Integer state =orderPrivateCar1.getState();
							if (state > 1) {
								orderIds.remove(orderPrivateCar.getId());
								push = true;
								break;
							}
							if (num == 18) {
								ResultUtil refundResult = handlePrivateCarPrepayCancelRefund(orderPrivateCar1, "无司机接单", "无司机接单", orderPrivateCar1.getUserId());
								if (refundResult == null) {
									orderPrivateCar1.setState(10);
									orderPrivateCarMapper.updateById(orderPrivateCar1);
								}
								pushUtil.pushEndPush(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, 1);
								orderIds.remove(orderPrivateCar.getId());
							}
						}
						if(push){
							break;
						}
					}

				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();
	}
	
	/**
	 * 推送抢单数据
	 *
	 * @param orderPrivateCar
	 * @throws Exception
	 */
	public void pushOrder(OrderPrivateCar orderPrivateCar) throws Exception {


		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					System.out.println("推单推单推单！！");
					Integer id = orderPrivateCar.getId();
					Integer orderType = orderPrivateCar.getRideType() == 1 ? 1 : orderPrivateCar.getRideType() == 2 ? 9 : 8;
					orderIds.add(orderPrivateCar.getId());//添加记录，防止调用接口重复提醒无人接单
					String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
					List<Integer> integers = new ArrayList<>();
					if (ToolUtil.isNotEmpty(vehicle)) {
						integers = JSON.parseArray(vehicle).toJavaList(Integer.class);
					}
					OpenCity openCity = openCityService.openCity1(orderPrivateCar.getStartLon().toString(), orderPrivateCar.getStartLat().toString());

					// 判断是否为派单模式
					TSysPushType sysPushType = tSysPushTypeService.selectOne(new EntityWrapper<TSysPushType>().eq("openCityId", openCity.getId()));
					if(sysPushType!=null && sysPushType.getPushType()==2){
						System.out.println( "派单模式");
						OrderPrivateCar orderPrivateCar = orderPrivateCarMapper.selectById(id);
						if (null != orderPrivateCar && orderPrivateCar.getState() == 1) {
							// 固定5公里进行派单
							List<Driver> list = driverService.queryIdleDriver(orderType, orderPrivateCar.getServerCarModelId(), orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat(), 5.0, null);//所有附近空闲司机
							if (list.size() > 0) {
								Driver driver1 = list.stream().sorted(Comparator.comparingDouble(Driver::getDistance).reversed()).findFirst().get();
								if(orderPrivateCar.getType() == 3){
									//批量订单
									CarService carService = new CarService();
									carService.setCarId(driver1.getCarId());
									carService.setType(1);
									CarService carService1 = carServiceMapper.selectOne(carService);
									orderPrivateCar.setServerCarModelId(carService1.getServerCarModelId());
									//1=独享，2=一口价
									String serverCarModel = orderPrivateCar.getServerCarModel();
									JSONArray jsonArray = JSON.parseArray(serverCarModel);
									Integer rideType1 = null;
									for (int i = 0; i < jsonArray.size(); i++) {
										JSONObject jsonObject = jsonArray.getJSONObject(i);
										Integer serverCarModelId = jsonObject.getInteger("serverCarModelId");
										Integer rideType = jsonObject.getInteger("rideType");
										if(serverCarModelId.equals(carService1.getServerCarModelId())){
											rideType1 = rideType;
											if(rideType == 1){
												break;
											}
										}
									}
									orderPrivateCar.setRideType(rideType1);
								}
								orderPrivateCar.setDriverId(driver1.getId());
								orderPrivateCar.setCarId(driver1.getCarId());
								orderPrivateCar.setCompanyId(driver1.getFranchiseeId() != null && driver1.getFranchiseeId() != 0 ? driver1.getFranchiseeId() : (
										driver1.getCompanyId() != null && driver1.getCompanyId() != 0 ? driver1.getCompanyId() : 1));
								orderPrivateCar.setState(2);
								orderPrivateCar.setSnatchOrderTime(new Date());

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

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

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

									}
								}).start();

								new Thread(new Runnable() {
									@Override
									public void run() {
										pushUtil.pushDriverPosition(orderPrivateCar.getId(), 1);
									}
								}).start();

								systemNoticeService.addSystemNotice(2, "已为您派得快车订单，请及时联系客户！", orderPrivateCar.getDriverId(), 1);
								systemNoticeService.addSystemNotice(1, "您的订单已指派给" + driver1.getName().substring(0, 1) + "师傅，请保持电话畅通！", orderPrivateCar.getUserId(), 1);

								if(pushMinistryOfTransport){
									new Thread(new Runnable() {
										@Override
										public void run() {
											//上传数据
											pushMinistryOfTransportUtil.orderCreate(orderPrivateCar.getId());
											pushMinistryOfTransportUtil.orderMatch(orderPrivateCar.getId());
										}
									}).start();
								}


							}else {
								// 没找到车辆
								Thread.sleep(5000);
								ResultUtil refundResult = handlePrivateCarPrepayCancelRefund(orderPrivateCar, "无司机接单", "无司机接单", orderPrivateCar.getUserId());
								if (refundResult == null) {
									orderPrivateCar.setState(10);
									orderPrivateCarMapper.updateById(orderPrivateCar);
								}
								pushUtil.pushEndPush(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, 10);
							}


						}

					}else {
						System.out.println( "推单模式");

						List<PushOrder> querys = pushOrderService.querys(null, 1, openCity.getId());//获取需要推送的次数
						for (int i = 1; i <= querys.size() + 15; i++) {
							OrderPrivateCar orderPrivateCar = orderPrivateCarMapper.selectById(id);
							if (null == orderPrivateCar || orderPrivateCar.getState() > 1) {
								break;
							}
							int finalI = i;
							PushOrder pushOrder = querys.stream().filter(s -> s.getType() == (finalI <= 3 ? finalI : 3)).findFirst().orElse(null);
							System.out.println("pushOrder1:" + pushOrder);
							int i2 = pushOrder.getPushTime() / 10;
							if (i2 == 0) {
								i2 = 1;
							}
							for (int i1 = 0; i1 < i2; i1++) {
								if (orderPrivateCar.getState() > 1) {
									break;
								}
								//获取空闲司机
								List<Driver> list = driverService.queryIdleDriver(orderType, orderPrivateCar.getServerCarModelId(), orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat(), pushOrder.getPushDistance(), null);//所有附近空闲司机
								System.out.println(list.toString()+"XXXXXXXX");
								if (list.size() > 0) {
									double driverProportion = pushOrder.getDriverProportion() / 100;//推送占比计算成小数
									int lastIndex = Double.valueOf(list.size() * driverProportion).intValue();//计算占比转成整数（下标截取）
									lastIndex = lastIndex == 0 ? list.size() : lastIndex;
									list = list.subList(0, lastIndex);//获取空闲司机中占比数据
									for (Driver driver : list) {//开始进行推送
										boolean bo = false;
										for (Integer integer : integers) {
											if (integer.compareTo(driver.getId()) == 0) {
												bo = true;
												break;
											}
										}
										if (bo) {
											continue;
										}
										pushUtil.pushOrderState(2, driver.getId(), orderPrivateCar.getId(), 1, orderPrivateCar.getState(), pushOrder.getPushTime());
									}
								}
								Thread.sleep(10000);//设置等待时间
								Integer state = orderPrivateCar.getState();
								if (state > 1) {
									orderIds.remove(orderPrivateCar.getId());
									return;
								}
								if (i == querys.size() + 15 && state == 1) {
									pushUtil.pushEndPush(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, 1);
									orderIds.remove(orderPrivateCar.getId());

									// 没找到车辆
									ResultUtil refundResult = handlePrivateCarPrepayCancelRefund(orderPrivateCar, "无司机接单", "无司机接单", orderPrivateCar.getUserId());
									if (refundResult == null) {
										orderPrivateCar.setState(10);
										orderPrivateCarMapper.updateById(orderPrivateCar);
									}
								}
							}
						}
					}

				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}).start();
	}
	
	
	
	
	@Override
	public void addAppeal(Integer uid, Integer orderId,String abnormalIntro, String abnormalImg) {
		OrderPrivateCar orderPrivateCar = this.selectById(orderId);
		if(orderPrivateCar.getState()!=7 || orderPrivateCar.getAbnormalIntro()!=null){
			throw new RuntimeException("此订单无法申诉");
		}
		orderPrivateCar.setAbnormalIntro(abnormalIntro);
		orderPrivateCar.setAbnormalImg(abnormalImg);
		orderPrivateCar.setAbnormal(2);
		this.baseMapper.updateById(orderPrivateCar);
		
	}

	@Override
	public void promotion(Integer orderId) {
		OrderPrivateCar orderPrivateCar = this.baseMapper.selectById(orderId);
		UserInfo userInfo = userInfoService.selectById(orderPrivateCar.getUserId());
//		if(userInfo.getBindDriverId()!=null && userInfo.getBindExpireDate().getTime()<=System.currentTimeMillis()){
		// 开始绑定的  后面到期也结算
		System.out.println("eeeee+"+orderPrivateCar.getPromotionDriverId());
		if(orderPrivateCar.getPromotionDriverId()!=null ){
			String registAreaCode = driverService.selectById(orderPrivateCar.getPromotionDriverId()).getPlaceOfEmployment();
			TDriverPromotionActivity tDriverPromotionActivity = driverPromotionActivityService.selectOne(new EntityWrapper<TDriverPromotionActivity>().eq("districtCode", registAreaCode).le("startTime", new Date()).ge("endTime", new Date()).last("AND FIND_IN_SET(" + 1 + ", bizType) limit 1"));
			System.out.println("ddddd"+tDriverPromotionActivity);
			if(tDriverPromotionActivity!=null){
				Double payMoney = orderPrivateCar.getPayMoney();
				System.out.println(payMoney);
				BigDecimal bigDecimal = tDriverPromotionActivity.getCommissionRatio().divide(new BigDecimal(100), 2, RoundingMode.HALF_UP).multiply(new BigDecimal(payMoney)).setScale(2, RoundingMode.HALF_UP);
				System.out.println(bigDecimal);
				orderPrivateCar.setPromotionDriverId(userInfo.getBindDriverId());
				orderPrivateCar.setPromotionMoney(bigDecimal);
				orderPrivateCar.setPromotionActivityId(tDriverPromotionActivity.getId());
				orderPrivateCar.setSuccessTime(new Date());
				this.baseMapper.updateById(orderPrivateCar);
			}
		}
	}

	@Override
	public List<Map<String, Object>> queryMyTripList(Integer uid, Integer pageNum, Integer size) throws Exception {
		pageNum = (pageNum - 1) * size;
		List<Map<String, Object>> maps = orderPrivateCarMapper.queryMyTripList(uid, pageNum, size);
		for (Map<String, Object> map : maps) {
			if (Integer.valueOf(String.valueOf(map.get("state"))) == 11) {
				map.put("state", map.get("oldState"));
			}
		}
		return maps;
	}

	@Override
	public List<Map<String, Object>> queryMyTripListAll(Integer uid) throws Exception {

		List<Map<String, Object>> maps = orderPrivateCarMapper.queryMyTripListAll(uid);
		for (Map<String, Object> map : maps) {
			if (Integer.valueOf(String.valueOf(map.get("state"))) == 11) {
				map.put("state", map.get("oldState"));
			}
		}
		return maps;
	}


}