package com.stylefeng.guns.modular.smallLogistics.server.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.smallLogistics.dao.OrderLogisticsMapper;
import com.stylefeng.guns.modular.smallLogistics.model.OrderLogistics;
import com.stylefeng.guns.modular.smallLogistics.model.OrderLogisticsSpread;
import com.stylefeng.guns.modular.smallLogistics.server.IOrderLogisticsService;
import com.stylefeng.guns.modular.smallLogistics.server.IOrderLogisticsSpreadService;
import com.stylefeng.guns.modular.system.dao.*;
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.system.warpper.BaseWarpper;
import com.stylefeng.guns.modular.taxi.model.PaymentRecord;
import com.stylefeng.guns.modular.taxi.service.IPaymentRecordService;
import com.stylefeng.guns.modular.taxi.service.ITransactionDetailsService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

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


@Service
public class OrderLogisticsServiceImpl extends ServiceImpl<OrderLogisticsMapper, OrderLogistics> implements IOrderLogisticsService {

    @Resource
    private SystemPriceMapper systemPriceMapper;

    @Resource
    private OrderLogisticsMapper orderLogisticsMapper;

    @Resource
    private SensitiveWordsMapper sensitiveWordsMapper;

    @Autowired
    private ICompanyCityService companyCityService;

    @Autowired
    private GDMapGeocodingUtil gdMapGeocodingUtil;

    @Autowired
    private DateUtil dateUtil;

    @Autowired
    private ISystemNoticeService systemNoticeService;

    @Autowired
    private IPushOrderService pushOrderService;

    @Autowired
    private IDriverService driverService;

    @Autowired
    private PushUtil pushUtil;

    @Autowired
    private IUserInfoService userInfoService;
    
    @Autowired
    private IUserRedPacketRecordService userRedPacketRecordService;
    
    @Resource
    private UserActivityDiscount1Mapper userActivityDiscount1Mapper;

    @Autowired
    private IPaymentRecordService paymentRecordService;

//    @Autowired
//    private ICBCPayUtil icbcPayUtil;

    @Resource
    private SysIntegralMapper sysIntegralMapper;

    @Autowired
    private ITransactionDetailsService transactionDetailsService;

    @Autowired
    private ICompanyService companyService;

    @Autowired
    private IIncomeService incomeService;

    @Autowired
    private IOrderCancelService orderCancelService;

    @Autowired
    private IOrderLogisticsSpreadService orderLogisticsSpreadService;

    @Autowired
    private RedisUtil redisUtil;

    @Resource
    private RegionMapper regionMapper;

    @Autowired
    private GDMapElectricFenceUtil gdMapElectricFenceUtil;

    @Autowired
    private PayMoneyUtil payMoneyUtil;

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

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



    /**
     * 根据起点和终点坐标判断是不是同一个市内
     * @param startLonLat
     * @param endAddress
     * @return
     */
    @Override
    public ResultUtil judgingTheCity(String startLonLat, String endAddress) throws Exception {
        Map<String, String> sgeocode = gdMapGeocodingUtil.geocode(startLonLat.split(",")[0], startLonLat.split(",")[1]);
        String scityCode = sgeocode.get("cityCode");
        Map<String, Object> geocoding = gdMapGeocodingUtil.geocoding(endAddress);
        if(Integer.valueOf(geocoding.get("status").toString()) != 0){
            return ResultUtil.error("收货地址有误，无法查询具体地址信息");
        }
        List<String> list = (List<String>)geocoding.get("data");
        Map<String, String> egeocode = gdMapGeocodingUtil.geocode(list.get(0).split(",")[0], list.get(0).split(",")[1]);
        String ecityCode = egeocode.get("cityCode");
        if(!scityCode.equals(ecityCode)){
            return ResultUtil.error("已超出服务范围，请重新选择跨城小件物流");
        }
        return ResultUtil.success();
    }


    /**
     * 获取小件物流的单价
     * @param type
     * @param startLonLat
     * @param endAddress
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil queryLogisticsUnitPrice(Integer type, String startLonLat, String endAddress, Integer uid) throws Exception {
        Company query = companyCityService.query(startLonLat.split(",")[0], startLonLat.split(",")[1]);
        if(null == query){
            return ResultUtil.error("预约取货点暂无企业服务");
        }
        Double price1 = 0D;
        Double price2 = 0D;
        if(type == 4){//同城
            Map<String, Object> query1 = systemPriceMapper.query(query.getId(), type, null);
            if(null == query1){
                return ResultUtil.error("请先完善价格设定");
            }
            String content = String.valueOf(query1.get("content"));
            JSONObject jsonObject = JSON.parseObject(content);
            price1 = jsonObject.getDouble("num2");
            price2 = jsonObject.getDouble("num13");
        }else{
            Map<String, Object> query1 = systemPriceMapper.query(query.getId(), type, null);
            if(null == query1){
                return ResultUtil.error("请先完善价格设定");
            }
            String content = String.valueOf(query1.get("content"));
            JSONObject jsonObject = JSON.parseObject(content);
            price1 = jsonObject.getDouble("num1");
            price2 = jsonObject.getDouble("num2");
        }
        int i = this.selectCount(new EntityWrapper<OrderLogistics>().eq("userId", uid).eq("isDelete", 1));
        Map<String, Object> map = new HashMap<>();
        map.put("ordinary", price1);
        map.put("precious", price2);
        map.put("first", i);
        return ResultUtil.success(map);
    }


    /**
     * 获取支付金额
     * @param type
     * @param startLonLat
     * @param endAddress
     * @return
     * @throws Exception
     */
    public ResultUtil queryPayMoney(Integer number, Integer type, String startLonLat, String endAddress) throws Exception{
        Map<String, Object> geocoding = gdMapGeocodingUtil.geocoding(endAddress);
        if(Integer.valueOf(geocoding.get("status").toString()) != 0){
            return ResultUtil.error("收货地址有误，无法查询具体地址信息");
        }
        String location = ((List<String>)geocoding.get("data")).get(0);
        ResultUtil<Map<String, Double>> price = this.getPrice(type, startLonLat.split(",")[0], startLonLat.split(",")[1], location.split(",")[0], location.split(",")[1]);
        if(price.getCode() == 200 && type == 5){
            Map<String, Double> data = price.getData();
            data.put("ordinary", data.get("ordinary") * number);
            data.put("precious", data.get("precious") * number);
        }
        return price;
    }




