package com.zteits.ipay.biz;

import org.apache.commons.lang3.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.clouds.common.cache.park.ParkingLotCacheUtil;
import com.clouds.common.cache.sys.SysCodeValueCacheUtil;
import com.clouds.common.constants.CodeValKindEnum;
import com.xiaoleilu.hutool.util.CollectionUtil;
import com.zteits.clouds.api.apibase.bean.BizResult;
import com.zteits.clouds.api.apibase.constants.*;
import com.zteits.clouds.api.apibase.exception.BizException;
import com.zteits.clouds.api.dto.order.closecarpark.QueryCompanyAccountByOrderInfoRequest;
import com.zteits.clouds.api.dto.order.payorder.dto.PayOrderDTO;
import com.zteits.clouds.api.dto.park.dto.ParkingLotDTO;
import com.zteits.clouds.api.dto.park.param.QueryParkLotInfoByPkNoRequest;
import com.zteits.clouds.api.dto.pay.NoPassPayDTO;
import com.zteits.clouds.api.dto.pay.TdCCarDTO;
import com.zteits.clouds.api.dto.pay.TdCCustPersonDTO;
import com.zteits.clouds.api.dto.pay.dto.CompanyAccountDTO;
import com.zteits.clouds.api.dto.pay.dto.TdCStoreCarDTO;
import com.zteits.clouds.api.dto.pay.param.NoPassPayRequest;
import com.zteits.clouds.api.dto.pay.param.TdCCarRequest;
import com.zteits.clouds.api.dto.pay.param.TdCCustPersonRequest;
import com.zteits.clouds.api.dto.pay.param.TdCStoreCarRequest;
import com.zteits.clouds.api.dto.third.jiangyin.IsLeaveBeforePaidCheckRequest;
import com.zteits.clouds.api.service.order.pay.NoPassPayService;
import com.zteits.clouds.api.service.park.ParkingLotQueryService;
import com.zteits.clouds.api.service.pay.CompanyAccountQueryService;
import com.zteits.clouds.api.service.pay.TdCCarService;
import com.zteits.clouds.api.service.pay.TdCCustPersonService;
import com.zteits.clouds.api.service.pay.appservice.query.TdCStoreCarQueryService;
import com.zteits.ipay.service.apppubpay.busigroup.base.CommonBusiPayInnerService;
import com.zteits.ipay.service.bank.ABCBankPayInnerService;
import com.zteits.ipay.service.bank.vo.ABCBankQueryStateReq;
import com.zteits.ipay.service.nopasspay.NoPassPayInnerService;
import com.zteits.ipay.util.alipay.AliSyncUtil;
import com.zteits.order.dao.parkorder.OrderParkDao;
import com.zteits.order.domain.OrderPark;
import com.zteits.order.domain.PayOrder;
import com.zteits.order.service.payorder.oper.PubPayOrderOperInnerService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

@Service("com.zteits.ipay.biz.NoPassPayServiceImpl")
public class NoPassPayServiceImpl extends CommonBusiPayInnerService implements NoPassPayService {

    private static final Logger logger = LoggerFactory.getLogger(NoPassPayServiceImpl.class);
    @Autowired
    private NoPassPayInnerService noPassPayInnerService;
    @Autowired
    private OrderParkDao orderParkDao;
    @Autowired
    private TdCCarService tdCCarService;
    @Autowired
    private TdCStoreCarQueryService tdCStoreCarQueryService;
    @Autowired
    private PushPaySuccessMsgService pushPaySuccessMsgService;
    @Autowired
    private PubPayOrderOperInnerService pubPayOrderOperInnerService;
    @Autowired
    private ParkingLotQueryService parkingLotQueryService;

    @Autowired
    private TdCCustPersonService tdCCustPersonService;

    @Autowired
    private ABCBankPayInnerService abcBankPayInnerService;

    @Autowired
    private CompanyAccountQueryService companyAccountQueryService;

//    @Autowired
//    private PlatformService platformService;


