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

import com.alibaba.fastjson.JSON;
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.service.ITEnterpriseWithdrawalService;
import com.stylefeng.guns.modular.account.unionpay.GetOpenBodySig;
import com.stylefeng.guns.modular.account.unionpay.QrCodeConfiguration;
import com.stylefeng.guns.modular.account.unionpay.Util;
import com.stylefeng.guns.modular.crossCity.dao.LineShiftDriverMapper;
import com.stylefeng.guns.modular.crossCity.dao.LineShiftMapper;
import com.stylefeng.guns.modular.crossCity.dao.LineSiteMapper;
import com.stylefeng.guns.modular.crossCity.model.Line;
import com.stylefeng.guns.modular.crossCity.model.LineShift;
import com.stylefeng.guns.modular.crossCity.model.LineShiftDriver;
import com.stylefeng.guns.modular.crossCity.model.OrderCrossCity;
import com.stylefeng.guns.modular.crossCity.server.IOrderCrossCityService;
import com.stylefeng.guns.modular.smallLogistics.model.OrderLogistics;
import com.stylefeng.guns.modular.smallLogistics.server.IOrderLogisticsService;
import com.stylefeng.guns.modular.specialTrain.model.OrderPrivateCar;
import com.stylefeng.guns.modular.specialTrain.server.IOrderPrivateCarService;
import com.stylefeng.guns.modular.system.dao.DispatchMapper;
import com.stylefeng.guns.modular.system.dao.ReassignMapper;
import com.stylefeng.guns.modular.system.dao.SensitiveWordsMapper;
import com.stylefeng.guns.modular.system.dao.CarBrandMapper;
import com.stylefeng.guns.modular.system.dao.CarModelMapper;
import com.stylefeng.guns.modular.system.model.*;
import com.stylefeng.guns.modular.system.service.*;
import com.stylefeng.guns.modular.system.util.*;
import com.stylefeng.guns.modular.taxi.model.OrderTaxi;
import com.stylefeng.guns.modular.taxi.service.IOrderTaxiService;
import org.apache.commons.lang.time.DateFormatUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

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