    /**
     * 小件物流下单操作
     * @param type
     * @param cargoType
     * @param cargoNumber
     * @param remark
     * @param placementLon
     * @param placementLat
     * @param startLon
     * @param startLat
     * @param startAddress
     * @param recipient
     * @param recipientPhone
     * @param endAddress
     * @param travelTime
     * @param orderSource
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil smallLogistics(Integer type, Integer cargoType, Integer cargoNumber, String remark, String placementLon, String placementLat, String startLon, String startLat, String startAddress, String recipient,
                                     String recipientPhone, String endAddress, Integer urgent, Double tipMoney, Date travelTime, Integer orderSource, Integer uid) throws Exception {
        startAddress = startAddress.replaceAll("& #40;", "(");
        startAddress = startAddress.replaceAll("& #41;", ")");
        endAddress = endAddress.replaceAll("& #40;", "(");
        endAddress = endAddress.replaceAll("& #41;", ")");
        OrderLogistics orderLogistics = new OrderLogistics();
        Company query = companyCityService.query(placementLon, placementLat);
        if(null == query){
            return ResultUtil.error("该地点暂无企业服务");
        }
        orderLogistics.setCompanyId(query.getId());
        orderLogistics.setType(type);
        orderLogistics.setUserId(uid);
        orderLogistics.setOrderNum(this.getOrderNum());
        orderLogistics.setCargoType(cargoType);
        orderLogistics.setCargoNumber(cargoNumber);
        orderLogistics.setRemark(remark);
        orderLogistics.setPlacementLon(Double.valueOf(placementLon));
        orderLogistics.setPlacementLat(Double.valueOf(placementLat));
        Map<String, String> geocode = gdMapGeocodingUtil.geocode(placementLon, placementLat);
        orderLogistics.setPlacementAddress(geocode.get("address"));
        orderLogistics.setStartLon(Double.valueOf(startLon));
        orderLogistics.setStartLat(Double.valueOf(startLat));
        orderLogistics.setStartAddress(startAddress);
        Map<String, Object> geocoding = gdMapGeocodingUtil.geocoding(endAddress);
        if(Integer.valueOf(geocoding.get("status").toString()) != 0){
            return ResultUtil.error("收货地址有误，无法查询具体地址信息");
        }
        if(((List<String>)geocoding.get("data")).size() == 0){
            return ResultUtil.error("无法查询具体地址信息");
        }
        String location = ((List<String>)geocoding.get("data")).get(0);
        orderLogistics.setEndLon(Double.valueOf(location.split(",")[0]));
        orderLogistics.setEndLat(Double.valueOf(location.split(",")[1]));
        orderLogistics.setEndAddress(endAddress);
        orderLogistics.setUrgent(urgent);
        orderLogistics.setRecipient(recipient);
        orderLogistics.setRecipientPhone(recipientPhone);
        orderLogistics.setMileage(0D);
        orderLogistics.setIsReassign(1);
        orderLogistics.setReassignNotice(0);
        ResultUtil<Map<String, Double>> price = this.getPrice(type, String.valueOf(startLon), String.valueOf(startLat), location.split(",")[0], location.split(",")[1]);
        if(price.getCode() != 200){
            return price;
        }
        Map<String, Double> data = price.getData();
        orderLogistics.setOrderMoney((cargoType == 1 ? data.get("ordinary") : data.get("precious")) + tipMoney);
        orderLogistics.setTravelMoney(cargoType == 1 ? data.get("ordinary") : data.get("precious"));
        if(type == 5){
            orderLogistics.setOrderMoney(((cargoType == 1 ? data.get("ordinary") : data.get("precious")) * cargoNumber) + tipMoney);
            orderLogistics.setTravelMoney((cargoType == 1 ? data.get("ordinary") : data.get("precious")) * cargoNumber);
        }
        orderLogistics.setTipMoney(tipMoney);
        orderLogistics.setState(7);//待支付
        orderLogistics.setInsertTime(new Date());
        orderLogistics.setTravelTime(travelTime);
        orderLogistics.setOrderSource(orderSource);
        orderLogistics.setIsDelete(1);
        this.insert(orderLogistics);

        //添加消息
        systemNoticeService.addSystemNotice(1, "您的"+ (type == 4 ? "同城" : "跨城") + "小件物流订单已下单成功，我们正在为您指派司机，请稍后！", orderLogistics.getUserId(), 1);

        BaseWarpper baseWarpper = new BaseWarpper();
        baseWarpper.setId(orderLogistics.getId());
        return ResultUtil.success(baseWarpper);
    }


    /**
     * 获取价格
     * @param type
     * @return
     * @throws Exception
     */
    public ResultUtil<Map<String, Double>> getPrice(Integer type, String startLon, String startLat, String endLon, String endLat) throws Exception{
        Company query = companyCityService.query(startLon, startLat);
        if(null == query){
            return ResultUtil.error("预约取货点暂无企业服务");
        }
        Double price1 = 0D;
        Double price2 = 0D;
        if(type == 4){//同城
            Map<String, Object> query1 = systemPriceMapper.query(query.getId(), type, null);
            Map<String, String> distance = gdMapElectricFenceUtil.getDistance(startLon + "," + startLat, endLon + "," + endLat, 1);
            String content = String.valueOf(query1.get("content"));
            JSONObject jsonObject = JSON.parseObject(content);
            String distance1 = distance.get("distance");
            Double dist = Double.valueOf(distance1) / 1000;
            if(dist.compareTo(0D) >= 0 && dist.compareTo(jsonObject.getDouble("num1")) < 0){
                price1 = jsonObject.getDouble("num2");
            }
            if(dist.compareTo(0D) >= 0 && dist.compareTo(jsonObject.getDouble("num12")) < 0){
                price2 = jsonObject.getDouble("num13");
            }

            if(dist.compareTo(jsonObject.getDouble("num3")) >= 0 && dist.compareTo(jsonObject.getDouble("num4")) < 0){
                price1 = jsonObject.getDouble("num5");
            }
            if(dist.compareTo(jsonObject.getDouble("num14")) >= 0 && dist.compareTo(jsonObject.getDouble("num15")) < 0){
                price2 = jsonObject.getDouble("num16");
            }

            if(dist.compareTo(jsonObject.getDouble("num6")) >= 0 && dist.compareTo(jsonObject.getDouble("num7")) < 0){
                price1 = jsonObject.getDouble("num8");
            }
            if(dist.compareTo(jsonObject.getDouble("num17")) >= 0 && dist.compareTo(jsonObject.getDouble("num18")) < 0){
                price2 = jsonObject.getDouble("num19");
            }

            if(dist.compareTo(jsonObject.getDouble("num9")) >= 0 && dist.compareTo(jsonObject.getDouble("num10")) < 0){
                price1 = jsonObject.getDouble("num11");
            }
            if(dist.compareTo(jsonObject.getDouble("num20")) >= 0 && dist.compareTo(jsonObject.getDouble("num21")) < 0){
                price2 = jsonObject.getDouble("num22");
            }
            if(dist.compareTo(jsonObject.getDouble("num10")) >= 0){
                price1 = jsonObject.getDouble("num11");
            }
            if(dist.compareTo(jsonObject.getDouble("num21")) >= 0){
                price2 = jsonObject.getDouble("num22");
            }
        }else{
            Map<String, Object> query1 = systemPriceMapper.query(query.getId(), type, null);
            String content = String.valueOf(query1.get("content"));
            JSONObject jsonObject = JSON.parseObject(content);
            price1 = jsonObject.getDouble("num1");
            price2 = jsonObject.getDouble("num2");
        }
        Map<String, Double> map = new HashMap<>();
        map.put("ordinary", price1);//普通
        map.put("precious", price2);//贵重
        return ResultUtil.success(map);
    }