    /**
     * 道闸免密支付
     *
     * @Modify niueb 2020/6/28 免密支付新增ETC支付
     */
    @Transactional
    @Override
    public BizResult<NoPassPayDTO> noPassPay(NoPassPayRequest request) {
        logger.info("道闸免密支付：" + JSON.toJSONString(request));
        NoPassPayDTO noPassPayDTO = new NoPassPayDTO();
        try {
            //通过道闸编号获取订单信息
            OrderPark orderPark = orderParkDao.queryParkOrderByPlNoAndRecordId(request.getParkCode(), request.getRecordId());
            if (orderPark == null) {
                throw new BizException(ErrorType.BIZ_ERROR, "根据RecordId" + request.getRecordId() + "没有找到对应的订单");
            }

            /**0.ETC支付**/
            noPassPayDTO = this.etcNoPassPay(noPassPayDTO, orderPark, request);
            logger.info("ETC支付返回参数：" + JSONObject.toJSONString(noPassPayDTO));
            if (noPassPayDTO.getRespCode().equals("0")) {
                return new BizResult<>(noPassPayDTO);
            }

            /** 4.临时使用支付宝的代缴接口 订单不同单独做 目前没有实现 **/
            logger.info("支付宝的代缴开始：" + JSONObject.toJSONString(orderPark));
            noPassPayDTO = this.alipayEcoMycarParkingOrderPay(noPassPayDTO, orderPark, request);
            logger.info("支付宝的代缴返回参数：" + JSONObject.toJSONString(noPassPayDTO));
            if (noPassPayDTO.getRespCode().equals("0")) {
                return new BizResult<>(noPassPayDTO);
            }

//            /**1.先判断储值卡账户扣款*/
//            OrderPark storeOrderPark = new OrderPark();
//            BeanUtils.copyProperties(orderPark, storeOrderPark);
//            noPassPayDTO = this.storeCarNoPassPay(noPassPayDTO, storeOrderPark, request);
//            logger.info("储值卡扣款返回参数：" + JSONObject.toJSONString(noPassPayDTO));
//            if (noPassPayDTO.getRespCode().equals("0")) {
//                return new BizResult<>(noPassPayDTO);
//            }

//            /*.-----------增加判断封闭车场公司储值卡账户扣款开始--zengqc 2020-12-28*/
////            this.closedParkStoreCarNoPassPay(noPassPayDTO, storeOrderPark, request);
////            logger.info("封闭车场公司储值卡账户扣款返回参数[respCode:0成功]：" + JSONObject.toJSONString(noPassPayDTO));
//            if (noPassPayDTO.getRespCode().equals("0")) {
//                return new BizResult<>(noPassPayDTO);
//            }
//            logger.info("封闭车场公司储值卡账户扣款失败，进行下一步支付");

            /* ---------增加判断封闭车场公司储值卡账户扣款结束--zengqc 2020-12-28 */

            /**2.储值卡扣款失败，进行个人账户无感支付**/
//            noPassPayDTO = this.custAcctNoPassPay(noPassPayDTO, orderPark, request);
//            logger.info("个人账户无感支付返回参数：" + JSONObject.toJSONString(noPassPayDTO));
//            if (noPassPayDTO.getRespCode().equals("0")) {
//                return new BizResult<>(noPassPayDTO);
//            }
//            /**3.个人账户无感支付失败，农行无感支付**/
//            noPassPayDTO = this.abcBankAcctNoPassPay(noPassPayDTO, orderPark, request);
//            logger.info("农行无感支付返回参数：" + JSONObject.toJSONString(noPassPayDTO));
//            if (noPassPayDTO.getRespCode().equals("0")) {
//                return new BizResult<>(noPassPayDTO);
//            }

        } catch (Exception e) {
            noPassPayDTO.setRespCode("1");
            logger.error("道闸免密支付失败{}", e.getMessage());
        }
        return new BizResult<NoPassPayDTO>(noPassPayDTO);
    }

    @Override
    public BizResult<Boolean> queryABCContractType(NoPassPayRequest noPassPayRequest) {
        try {
            ParkingLotDTO parkingLotDTO = ParkingLotCacheUtil.getParkLotByPlNo(noPassPayRequest.getParkCode());
            ABCBankQueryStateReq abcBankQueryStateReq = new ABCBankQueryStateReq();
            String appId = this.getAppIdByOrgId(parkingLotDTO.getOrgId(), PayTypeEnum.ABC_BANK_PAY.getValue());
            abcBankQueryStateReq.setPartnerId(appId);
            abcBankQueryStateReq.setCarNo(noPassPayRequest.getCarNumber());
            if (noPassPayRequest.getVplType().equals("1")) {
                abcBankQueryStateReq.setPlateColor("YELLOW");
            }
            if (noPassPayRequest.getVplType().equals("4")) {
                abcBankQueryStateReq.setPlateColor("GREEN");
            }
            Boolean state = abcBankPayInnerService.queryContractType(abcBankQueryStateReq);
            return new BizResult<>(state);
        } catch (Exception e) {
            logger.error("查询农行无感支付状态报错", e);
        }
        return new BizResult<>(false);
    }