@Service
@Transactional(isolation = Isolation.READ_UNCOMMITTED, propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
public class ReassignServiceImpl extends ServiceImpl<ReassignMapper, Reassign> implements IReassignService {

    @Resource
    private ReassignMapper reassignMapper;

    @Resource
    private SensitiveWordsMapper sensitiveWordsMapper;

    @Autowired
    private IOrderService orderService;

    @Autowired
    private IDriverService driverService;

    @Autowired
    private ITransactionDetailsService transactionDetailsService;

    @Autowired
    private IPaymentRecordService paymentRecordService;

    @Autowired
    private PayMoneyUtil payMoneyUtil;

    @Autowired
    private CbyzxOrderPayHelper cbyzxOrderPayHelper;

    @Autowired
    private IOrderTaxiService orderTaxiService;

    @Autowired
    private IIncomeService incomeService;

    @Autowired
    private ISystemNoticeService systemNoticeService;

    @Autowired
    private IOrderPrivateCarService orderPrivateCarService;

    @Autowired
    private IOrderCrossCityService orderCrossCityService;

    @Autowired
    private JGPushUtil jgPushUtil;
    @Autowired
    private QrCodeConfiguration qrCodeConfiguration;
    @Resource
    private DispatchMapper dispatchMapper;

    @Autowired
    private IOrderLogisticsService orderLogisticsService;

    @Autowired
    private ICompanyService companyService;
    @Autowired
    private ITEnterpriseWithdrawalService enterpriseWithdrawalService;
    @Autowired
    private LineShiftMapper lineShiftMapper;

    @Autowired
    private LineSiteMapper lineSiteMapper;


    @Value("${callbackPath}")
    private String callbackPath;
    @Autowired
    private LineShiftDriverMapper lineShiftDriverMapper;

    @Autowired
    private ICarService carService;

    @Resource
    private CarBrandMapper carBrandMapper;

    @Resource
    private CarModelMapper carModelMapper;

    @Autowired
    private IOrderEvaluateService orderEvaluateService;


    /**
     * 提交改派申请
     * @param uid           申请司机id
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil saveData(Reassign reassign, Integer uid, Integer type,Integer driverId) throws Exception {
        type = null == type ? 2 : type;//现目前微信只支持小程序支付
        String content = reassign.getRemark();
        if (ToolUtil.isNotEmpty(content)) {
            List<SensitiveWords> sensitiveWords = sensitiveWordsMapper.selectList(null);
            for (SensitiveWords s : sensitiveWords) {
                content = content.replaceAll(s.getContent(), "***");
            }
        }
        reassign.setRemark(content);
        ResultUtil resultUtil = ResultUtil.success();
        Driver driver = driverService.selectById(uid);
        // TODO: 2020/11/12 司机端不控制重复提交（如果重复提交且未支付，直接将之前的数据删除）
//        Reassign query = reassignMapper.query(uid, null, null, null, 1);
//        if(null != query){
//            return ResultUtil.error("有未完成支付的改派申请");
//        }
        int types = 1;
        Reassign query = reassignMapper.query(uid, null, reassign.getOrderId(), reassign.getOrderType(), 1);
        if (isActiveReassign(query)) {
            types = 2;
//            return ResultUtil.error("不能重复提交申请");
            reassignMapper.deleteById(query.getId());
        }
        query = reassignMapper.query(uid, null, reassign.getOrderId(), reassign.getOrderType(), 2);

        if (isActiveReassign(query)) {
            types = 2;
//            return ResultUtil.error("您提交的申请正在处理中");
        }
        //获取支付金额
        Double aDouble = orderService.queryReassignMoney(reassign.getOrderId(), reassign.getOrderType());
        reassign.setMoney(aDouble);
        reassign.setOriginalDriverId(uid);
        reassign.setOriginalCarId(driver.getCarId());
        reassign.setInsertTime(new Date());
        if (types == 1) {
            this.insert(reassign);
        }
//        systemNoticeService.addSystemNotice(2, "您的改派申请已成功提交，我们会尽快为你处理！", uid, 1);

        //开始支付
        if (null != reassign.getPayType()) {
            if (reassign.getPayType() == 1) {//微信支付
                reassign.setState(1);
                if (ToolUtil.isEmpty(driver.getAppletsOpenId())) {
                    return ResultUtil.errorOpenId("司机未绑定微信小程序openid，无法发起微信支付");
                }
                String outTradeNo = buildCbyzxReassignOutTradeNo(reassign.getId(), reassign.getOrderType());
                JSONObject response = cbyzxOrderPayHelper.createOrder(uid, driver.getAppletsOpenId(), outTradeNo, aDouble);
                if (!cbyzxOrderPayHelper.isCreateSuccess(response)) {
                    return ResultUtil.error(cbyzxOrderPayHelper.extractMessage(response), response);
                }
                resultUtil = ResultUtil.success(response);
                paymentRecordService.saveData(1, uid, 2, reassign.getOrderId(), reassign.getOrderType(), 1, aDouble, outTradeNo, 1);//添加预支付数据
            }
            if (reassign.getPayType() == 2) {//支付宝
                reassign.setState(1);
                resultUtil = payMoneyUtil.alipay("改派订单", "改派订单", "", reassign.getId() + "_" + reassign.getOrderType() + "_" + UUIDUtil.getRandomCode(5), "0", "/base/aliReassign");
                paymentRecordService.saveData(1, uid, 2, reassign.getOrderId(), reassign.getOrderType(), 2, 0.0, "", 1);//添加预支付数据
            }
            if (reassign.getPayType() == 3) {//余额
                reassign.setState(2);
                reassign.setPayTime(new Date());
                reassignMapper.updateById(reassign);

                Double balance = driver.getBalance();
                Double laveBusinessMoney = driver.getLaveBusinessMoney();
                Double laveActivityMoney = driver.getLaveActivityMoney();
                if (null == balance || balance < aDouble) {
                    throw new SystemException("账户余额不足");
                }
                if (null != laveBusinessMoney && laveBusinessMoney.compareTo(aDouble) >= 0) {
                    driver.setLaveBusinessMoney(new BigDecimal(laveBusinessMoney).subtract(new BigDecimal(aDouble)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
                } else if (null != laveActivityMoney && laveActivityMoney.compareTo(aDouble) >= 0) {
                    driver.setLaveActivityMoney(new BigDecimal(laveActivityMoney).subtract(new BigDecimal(aDouble)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
                }
                driver.setBalance(new BigDecimal(balance).subtract(new BigDecimal(aDouble)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
                driverService.updateById(driver);
                // 添加交易明细
                transactionDetailsService.saveData(uid, "司机改派支付", aDouble, 2, 1, 2, reassign.getOrderType(), reassign.getOrderId());


                //修改改派通知状态
                switch (reassign.getOrderType()) {
                    case 1:
                        OrderPrivateCar orderPrivateCar = orderPrivateCarService.selectById(reassign.getOrderId());
                        orderPrivateCar.setOldState(orderPrivateCar.getState());
                        orderPrivateCar.setState(11);
                        orderPrivateCar.setReassignNotice(2);
                        orderPrivateCar.setIsReassign(2);
                        orderPrivateCarService.updateById(orderPrivateCar);
                        //添加已收入明细
//                        incomeService.saveData(1, orderPrivateCar.getCompanyId(), 4, orderPrivateCar.getId(), 1, reassign.getMoney());
                        // qyt 改派直接推送
                        pushOrderPrivate(orderPrivateCar, uid, types);
                        break;
                    case 2:
                        OrderTaxi orderTaxi = orderTaxiService.selectById(reassign.getOrderId());
                        orderTaxi.setOldState(orderTaxi.getState());
                        orderTaxi.setState(11);
                        orderTaxi.setReassignNotice(2);
                        orderTaxi.setIsReassign(2);
                        orderTaxiService.updateById(orderTaxi);
                        //添加已收入明细
//                        incomeService.saveData(1, orderTaxi.getCompanyId(), 4, orderTaxi.getId(), 2, reassign.getMoney());

                        // qyt 改派直接推送
                        pushOrderTaxi(orderTaxi, uid, types);
                        break;
                    case 3:
                        OrderCrossCity orderCrossCity = orderCrossCityService.selectById(reassign.getOrderId());
                        orderCrossCity.setOldState(orderCrossCity.getState());
                        orderCrossCity.setIsReassign(2);
                        orderCrossCity.setReassignNotice(2);
                        if(driverId==null){
                            orderCrossCity.setState(11);
                        }else {
                            orderCrossCity.setDriverId(driverId);
                        }
                        orderCrossCityService.updateById(orderCrossCity);
                        //添加已收入明细
                        incomeService.saveData(1, orderCrossCity.getCompanyId(), 4, orderCrossCity.getId(), 3, reassign.getMoney());

                        // 推送用户消息
                        pushUtil.pushOrderReassign(orderCrossCity.getUserId(), 1, orderCrossCity.getId(), 3);
                        // 推送司机消息
                        pushUtil.pushOrderReassign(orderCrossCity.getDriverId(), 2, orderCrossCity.getId(), 3);

                    case 4:
                        OrderLogistics orderLogistics = orderLogisticsService.selectById(reassign.getOrderId());
                        orderLogistics.setOldState(orderLogistics.getState());
                        orderLogistics.setState(11);
                        orderLogistics.setReassignNotice(2);
                        orderLogistics.setIsReassign(2);
                        orderLogisticsService.updateById(orderLogistics);

                        //添加已收入明细
                        incomeService.saveData(1, orderLogistics.getCompanyId(), 4, orderLogistics.getId(), orderLogistics.getType(), reassign.getMoney());
                        break;
                    case 5:
                        OrderLogistics orderLogistics1 = orderLogisticsService.selectById(reassign.getOrderId());
                        orderLogistics1.setOldState(orderLogistics1.getState());
                        orderLogistics1.setState(11);
                        orderLogistics1.setReassignNotice(2);
                        orderLogistics1.setIsReassign(2);
                        orderLogisticsService.updateById(orderLogistics1);

                        //添加已收入明细
                        incomeService.saveData(1, orderLogistics1.getCompanyId(), 4, orderLogistics1.getId(), orderLogistics1.getType(), reassign.getMoney());
                        break;
                }

                systemNoticeService.addSystemNotice(2, "您已使用余额成功支付改派申请费用！", uid, 1);
                //开始推送调度单
                Map<String, String> map = new HashMap<>();
                map.put("orderId", reassign.getOrderId().toString());
                map.put("orderType", reassign.getOrderType().toString());
//                List<Dispatch> dispatches = dispatchMapper.queryDispatchs(driver.getFranchiseeId() == null ? driver.getCompanyId() : driver.getFranchiseeId(), 1);
//                for(Dispatch dispatch : dispatches){
//                    jgPushUtil.push(2,"有新的改派订单需要处理，请及时处理！", "订单改派", map, "DISPATCH" + dispatch.getId());
//                }

            }
//            if (reassign.getPayType() == 4) {
//                // TODO 司机云闪付 改派调起云闪付
//                Double payMoney = reassign.getMoney();
//                paymentRecordService.saveData(1, uid, 2, reassign.getOrderId(), reassign.getOrderType(), 4, aDouble, "", 1);//添加预支付数据
//                resultUtil = placeAnOrder(new BigDecimal(payMoney), 4, 1, reassign.getId());
//            }
        }
        return resultUtil;
    }

    @Override
    public ResultUtil saveDataCancel(Reassign reassign, Integer uid, Integer type) throws Exception {
        Driver driver = driverService.selectById(uid);
        //修改改派通知状态
        switch (reassign.getOrderType()) {

            case 1:
                OrderPrivateCar orderPrivateCar = orderPrivateCarService.selectById(reassign.getOrderId());
                if (orderPrivateCar.getState() == 10) {
                    return ResultUtil.error("订单已取消");
                }
                orderPrivateCar.setState(orderPrivateCar.getOldState());
                orderPrivateCar.setReassignNotice(0);
                orderPrivateCarService.updateById(orderPrivateCar);
                break;
            case 2:
                OrderTaxi orderTaxi = orderTaxiService.selectById(reassign.getOrderId());
                if (orderTaxi.getState() == 10) {
                    return ResultUtil.error("订单已取消");
                }
                orderTaxi.setState(orderTaxi.getOldState());
                orderTaxi.setReassignNotice(0);
                orderTaxiService.updateById(orderTaxi);
                break;
        }
        reassignMapper.delete(new EntityWrapper<Reassign>().eq("orderId", reassign.getOrderId()).eq("orderType", reassign.getOrderType()));
        return ResultUtil.success();
    }


    private ResultUtil placeAnOrder(BigDecimal amount, Integer type, Integer orderType, Integer reassignId) throws Exception {
        Reassign reassign = reassignMapper.selectById(reassignId);
        String merOrderId = Util.getMerOrderId(qrCodeConfiguration.getMsgSrcId());
        reassign.setBillNo(merOrderId + "0");
        reassignMapper.updateById(reassign);
        JSONObject json = new JSONObject();
        json.put("requestTimestamp", DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"));    // 报文请求时间
        json.put("merOrderId", merOrderId); // 商户订单号
        json.put("mid", qrCodeConfiguration.getMid()); // 商户号
        json.put("tid", qrCodeConfiguration.getTid());    // 终端号
        json.put("instMid", qrCodeConfiguration.getInstMid()); // 业务类型
        json.put("totalAmount", amount.multiply(new BigDecimal("100")).intValue());      // 支付总金额
        json.put("orderDesc", "APP下单"); // 订单描述
        json.put("srcReserve", reassignId + "_" + orderType + "_" + UUIDUtil.getRandomCode(5) + "-" + orderType + "-" + type); // 预留字段
        json.put("subAppId", "wxasdasdasdasdads");
        json.put("notifyUrl", "https://zhentonggongsi.com:443/driver/api/placeOrder/notifyUrl");
        json.put("tradeType", "APP");  // 交易类型，微信必传
        //  json.put("divisionFlag", true); // 分账标记
        //  json.put("platformAmount", 0); // 平台商户分账金额
//        ArrayList<JSONObject> subOrders = new ArrayList<>();
//        JSONObject jsonObject = new JSONObject();
//        jsonObject.put("mid", "988460101800201");
//        jsonObject.put("totalAmount", 1);
//        subOrders.add(jsonObject);
        //    json.put("subOrders", subOrders);

        System.err.println("请求报文json:\n" + json);
        String url;
        if (1 == type) {
//            url = "https://test-api-open.chinaums.com/v1/netpay/wx/app-pre-order";// 测试
            url = "https://api-mop.chinaums.com/v1/netpay/wx/app-pre-order";
        } else if (2 == type) {
//            url = "https://test-api-open.chinaums.com/v1/netpay/trade/precreate";// 测试
            url = "https://api-mop.chinaums.com/v1/netpay/trade/precreate";
        } else {
//            url = "https://test-api-open.chinaums.com/v1/netpay/uac/app-order";// 测试
            url = "https://api-mop.chinaums.com/v1/netpay/uac/app-order";
        }
        //OPEN-BODY-SIG 方式
        String result = GetOpenBodySig.sendOpenBodySig(qrCodeConfiguration.getAppId(), qrCodeConfiguration.getAppKey(), url, json.toString());
        System.err.println("响应报文json:\n" + result);
        JSONObject jsonObject = JSONObject.parseObject(result);
        Object appPayRequest = jsonObject.get("appPayRequest");
        System.out.println(appPayRequest);
        return ResultUtil.success(appPayRequest);
    }

    /**
     * 跨城订单改派
     * @param amount
     * @param type
     * @param orderType
     * @param reassignId
     * @return
     * @throws Exception
     */
    private ResultUtil placeAnOrder1(BigDecimal amount, Integer type, Integer orderType, Integer reassignId) throws Exception {
        Reassign reassign = reassignMapper.selectById(reassignId);
        String merOrderId = Util.getMerOrderId(qrCodeConfiguration.getMsgSrcId());
        reassign.setBillNo(merOrderId + "0");
        reassignMapper.updateById(reassign);
        JSONObject json = new JSONObject();
        json.put("requestTimestamp", DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss"));    // 报文请求时间
        json.put("merOrderId", merOrderId); // 商户订单号
        json.put("mid", qrCodeConfiguration.getMid()); // 商户号
        json.put("tid", qrCodeConfiguration.getTid());    // 终端号
        json.put("instMid", qrCodeConfiguration.getInstMid()); // 业务类型
        json.put("totalAmount", amount.multiply(new BigDecimal("100")).intValue());      // 支付总金额
        json.put("orderDesc", "APP下单"); // 订单描述
        json.put("srcReserve", reassignId + "_" + orderType + "_" + UUIDUtil.getRandomCode(5) + "-" + 1 + "-" + type); // 预留字段
        json.put("subAppId", "wxasdasdasdasdads");
        json.put("notifyUrl", "https://zhentonggongsi.com:443/driver/api/placeOrder/notifyUrl");
        json.put("tradeType", "APP");  // 交易类型，微信必传
        //  json.put("divisionFlag", true); // 分账标记
        //  json.put("platformAmount", 0); // 平台商户分账金额
//        ArrayList<JSONObject> subOrders = new ArrayList<>();
//        JSONObject jsonObject = new JSONObject();
//        jsonObject.put("mid", "988460101800201");
//        jsonObject.put("totalAmount", 1);
//        subOrders.add(jsonObject);
        //    json.put("subOrders", subOrders);

        System.err.println("请求报文json:\n" + json);
        String url;
        if (1 == type) {
//            url = "https://test-api-open.chinaums.com/v1/netpay/wx/app-pre-order";// 测试
            url = "https://api-mop.chinaums.com/v1/netpay/wx/app-pre-order";
        } else if (2 == type) {
//            url = "https://test-api-open.chinaums.com/v1/netpay/trade/precreate";// 测试
            url = "https://api-mop.chinaums.com/v1/netpay/trade/precreate";
        } else {
//            url = "https://test-api-open.chinaums.com/v1/netpay/uac/app-order";// 测试
            url = "https://api-mop.chinaums.com/v1/netpay/uac/app-order";
        }
        //OPEN-BODY-SIG 方式
        String result = GetOpenBodySig.sendOpenBodySig(qrCodeConfiguration.getAppId(), qrCodeConfiguration.getAppKey(), url, json.toString());
        System.err.println("响应报文json:\n" + result);
        JSONObject jsonObject = JSONObject.parseObject(result);
        Object appPayRequest = jsonObject.get("appPayRequest");
        System.out.println(appPayRequest);
        return ResultUtil.success(appPayRequest);
    }


    /**
     * 提交改派申请（跨城专用）
     * @param uid           申请司机id
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil saveData_(Reassign reassign, String orderIds, Integer uid, Integer type) throws Exception {
        type = null == type ? 2 : type;//现目前微信只支持小程序支付
        String content = reassign.getRemark();
        if (ToolUtil.isNotEmpty(content)) {
            List<SensitiveWords> sensitiveWords = sensitiveWordsMapper.selectList(null);
            for (SensitiveWords s : sensitiveWords) {
                content = content.replaceAll(s.getContent(), "***");
            }
        }
        reassign.setRemark(content);
        ResultUtil resultUtil = ResultUtil.success();
        Driver driver = driverService.selectById(uid);
        // TODO: 2020/11/12 司机端不控制重复提交（如果重复提交且未支付，直接将之前的数据删除）
//        Reassign query = reassignMapper.query(uid, null, null, null, 1);
//        if(null != query){
//            return ResultUtil.error("有未完成支付的改派申请");
//        }
        String[] split = orderIds.split(",");//获取支付金额

        // 跨城改派：如果指定了司机，不收改派费用
        Double aDouble;
        if (isAssignedReassignTarget(reassign.getNowDriverId())) {
            aDouble = 0.0; // 指定司机，免费
        } else {
            aDouble = orderService.queryReassignMoney(Integer.valueOf(split[0]), 3);
        }

        Double totalMoney = aDouble * split.length;
        String ids = "";
        Integer requestTargetId = reassign.getNowDriverId();
        List<Reassign> currentReassignList = new ArrayList<>();
        for (String id : split) {
            Reassign query = reassignMapper.query(uid, null, Integer.valueOf(id), 3, 1);
            if (isActiveReassign(query)) {
//                return ResultUtil.error("不能重复提交申请");
                reassignMapper.deleteById(query.getId());
            }
            query = reassignMapper.query(uid, null, Integer.valueOf(id), 3, 2);
            if (isActiveReassign(query)) {
                return ResultUtil.error("您提交的申请正在处理中");
            }

            reassign.setMoney(aDouble);
            reassign.setOrderId(Integer.valueOf(id));
            reassign.setOrderType(3);
            reassign.setOriginalDriverId(uid);
            reassign.setOriginalCarId(driver.getCarId());
            reassign.setInsertTime(new Date());
            reassign.setState(1);
            reassign.setNowDriverId(requestTargetId);
            reassign.setNeedConfirm(null);
            reassign.setConfirmStatus(null);
            reassign.setConfirmTime(null);
            reassign.setExpireTime(null);
            reassign.setTempLineShiftDriverId(null);

            // 设置是否需要确认相关字段
            if (isAssignedReassignTarget(requestTargetId)) {
                OrderCrossCity orderCrossCity = orderCrossCityService.selectById(Integer.valueOf(id));
                boolean needConfirm = checkIfNeedConfirm(requestTargetId, orderCrossCity);
                reassign.setNeedConfirm(needConfirm ? 2 : 1);

                if (needConfirm) {
                    reassign.setNowDriverId(resolveConfirmDriverId(requestTargetId));
                    // 需要确认：设置超时时间
                    reassign.setConfirmStatus(1); // 待确认
                    Date expireTime = new Date(System.currentTimeMillis() + 60000); // 60秒后
                    reassign.setExpireTime(expireTime);
                } else {
                    reassign.setNowDriverId(requestTargetId);
                    // 不需要确认
                    reassign.setConfirmStatus(2); // 直接同意
                }
            } else {
                // 未指定司机，由调度分配
                reassign.setNeedConfirm(1);
            }

            this.insert(reassign);
            currentReassignList.add(this.selectById(reassign.getId()));
            ids += reassign.getId() + ",";
        }
        ids = ids.substring(0, ids.length() - 1);
        systemNoticeService.addSystemNotice(2, "您的改派申请已成功提交，我们会尽快为你处理！", uid, 1);

        if (isAssignedReassignTarget(requestTargetId)) {
            processFreeAssignedCrossCityReassign(split, currentReassignList, reassign);
            return ResultUtil.success();
        }

        //开始支付
        if (null != reassign.getPayType()) {
            if (reassign.getPayType() == 1) {//微信支付
                String[] split1 = ids.split(",");
                if (ToolUtil.isEmpty(driver.getAppletsOpenId())) {
                    return ResultUtil.errorOpenId("司机未绑定微信小程序openid，无法发起微信支付");
                }
                String outTradeNo = buildCbyzxBatchReassignOutTradeNo(ids);
                JSONObject response = cbyzxOrderPayHelper.createOrder(uid, driver.getAppletsOpenId(), outTradeNo, totalMoney);
                if (!cbyzxOrderPayHelper.isCreateSuccess(response)) {
                    return ResultUtil.error(cbyzxOrderPayHelper.extractMessage(response), response);
                }
                resultUtil = ResultUtil.success(response);
                for (String id : split1) {
                    paymentRecordService.saveData(1, uid, 2, Integer.valueOf(id), 3, 1, aDouble, outTradeNo, 1);//添加预支付数据
                }
            }
            if (reassign.getPayType() == 2) {//支付宝
                String[] split1 = ids.split(",");
                resultUtil = payMoneyUtil.alipay("改派订单", "改派订单", "", ids + "_3_" + UUIDUtil.getRandomCode(5), totalMoney.toString(), "/base/aliReassign");
                for (String id : split1) {
                    paymentRecordService.saveData(1, uid, 2, Integer.valueOf(id), 3, 2, aDouble, "", 1);//添加预支付数据
                }
            }
            if (reassign.getPayType() == 3) {//余额
                for (String id : split) {
                    Reassign query = reassignMapper.query(uid, null, Integer.valueOf(id), 3, 1);
                    query.setState(2);
                    if (reassign.getNowDriverId() != null) {
                        query.setState(3);
                    }
                    query.setPayTime(new Date());
                    reassignMapper.updateById(query);
                    //添加交易明细
                    transactionDetailsService.saveData(uid, "司机改派支付", aDouble, 2, 1, 2, 3, Integer.valueOf(id));
                }
                Double balance = driver.getBalance();
                Double laveBusinessMoney = driver.getLaveBusinessMoney();
                Double laveActivityMoney = driver.getLaveActivityMoney();
                if (null == balance || balance < totalMoney) {
                    throw new SystemException("账户余额不足");
                }
                if (null != laveBusinessMoney && laveBusinessMoney.compareTo(totalMoney) >= 0) {
                    driver.setLaveBusinessMoney(new BigDecimal(laveBusinessMoney).subtract(new BigDecimal(totalMoney)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
                } else if (null != laveActivityMoney && laveActivityMoney.compareTo(totalMoney) >= 0) {
                    driver.setLaveActivityMoney(new BigDecimal(laveActivityMoney).subtract(new BigDecimal(totalMoney)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
                }
                driver.setBalance(new BigDecimal(balance).subtract(new BigDecimal(totalMoney)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
                driverService.updateById(driver);


                //修改改派通知状态
                boolean needConfirmPush = false; // 标记是否需要发送确认推送
                OrderCrossCity firstOrder = null; // 保存第一个订单用于发送推送
                Reassign firstConfirmReassign = null; // 保存第一条待确认改派记录
                int totalPeopleNumber = 0; // 累计总人数
                List<String> orderIdList = new ArrayList<>(); // 收集所有订单ID
                List<String> reassignIdList = new ArrayList<>(); // 收集所有改派记录ID

                for (String id : split) {
                    OrderCrossCity orderCrossCity = orderCrossCityService.selectById(id);
                    orderCrossCity.setOldState(orderCrossCity.getState());

                    // 查询改派记录
                    Reassign reassignRecord = reassignMapper.query(uid, null, Integer.valueOf(id), 3, 1, 2, 3);
                    if (reassignRecord != null) {
                        reassignIdList.add(String.valueOf(reassignRecord.getId()));
                    }

                    // 累加人数
                    if (orderCrossCity.getPeopleNumber() != null) {
                        totalPeopleNumber += orderCrossCity.getPeopleNumber();
                    }
                    orderIdList.add(id);

                    if(reassignRecord == null || reassignRecord.getNowDriverId()==null){
                        System.out.println("跨城改派确认Socket未触发: reassignRecord为空或未指定司机, orderId=" + id);
                        orderCrossCity.setState(11);
                    }else {
                        boolean needConfirm = reassignRecord.getNeedConfirm() != null && reassignRecord.getNeedConfirm() == 2;
                        System.out.println("跨城改派余额支付确认判断: orderId=" + id
                                + ", reassignId=" + reassignRecord.getId()
                                + ", nowDriverId=" + reassignRecord.getNowDriverId()
                                + ", needConfirm=" + reassignRecord.getNeedConfirm()
                                + ", confirmStatus=" + reassignRecord.getConfirmStatus()
                                + ", state=" + reassignRecord.getState());

                        if (needConfirm) {
                            // 需要确认：标记需要发送推送，但不立即发送
                            orderCrossCity.setState(11); // 改派中状态
                            needConfirmPush = true;
                            if (firstConfirmReassign == null) {
                                firstConfirmReassign = reassignRecord;
                            }
                            if (firstOrder == null) {
                                firstOrder = orderCrossCity; // 保存第一个订单
                            }
                        } else {
                            // 不需要确认：直接改派
                            driverReassignSelf(reassignRecord, orderCrossCity);

                            // 只有无需确认时才推送乘客和司机信息
                            try {
                                // 推送用户消息
                                pushUtil.pushOrderReassign(orderCrossCity.getUserId(), 1, orderCrossCity.getId(), 3);
                                // 推送司机消息
                                pushUtil.pushOrderReassign(orderCrossCity.getDriverId(), 2, orderCrossCity.getId(), 3);
                            } catch (Exception ignore) {

                            }
                        }
                    }

                    orderCrossCity.setReassignNotice(2);
                    orderCrossCity.setIsReassign(2);
                    orderCrossCityService.updateById(orderCrossCity);
                    //添加已收入明细
                    incomeService.saveData(1, orderCrossCity.getCompanyId(), 4, orderCrossCity.getId(), 3, reassign.getMoney());
                }

                // 所有订单处理完后，只发送一次确认推送
                if (needConfirmPush && firstOrder != null && firstConfirmReassign != null) {
                    System.out.println("准备发送跨城改派确认Socket(余额支付): driverId=" + firstConfirmReassign.getNowDriverId()
                            + ", reassignIds=" + String.join(",", reassignIdList)
                            + ", orderIds=" + String.join(",", orderIdList));
                    sendReassignConfirmPush(firstConfirmReassign.getNowDriverId(), firstConfirmReassign, firstOrder, totalPeopleNumber, orderIdList, reassignIdList);
                } else {
                    System.out.println("跨城改派确认Socket未发送(余额支付): needConfirmPush=" + needConfirmPush
                            + ", firstOrder=" + (firstOrder == null ? "null" : firstOrder.getId())
                            + ", firstConfirmReassign=" + (firstConfirmReassign == null ? "null" : firstConfirmReassign.getId()));
                }
                systemNoticeService.addSystemNotice(2, "您已使用余额成功支付改派申请费用！", uid, 1);


                //开始推送调度单
//                Map<String, String> map = new HashMap<>();
//                map.put("orderId", reassign.getOrderId().toString());
//                map.put("orderType", reassign.getOrderType().toString());
//                List<Dispatch> dispatches = dispatchMapper.queryDispatchs(driver.getFranchiseeId() == null ? driver.getCompanyId() : driver.getFranchiseeId(), 1);
//                for (Dispatch dispatch : dispatches) {
//                    jgPushUtil.push(2, "有新的改派订单需要处理，请及时处理！", "订单改派", map, "DISPATCH" + dispatch.getId());
//                }
            }
//            if (reassign.getPayType() == 4) {
//
//                String[] split1 = ids.split(",");
//                resultUtil = placeAnOrder1(new BigDecimal(aDouble), 4, 3, Integer.valueOf(split1[0]));
//                for (String id : split1) {
//                     TODO 司机云闪付 跨城改派调起云闪付
//                    paymentRecordService.saveData(1, uid, 2, Integer.valueOf(id), 3, 4, aDouble, "", 1);//添加预支付数据
//                }
//            }
        }
        return resultUtil;
    }


    /**
     * 获取列表数据
     * @param uid
     * @param pageNum
     * @param size
     * @return
     * @throws Exception
     */
    @Override
    public List<Map<String, Object>> queryList(Integer uid, Integer pageNum, Integer size) throws Exception {
        pageNum = (pageNum - 1) * size;
        return reassignMapper.queryList(uid, pageNum, size);
    }

    /**
     * 创博优单条改派支付单号，保留原有 reassignId_orderType 结构用于回调复用旧逻辑。
     */
    private String buildCbyzxReassignOutTradeNo(Integer reassignId, Integer orderType) throws Exception {
        return "reassign_" + reassignId + "_" + orderType + "_" + UUIDUtil.getRandomCode(5);
    }

    /**
     * 创博优批量跨城改派支付单号，使用前缀避免与跨城完成订单支付冲突。
     */
    private String buildCbyzxBatchReassignOutTradeNo(String reassignIds) throws Exception {
        return "reassignBatch_" + reassignIds + "_3_" + UUIDUtil.getRandomCode(5);
    }


    public static List<Integer> orderIds = new ArrayList<>();


    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 改派支付完成后的操作
     * @param id            改派回调中的平台业务单号，格式仍按 reassignId_orderType_random 解析
     * @param order_id      第三方支付流水号
     * @param type          1=微信，2=支付宝,4=云闪付
     * @throws Exception
     */
    @Override
    public void payReassign(String id, String order_id, Integer type) throws Exception {
        System.out.println("改派支付完成后的操作");
        String[] s = id.split("_");
        if (Integer.valueOf(s[1]) == 3) {//跨城订单
            System.out.println("跨城订单");
            String[] split = s[0].split(",");
            List<Reassign> reassigns = this.selectBatchIds(Arrays.asList(split));
            Driver driver = driverService.selectById(reassigns.get(0).getOriginalDriverId());
            boolean batchHandled = false;
            for (String key : split) {
                PaymentRecord query = paymentRecordService.query(1, driver.getId(), 2, Integer.valueOf(key), 3, type, 1);
                if (null != query) {
                    System.out.println("跨城订单开始");
                    //添加交易明细
                    transactionDetailsService.saveData(reassigns.get(0).getOriginalDriverId(), "司机改派支付", reassigns.get(0).getMoney(), 2, 1, 2, 3, Integer.valueOf(key));
                    System.out.println("==============添加交易明细完毕===================");
                    for (Reassign reassign : reassigns) {
                        reassign.setState(2);
                        reassign.setPayOrder(order_id);
                        reassign.setPayTime(new Date());
                        this.updateById(reassign);
//                        //开始推送调度单
//                        Map<String, String> map = new HashMap<>();
//                        map.put("orderId", reassign.getOrderId().toString());
//                        map.put("orderType", reassign.getOrderType().toString());
//                        List<Dispatch> dispatches = dispatchMapper.queryDispatchs(driver.getFranchiseeId() == null ? driver.getCompanyId() : driver.getFranchiseeId(), 1);
//                        for (Dispatch dispatch : dispatches) {
//                            jgPushUtil.push(2, "有新的改派订单需要处理，请及时处理！", "订单改派", map, "DISPATCH" + dispatch.getId());
//                        }
                    }
                    query.setState(2);
                    if (reassigns.get(0).getNowDriverId() != null) {
                        query.setState(3);
                    }
                    query.setCode(order_id);
                    paymentRecordService.updateById(query);
                    System.out.println("==============paymentRecord完毕===================" + query);

                    if (batchHandled) {
                        continue;
                    }
                    batchHandled = true;

                    //修改改派通知状态
                    boolean needConfirmPush = false;
                    OrderCrossCity firstOrder = null;
                    Reassign firstConfirmReassign = null;
                    int totalPeopleNumber = 0;
                    List<String> orderIdList = new ArrayList<>();
                    List<String> reassignIdList = new ArrayList<>();
                    for (Reassign reassign : reassigns) {
                        OrderCrossCity orderCrossCity1 = orderCrossCityService.selectById(reassign.getOrderId());
                        orderCrossCity1.setOldState(orderCrossCity1.getState());
                        if (orderCrossCity1.getPeopleNumber() != null) {
                            totalPeopleNumber += orderCrossCity1.getPeopleNumber();
                        }
                        orderIdList.add(String.valueOf(orderCrossCity1.getId()));
                        reassignIdList.add(String.valueOf(reassign.getId()));
                        if(reassign.getNowDriverId()==null){
                            System.out.println("跨城改派确认Socket未触发: 未指定司机, reassignId=" + reassign.getId() + ", orderId=" + reassign.getOrderId());
                            orderCrossCity1.setState(11);
                        } else {
                            boolean needConfirm = reassign.getNeedConfirm() != null
                                    ? reassign.getNeedConfirm() == 2
                                    : checkIfNeedConfirm(reassign.getNowDriverId(), orderCrossCity1);
                            System.out.println("跨城改派在线支付确认判断: orderId=" + reassign.getOrderId()
                                    + ", reassignId=" + reassign.getId()
                                    + ", nowDriverId=" + reassign.getNowDriverId()
                                    + ", needConfirm=" + reassign.getNeedConfirm()
                                    + ", confirmStatus=" + reassign.getConfirmStatus()
                                    + ", state=" + reassign.getState()
                                    + ", needConfirmResult=" + needConfirm);
                            if (needConfirm) {
                                if (reassign.getNeedConfirm() == null) {
                                    reassign.setNowDriverId(resolveConfirmDriverId(reassign.getNowDriverId()));
                                }
                                ensureReassignConfirmTimeout(reassign);
                                reassign.setState(3);
                                this.updateById(reassign);
                                orderCrossCity1.setState(11);
                                needConfirmPush = true;
                                if (firstConfirmReassign == null) {
                                    firstConfirmReassign = reassign;
                                }
                                if (firstOrder == null) {
                                    firstOrder = orderCrossCity1;
                                }
                            } else {
                                // reassign.getNowDriverId() 是 lineShiftDriverId
                                driverReassignSelf(reassign, orderCrossCity1);
                            }
                        }
                        orderCrossCity1.setReassignNotice(2);
                        orderCrossCity1.setIsReassign(2);
                        orderCrossCityService.updateById(orderCrossCity1);
                        System.out.println("==============跨城修改改派通知状态完毕===================" + orderCrossCity1);

                        //添加已收入明细
                        incomeService.saveData(1, orderCrossCity1.getCompanyId(), 4, orderCrossCity1.getId(), 3, reassign.getMoney());


                        if(reassign.getNowDriverId()!=null){
                            if (reassign.getNeedConfirm() == null || reassign.getNeedConfirm().intValue() != 2) {
                                // 推送用户消息
                                pushUtil.pushOrderReassign(orderCrossCity1.getUserId(), 1, orderCrossCity1.getId(), 3);
                                // 推送司机消息
                                pushUtil.pushOrderReassign(orderCrossCity1.getDriverId(), 2, orderCrossCity1.getId(), 3);
                            }
                        }
                    }
                    if (needConfirmPush && firstOrder != null && firstConfirmReassign != null) {
                        System.out.println("准备发送跨城改派确认Socket(在线支付): driverId=" + firstConfirmReassign.getNowDriverId()
                                + ", reassignIds=" + String.join(",", reassignIdList)
                                + ", orderIds=" + String.join(",", orderIdList));
                        sendReassignConfirmPush(firstConfirmReassign.getNowDriverId(), firstConfirmReassign, firstOrder, totalPeopleNumber, orderIdList, reassignIdList);
                    } else {
                        System.out.println("跨城改派确认Socket未发送(在线支付): needConfirmPush=" + needConfirmPush
                                + ", firstOrder=" + (firstOrder == null ? "null" : firstOrder.getId())
                                + ", firstConfirmReassign=" + (firstConfirmReassign == null ? "null" : firstConfirmReassign.getId()));
                    }
                    systemNoticeService.addSystemNotice(2, "您已使用" + (type == 1 ? "微信" : (type == 2 ? "支付宝" : "云闪付")) + "成功支付改派申请费用！", reassigns.get(0).getOriginalDriverId(), 1);
                    System.out.println("==============跨城修改改派通知状态完毕===================");


                    // qyt 新增改派 重新推送


                } else {
                    System.err.println("预支付数据异常（orderId = " + id + ")");
                }
            }


        } else {//其他订单
            System.out.println("其他订单");
            Reassign reassign = this.selectById(s[0]);
            Driver driver = driverService.selectById(reassign.getOriginalDriverId());
            PaymentRecord query = paymentRecordService.query(1, driver.getId(), 2, reassign.getOrderId(), reassign.getOrderType(), type, 1);
            System.out.println("==============paymentRecord查询===================" + query);
            if (null != query) {
                //添加交易明细
                transactionDetailsService.saveData(reassign.getOriginalDriverId(), "司机改派支付", reassign.getMoney(), 2, 1, 2, reassign.getOrderType(), reassign.getOrderId());
                reassign.setState(2);
                reassign.setPayOrder(order_id);
                reassign.setPayTime(new Date());
                this.updateById(reassign);

                query.setState(2);
                query.setCode(order_id);
                paymentRecordService.updateById(query);
                System.out.println("==============paymentRecord完毕===================" + query);

                //修改改派通知状态
                switch (reassign.getOrderType()) {
                    case 1:
                        OrderPrivateCar orderPrivateCar = orderPrivateCarService.selectById(reassign.getOrderId());
                        orderPrivateCar.setOldState(orderPrivateCar.getState());
                        orderPrivateCar.setState(11);
                        orderPrivateCar.setReassignNotice(2);
                        orderPrivateCar.setIsReassign(2);
                        orderPrivateCarService.updateById(orderPrivateCar);

                        //添加已收入明细
                        incomeService.saveData(1, orderPrivateCar.getCompanyId(), 4, orderPrivateCar.getId(), 1, reassign.getMoney());
                        System.out.println("==============快车完毕===================" + orderPrivateCar);
                        break;
                    case 2:
                        OrderTaxi orderTaxi = orderTaxiService.selectById(reassign.getOrderId());
                        orderTaxi.setOldState(orderTaxi.getState());
                        orderTaxi.setState(11);
                        orderTaxi.setReassignNotice(2);
                        orderTaxi.setIsReassign(2);
                        orderTaxiService.updateById(orderTaxi);

                        //添加已收入明细
                        incomeService.saveData(1, orderTaxi.getCompanyId(), 4, orderTaxi.getId(), 2, reassign.getMoney());
                        System.out.println("==============出租车完毕===================" + orderTaxi);
                        break;
                    case 4:
                        OrderLogistics orderLogistics = orderLogisticsService.selectById(reassign.getOrderId());
                        orderLogistics.setOldState(orderLogistics.getState());
                        orderLogistics.setState(11);
                        orderLogistics.setReassignNotice(2);
                        orderLogistics.setIsReassign(2);
                        orderLogisticsService.updateById(orderLogistics);

                        //添加已收入明细
                        incomeService.saveData(1, orderLogistics.getCompanyId(), 4, orderLogistics.getId(), 4, reassign.getMoney());
                        System.out.println("==============物流订单完毕1===================" + orderLogistics);
                        break;
                    case 5:
                        OrderLogistics orderLogistics1 = orderLogisticsService.selectById(reassign.getOrderId());
                        orderLogistics1.setOldState(orderLogistics1.getState());
                        orderLogistics1.setState(11);
                        orderLogistics1.setReassignNotice(2);
                        orderLogistics1.setIsReassign(2);
                        orderLogisticsService.updateById(orderLogistics1);

                        //添加已收入明细
                        incomeService.saveData(1, orderLogistics1.getCompanyId(), 4, orderLogistics1.getId(), 5, reassign.getMoney());
                        System.out.println("==============物流订单完毕2===================" + orderLogistics1);
                        break;
                }
                systemNoticeService.addSystemNotice(2, "您已使用" + (type == 1 ? "微信" : (type == 2 ? "支付宝" : "云闪付")) + "成功支付改派申请费用！", reassign.getOriginalDriverId(), 1);
//                //开始推送调度单
//                Map<String, String> map = new HashMap<>();
//                map.put("orderId", reassign.getOrderId().toString());
//                map.put("orderType", reassign.getOrderType().toString());
//                List<Dispatch> dispatches = dispatchMapper.queryDispatchs(driver.getFranchiseeId() == null ? driver.getCompanyId() : driver.getFranchiseeId(), 1);
//                for (Dispatch dispatch : dispatches) {
//                    jgPushUtil.push(2, "有新的改派订单需要处理，请及时处理！", "订单改派", map, "DISPATCH" + dispatch.getId());
//                }
                System.out.println("==============其他订单完毕===================");
            } else {
                System.err.println("预支付数据异常（orderId = " + id + ")");
            }
        }


    }

    private void driverReassignSelf(Reassign reassign, OrderCrossCity orderCrossCity1) {
        driverReassignSelf(reassign, orderCrossCity1, null);
    }

    private void driverReassignSelf(Reassign reassign, OrderCrossCity orderCrossCity1, Integer peopleNumberOverride) {
        // 交换人数 交换座位
        Integer oldLineShiftDriverId = orderCrossCity1.getLineShiftDriverId();
        LineShiftDriver oldLineShiftDriver = lineShiftDriverMapper.selectById(oldLineShiftDriverId);
        LineShiftDriver lineShiftDriver = lineShiftDriverMapper.selectById(reassign.getNowDriverId());
        orderCrossCity1.setDriverId(lineShiftDriver.getDriverId());
        orderCrossCity1.setLineShiftDriverId(reassign.getNowDriverId());
        Driver driver1 = driverService.selectById(lineShiftDriver.getDriverId());
        orderCrossCity1.setCarId(driver1.getCarId());
        Integer peopleNumber = peopleNumberOverride == null ? orderCrossCity1.getPeopleNumber() : peopleNumberOverride;
        oldLineShiftDriver.setLaveSeat(oldLineShiftDriver.getLaveSeat() + peopleNumber);
        lineShiftDriver.setLaveSeat(lineShiftDriver.getLaveSeat() - peopleNumber);
        String laveSeatNumber = Arrays.stream(lineShiftDriver.getLaveSeatNumber().split(",")).skip(peopleNumber).collect(Collectors.joining(","));
        Set<String> oldLaveSeatSet = Arrays.stream(oldLineShiftDriver.getLaveSeatNumber().split(",")).collect(Collectors.toSet());
        for (int i = 1; i <= 6; i++) {
            oldLaveSeatSet.add(String.valueOf(i));
            if (oldLaveSeatSet.size() == oldLineShiftDriver.getLaveSeat()) {
                break;
            }
        }
        String oldLaveSeatNumber = oldLaveSeatSet.stream().sorted().collect(Collectors.joining(","));
        oldLineShiftDriver.setLaveSeatNumber(oldLaveSeatNumber);
        lineShiftDriver.setLaveSeatNumber(laveSeatNumber);
        lineShiftDriverMapper.updateById(oldLineShiftDriver);
        lineShiftDriverMapper.updateById(lineShiftDriver);
    }

    private void processFreeAssignedCrossCityReassign(String[] orderIds, List<Reassign> currentReassignList, Reassign requestReassign) throws Exception {
        Map<Integer, Reassign> currentReassignMap = new HashMap<>();
        for (Reassign currentReassign : currentReassignList) {
            if (currentReassign == null || currentReassign.getOrderId() == null) {
                continue;
            }
            currentReassign.setState(currentReassign.getNowDriverId() != null ? 3 : 2);
            currentReassign.setPayTime(new Date());
            reassignMapper.updateById(currentReassign);
            currentReassignMap.put(currentReassign.getOrderId(), currentReassign);
        }

        boolean needConfirmPush = false;
        OrderCrossCity firstOrder = null;
        Reassign firstConfirmReassign = null;
        int totalPeopleNumber = 0;
        List<String> orderIdList = new ArrayList<>();
        List<String> reassignIdList = new ArrayList<>();

        for (String id : orderIds) {
            OrderCrossCity orderCrossCity = orderCrossCityService.selectById(id);
            if (orderCrossCity == null) {
                continue;
            }
            orderCrossCity.setOldState(orderCrossCity.getState());

            Reassign reassignRecord = currentReassignMap.get(Integer.valueOf(id));
            if (reassignRecord != null) {
                reassignIdList.add(String.valueOf(reassignRecord.getId()));
            }

            if (orderCrossCity.getPeopleNumber() != null) {
                totalPeopleNumber += orderCrossCity.getPeopleNumber();
            }
            orderIdList.add(id);

            if (reassignRecord == null || reassignRecord.getNowDriverId() == null) {
                orderCrossCity.setState(11);
            } else {
                boolean needConfirm = reassignRecord.getNeedConfirm() != null && reassignRecord.getNeedConfirm() == 2;
                System.out.println("跨城指定司机免费改派确认判断: orderId=" + id
                        + ", reassignId=" + reassignRecord.getId()
                        + ", nowDriverId=" + reassignRecord.getNowDriverId()
                        + ", needConfirm=" + reassignRecord.getNeedConfirm()
                        + ", confirmStatus=" + reassignRecord.getConfirmStatus()
                        + ", state=" + reassignRecord.getState());

                if (needConfirm) {
                    orderCrossCity.setState(11);
                    needConfirmPush = true;
                    if (firstConfirmReassign == null) {
                        firstConfirmReassign = reassignRecord;
                    }
                    if (firstOrder == null) {
                        firstOrder = orderCrossCity;
                    }
                } else {
                    driverReassignSelf(reassignRecord, orderCrossCity);
                    try {
                        pushUtil.pushOrderReassign(orderCrossCity.getUserId(), 1, orderCrossCity.getId(), 3);
                        pushUtil.pushOrderReassign(orderCrossCity.getDriverId(), 2, orderCrossCity.getId(), 3);
                    } catch (Exception ignore) {
                    }
                }
            }

            orderCrossCity.setReassignNotice(2);
            orderCrossCity.setIsReassign(2);
            orderCrossCityService.updateById(orderCrossCity);
            incomeService.saveData(1, orderCrossCity.getCompanyId(), 4, orderCrossCity.getId(), 3, requestReassign.getMoney());
        }

        if (needConfirmPush && firstOrder != null && firstConfirmReassign != null) {
            System.out.println("准备发送跨城改派确认Socket(指定司机免费): driverId=" + firstConfirmReassign.getNowDriverId()
                    + ", reassignIds=" + String.join(",", reassignIdList)
                    + ", orderIds=" + String.join(",", orderIdList));
            sendReassignConfirmPush(firstConfirmReassign.getNowDriverId(), firstConfirmReassign, firstOrder, totalPeopleNumber, orderIdList, reassignIdList);
        } else {
            System.out.println("跨城改派确认Socket未发送(指定司机免费): needConfirmPush=" + needConfirmPush
                    + ", firstOrder=" + (firstOrder == null ? "null" : firstOrder.getId())
                    + ", firstConfirmReassign=" + (firstConfirmReassign == null ? "null" : firstConfirmReassign.getId()));
        }
    }

    private void ensureReassignConfirmTimeout(Reassign reassign) {
        reassign.setNeedConfirm(2);
        reassign.setConfirmStatus(1);
        if (reassign.getExpireTime() == null) {
            reassign.setExpireTime(new Date(System.currentTimeMillis() + 60000));
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void timeoutReassign(Reassign reassign) throws Exception {
        if (reassign == null) {
            return;
        }
        Reassign current = this.selectById(reassign.getId());
        if (current == null || current.getConfirmStatus() == null || current.getConfirmStatus() != 1) {
            return;
        }
        current.setConfirmStatus(4);
        current.setState(5);
        current.setConfirmTime(new Date());
        this.updateById(current);
        restoreCrossCityOrderAfterReassignEnd(current);
    }

    private void restoreCrossCityOrderAfterReassignEnd(Reassign reassign) {
        if (reassign == null || reassign.getOrderType() == null || reassign.getOrderType() != 3 || reassign.getOrderId() == null) {
            return;
        }
        OrderCrossCity order = orderCrossCityService.selectById(reassign.getOrderId());
        if (order == null || order.getState() == null || order.getState() != 11) {
            return;
        }
        order.setState(order.getOldState() == null ? 2 : order.getOldState());
        order.setReassignNotice(0);
        order.setIsReassign(1);
        orderCrossCityService.updateById(order);
    }
    private void restoreCrossCityOrderAfterReassignSuccess(OrderCrossCity order) {
        if (order == null || order.getState() == null || order.getState() != 11) {
            return;
        }
        order.setState(order.getOldState() == null ? 2 : order.getOldState());
        order.setReassignNotice(0);
        order.setIsReassign(1);
    }

    @Override
    public List<Map<String, Object>> queryDriver(String orderId) throws Exception {
        OrderCrossCity orderCrossCity = orderCrossCityService.selectById(orderId);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String day = sdf.format(new Date());
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        c.set(c.get(Calendar.YEAR), c.get(Calendar.MONTH), c.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
        c.set(Calendar.MILLISECOND, 0);
        List<Map<String, Object>> list = new ArrayList<>();

        // 1. 查询同批次同时间的司机（不需要确认）
        List<Map<String, Object>> sameBatchDrivers = querySameBatchDrivers(orderCrossCity, sdf, day, c);
        for (Map<String, Object> driver : sameBatchDrivers) {
            driver.put("needConfirm", 1); // 不需要确认
        }
        list.addAll(sameBatchDrivers);

        // 2. 查询其他同公司司机（需要确认）
        List<Map<String, Object>> otherCompanyDrivers = queryOtherCompanyDrivers(orderCrossCity, day);
        for (Map<String, Object> driver : otherCompanyDrivers) {
            driver.put("needConfirm", 2); // 需要确认
        }
        list.addAll(otherCompanyDrivers);

        return list;
    }

    /**
     * 查询同批次同时间的司机（原逻辑）
     */
    private List<Map<String, Object>> querySameBatchDrivers(OrderCrossCity orderCrossCity, SimpleDateFormat sdf, String day, Calendar c) throws Exception {
        List<Map<String, Object>> list = new ArrayList<>();
        List<LineShift> lineShifts = lineShiftMapper.getOtherDriverLineShift(orderCrossCity.getLineShiftDriverId());
        List<Map<String, Object>> s = lineSiteMapper.queryOtherDriver(orderCrossCity.getLineId(), sdf.parse(day), orderCrossCity.getDriverId());
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(sdf.parse(day));
        String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
        List<Integer> integers = new ArrayList<>();
        if (ToolUtil.isNotEmpty(vehicle)) {
            integers = JSON.parseArray(vehicle).toJavaList(Integer.class);
        }
        for (LineShift lineShift : lineShifts) {
            boolean b = true;
            String[] split = lineShift.getEndTime().split(":");
            calendar.set(Calendar.HOUR_OF_DAY, Integer.valueOf(split[0]));
            calendar.set(Calendar.MINUTE, Integer.valueOf(split[1]));
            if (calendar.getTimeInMillis() < System.currentTimeMillis()) {//结束时间小于当前时间不显示
                continue;
            }

            Map<String, Object> data = new HashMap<>();
            for (Map<String, Object> map : s) {
                //先判断司机是否在限制接单范围内
                boolean bo = false;
                for (Integer integer : integers) {
                    if (integer.compareTo(Integer.valueOf(map.get("driverId").toString())) == 0) {
                        bo = true;
                        break;
                    }
                }
                if (bo) {
                    continue;
                }

                int i = orderTaxiService.selectCount(new EntityWrapper<OrderTaxi>().eq("driverId", map.get("driverId")).in("state", Arrays.asList(2, 3, 4, 5, 11)).eq("DATE_FORMAT(travelTime, '%Y-%m-%d')", day));
                if (i > 0) {
                    continue;
                }
                i = orderPrivateCarService.selectCount(new EntityWrapper<OrderPrivateCar>().eq("driverId", map.get("driverId")).in("state", Arrays.asList(2, 3, 4, 5, 11)).eq("DATE_FORMAT(travelTime, '%Y-%m-%d')", day));
                if (i > 0) {
                    continue;
                }
                List<OrderCrossCity> driverId1 = orderCrossCityService.queryListOrder(Integer.valueOf(map.get("driverId").toString()), lineShift.getId(), Arrays.asList(5), day);
                if (driverId1.size() > 0) {
                    continue;
                }
                if (Integer.valueOf(map.get("laveSeat").toString()) < orderCrossCity.getPeopleNumber()) {
                    continue;
                }
                if (lineShift.getId().intValue() == Integer.valueOf(map.get("id").toString()).intValue()) {
                    b = false;
                    String content = map.get("content").toString();
                    JSONObject jsonObject = JSON.parseObject(content);
                    map.put("price", jsonObject.getString("num1"));
                    data = map;
                    list.add(data);
                }
            }
            if (b) {
                data.put("id", lineShift.getId());
                data.put("startTime", lineShift.getStartTime() + "-" + lineShift.getEndTime());
                list.add(data);
            }
        }
        return list;
    }

    /**
     * 查询其他同公司司机（需要确认）
     * 条件：同公司 + 该时段无排班 + 该时段无订单 + 座位数足够
     */
    private List<Map<String, Object>> queryOtherCompanyDrivers(OrderCrossCity orderCrossCity, String day) throws Exception {
        List<Map<String, Object>> list = new ArrayList<>();

        // 获取原司机信息
        Driver originalDriver = driverService.selectById(orderCrossCity.getDriverId());
        if (originalDriver == null || originalDriver.getCompanyId() == null) {
            return list;
        }

        // 获取班次时间信息
        LineShiftDriver originalLsd = lineShiftDriverMapper.selectById(orderCrossCity.getLineShiftDriverId());
        if (originalLsd == null) {
            return list;
        }
        LineShift lineShift = lineShiftMapper.selectById(originalLsd.getLineShiftId());
        if (lineShift == null) {
            return list;
        }

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date dayDate = sdf.parse(day);

        // 获取 VEHICLE 黑名单
        String vehicle = (String) redisTemplate.opsForValue().get("VEHICLE");
        List<Integer> blacklist = new ArrayList<>();
        if (ToolUtil.isNotEmpty(vehicle)) {
            blacklist = JSON.parseArray(vehicle).toJavaList(Integer.class);
        }

        // 查询同公司的所有空闲司机
        List<Driver> companyDrivers = driverService.selectList(
            new EntityWrapper<Driver>()
                .eq("companyId", originalDriver.getCompanyId())
                .eq("state", 2) // 空闲状态
                .ne("id", orderCrossCity.getDriverId()) // 排除当前司机
        );

        for (Driver driver : companyDrivers) {
            // 检查司机是否在黑名单中
            if (blacklist.contains(driver.getId())) {
                continue; // 黑名单司机，跳过
            }

            // 检查该司机在该时段是否有排班
            int shiftCount = lineShiftDriverMapper.selectCount(
                new EntityWrapper<LineShiftDriver>()
                    .eq("driverId", driver.getId())
                    .eq("day", dayDate)
                    .exists("SELECT 1 FROM t_line_shift ls WHERE ls.id = {0}.lineShiftId " +
                            "AND ls.startTime <= '" + lineShift.getEndTime() + "' " +
                            "AND ls.endTime >= '" + lineShift.getStartTime() + "'")
            );
            if (shiftCount > 0) {
                continue; // 该时段有排班，跳过
            }

            // 检查该司机在该时段是否有跨城订单（使用相同的方法检查）
            List<OrderCrossCity> orderList = orderCrossCityService.queryListOrder(
                driver.getId(),
                lineShift.getId(),
                Arrays.asList(2, 3, 4, 5), // 待出发、服务中等
                day
            );
            if (orderList != null && orderList.size() > 0) {
                continue; // 该时段有跨城订单，跳过
            }

            // 检查该司机在该时段是否有出租车订单
            int taxiOrderCount = orderTaxiService.selectCount(
                new EntityWrapper<OrderTaxi>()
                    .eq("driverId", driver.getId())
                    .in("state", Arrays.asList(2, 3, 4, 5, 11)) // 待出发、服务中等
                    .eq("DATE_FORMAT(travelTime, '%Y-%m-%d')", day)
            );
            if (taxiOrderCount > 0) {
                continue; // 该时段有出租车订单，跳过
            }

            // 检查该司机在该时段是否有专车订单
            int privateCarOrderCount = orderPrivateCarService.selectCount(
                new EntityWrapper<OrderPrivateCar>()
                    .eq("driverId", driver.getId())
                    .in("state", Arrays.asList(2, 3, 4, 5, 11)) // 待出发、服务中等
                    .eq("DATE_FORMAT(travelTime, '%Y-%m-%d')", day)
            );
            if (privateCarOrderCount > 0) {
                continue; // 该时段有专车订单，跳过
            }

            // 检查车辆信息和座位数
            if (driver.getCarId() == null) {
                continue; // 未分配车辆，跳过
            }
            Car car = carService.selectById(driver.getCarId());
            if (car == null || car.getCarModelId() == null) {
                continue; // 车辆不存在或未设置车型，跳过
            }

            // 从车型获取座位数
            CarModel carModel = carModelMapper.selectById(car.getCarModelId());
            if (carModel == null || carModel.getSeat() == null || carModel.getSeat() < orderCrossCity.getPeopleNumber()) {
                continue; // 座位数不足，跳过
            }

            // 构建返回数据
            Map<String, Object> data = new HashMap<>();
            data.put("id", lineShift.getId());
            data.put("lineShiftDriverId", null); // 无现有排班
            data.put("startTime", lineShift.getStartTime() + "-" + lineShift.getEndTime());
            data.put("headImgUrl", driver.getHeadImgUrl());
            data.put("name", driver.getName().substring(0, 1) + "师傅");
            data.put("carLicensePlate", car.getCarLicensePlate());
            data.put("carColor", car.getCarColor());
            data.put("driverId", driver.getId());
            data.put("carId", car.getId());
            data.put("totalSeat", carModel.getSeat() - 1); // 总座位数（减去司机位）
            data.put("laveSeat", carModel.getSeat() - 1); // 全部座位可用

            // 获取品牌型号
            if (car.getCarBrandId() != null && car.getCarModelId() != null) {
                CarBrand brand = carBrandMapper.selectById(car.getCarBrandId());
                CarModel model = carModelMapper.selectById(car.getCarModelId());
                if (brand != null && model != null) {
                    data.put("brand", brand.getName() + model.getName());
                }
            }

            // 设置默认评分
            data.put("evaluate", 5.0);

            list.add(data);
        }

        return list;
    }

    @Autowired
    private ICompanyCityService companyCityService;

    @Autowired
    private IPushOrderService pushOrderService;

    @Autowired
    private IOpenCityService openCityService;

    @Autowired
    private PushUtil pushUtil;

    /**
     * 推送订单给司机抢单
     * @param orderTaxi
     * @throws Exception
     */
    public void pushOrderTaxi(OrderTaxi orderTaxi, Integer uid, int type) throws Exception {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    orderIds.add(orderTaxi.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(orderTaxi.getStartLon().toString(), orderTaxi.getStartLat().toString());
                    List<PushOrder> querys = pushOrderService.querys(null, 2, openCity.getId());//获取需要推送的次数
                    int num = 0;
                    for (int j = 0; j < 6; j++) {
                        Boolean push = false;
                        for (int i = 1; i <= querys.size(); i++) {
                            num++;
                            int finalI = i;
                            PushOrder pushOrder = querys.stream().filter(s -> s.getType() == finalI).findFirst().orElse(null);
                            System.out.println("pushOrder:" + pushOrder);
                            //获取空闲司机
                            List<Driver> list = driverService.queryIdleDriver(2, orderTaxi.getStartLon(), orderTaxi.getStartLat(), pushOrder.getPushDistance(), null);//所有附近空闲司机
                            list = list.stream().filter(e -> e.getId() != uid).collect(Collectors.toList());
                            OrderTaxi orderTaxi1 = orderTaxiService.selectById(orderTaxi.getId());
                            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(), orderTaxi.getId(), 2, orderTaxi.getState(), pushOrder.getPushTime());
                                }
                            }
                            Thread.sleep(pushOrder.getPushTime() * 1000);//设置等待时间
                            Integer state = orderTaxi1.getState();
                            if (state != 1 && state != 11) {
                                orderIds.remove(orderTaxi.getId());
                                push = true;
                                break;
                            }
                            if (num == 18 && (state == 1 || state == 11)) {
                                System.err.println("结束改派退单-------------修改订单为取消状态");
                                pushUtil.pushEndPush(1, orderTaxi.getUserId(), orderTaxi.getId(), 2, 11);
                                pushUtil.pushOrderState(2, orderTaxi.getDriverId(), orderTaxi.getId(), 2, 10);
                                orderTaxi1.setState(10);
                                orderTaxiService.updateById(orderTaxi1);
                                Driver driver = driverService.selectById(orderTaxi1.getDriverId());
                                driver.setState(2);
                                driverService.updateById(driver);
                                orderIds.remove(orderTaxi.getId());
                            }
                        }
                        if (push) {
                            break;
                        }
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }


    /**
     * 推送抢单数据
     * @param orderPrivateCar
     * @throws Exception
     */
    public void pushOrderPrivate(OrderPrivateCar orderPrivateCar, Integer uid, int type) throws Exception {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    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());
                    List<PushOrder> querys = pushOrderService.querys(null, 1, openCity.getId());//获取需要推送的次数
                    int num = 0;
                    for (int j = 0; j < 6; j++) {
                        Boolean push = false;
                        for (int i = 1; i <= querys.size(); i++) {
                            num++;
                            OrderPrivateCar orderPrivateCar = orderPrivateCarService.selectById(id);
                            if (null == orderPrivateCar || (orderPrivateCar.getState() > 1 && orderPrivateCar.getState() != 11)) {
                                push = true;
                                break;
                            }
                            int finalI = i;
                            PushOrder pushOrder = querys.stream().filter(s -> s.getType() == (finalI <= 3 ? finalI : 3)).findFirst().orElse(null);
                            System.out.println("pushOrder:" + pushOrder);

                            if (orderPrivateCar.getState() > 1 && orderPrivateCar.getState() != 11) {
                                push = true;
                                break;
                            }
                            //获取空闲司机
                            List<Driver> list = driverService.queryIdleDriver(orderType, orderPrivateCar.getServerCarModelId(), orderPrivateCar.getStartLon(), orderPrivateCar.getStartLat(), pushOrder.getPushDistance(), null);//所有附近空闲司机
                            list = list.stream().filter(e -> !e.getId().equals(uid)).collect(Collectors.toList());
                            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(pushOrder.getPushTime() * 1000);//设置等待时间
                            Integer state = orderPrivateCar.getState();
                            if (state > 1 && state != 11) {
                                orderIds.remove(orderPrivateCar.getId());
                                push = true;
                                return;
                            }
                            if (num == 18 && (state == 1 || state == 11)) {
                                System.err.println("结束改派退单-------------修改订单为取消状态");
                                pushUtil.pushEndPush(1, orderPrivateCar.getUserId(), orderPrivateCar.getId(), 1, 11);
                                pushUtil.pushReassignEndCancel(2, orderPrivateCar.getDriverId(), orderPrivateCar.getId(), 1, 10);
                                orderPrivateCar.setState(10);
                                orderPrivateCarService.updateById(orderPrivateCar);
                                Driver driver = driverService.selectById(orderPrivateCar.getDriverId());
                                driver.setState(2);
                                driverService.updateById(driver);
                                orderIds.remove(orderPrivateCar.getId());
                            }
                        }
                        if (push) {
                            break;
                        }
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    /**
     * 检查是否需要对方确认
     * @param targetId 正数为同批次 lineShiftDriverId，负数为扩展司机的 0-driverId
     * @param orderCrossCity 订单
     * @return true=需要确认, false=不需要确认
     */
    private boolean checkIfNeedConfirm(Integer targetId, OrderCrossCity orderCrossCity) {
        try {
            if (targetId == null || orderCrossCity == null || orderCrossCity.getLineShiftDriverId() == null) {
                return true;
            }
            if (targetId < 0) {
                return true;
            }
            LineShiftDriver targetLineShiftDriver = lineShiftDriverMapper.selectById(targetId);
            if (targetLineShiftDriver == null) {
                return true;
            }
            LineShiftDriver originalLsd = lineShiftDriverMapper.selectById(orderCrossCity.getLineShiftDriverId());
            if (originalLsd == null || targetLineShiftDriver.getLineShiftId() == null || originalLsd.getLineShiftId() == null) {
                return true;
            }
            return targetLineShiftDriver.getLineShiftId().compareTo(originalLsd.getLineShiftId()) != 0
                    || targetLineShiftDriver.getDay() == null
                    || originalLsd.getDay() == null
                    || !new SimpleDateFormat("yyyy-MM-dd").format(targetLineShiftDriver.getDay())
                    .equals(new SimpleDateFormat("yyyy-MM-dd").format(originalLsd.getDay()));
        } catch (Exception e) {
            e.printStackTrace();
            return true; // 出错默认需要确认
        }
    }

    private boolean isAssignedReassignTarget(Integer targetId) {
        return targetId != null && targetId != 0;
    }

    private boolean isActiveReassign(Reassign reassign) {
        if (reassign == null) {
            return false;
        }
        if (reassign.getState() != null && (reassign.getState() == 4 || reassign.getState() == 5)) {
            return false;
        }
        return reassign.getConfirmStatus() == null
                || (reassign.getConfirmStatus() != 3 && reassign.getConfirmStatus() != 4);
    }

    private Integer resolveConfirmDriverId(Integer targetId) {
        if (targetId == null) {
            return null;
        }
        if (targetId < 0) {
            return 0 - targetId;
        }
        LineShiftDriver lineShiftDriver = lineShiftDriverMapper.selectById(targetId);
        return lineShiftDriver == null ? targetId : lineShiftDriver.getDriverId();
    }

    /**
     * 发送改派确认推送给目标司机（使用Socket推送，不用极光推送）
     * @param driverId 目标司机ID
     * @param reassign 改派记录
     * @param order 订单信息
     * @param totalPeopleNumber 总人数（已在调用处计算好）
     * @param orderIdList 订单ID列表
     * @param reassignIdList 改派记录ID列表
     */
    private void sendReassignConfirmPush(Integer driverId, Reassign reassign, OrderCrossCity order, int totalPeopleNumber, List<String> orderIdList, List<String> reassignIdList) {
        try {
            System.out.println("进入跨城改派确认Socket发送方法: driverId=" + driverId
                    + ", reassignId=" + (reassign == null ? "null" : reassign.getId())
                    + ", orderId=" + (order == null ? "null" : order.getId())
                    + ", totalPeopleNumber=" + totalPeopleNumber);
            // 使用订单的起点和终点地址（订单的startAddress和endAddress就是跨城站点地址）
            String startSite = order.getStartAddress() != null ? order.getStartAddress() : "";
            String endSite = order.getEndAddress() != null ? order.getEndAddress() : "";

            // 转换时间为字符串
            SimpleDateFormat dateTimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String travelTime = order.getTravelTime() != null ? dateTimeFormat.format(order.getTravelTime()) : "";
            String expireTime = reassign.getExpireTime() != null ? dateTimeFormat.format(reassign.getExpireTime()) : "";

            // 使用 Socket 推送（不用极光推送）
            pushUtil.pushReassignConfirmRequest(
                driverId,
                String.join(",", reassignIdList), // 改派记录ID列表（逗号分隔）
                String.join(",", orderIdList),     // 订单ID列表（逗号分隔）
                startSite,
                endSite,
                totalPeopleNumber,
                travelTime,
                expireTime
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 为司机创建临时 LineShiftDriver
     * @param order 订单
     * @param driverId 司机ID
     * @return 新创建的 LineShiftDriverId
     */
    private Integer createTempLineShiftDriver(OrderCrossCity order, Integer driverId) throws Exception {
        return createTempLineShiftDriver(order, driverId, order.getPeopleNumber());
    }

    private Integer createTempLineShiftDriver(OrderCrossCity order, Integer driverId, Integer peopleNumber) throws Exception {
        // 获取原始班次信息
        LineShiftDriver originalLsd = lineShiftDriverMapper.selectById(order.getLineShiftDriverId());
        if (originalLsd == null) {
            throw new Exception("原始班次信息不存在");
        }

        // 创建新的 LineShiftDriver
        LineShiftDriver tempLsd = new LineShiftDriver();
        tempLsd.setLineShiftId(originalLsd.getLineShiftId()); // 相同班次
        tempLsd.setDriverId(driverId); // 新司机
        tempLsd.setDay(originalLsd.getDay());

        Driver driver = driverService.selectById(driverId);
        if (driver == null) {
            throw new Exception("司机信息不存在");
        }

        Car car = carService.selectById(driver.getCarId());
        if (car == null || car.getCarModelId() == null) {
            throw new Exception("车辆信息不存在或未设置车型");
        }

        // 从车型获取座位数
        CarModel carModel = carModelMapper.selectById(car.getCarModelId());
        if (carModel == null || carModel.getSeat() == null) {
            throw new Exception("车型信息不存在");
        }

        int totalSeat = carModel.getSeat() - 1; // 总座位数（减去司机位）
        tempLsd.setTotalSeat(totalSeat);
        tempLsd.setLaveSeat(totalSeat);

        // 新建临时班次时先放全部可用座位，后续统一按本批总人数扣减。
        StringBuilder seatNumbers = new StringBuilder();
        for (int i = 1; i <= totalSeat; i++) {
            if (i > 1) seatNumbers.append(",");
            seatNumbers.append(i);
        }
        tempLsd.setLaveSeatNumber(seatNumbers.toString());

        tempLsd.setInserTime(new Date());

        lineShiftDriverMapper.insert(tempLsd);
        return tempLsd.getId();
    }

    /**
     * 通知原司机改派成功（使用Socket推送）
     */
    private void pushReassignSuccess(Reassign reassign) {
        try {
            pushUtil.pushReassignSuccess(
                reassign.getOriginalDriverId(),
                reassign.getId(),
                reassign.getOrderId(),
                reassign.getOrderType()
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 通知原司机改派被拒绝（使用Socket推送）
     */
    private void pushReassignRejected(Reassign reassign) {
        try {
            pushUtil.pushReassignRejected(
                reassign.getOriginalDriverId(),
                reassign.getId(),
                reassign.getOrderId(),
                reassign.getOrderType()
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 通知原司机改派超时（使用Socket推送）
     */
    private void pushReassignTimeout(Reassign reassign) {
        try {
            pushUtil.pushReassignTimeout(
                reassign.getOriginalDriverId(),
                reassign.getId(),
                reassign.getOrderId(),
                reassign.getOrderType()
            );
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public ResultUtil respondReassign(Integer reassignId, Integer driverId, Integer responseType) {
        // 兼容旧接口：单个改派记录
        return respondReassignBatch(String.valueOf(reassignId), driverId, responseType);
    }

    /**
     * 批量响应改派请求（同意或拒绝）
     * @param reassignIds 改派记录ID列表（逗号分隔）
     * @param driverId 司机ID
     * @param responseType 响应类型（1=同意，2=拒绝）
     * @return 处理结果
     */
    @Transactional(rollbackFor = Exception.class)
    public ResultUtil respondReassignBatch(String reassignIds, Integer driverId, Integer responseType) {
        try {
            if (reassignIds == null || reassignIds.trim().isEmpty()) {
                return reassignResponse("改派申请ID不能为空", false);
            }

            String[] idArray = reassignIds.split(",");
            List<Reassign> reassignList = new ArrayList<>();

            // 第一步：验证所有改派记录
            for (String idStr : idArray) {
                Integer reassignId = Integer.valueOf(idStr.trim());
                Reassign reassign = this.baseMapper.selectById(reassignId);

                if (reassign == null) {
                    return reassignResponse("改派申请不存在: " + reassignId, false);
                }

                // 验证权限：检查nowDriverId是否匹配
                if (reassign.getNowDriverId() == null || !reassign.getNowDriverId().equals(driverId)) {
                    return reassignResponse("无权操作改派申请: " + reassignId, false);
                }

                // 幂等性检查：只有待确认状态才能响应
                if (reassign.getConfirmStatus() != 1) {
                    if (reassign.getConfirmStatus() == 2) {
                        return reassignResponse("改派申请已被接受: " + reassignId, false);
                    } else if (reassign.getConfirmStatus() == 3) {
                        return reassignResponse("改派申请已被拒绝: " + reassignId, false);
                    } else if (reassign.getConfirmStatus() == 4) {
                        return reassignResponse("改派申请已超时: " + reassignId, false);
                    } else {
                        return reassignResponse("改派申请已处理: " + reassignId, false);
                    }
                }

                // 验证是否超时
                if (new Date().after(reassign.getExpireTime())) {
                    reassign.setConfirmStatus(4);
                    this.updateById(reassign);
                    return reassignResponse("改派申请已超时: " + reassignId, false);
                }

                reassignList.add(reassign);
            }

            // 第二步：批量处理所有改派记录
            if (responseType == 1) {
                // 同意改派
                List<OrderCrossCity> orderList = new ArrayList<>();
                int totalPeopleNumber = 0;
                for (Reassign reassign : reassignList) {
                    OrderCrossCity order = orderCrossCityService.selectById(reassign.getOrderId());
                    if (order == null) {
                        return reassignResponse("订单不存在: " + reassign.getOrderId(), false);
                    }
                    if (order.getState() != 11) {
                        return reassignResponse("订单状态已变更，无法改派: " + order.getId(), false);
                    }
                    orderList.add(order);
                    if (order.getPeopleNumber() != null) {
                        totalPeopleNumber += order.getPeopleNumber();
                    }
                }

                OrderCrossCity firstOrder = orderList.get(0);
                String batchOrderNum = firstOrder.getOrderNum();
                Integer tempLineShiftDriverId = createTempLineShiftDriver(firstOrder, driverId, totalPeopleNumber);
                Reassign tempReassign = new Reassign();
                tempReassign.setNowDriverId(tempLineShiftDriverId);
                driverReassignSelf(tempReassign, firstOrder, totalPeopleNumber);

                LineShiftDriver tempLineShiftDriver = lineShiftDriverMapper.selectById(tempLineShiftDriverId);
                Driver targetDriver = driverService.selectById(driverId);

                for (int i = 0; i < reassignList.size(); i++) {
                    Reassign reassign = reassignList.get(i);
                    OrderCrossCity order = orderList.get(i);
                    // 使用乐观锁更新状态
                    reassign.setConfirmStatus(2);
                    reassign.setConfirmTime(new Date());
                    reassign.setTempLineShiftDriverId(tempLineShiftDriverId);
                    int updateCount = this.baseMapper.update(reassign,
                        new EntityWrapper<Reassign>()
                            .eq("id", reassign.getId())
                            .eq("confirmStatus", 1) // 只有待确认状态才能更新
                    );

                    if (updateCount == 0) {
                        return reassignResponse("改派申请已被处理: " + reassign.getId(), false);
                    }

                    order.setDriverId(tempLineShiftDriver.getDriverId());
                    order.setLineShiftDriverId(tempLineShiftDriverId);
                    order.setOrderNum(batchOrderNum);
                    restoreCrossCityOrderAfterReassignSuccess(order);
                    if (targetDriver != null) {
                        order.setCarId(targetDriver.getCarId());
                    }
                    orderCrossCityService.updateById(order);

                    // 推送乘客和司机通知
                    try {
                        pushUtil.pushOrderReassign(order.getUserId(), 1, order.getId(), 3);
                        //司机就是发起确定的人 这里就不需要通知司机了
                    } catch (Exception ignore) {
                    }
                }

                // 通知原司机改派成功（只通知一次）
                if (!reassignList.isEmpty()) {
                    pushReassignSuccess(reassignList.get(0));
                }

                return reassignResponse("批量改派成功，共处理 " + reassignList.size() + " 条订单", true);

            } else {
                // 拒绝改派
                for (Reassign reassign : reassignList) {
                    reassign.setConfirmStatus(3);
                    reassign.setConfirmTime(new Date());
                    int updateCount = this.baseMapper.update(reassign,
                        new EntityWrapper<Reassign>()
                            .eq("id", reassign.getId())
                            .eq("confirmStatus", 1)
                    );

                    if (updateCount == 0) {
                        return reassignResponse("改派申请已被处理: " + reassign.getId(), false);
                    }
                    restoreCrossCityOrderAfterReassignEnd(reassign);
                }

                // 通知原司机被拒绝（只通知一次）
                if (!reassignList.isEmpty()) {
                    pushReassignRejected(reassignList.get(0));
                }

                return reassignResponse("已拒绝改派，共 " + reassignList.size() + " 条订单", true);
            }

        } catch (Exception e) {
            e.printStackTrace();
            return reassignResponse("操作失败：" + e.getMessage(), false);
        }
    }

    private ResultUtil<Boolean> reassignResponse(String message, boolean success) {
        return ResultUtil.success(message, success);
    }

    @Override
    public List<Map<String, Object>> queryPendingReassigns(Integer driverId) {
        try {
            List<Reassign> list = this.selectList(
                new EntityWrapper<Reassign>()
                    .eq("nowDriverId", driverId)
                    .eq("needConfirm", 2)
                    .eq("confirmStatus", 1)
                    .gt("expireTime", new Date()) // 未超时
                    .orderBy("insertTime", false)
            );

            List<Map<String, Object>> result = new ArrayList<>();
            for (Reassign reassign : list) {
                Map<String, Object> data = new HashMap<>();
                data.put("reassignId", reassign.getId());
                data.put("orderId", reassign.getOrderId());
                data.put("orderType", reassign.getOrderType());
                data.put("expireTime", reassign.getExpireTime());
                data.put("reason", reassign.getReason());
                data.put("insertTime", reassign.getInsertTime());

                // 获取订单详情
                if (reassign.getOrderType() == 3) {
                    OrderCrossCity order = orderCrossCityService.selectById(reassign.getOrderId());
                    if (order != null) {
                        data.put("startAddress", order.getStartAddress());
                        data.put("endAddress", order.getEndAddress());
                        data.put("peopleNumber", order.getPeopleNumber());
                        data.put("travelTime", order.getTravelTime());
                        data.put("orderMoney", order.getOrderMoney());
                    }
                }

                // 获取原司机信息
                Driver originalDriver = driverService.selectById(reassign.getOriginalDriverId());
                if (originalDriver != null) {
                    data.put("originalDriverName", originalDriver.getName());
                    data.put("originalDriverPhone", originalDriver.getPhone());
                }

                result.add(data);
            }

            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

}