    /**
     * 推送抢单数据
     * @param orderLogistics
     * @throws Exception
     */
    public void pushOrder(OrderLogistics orderLogistics) throws Exception{
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    orderIds.add(orderLogistics.getId());//添加记录，防止调用接口重复提醒无人接单
                    String vehicle = redisUtil.getValue("VEHICLE");
                    List<Integer> integers = new ArrayList<>();
                    if(ToolUtil.isNotEmpty(vehicle)){
                        integers = JSON.parseArray(vehicle).toJavaList(Integer.class);
                    }
                    Company query = companyCityService.query(String.valueOf(orderLogistics.getStartLon()), String.valueOf(orderLogistics.getStartLat()));//获取起点所属分公司
                    List<PushOrder> querys = pushOrderService.querys(null, 1, query.getId());//用专车的推单配置
                    for(int i = 1; i <= querys.size(); i++){
                        PushOrder pushOrder = pushOrderService.querys(i, 1, query.getId()).get(0);
                        //获取空闲司机
                        List<Driver> list = driverService.queryIdleDriver(orderLogistics.getType(), null, orderLogistics.getStartLon(), orderLogistics.getStartLat(), pushOrder.getPushDistance(), null);//所有附近空闲司机
                        if(list.size() > 0){
                            double driverProportion = pushOrder.getDriverProportion() / 100;//推送占比计算成小数
                            int lastIndex = Double.valueOf(list.size() * driverProportion).intValue();//计算占比转成整数（下标截取）
                            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(), orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getState(), pushOrder.getPushTime());
                            }
                        }
                        Thread.sleep(pushOrder.getPushTime() * 1000);//设置等待时间
                        Integer state = orderLogisticsMapper.selectById(orderLogistics.getId()).getState();
                        if(state > 1){
                            break;
                        }
                        if(i == querys.size() && state == 1){
//                            pushUtil.pushEndPush(1, orderLogistics.getUserId(), orderLogistics.getId(), orderLogistics.getType());
                            orderIds.remove(orderLogistics.getId());
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }




    /**
     * 订单支付
     * @param payType
     * @param orderId
     * @param type
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil payLogisticsOrder(Integer payType, Integer orderId, Integer type) throws Exception {
        OrderLogistics orderLogistics = this.selectById(orderId);
        if(orderLogistics.getState() != 7){
            return ResultUtil.error("订单已完成支付，不允许重复支付");
        }
        Integer uid = orderLogistics.getUserId();
        Double orderMoney = orderLogistics.getOrderMoney();
        UserInfo userInfo = userInfoService.selectById(uid);
        ResultUtil resultUtil = ResultUtil.success();
        orderLogistics.setCouponMoney(0D);//初始化历史数据
        orderLogistics.setCouponId(null);
    
        //计算折扣
        UserActivityDiscount1 query2 = userActivityDiscount1Mapper.query(orderLogistics.getCompanyId());
        if(null != query2){
            Double special = query2.getLogistics();
            orderLogistics.setDiscount(special);
            double v = new BigDecimal(orderMoney).multiply(new BigDecimal(special / 10)).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue();
            if(orderMoney.compareTo(v) > 0){
                orderLogistics.setDiscountMoney(orderMoney - v);
                orderLogistics.setActivityId(query2.getId());
                orderMoney = v;
            }
        }

        if(payType == 1){//微信支付
            String app = type == 1 ? "APP" : "JSAPI";
            resultUtil = payMoneyUtil.weixinpay("小件物流下单支付", "", orderId + "_" + orderLogistics.getType() + "_" + UUIDUtil.getRandomCode(5), orderMoney.toString(),  "/base/wxPayOrderTaxi", app, userInfo.getAppletsOpenId());
            paymentRecordService.saveData(1, orderLogistics.getUserId(), 1, orderId, orderLogistics.getType(), 1, orderMoney, "", 1);//添加预支付数据
        }
        if(payType == 2){//支付宝支付
            resultUtil = payMoneyUtil.alipay("小件物流下单支付", "小件物流下单支付", "", orderId + "_" + orderLogistics.getType() + "_" + UUIDUtil.getRandomCode(5), orderMoney.toString(), "/base/aliPayOrderTaxi");
            paymentRecordService.saveData(1, orderLogistics.getUserId(), 1, orderId, orderLogistics.getType(), 2, orderMoney, "", 1);//添加预支付数据
        }


//        if(payType == 1){//微信支付
//            String value = redisUtil.getValue("appletOpenId");
//            String appletsOpenId = null;
//            if(ToolUtil.isNotEmpty(value)){
//                JSONObject jsonObject = JSON.parseObject(value);
//                appletsOpenId = jsonObject.getString(uid.toString());
//            }else{
//                appletsOpenId = userInfo.getAppletsOpenId();
//            }
//            Map<String, String> map = icbcPayUtil.placeAnOrder(orderId + "," + orderLogistics.getType(), 9, 5, uid.toString(), "小件物流下单支付", orderMoney, callbackPath + "/base/wxPayOrderTaxi", "", type, appletsOpenId);
//            if(map.get("code").equals("200")){
//                paymentRecordService.saveData(1, orderLogistics.getUserId(), 1, orderId, orderLogistics.getType(), 1, orderMoney, map.get("order_id"), 1);//添加预支付数据
//                resultUtil = ResultUtil.success(map.get("data"));
//            }else{
//                resultUtil = ResultUtil.error(map.get("msg"), "");
//            }
//        }
//        if(payType == 2){//支付宝支付
//            Map<String, String> map = icbcPayUtil.placeAnOrder(orderId + "," + orderLogistics.getType(), 10, 5, uid.toString(), "小件物流下单支付", orderMoney, callbackPath + "/base/aliPayOrderTaxi", "", type, null);
//            if(map.get("code").equals("200")){
//                paymentRecordService.saveData(1, orderLogistics.getUserId(), 1, orderId, orderLogistics.getType(), 2, orderMoney, map.get("order_id"), 1);//添加预支付数据
//                resultUtil = ResultUtil.success(map.get("data"));
//            }else{
//                resultUtil = ResultUtil.error(map.get("msg"), "");
//            }
//        }
        if(payType == 3){//余额支付
            if(userInfo.getBalance() == null || userInfo.getBalance() < orderMoney){
                return ResultUtil.error("余额不足，无法完成支付");
            }

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

            SysIntegral query1 = sysIntegralMapper.query(orderLogistics.getCompanyId());
            userInfo.setIntegral(userInfo.getIntegral() + (orderMoney.intValue() * query1.getIntegral()));//积分

            //添加交易明细
            transactionDetailsService.saveData(uid, "小件物流下单支付", orderMoney, 2, 1, 1, 4, orderId);
            userInfoService.updateById(userInfo);

            orderLogistics.setState(1);//小件物流先支付后司机抢单
            orderLogistics.setPayType(3);
            orderLogistics.setPayMoney(orderMoney);

            // TODO: 2020/5/24 这里需要给司机和用户推送订单状态
            new Thread(new Runnable() {
                @Override
                public void run() {
                    pushUtil.pushOrderState(1, orderLogistics.getUserId(), orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getState(), 0);
                }
            }).start();

            systemNoticeService.addSystemNotice(1, "您已使用余额成功完成小件物流订单支付，谢谢使用！", uid, 1);

            this.pushOrder(orderLogistics);//推单
        }

        this.updateById(orderLogistics);
        return resultUtil;
    }




    /**
     * 补差价支付
     * @param payType
     * @param orderId
     * @param type
     * @return
     * @throws Exception
     */
    @Override
    public ResultUtil payLogisticsOrder_(Integer payType, Integer orderId, Integer type) throws Exception {
        OrderLogistics orderLogistics = this.selectById(orderId);
        Integer uid = orderLogistics.getUserId();
        OrderLogisticsSpread orderLogisticsSpread = orderLogisticsSpreadService.selectOne(new EntityWrapper<OrderLogisticsSpread>().eq("orderLogisticsId", orderId));
        Double orderMoney = orderLogisticsSpread.getPrice();
        UserInfo userInfo = userInfoService.selectById(uid);
        ResultUtil resultUtil = ResultUtil.success("");

        if(payType == 1){//微信支付
            String app = type == 1 ? "APP" : "JSAPI";
            resultUtil = payMoneyUtil.weixinpay("小件物流补差价", "", orderId + "_" + orderLogistics.getType() + "_" + UUIDUtil.getRandomCode(5), orderMoney.toString(), "/base/wxPayOrderLogisticsSpread", app, userInfo.getAppletsOpenId());
            paymentRecordService.saveData(1, orderLogistics.getUserId(), 1, orderId, orderLogistics.getType(), 1, orderMoney, "", 1);//添加预支付数据
        }
        if(payType == 2){//支付宝支付
            resultUtil = payMoneyUtil.alipay("小件物流补差价", "小件物流补差价", "", orderId + "_" + orderLogistics.getType() + "_" + UUIDUtil.getRandomCode(5), orderMoney.toString(), "/base/aliPayOrderLogisticsSpread");
            paymentRecordService.saveData(1, orderLogistics.getUserId(), 1, orderId, orderLogistics.getType(), 2, orderMoney, "", 1);//添加预支付数据
        }

//        if(payType == 1){//微信支付
//            String value = redisUtil.getValue("appletOpenId");
//            String appletsOpenId = null;
//            if(ToolUtil.isNotEmpty(value)){
//                JSONObject jsonObject = JSON.parseObject(value);
//                appletsOpenId = jsonObject.getString(uid.toString());
//            }else{
//                appletsOpenId = userInfo.getAppletsOpenId();
//            }
//            Map<String, String> map = icbcPayUtil.placeAnOrder(orderId + "," + orderLogistics.getType(), 9, 5, uid.toString(), "小件物流补差价", orderMoney, callbackPath + "/base/wxPayOrderLogisticsSpread", "", type, appletsOpenId);
//            if(map.get("code").equals("200")){
//                paymentRecordService.saveData(1, orderLogistics.getUserId(), 1, orderId, orderLogistics.getType(), 1, orderMoney, map.get("order_id"), 1);//添加预支付数据
//                resultUtil = ResultUtil.success(map.get("data"));
//            }else{
//                resultUtil = ResultUtil.error(map.get("msg"), "");
//            }
//        }
//        if(payType == 2){//支付宝支付
//            Map<String, String> map = icbcPayUtil.placeAnOrder(orderId + "," + orderLogistics.getType(), 10, 5, uid.toString(), "小件物流补差价", orderMoney, callbackPath + "/base/aliPayOrderLogisticsSpread", "", type, null);
//            if(map.get("code").equals("200")){
//                paymentRecordService.saveData(1, orderLogistics.getUserId(), 1, orderId, orderLogistics.getType(), 2, orderMoney, map.get("order_id"), 1);//添加预支付数据
//                resultUtil = ResultUtil.success(map.get("data"));
//            }else{
//                resultUtil = ResultUtil.error(map.get("msg"), "");
//            }
//        }
        if(payType == 3){//余额支付
            if(userInfo.getBalance() == null || userInfo.getBalance() < orderMoney){
                return ResultUtil.error("余额不足，无法完成支付", "");
            }

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

            SysIntegral query1 = sysIntegralMapper.query(orderLogistics.getCompanyId());
            userInfo.setIntegral(userInfo.getIntegral() + (orderMoney.intValue() * query1.getIntegral()));//积分

            //添加交易明细
            transactionDetailsService.saveData(uid, "小件物流补差价", orderMoney, 2, 1, 1, 4, orderId);
            userInfoService.updateById(userInfo);

            orderLogistics.setState(12);//已支付差价
            this.updateById(orderLogistics);

            orderLogistics.setOrderMoney(orderLogistics.getOrderMoney() + orderMoney);
            orderLogistics.setTravelMoney(orderLogistics.getTravelMoney() + orderMoney);
            orderLogistics.setPayMoney(orderLogistics.getPayMoney() + orderMoney);

            orderLogisticsSpread.setPayMoney(orderMoney);
            orderLogisticsSpread.setPayTime(new Date());
            orderLogisticsSpread.setPayType(3);
            orderLogisticsSpreadService.updateById(orderLogisticsSpread);

            //添加已收入明细
            Company company = companyService.selectById(orderLogistics.getCompanyId());
            Double speMoney =  orderLogistics.getType() == 4 ? company.getSameLogisticsMoney() : company.getCrossLogisticsMoney();
            BigDecimal d = null;
            BigDecimal c = null;
            if(company.getIsSpeFixedOrProportional() == 2){//固定
                d = new BigDecimal(speMoney);
                c = new BigDecimal(orderMoney).subtract(d);
            }
            if(company.getIsSpeFixedOrProportional() == 1){//比例
                d = new BigDecimal(orderMoney).multiply(new BigDecimal(speMoney).divide(new BigDecimal(100))).setScale(2, BigDecimal.ROUND_HALF_EVEN);
                c = new BigDecimal(orderMoney).subtract(d).setScale(2, BigDecimal.ROUND_HALF_EVEN);
            }

            Income income = incomeService.selectOne(new EntityWrapper<Income>().eq("userType", 1).eq("objectId", orderLogistics.getCompanyId()).eq("type", 2).eq("incomeId", orderLogistics.getId()).eq("orderType", orderLogistics.getType()));
            income.setMoney(income.getMoney() + d.doubleValue());
            incomeService.updateById(income);
            income = incomeService.selectOne(new EntityWrapper<Income>().eq("userType", 2).eq("objectId", orderLogistics.getDriverId()).eq("type", 2).eq("incomeId", orderLogistics.getId()).eq("orderType", orderLogistics.getType()));
            income.setMoney(income.getMoney() + c.doubleValue());
            incomeService.updateById(income);
            Driver driver = driverService.selectById(orderLogistics.getDriverId());
            driver.setBusinessMoney(new BigDecimal(null != driver.getBusinessMoney() ? driver.getBusinessMoney() : 0).add(c).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
            driver.setLaveBusinessMoney(new BigDecimal(null != driver.getLaveBusinessMoney() ? driver.getLaveBusinessMoney() : 0).add(c).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
            driver.setBalance(new BigDecimal(null != driver.getBalance() ? driver.getBalance() : 0).add(c).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
            driverService.updateById(driver);

            // TODO: 2020/5/24 这里需要给司机和用户推送订单状态
            new Thread(new Runnable() {
                @Override
                public void run() {
                    pushUtil.pushOrderState(1, orderLogistics.getUserId(), orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getState(), 0);
                    pushUtil.pushOrderState(2, orderLogistics.getDriverId(), orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getState(), 0);
                }
            }).start();

            systemNoticeService.addSystemNotice(1, "您已使用余额成功完成小件物流订单差价支付，谢谢使用！", uid, 1);
        }

        this.updateById(orderLogistics);
        return resultUtil;
    }



    @Override
    public void payOrderLogisticsCallback(Integer id, String order_id, Integer type) throws Exception {
        OrderLogistics orderLogistics = this.selectById(id);
        PaymentRecord query = paymentRecordService.query(1, orderLogistics.getUserId(), 1, Integer.valueOf(id), orderLogistics.getType(), type, 1);
        if(null != query){
            //添加交易明细
            transactionDetailsService.saveData(orderLogistics.getUserId(), "完成订单", query.getAmount(), 2, 1, 1, orderLogistics.getType(), query.getOrderId());
            orderLogistics.setState(1);//先支付后抢单
            orderLogistics.setPayType(type);
            orderLogistics.setPayMoney(query.getAmount());
            this.updateById(orderLogistics);

            UserInfo userInfo = userInfoService.selectById(orderLogistics.getUserId());
            SysIntegral query1 = sysIntegralMapper.query(orderLogistics.getCompanyId());
            userInfo.setIntegral(userInfo.getIntegral() + (query.getAmount().intValue() * query1.getIntegral()));//积分
            userInfoService.updateById(userInfo);

            query.setState(2);
            query.setCode(order_id);
            paymentRecordService.updateById(query);

            // TODO: 2020/5/24 这里需要给司机和用户推送订单状态
            new Thread(new Runnable() {
                @Override
                public void run() {
                    pushUtil.pushOrderState(1, orderLogistics.getUserId(), orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getState(), 0);
                }
            }).start();


            systemNoticeService.addSystemNotice(1, "您已使用" + (type == 1 ? "微信" : "支付宝") + "成功完成小件物流订单支付，谢谢使用！", orderLogistics.getUserId(), 1);

            this.pushOrder(orderLogistics);//推单
        }else{
            System.err.println("预支付数据异常（orderId = "  + id + ")");
        }
    }



    @Override
    public void payOrderLogisticsSpreadCallback(Integer id, String order_id, Integer type) throws Exception {
        OrderLogistics orderLogistics = this.selectById(id);
        OrderLogisticsSpread orderLogisticsSpread = orderLogisticsSpreadService.selectOne(new EntityWrapper<OrderLogisticsSpread>().eq("orderLogisticsId", id));
        PaymentRecord query = paymentRecordService.query(1, orderLogistics.getUserId(), 1, Integer.valueOf(id), orderLogistics.getType(), type, 1);
        if(null != query){
            //添加交易明细
            transactionDetailsService.saveData(orderLogistics.getUserId(), "小件物流补差价", query.getAmount(), 2, 1, 1, 4, query.getOrderId());
            orderLogistics.setState(4);//待取货

            orderLogistics.setOrderMoney(orderLogistics.getOrderMoney() + query.getAmount());
            orderLogistics.setTravelMoney(orderLogistics.getTravelMoney() + query.getAmount());
            orderLogistics.setPayMoney(orderLogistics.getPayMoney() + query.getAmount());

            orderLogisticsSpread.setPayMoney(query.getAmount());
            orderLogisticsSpread.setPayTime(new Date());
            orderLogisticsSpread.setPayType(3);
            orderLogisticsSpreadService.updateById(orderLogisticsSpread);

            UserInfo userInfo = userInfoService.selectById(orderLogistics.getUserId());
            SysIntegral query1 = sysIntegralMapper.query(orderLogistics.getCompanyId());
            userInfo.setIntegral(userInfo.getIntegral() + (query.getAmount().intValue() * query1.getIntegral()));//积分
            userInfoService.updateById(userInfo);

            query.setState(2);
            query.setCode(order_id);
            paymentRecordService.updateById(query);

            //添加已收入明细
            Company company = companyService.selectById(orderLogistics.getCompanyId());
            Double speMoney =  orderLogistics.getType() == 4 ? company.getSameLogisticsMoney() : company.getCrossLogisticsMoney();
            BigDecimal d = null;
            BigDecimal c = null;
            if(company.getIsSpeFixedOrProportional() == 2){//固定
                d = new BigDecimal(speMoney);
                c = new BigDecimal(query.getAmount()).subtract(d).setScale(2, BigDecimal.ROUND_HALF_EVEN);
            }
            if(company.getIsSpeFixedOrProportional() == 1){//比例
                d = new BigDecimal(query.getAmount()).multiply(new BigDecimal(speMoney).divide(new BigDecimal(100))).setScale(2, BigDecimal.ROUND_HALF_EVEN);
                c = new BigDecimal(query.getAmount()).subtract(d).setScale(2, BigDecimal.ROUND_HALF_EVEN);
            }
            Income income = incomeService.selectOne(new EntityWrapper<Income>().eq("userType", 1).eq("objectId", orderLogistics.getCompanyId()).eq("type", 2).eq("incomeId", orderLogistics.getId()).eq("orderType", orderLogistics.getType()));
            income.setMoney(income.getMoney() + d.doubleValue());
            incomeService.updateById(income);
            income = incomeService.selectOne(new EntityWrapper<Income>().eq("userType", 2).eq("objectId", orderLogistics.getDriverId()).eq("type", 2).eq("incomeId", orderLogistics.getId()).eq("orderType", orderLogistics.getType()));
            income.setMoney(income.getMoney() + c.doubleValue());
            incomeService.updateById(income);
            Driver driver = driverService.selectById(orderLogistics.getDriverId());
            driver.setBusinessMoney(new BigDecimal(null != driver.getBusinessMoney() ? driver.getBusinessMoney() : 0).add(c).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
            driver.setLaveBusinessMoney(new BigDecimal(null != driver.getLaveBusinessMoney() ? driver.getLaveBusinessMoney() : 0).add(c).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
            driver.setBalance(new BigDecimal(null != driver.getBalance() ? driver.getBalance() : 0).add(c).setScale(2, BigDecimal.ROUND_HALF_EVEN).doubleValue());
            driverService.updateById(driver);

            // TODO: 2020/5/24 这里需要给司机和用户推送订单状态
            new Thread(new Runnable() {
                @Override
                public void run() {
                    pushUtil.pushOrderState(1, orderLogistics.getUserId(), orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getState(), 0);
                    pushUtil.pushOrderState(2, orderLogistics.getDriverId(), orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getState(), 0);
                }
            }).start();


            systemNoticeService.addSystemNotice(1, "您已使用" + (type == 1 ? "微信" : "支付宝") + "成功完成小件物流订单差价支付，谢谢使用！", orderLogistics.getUserId(), 1);
            this.updateById(orderLogistics);
        }else{
            System.err.println("预支付数据异常（orderId = "  + id + ")");
        }
    }





    /**
     * 获取首页订单数量
     * @param uid
     * @return
     * @throws Exception
     */
    @Override
    public int queryLogisticsNumber(Integer uid) throws Exception {
        return orderLogisticsMapper.queryLogisticsNumber(uid);
    }


    /**
     * 获取个人中心订单列表
     * @param uid
     * @param pageNum
     * @param size
     * @return
     * @throws Exception
     */
    @Override
    public List<Map<String, Object>> queryMyOrderList(Integer uid, Integer pageNum, Integer size) throws Exception {
        pageNum = (pageNum - 1) * size;
        List<Map<String, Object>> maps = orderLogisticsMapper.queryMyOrderList(uid, pageNum, size);
        return maps;
    }


    /**
     * 获取历史消费记录
     * @param uid
     * @return
     */
    @Override
    public List<Map<String, Object>> queryMyTravelRecord(Integer uid) {
        return orderLogisticsMapper.queryMyTravelRecord(uid);
    }


    @Override
    public List<Map<String, Object>> queryInvoiceOrder(Integer type, Date startTime, Date endTime, Double startMoney, Double endMoney, Integer uid, Integer orderType) throws Exception {
        startTime = dateUtil.getStartOrEndDate(startTime, "start");
        endTime = dateUtil.getStartOrEndDate(endTime, "end");
        return orderLogisticsMapper.queryInvoiceOrder(type, startTime, endTime, startMoney, endMoney, uid, orderType);
    }



    @Override
    public ResultUtil addCancle(Integer id, String reason, String remark, Integer uid) throws Exception {
        if(ToolUtil.isNotEmpty(remark)){
            if(ToolUtil.isNotEmpty(remark)){
                List<SensitiveWords> sensitiveWords = sensitiveWordsMapper.selectList(null);
                for(SensitiveWords s : sensitiveWords){
                    remark = remark.replaceAll(s.getContent(), "***");
                }
            }
        }

        OrderLogistics orderLogistics = this.selectById(id);
        Integer integer = null;
        if(null == orderLogistics){
            return ResultUtil.error("取消订单失败，订单信息有误");
        }
        if(orderLogistics.getState() >= 5 && orderLogistics.getState() != 7 && orderLogistics.getState() != 8  && orderLogistics.getState() != 11){
            return ResultUtil.error("取消订单失败，不合法的操作");
        }

        if(orderLogistics.getState() == 7){
            integer = orderCancelService.saveData(orderLogistics.getId(), orderLogistics.getType(), reason, remark, null, null, 2, 1, orderLogistics.getUserId());
            orderLogistics.setState(10);
            this.updateById(orderLogistics);
            //添加消息
            systemNoticeService.addSystemNotice(1, "您已成功取消小件物流订单，谢谢使用！", orderLogistics.getUserId(), 1);
            Map<String, Object> map = new HashMap<>();
            map.put("id", integer);
            return ResultUtil.success(map);
        }


        //回退支付金额
        if(null != orderLogistics.getPayType() && null != orderLogistics.getPayMoney()) {//已支付
            if(orderLogistics.getPayType() == 3){//余额支付
                UserInfo userInfo = userInfoService.selectById(orderLogistics.getUserId());
                userInfo.setBalance(userInfo.getBalance() + orderLogistics.getPayMoney());
                userInfoService.updateById(userInfo);
            }else{
                //调用回退接口
                PaymentRecord query = paymentRecordService.query(1, orderLogistics.getUserId(), 1, orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getPayType(), 2);
                boolean b = false;

                if(query.getPayType() == 1){//微信
                    Map<String, String> map = payMoneyUtil.wxRefund(query.getCode(), orderLogistics.getId() + "_" + orderLogistics.getType(), query.getAmount().toString(), query.getAmount().toString(), "/base/cancleOrderWXPay");
                    if(!"SUCCESS".equals(map.get("return_code"))){
                        return ResultUtil.error(map.get("return_msg"));
                    }
                }else{//支付宝
                    Map<String, String> map = payMoneyUtil.aliRefund(query.getCode(), query.getAmount().toString());
                    if(!"10000".equals(map.get("code"))){
                        return ResultUtil.error(map.get("msg"));
                    }
                }


//                //调用回退接口
//                PaymentRecord query = paymentRecordService.query(1, orderLogistics.getUserId(), 1, orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getPayType(), 2);
//                boolean b = false;
//                Map<String, Object> merrefund = icbcPayUtil.merrefund(query.getCode(), "", query.getAmount(), orderLogistics.getId() + "_" + orderLogistics.getType(), orderLogistics.getOrderNum());
//                if (Integer.valueOf(merrefund.get("code").toString()) == 0) {
//                    Map<String, Object> refundqry = icbcPayUtil.refundqry("", query.getCode(), orderLogistics.getOrderNum());
//                    if (Integer.valueOf(refundqry.get("code").toString()) == 0 && Integer.valueOf(refundqry.get("pay_status").toString()) == 0) {//成功
//                        b = true;
//                    }
//                    if (Integer.valueOf(refundqry.get("code").toString()) == 0 && Integer.valueOf(refundqry.get("pay_status").toString()) == 1) {//失败
//                        return ResultUtil.error("订单取消失败（退款不成功）");
//                    }
//                    if (Integer.valueOf(refundqry.get("code").toString()) == 0 && Integer.valueOf(refundqry.get("pay_status").toString()) == 2) {//未知
//                        return ResultUtil.error("退款返回未知异常");
//
//                    }
//                }
                if(b){

                }
            }
            //添加交易明细
            transactionDetailsService.saveData(orderLogistics.getUserId(), "小件物流取消退款", orderLogistics.getPayMoney(), 1, 1, 1, 4, orderLogistics.getId());

            integer = orderCancelService.saveData(orderLogistics.getId(), orderLogistics.getType(), reason, remark, null, null, 2, 1, orderLogistics.getUserId());
            orderLogistics.setState(10);
            this.updateById(orderLogistics);

            //添加负的收入明细
            List<Income> incomes = incomeService.selectList(new EntityWrapper<Income>().eq("type", 2).eq("incomeId", id).eq("orderType", orderLogistics.getType()));
            for(Income income : incomes){
                if(income.getUserType() == 2){//处理司机的收入
                    Driver driver = driverService.selectById(income.getObjectId());
                    driver.setBalance(driver.getBalance() - income.getMoney());
                    driver.setBusinessMoney(driver.getBusinessMoney() - income.getMoney());
                    driver.setLaveBusinessMoney(driver.getLaveBusinessMoney() - income.getMoney());
                    driverService.updateById(driver);
                }
                Income income1 = new Income();
                BeanUtils.copyProperties(income, income1);
                income1.setMoney(income.getMoney() * -1);
                income1.setId(null);
                income1.setInsertTime(new Date());
                incomeService.insert(income1);
            }

        }

        if(null != orderLogistics.getDriverId()){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    pushUtil.pushOrderState(2, orderLogistics.getDriverId(), orderLogistics.getId(), orderLogistics.getType(), orderLogistics.getState(), 0);
                }
            }).start();
        }

        //添加消息
        systemNoticeService.addSystemNotice(1, "您已成功取消小件物流订单，谢谢使用！", orderLogistics.getUserId(), 1);
        Map<String, Object> map = new HashMap<>();
        map.put("id", integer);
        return ResultUtil.success(map);
    }


    /**
     * 获取行政区域数据
     * @return
     * @throws Exception
     */
    @Override
    public Map<String, Object> queryRegion() throws Exception {
        Map<String, Object> map = new HashMap<>();
        List<Region> querys = regionMapper.querys(0);
        Map<Integer, String> map1 = new HashMap<>();
        Map<Integer, String> map2 = new HashMap<>();
        Map<Integer, String> map3 = new HashMap<>();
        for(Region region : querys){
            map1.put(Integer.valueOf(region.getCode()), region.getName());

            List<Region> querys1 = regionMapper.querys(region.getId());
            for(Region region1 : querys1){
                map2.put(Integer.valueOf(region1.getCode()), region1.getName());

                List<Region> querys2 = regionMapper.querys(region1.getId());
                for(Region region2 : querys2) {
                    map3.put(Integer.valueOf(region2.getCode()), region2.getName());
                }
            }
        }
        map.put("province_list", map1);
        map.put("city_list", map2);
        map.put("county_list", map3);
        return map;
    }


    /**
     * 获取行政区域
     * @param parentId
     * @return
     * @throws Exception
     */
    @Override
    public List<Region> queryRegions(Integer parentId) throws Exception {
        return regionMapper.querys(parentId);
    }

    @Override
    public Map<String, Object> queryBalance(Integer orderId, Integer uid) throws Exception {
        Map<String, Object> map = new HashMap<>();
        UserInfo userInfo = userInfoService.selectById(uid);
        map.put("balance", userInfo.getBalance());
        map.put("coupon", 0);
        return map;
    }



    public synchronized String getOrderNum() throws Exception{
        int size = this.selectCount(null);
        return "LOGISTICS" + String.valueOf(1000000 + size + 1).substring(1);
    }
}