    @Override
    public BizResult<Boolean> isLeaveBeforePaidCheck(IsLeaveBeforePaidCheckRequest isLeaveBeforePaidCheckRequest) {
        return null;
    }


    /**
     * ETC免密支付
     * 调用ETC天线deduct接口完成扣费
     */
    private NoPassPayDTO etcNoPassPay(NoPassPayDTO noPassPayDTO, OrderPark orderPark, NoPassPayRequest request) {
        logger.info("ETC免密支付:" + orderPark.getCarNumber());
        try {
            // 判断车场和用户是否支持ETC支付
            if (!this.checkIsUseETCpay(orderPark)) {
                noPassPayDTO.setRespCode("1");
                logger.info("车场{}或用户{}不支持ETC支付", orderPark.getPlNo(), orderPark.getCarNumber());
                return noPassPayDTO;
            }
            // 调用ETC扣费
            PayOrderDTO payOrder = noPassPayInnerService.etcNoPassPay(orderPark,
                    new BigDecimal(request.getAccount()).longValue(), request.getChargerCode(), request.getsOpName());

            // 更新订单金额
            Long orderActFee = payOrder.getOrderActFee();
            Long orderTotalFee = payOrder.getOrderTotalFee();
            Long orderDicountFee = payOrder.getOrderDicountFee();
            OrderPark upOrderPark = new OrderPark();
            upOrderPark.setId(orderPark.getId());
            upOrderPark.setOrderState(OrderStateEnum.PAYED.value());
            upOrderPark.setOrderTotalFee(orderPark.getOrderTotalFee() + orderTotalFee);
            upOrderPark.setOrderActFee(orderPark.getOrderActFee() + orderActFee);
            upOrderPark.setOrderDicountFee(orderPark.getOrderDicountFee() + orderDicountFee);
            orderParkDao.updateOrderParkById(upOrderPark);

            noPassPayDTO.setOrderNo(payOrder.getRltOrderId());
            noPassPayDTO.setRespCode("0");

            // 发送支付成功消息
            List<PayOrderDTO> payOrderDTOS = new ArrayList<>();
            payOrderDTOS.add(payOrder);
            pushPaySuccessMsgService.sendPaySuccessMsg(payOrderDTOS);
        } catch (Exception e) {
            noPassPayDTO.setRespCode("1");
            logger.error("ETC免密支付失败", e);
        }
        return noPassPayDTO;
    }

    /**
     * 判断是否使用ETC支付
     *
     * @param orderPark
     * @return
     */
    private boolean checkIsUseETCpay(OrderPark orderPark) {
        /**判断当前车场是否支持ETC支付*/
        QueryParkLotInfoByPkNoRequest parkReq = new QueryParkLotInfoByPkNoRequest();
        parkReq.setPklNo(orderPark.getPlNo());
        parkReq.setSysCode(BasicEnum.SYS_CODE.getValue());
        BizResult<ParkingLotDTO> parkingLotDTOBizResult = parkingLotQueryService.QueryParkingLotByPkNo(parkReq);
        //如果不支持，直接返回
        if (!parkingLotDTOBizResult.isSuccess() || parkingLotDTOBizResult.getData() == null
                || parkingLotDTOBizResult.getData().getSupportEtc() == 0) {
            return false;
        }else {
            return true;
        }
        }
//        /**判断当前用户是否开通ETC支付*/
//        TdCCustPersonRequest personRequest = new TdCCustPersonRequest();
//        personRequest.setCustId(orderPark.getCustId());
//        personRequest.setSysCode(BasicEnum.SYS_CODE.getValue());
//        BizResult<TdCCustPersonDTO> bizResult = tdCCustPersonService.selectByCustId(personRequest);
//        if (!bizResult.isSuccess() || bizResult.getData() == null) {
//            return false;
//        }
//        return bizResult.getData().getEtcOpenState() == 1 ? true : false;
//    }

    /**
     * 根据车牌号查询客户ID
     *
     * @param carNumber
     * @return 2017年11月22日 zhaowg
     */
    private String getCustIdByCarNo(String carNumber) {
        logger.info("根据车牌号查询客户ID：" + carNumber);
        if (StringUtils.isBlank(carNumber)) {
            return null;
        }
        TdCCarRequest request = new TdCCarRequest();
        request.setCarNumber(carNumber);
        request.setSysCode(BasicEnum.SYS_CODE.getValue());
        BizResult<List<TdCCarDTO>> rs = tdCCarService.selectCustInfo(request);
        if (!rs.isSuccess() || CollectionUtil.isEmpty(rs.getData())) {
            return null;
        }
        return rs.getData().get(0).getCustId();
    }

    /**
     * 根据车牌号查询储值车客户ID
     *
     * @param
     * @return
     * @Author: xiejianpeng
     * @Date: 2019/12/11 14:22
     */
    private String getStoreCustIdByCarNo(String carNumber, Long orgId) {
        logger.info("根据车牌号查询储值车客户ID：" + carNumber);
        if (StringUtils.isBlank(carNumber)) {
            return null;
        }
        TdCStoreCarRequest request = new TdCStoreCarRequest();
        request.setCarNumber(carNumber);
        request.setOrgId(orgId);
        request.setSysCode(BasicEnum.SYS_CODE.getValue());
        BizResult<List<TdCStoreCarDTO>> rs = tdCStoreCarQueryService.queryTdCStoreCar(request);
        if (!rs.isSuccess() || CollectionUtil.isEmpty(rs.getData())) {
            return null;
        }
        return rs.getData().get(0).getCustId();
    }

    /**
     * 储值车无感支付
     *
     * @param
     * @return
     * @Author: xiejianpeng
     * @Date: 2019/12/11 14:29
     */
    private NoPassPayDTO storeCarNoPassPay(NoPassPayDTO noPassPayDTO, OrderPark orderPark, NoPassPayRequest request) {
        logger.info("储值车无感支付:" + orderPark.getCarNumber());
        try {
            //该车牌对应的custId
            if (StringUtils.isBlank(orderPark.getCustId())) {
                String custId = this.getStoreCustIdByCarNo(orderPark.getCarNumber(), orderPark.getOrgId());
                if (StringUtils.isBlank(custId)) {
                    throw new BizException(ErrorType.NOTFUND_CUSTID_BY_CARNO);
                }
                orderPark.setCustId(custId);
            }
            PayOrderDTO payOrder = noPassPayInnerService.storeCarNoPassPay(orderPark, new BigDecimal(request.getAccount()).longValue(), request.getChargerCode(), request.getsOpName());
            //更新订单上金额
            /**优惠金额 单位:分*/
            Long orderDicountFee = payOrder.getOrderDicountFee();
            /**支付单实收 单位:分*/
            Long orderActFee = payOrder.getOrderActFee();
            /**支付单应收 单位:分*/
            Long orderTotalFee = payOrder.getOrderTotalFee();
            OrderPark upOrderPark = new OrderPark();
            upOrderPark.setId(orderPark.getId());
            upOrderPark.setOrderState(OrderStateEnum.PAYED.value());
            upOrderPark.setOrderTotalFee(orderPark.getOrderTotalFee() + orderTotalFee);
            upOrderPark.setOrderActFee(orderPark.getOrderActFee() + orderActFee);
            upOrderPark.setOrderDicountFee(orderPark.getOrderDicountFee() + orderDicountFee);
            orderParkDao.updateOrderParkById(upOrderPark);

            noPassPayDTO.setOrderNo(payOrder.getRltOrderId());
            noPassPayDTO.setRespCode("0");
            /**发送支付成功消息，用于处理其他非紧急事件，例如激光推送支付消息，根据赠送规则赠送积分，代金券等*/
            List<PayOrderDTO> payOrderDTOS = new ArrayList<>();
            payOrderDTOS.add(payOrder);
            pushPaySuccessMsgService.sendPaySuccessMsg(payOrderDTOS);
        } catch (Exception e) {
            noPassPayDTO.setRespCode("1");
            logger.error("储值车道闸免密支付失败", e);
        }
        return noPassPayDTO;
    }

    /**
     * 账户余额无感支付
     *
     * @param
     * @return
     * @Author: xiejianpeng
     * @Date: 2019/12/11 14:29
     */
    private NoPassPayDTO custAcctNoPassPay(NoPassPayDTO noPassPayDTO, OrderPark orderPark, NoPassPayRequest request) {
        logger.info("账户余额无感支付:" + orderPark.getCustId());
        try {
            //该车牌对应的custId
            if (StringUtils.isBlank(orderPark.getCustId())) {
                String custId = this.getCustIdByCarNo(orderPark.getCarNumber());
                if (StringUtils.isBlank(custId)) {
                    throw new BizException(ErrorType.NOTFUND_CUSTID_BY_CARNO);
                }
                orderPark.setCustId(custId);
            }
            List<PayOrderDTO> payOrders = noPassPayInnerService.noPassPay(orderPark, new BigDecimal(request.getAccount()).longValue(), request.getChargerCode(), request.getsOpName());
            //更新订单上金额
            /**优惠金额 单位:分*/
            Long orderDicountFee = 0L;
            /**支付单实收 单位:分*/
            Long orderActFee = 0L;
            /**支付单应收 单位:分*/
            Long orderTotalFee = 0L;
            for (PayOrderDTO payOrderQ : payOrders) {
                if (payOrderQ.getPayType() == PayTypeEnum.ZH.getValue()) {
                    orderActFee += payOrderQ.getOrderActFee();
                }
                orderTotalFee += payOrderQ.getOrderTotalFee();
            }
            orderDicountFee = orderTotalFee - orderActFee;
            OrderPark upOrderPark = new OrderPark();
            upOrderPark.setId(orderPark.getId());
            upOrderPark.setOrderState(OrderStateEnum.PAYED.value());
            upOrderPark.setOrderTotalFee(orderPark.getOrderTotalFee() + orderTotalFee);
            upOrderPark.setOrderActFee(orderPark.getOrderActFee() + orderActFee);
            upOrderPark.setOrderDicountFee(orderPark.getOrderDicountFee() + orderDicountFee);
            orderParkDao.updateOrderParkById(upOrderPark);

            noPassPayDTO.setOrderNo(payOrders.get(0).getRltOrderId());
            noPassPayDTO.setRespCode("0");
            /**发送支付成功消息，用于处理其他非紧急事件，例如激光推送支付消息，根据赠送规则赠送积分，代金券等*/
            pushPaySuccessMsgService.sendPaySuccessMsg(payOrders);
        } catch (Exception e) {
            noPassPayDTO.setRespCode("1");
            logger.error("个人账户免密支付失败", e);
        }
        return noPassPayDTO;
    }

    /**
     * 农行无感支付
     *
     * @param
     * @return
     * @Author: xiejianpeng
     * @Date: 2019/12/11 14:29
     */
    private NoPassPayDTO abcBankAcctNoPassPay(NoPassPayDTO noPassPayDTO, OrderPark orderPark, NoPassPayRequest request) {
        logger.info("农行无感支付:" + orderPark.getCustId());
        try {
            ABCBankQueryStateReq abcBankQueryStateReq = new ABCBankQueryStateReq();
            String appId = this.getAppIdByOrgId(orderPark.getOrgId(), PayTypeEnum.ABC_BANK_PAY.getValue());
            abcBankQueryStateReq.setPartnerId(appId);
            abcBankQueryStateReq.setCarNo(orderPark.getCarNumber());
            if (orderPark.getCarNumberColor().equals("1")) {
                abcBankQueryStateReq.setPlateColor("YELLOW");
            }
            if (orderPark.getCarNumberColor().equals("4")) {
                abcBankQueryStateReq.setPlateColor("GREEN");
            }
            Boolean state = abcBankPayInnerService.queryContractType(abcBankQueryStateReq);
            if (!state) {
                noPassPayDTO.setRespCode("1");
                logger.info("车牌号：{}，农行无感支付未开通", orderPark.getCarNumber());
                return noPassPayDTO;
            }

            PayOrderDTO payOrder = noPassPayInnerService.abcBankNoPassPay(orderPark, new BigDecimal(request.getAccount()).longValue(), request.getChargerCode(), request.getsOpName(), TerminalSourceEnum.DZ.value());
            //更新订单上金额
            /**优惠金额 单位:分*/
            Long orderDicountFee = payOrder.getOrderDicountFee();
            /**支付单实收 单位:分*/
            Long orderActFee = payOrder.getOrderActFee();
            /**支付单应收 单位:分*/
            Long orderTotalFee = payOrder.getOrderTotalFee();
            OrderPark upOrderPark = new OrderPark();
            upOrderPark.setId(orderPark.getId());
            upOrderPark.setOrderState(OrderStateEnum.PAYED.value());
            upOrderPark.setOrderTotalFee(orderPark.getOrderTotalFee() + orderTotalFee);
            upOrderPark.setOrderActFee(orderPark.getOrderActFee() + orderActFee);
            upOrderPark.setOrderDicountFee(orderPark.getOrderDicountFee() + orderDicountFee);
            upOrderPark.setThirdDiscFee(payOrder.getThirdDiscFee());
            orderParkDao.updateOrderParkById(upOrderPark);

            noPassPayDTO.setOrderNo(payOrder.getRltOrderId());
            noPassPayDTO.setRespCode("0");
            /**发送支付成功消息，用于处理其他非紧急事件，例如激光推送支付消息，根据赠送规则赠送积分，代金券等*/
            List<PayOrderDTO> payOrderDTOS = new ArrayList<>();
            payOrderDTOS.add(payOrder);
            pushPaySuccessMsgService.sendPaySuccessMsg(payOrderDTOS);
        } catch (Exception e) {
            noPassPayDTO.setRespCode("1");
            logger.error("农行无感支付失败", e);
        }
        return noPassPayDTO;
    }

    /**
     * 增加判断封闭车场公司储值卡账户扣款开始
     * by zegnqc 2020-12-28
     */
    private NoPassPayDTO closedParkStoreCarNoPassPay(NoPassPayDTO noPassPayDTO, OrderPark orderPark, NoPassPayRequest request) {
        logger.info("封闭车场公司储值卡账户无感支付:" + orderPark.getCarNumber());
        try {
            String accCode;
            //该车牌对应的 封闭车场公司储值卡账户
            accCode = this.getClosedParkAccountByCarNo(orderPark.getCarNumber(), orderPark.getPlNo());
            if (StringUtils.isBlank(accCode)) {
                throw new BizException(ErrorType.NOTFUND_CUSTID_BY_CARNO);
            }
            PayOrderDTO payOrder = noPassPayInnerService.closedParkStoreCarNoPassPay(orderPark, new BigDecimal(request.getAccount()).longValue(), request.getChargerCode(), request.getsOpName(), accCode);
            //更新订单上金额
            /**优惠金额 单位:分*/
            Long orderDicountFee = payOrder.getOrderDicountFee();
            /**支付单实收 单位:分*/
            Long orderActFee = payOrder.getOrderActFee();
            /**支付单应收 单位:分*/
            Long orderTotalFee = payOrder.getOrderTotalFee();
            OrderPark upOrderPark = new OrderPark();
            upOrderPark.setId(orderPark.getId());
            upOrderPark.setOrderState(OrderStateEnum.PAYED.value());
            upOrderPark.setOrderTotalFee(orderPark.getOrderTotalFee() + orderTotalFee);
            upOrderPark.setOrderActFee(orderPark.getOrderActFee() + orderActFee);
            upOrderPark.setOrderDicountFee(orderPark.getOrderDicountFee() + orderDicountFee);
            orderParkDao.updateOrderParkById(upOrderPark);

            noPassPayDTO.setOrderNo(payOrder.getRltOrderId());
            noPassPayDTO.setRespCode("0");
            /**发送支付成功消息，用于处理其他非紧急事件，例如激光推送支付消息，根据赠送规则赠送积分，代金券等*/
            List<PayOrderDTO> payOrderDTOS = new ArrayList<>();
            payOrderDTOS.add(payOrder);
            pushPaySuccessMsgService.sendPaySuccessMsg(payOrderDTOS);
        } catch (Exception e) {
            noPassPayDTO.setRespCode("1");
            logger.error("封闭车场公司储值卡账户免密支付失败", e);
        }
        return noPassPayDTO;
    }

    /**
     * 根据停车场编号以及车牌号码，获取该车绑定的公司储值账户
     *
     * @param carNo 车牌号码
     * @param plNo  停车场编号
     * @return
     */
    private String getClosedParkAccountByCarNo(String carNo, String plNo) {
        QueryCompanyAccountByOrderInfoRequest request = new QueryCompanyAccountByOrderInfoRequest();
        request.setCarNo(carNo);
        request.setPlNo(plNo);
        request.setSysCode(BasicEnum.SYS_CODE.getValue());
        BizResult<CompanyAccountDTO> bizResult = companyAccountQueryService.queryCompanyAccountInfo(request);
        CompanyAccountDTO companyAccountDTO = bizResult.getData();
        if (companyAccountDTO == null) {
            return null;
        } else {
            return companyAccountDTO.getAccCode();
        }
    }

    /**
     * 支付宝代付 alipay.eco.mycar.parking.order.pay(停车缴费代扣接口API)
     * 需要在支付宝小程序开通车辆代付
     *
     * @param noPassPayDTO
     * @param orderPark
     * @param request
     * @return
     */
    private NoPassPayDTO alipayEcoMycarParkingOrderPay(NoPassPayDTO noPassPayDTO, OrderPark orderPark, NoPassPayRequest request) {
        noPassPayDTO.setOrderNo(orderPark.getOrderId());
        noPassPayDTO.setRespCode("1");
        logger.info("支付宝代付车场判断:{},{}", orderPark.getPlNo(), orderPark.getCarNumber());
        if (StringUtils.isBlank(orderPark.getPlNo())) {
            return noPassPayDTO;
        }
        if (StringUtils.isBlank(orderPark.getCarNumber()) || orderPark.getCarNumber().length() < 7) {
            return noPassPayDTO;
        }

        boolean isAliPayPl = false;
        // 从字典获取已经开通支付宝代付的车场编号
        String plNos = SysCodeValueCacheUtil.queryCodeValue(CodeValKindEnum.ALIPAY_ORDER_PAY_PARKING);
        JSONArray arrPlNo = (JSONArray) JSON.parseArray(plNos);
        for (int i = 0; i < arrPlNo.size(); i++) {
            // 车场编号匹配
            if (orderPark.getPlNo().equals(arrPlNo.getString(i))) {
                isAliPayPl = true;
                break;
            }
        }
        logger.info("支付宝代付车场判断是否已开通支付宝车场:{}", isAliPayPl);
        if (isAliPayPl) {

            boolean payApplySuccess = AliSyncUtil.payApply(request, orderPark);
            if(!payApplySuccess){
                // 没有支付啥也不处理
                logger.info("支付宝免密支付数据，停车交易受理咨询-执行免密支付结果=fale, 也就是说没有支付成功, 直接返回");
                return noPassPayDTO;
            }

            PayOrder payOrder = noPassPayInnerService.alipayEcoMycarParkingOrderPay(orderPark, Long.valueOf(request.getAccount()), Long.valueOf(request.getAccount()));
            if (payOrder.getPayOrderState() == OrderStateEnum.PAYED.value()) {
                logger.info("{}在{}使用支付宝代付成功", orderPark.getCarNumber(), orderPark.getPlNo());

                OrderPark upOrderPark = new OrderPark();
                upOrderPark.setId(orderPark.getId());
                upOrderPark.setOrderState(OrderStateEnum.PAYED.value());
                upOrderPark.setOrderTotalFee(orderPark.getOrderTotalFee() + Long.valueOf(request.getAccount()));
                upOrderPark.setOrderActFee(orderPark.getOrderActFee() + Long.valueOf(request.getAccount()));
                upOrderPark.setThirdDiscFee(payOrder.getThirdDiscFee());
                orderParkDao.updateOrderParkById(upOrderPark);

                noPassPayDTO.setOrderNo(payOrder.getRltOrderId());
                noPassPayDTO.setRespCode("0");

                PayOrderDTO dto = new PayOrderDTO();
                BeanUtils.copyProperties(payOrder, dto);
                List<PayOrderDTO> payOrderDTOS = new ArrayList<>();
                payOrderDTOS.add(dto);
                /**发送支付成功消息，用于处理其他非紧急事件，例如激光推送支付消息，根据赠送规则赠送积分，代金券等*/
                pushPaySuccessMsgService.sendPaySuccessMsg(payOrderDTOS);

            } else {
                logger.info("{}在{}使用支付宝代付失败", orderPark.getCarNumber(), orderPark.getPlNo());
                noPassPayDTO.setRespCode("1");
            }
        }
        return noPassPayDTO;
    }
}