package com.stylefeng.guns.modular.api;

import com.alibaba.fastjson.JSON;
import com.stylefeng.guns.modular.smallLogistics.server.IOrderLogisticsService;
import com.stylefeng.guns.modular.system.dao.DriverWorkMapper;
import com.stylefeng.guns.modular.system.dao.TUseMoneyMapper;
import com.stylefeng.guns.modular.system.dao.UserCouponRecordMapper;
import com.stylefeng.guns.modular.system.model.*;
import com.stylefeng.guns.modular.system.service.*;
import com.stylefeng.guns.modular.system.util.ChinaMobileUtil;
import com.stylefeng.guns.modular.system.util.PushUtil;
import com.stylefeng.guns.modular.system.util.ResultUtil;
import com.stylefeng.guns.modular.system.util.SystemException;
import com.stylefeng.guns.modular.system.warpper.BaseWarpper;
import com.stylefeng.guns.modular.system.warpper.MoneyInfoWarpper;
import com.stylefeng.guns.modular.system.warpper.OrderInfoWarpper;
import com.stylefeng.guns.modular.system.warpper.OrderListWarpper;
import com.stylefeng.guns.modular.taxi.dao.OrderTaxiMapper;
import com.stylefeng.guns.modular.taxi.model.OrderTaxi;
import com.stylefeng.guns.modular.taxi.service.IOrderTaxiService;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.*;

/**
 * 订单相关控制器
 */
@RestController
@RequestMapping("")
public class OrderController {

    @Autowired
    private IOrderService orderService;

    @Autowired
    private IDriverService driverService;
    @Autowired
    private ICompanyService companyService;

    @Autowired
    private IReassignService reassignService;

    @Autowired
    private PushUtil pushUtil;

    @Autowired
    private ChinaMobileUtil chinaMobileUtil;

    @Autowired
    private IOrderLogisticsService orderLogisticsService;







    /**
     * 司机端获取首页订单列表
     * @param state
     * @param pageNum
     * @param size
     * @param request
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/queryOrderList")
    @ApiOperation(value = "获取首页订单列表", tags = {"司机端-首页"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "数据类型（1=服务中，2=待服务）", name = "state", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页码，首页1", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "size", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<List<OrderListWarpper>> queryOrderList(Integer state, Integer pageNum, Integer size, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            List<Map<String, Object>> list = orderService.queryOrderList(state, pageNum, size, uid);
            return ResultUtil.success(OrderListWarpper.getOrderListWarpper(list));
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 司机端获取首页订单列表
     * @param state
     * @param pageNum
     * @param size
     * @param request
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/queryOrderList1")
    @ApiOperation(value = "获取首页订单列表", tags = {"司机端-车载端"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "数据类型（1=服务中，2=待服务）", name = "state", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页码，首页1", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "size", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=其他订单，2=小件物流）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<List<OrderListWarpper>> queryOrderList1(Integer state, Integer type, Integer pageNum, Integer size, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            List<Map<String, Object>> list = orderService.queryOrderList1(state, type, pageNum, size, uid);
            return ResultUtil.success(OrderListWarpper.getOrderListWarpper(list));
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }





    /**
     * 获取我的订单列表
     * @param state
     * @param pageNum
     * @param size
     * @param request
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/queryMyAllOrder")
    @ApiOperation(value = "获取我的订单列表", tags = {"司机端-首页"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "数据类型（1=全部，2=待支付，3=已取消,4=已完成）", name = "state", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页码，首页1", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "size", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<List<OrderListWarpper>> queryMyAllOrder(Integer state, Integer pageNum, Integer size, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            List<OrderListWarpper> listWarppers = orderService.queryMyAllOrder(state, pageNum, size, uid);
            return ResultUtil.success(listWarppers);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }



    /**
     * 获取我的订单列表
     * @param pageNum
     * @param size
     * @param request
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/queryMyAllOrder1")
    @ApiOperation(value = "获取我的订单列表", tags = {"司机端-车载端"}, notes = "只含出租车")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "页码，首页1", name = "pageNum", required = true, dataType = "int"),
            @ApiImplicitParam(value = "页条数", name = "size", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<List<OrderListWarpper>> queryMyAllOrder1(Integer pageNum, Integer size, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            List<OrderListWarpper> listWarppers = orderService.queryMyAllOrder1(pageNum, size, uid);
            return ResultUtil.success(listWarppers);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 获取抢单界面的订单详情
     * @param orderId
     * @param orderType
     * @param lon
     * @param lat
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/queryPushOrder")
    @ApiOperation(value = "获取抢单界面的订单详情", tags = {"司机端-首页"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，3=城际，4=小件物流-同城，5=小件物流-跨城）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(value = "当前定位经度", name = "lon", required = true, dataType = "string"),
            @ApiImplicitParam(value = "当前定位纬度", name = "lat", required = true, dataType = "string"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<OrderInfoWarpper> queryPushOrder(Integer orderId, Integer orderType, String lon, String lat){
        try {
            Map<String, Object> map = orderService.queryPushOrder(orderId, orderType, lon, lat);
            return ResultUtil.success(OrderInfoWarpper.getOrderInfoWarpper(map));
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    @Resource
    private DriverWorkMapper driverWorkMapper;
    @Autowired
    private IOrderCancelService orderCancelService;
    @Autowired
    private IOrderTaxiService orderTaxiService;
    @ResponseBody
    @PostMapping("/api/order/addCancelOrder")
    @ApiOperation(value = "添加订单取消【2.0】", tags = {"司机端-首页"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "情况说明", name = "reason", required = true, dataType = "string"),
            @ApiImplicitParam(value = "其他", name = "remark", required = true, dataType = "string"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil addCancelOrder(Integer orderId, String reason, String remark, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            OrderTaxi orderTaxi = orderTaxiService.selectById(orderId);
            if (orderTaxi.getState()==5){
                return ResultUtil.error("服务中，不可取消订单!");
            }
            //修改之前司机状态 -- 空闲
            if(null != orderTaxi.getDriverId()){
                Driver driver = driverService.selectById(orderTaxi.getDriverId());
                driver.setState(2);
                driverService.updateById(driver);
            }

            orderTaxi.setState(10);
            orderTaxiService.updateById(orderTaxi);
            OrderCancel orderCancel = new OrderCancel();
            orderCancel.setOrderId(orderId);
            orderCancel.setOrderType(2);
            orderCancel.setReason(reason);
            orderCancel.setState(2);
            orderCancel.setInsertTime(new Date());
            orderCancel.setUserType(3);
            orderCancel.setRemark(remark);
            orderCancel.setUserId(orderTaxi.getUserId());
            orderCancelService.insert(orderCancel);
            pushUtil.removeTask(orderId, 2);//删除定时任务，结束推送数据
            // 给用户端推送一条订单取消的消息
            pushUtil.orderCancel(orderTaxi.getUserId(),1);
            return ResultUtil.success();
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }
    /**
     * 司机抢单操作
     * @param orderId
     * @param orderType
     * @param request
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/grabOrder")
    @ApiOperation(value = "司机抢单操作", tags = {"司机端-首页"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，3=城际，4=小件物流-同城，5=小件物流-跨城）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil grabOrder(Integer orderId, Integer orderType, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            // 抢单的时候 判断司机当前余额是否足够支付一笔软件使用费
            Driver driver = driverService.selectById(uid);
//            List<TUseMoney> tUseMoney = useMoneyMapper.selectList(null);
            Company company = companyService.selectById(driver.getCompanyId());
            if (company.getDriverRestriction() > driver.getBalance()) {
                // 将这个司机下线
                driver.setState(1);
                driverService.updateById(driver);
                DriverWork driverWork2 = driverWorkMapper.queryNewWork(driver.getId(), 2, 1);
                if(Objects.nonNull(driverWork2)){
                    driverWork2.setState(2);
                    driverWork2.setEndTime(new Date());
                    driverWorkMapper.updateById(driverWork2);
                }
                pushUtil.expireWork(uid,2);
                return new ResultUtil(-1, "您的余额不足，请及时充值!");
            }
            return orderService.grabOrder(orderId, orderType, uid);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }

    /**
     * 获取服务中页面订单详情
     * @param orderId
     * @param orderType
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/queryOrderInfo")
    @ApiOperation(value = "获取服务中页面订单详情", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，4=小件物流-同城，5=小件物流-跨城）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<OrderInfoWarpper> queryOrderInfo(Integer orderId, Integer orderType){
        try {
            Map<String, Object> map = orderService.queryOrderInfo(orderId, orderType);
            return ResultUtil.success(OrderInfoWarpper.getOrderInfoWarpper(map));
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 获取订单的改派金额
     * @param orderId
     * @param orderType
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/queryReassignMoney")
    @ApiOperation(value = "获取改派支付金额", tags = {"司机端-服务中"}, notes = "返回金额为0不需要调用支付")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id（跨城多个订单使用逗号分隔）", name = "orderId", required = true, dataType = "string"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，3=城际，4=小件物流-同城，5=小件物流-跨城）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<BaseWarpper> queryReassignMoney(String orderId, Integer orderType){
        try {
            String[] split = orderId.split(",");
            Double aDouble = orderService.queryReassignMoney(Integer.valueOf(split[0]), orderType);
            if(Objects.isNull(aDouble)){
                return ResultUtil.error("未设置改派金额",null);
            }
            BaseWarpper baseWarpper = new BaseWarpper();
            if(orderType == 3){
                aDouble = aDouble * split.length;
            }
            baseWarpper.setAmount(aDouble);
            return ResultUtil.success(baseWarpper);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 司机提交改派申请
     * @param reassign
     * @param request
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/reassign")
    @ApiOperation(value = "提交改派申请", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，4=小件物流-同城，5=小件物流-跨城）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(value = "改派支付方式（1=微信，2=支付宝，3=余额）", name = "payType", required = false, dataType = "int"),
            @ApiImplicitParam(value = "改派原因", name = "reason", required = true, dataType = "string"),
            @ApiImplicitParam(value = "备注", name = "remark", required = false, dataType = "string"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil reassign(Reassign reassign, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            return reassignService.saveData(reassign, uid, null);
        }catch (SystemException s){
            return ResultUtil.error(s.getMsg());
        } catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 司机走流程操作
     * @param orderId
     * @param orderType
     * @param state
     * @param lon
     * @param lat
     * @param request
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/process")
    @ApiOperation(value = "司机走流程操作", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，3=城际，4=小件物流-同城，5=小件物流-跨城）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(value = "流程操作状态（3=开始出发预约点，4=到达预约点，5=开始服务，6=服务结束）", name = "state", required = true, dataType = "int"),
            @ApiImplicitParam(value = "当前经度", name = "lon", required = true, dataType = "double"),
            @ApiImplicitParam(value = "当前纬度", name = "lat", required = true, dataType = "double"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil process(Integer orderId, Integer orderType, Integer state, Double lon, Double lat, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            return orderService.process(orderId, orderType, state, uid, lon, lat);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }

    @Autowired
    private IPaymentRecordService paymentRecordService;
    @Autowired
    private ITransactionDetailsService transactionDetailsService;
    @Autowired
    private UserCouponRecordMapper userCouponRecordMapper;
    /**
     * 司机手动确认收款
     * @param orderId
     * @param orderType
     * @param request
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/confirm")
    @ApiOperation(value = "司机手动确认收款", tags = {"司机端-2.0新增"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，3=城际，4=小件物流-同城，5=小件物流-跨城）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil process(Integer orderId, Integer orderType, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            OrderTaxi orderTaxi = orderTaxiService.selectById(orderId);
            paymentRecordService.saveData(1, orderTaxi.getUserId(), 1, orderId, 2, 1, orderTaxi.getOrderMoney(), "", 1);//添加预支付数据
            orderTaxi.setState(8);
            orderTaxi.setPayType(3);
            orderTaxi.setPayMoney(orderTaxi.getOrderMoney());
            Integer placeOrderWay = null;
            switch (orderTaxi.getOrderSource()){
                case 2:
                    placeOrderWay = 4;
                    break;
                case 3:
                    placeOrderWay = 4;
                    break;
                case 6:
                    placeOrderWay = 1;
                    break;
                case 7:
                    placeOrderWay = 2;
                    break;
                case 5:
                    placeOrderWay = 3;
                    break;
            }
            // 司机收入
            double moneyTwo;
            // 平台收入
            double money;
            Driver driver = driverService.selectById(orderTaxi.getDriverId());
            Company company = companyService.selectById(driver.getCompanyId());

            if(orderTaxi.getOrderSource() == 2 || orderTaxi.getOrderSource() == 3){
                double v = company.getPercentageDeduction() / 100;
                money = v * orderTaxi.getOrderMoney();
                moneyTwo = orderTaxi.getOrderMoney()-money;
            }else {
                money = company.getFixedDeduction();
                moneyTwo = orderTaxi.getOrderMoney()-money;
            }
            Double orderMoney = orderTaxi.getOrderMoney();
            if (orderTaxi.getCouponId()!=null){
                UserCouponRecord userCouponRecord = userCouponRecordMapper.selectById(orderTaxi.getCouponId());
//                    if(userCouponRecord.getCompanyId() != orderTaxi.getCompanyId()){
//                        return ResultUtil.error("优惠券不能用于此订单", "");
//                    }
//                    if(userCouponRecord.getState() == 2){
//                        return ResultUtil.error("优惠券已使用", "");
//                    }
//                    if(userCouponRecord.getState() == 3){
//                        return ResultUtil.error("优惠券已过期", "");
//                    }
//                    if(userCouponRecord.getCouponUseType() != 0 && userCouponRecord.getCouponUseType() != 2){
//                        return ResultUtil.error("优惠券不能用于此类型订单", "");
//                    }
//                    if(userCouponRecord.getCouponType() == 2 && orderMoney.compareTo(userCouponRecord.getFullMoney()) < 0){
//                        return ResultUtil.error("优惠券不能用于此订单", "");
//                    }
                    orderMoney = orderMoney - userCouponRecord.getMoney();
                    orderTaxi.setCouponMoney(userCouponRecord.getMoney());
                    orderTaxi.setCouponId(orderTaxi.getCouponId());
            }
            orderTaxi.setPayMoney(orderMoney);
            orderTaxiService.updateById(orderTaxi);

            driver.setBalance(driver.getBalance() + moneyTwo);
            // 新增扣除使用费记录
            transactionDetailsService.saveDataTaxi(driver.getId(), "软件使用费", money, 2, 1, 2, 6, orderTaxi.getId(),placeOrderWay,company.getId());
            // 司机订单收入
            transactionDetailsService.saveDataTaxi(driver.getId(), "完成订单", moneyTwo, 1, 1, 2, 2, orderTaxi.getId(),placeOrderWay,company.getId());

            driverService.updateById(driver);

            pushUtil.pushOrderState(1, orderTaxi.getUserId(), orderTaxi.getId(), 2, orderTaxi.getState());

            return ResultUtil.success();
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }



    /**
     * 司机抢单操作（车载端）
     * @param orderId
     * @param orderType
     * @param request
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/grabOrder_")
    @ApiOperation(value = "司机抢单操作", tags = {"司机端-车载端"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（2=出租车，4=小件物流-同城，5=小件物流-跨城）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil grabOrder_(Integer orderId, Integer orderType, HttpServletRequest request){
        try {
            Integer uid = driverService.getUserIdFormRedis(request);
            if(null == uid){
                return ResultUtil.tokenErr();
            }
            return orderService.grabOrder_(orderId, orderType, uid);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }



    /**
     * 司机确认费用
     * @param orderId
     * @param orderType
     * @param type
     * @param travelFee
     * @param parkingFee
     * @param crossingFee
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/confirmFees")
    @ApiOperation(value = "司机确认费用", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，3=城际）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(value = "支付方式（1=OK平台收款，2=其他方式收款）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(value = "行程费用（出租车必传）", name = "travelFee", required = false, dataType = "double"),
            @ApiImplicitParam(value = "停车费", name = "parkingFee", required = false, dataType = "double"),
            @ApiImplicitParam(value = "过路费", name = "crossingFee", required = false, dataType = "double"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil confirmFees(Integer orderId, Integer orderType, Integer type, Double travelFee, Double parkingFee, Double crossingFee){
        try{
            return orderService.confirmFees(orderId, orderType, type, travelFee, parkingFee, crossingFee);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }



    /**
     * 司机确认费用（车载端）
     * @param orderId
     * @param orderType
     * @param type
     * @param travelFee
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/confirmFees_")
    @ApiOperation(value = "司机确认费用（车载端）", tags = {"司机端-车载端"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（2=出租车）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(value = "支付方式（1=OK平台收款）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(value = "行程费用", name = "travelFee", required = false, dataType = "double"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil confirmFees_(Integer orderId, Integer orderType, Integer type, Double travelFee, Double lon, Double lat){
        try{
            return orderService.confirmFees_(orderId, orderType, type, travelFee, lon, lat);
        }catch (Exception e){
            e.printStackTrace();
            System.err.println(lon + "," + lat);
            return ResultUtil.runErr();
        }
    }





    /**
     * 获取待支付页详情
     * @param orderId
     * @param orderType
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/queryToBePaidPage")
    @ApiOperation(value = "获取待支付页详情", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<OrderInfoWarpper> queryToBePaidPage(Integer orderId, Integer orderType){
        try {
            Map<String, Object> map = orderService.queryToBePaidPage(orderId, orderType);
            return ResultUtil.success(OrderInfoWarpper.getOrderInfoWarpper(map));
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    /**
     * 后台改派成功后的推送接口
     * @param orderId
     * @param orderType
     * @return
     */
    @ResponseBody
    @PostMapping("/base/order/pushOrderState")
    public String pushOrderState(Integer orderId, Integer orderType){
        try {
            Map<String, Object> map = orderService.queryOrderInfo(orderId, orderType);
            //更新小号绑定关系
            orderService.RebindMidAxbBindSend(orderId, orderType);

            pushUtil.pushOrderReassign(Integer.valueOf(String.valueOf(map.get("driverId"))), 2,Integer.valueOf(String.valueOf(map.get("orderId"))), orderType);

            pushUtil.pushOrderReassign(Integer.valueOf(String.valueOf(map.get("userId"))), 1,Integer.valueOf(String.valueOf(map.get("orderId"))), orderType);
            pushUtil.pushOrderState(1, Integer.valueOf(String.valueOf(map.get("userId"))), Integer.valueOf(String.valueOf(map.get("orderId"))), orderType,
                    Integer.valueOf(String.valueOf(map.get("orderState"))));
            return JSON.toJSONString(ResultUtil.success());
        }catch (Exception e){
            e.printStackTrace();
            return JSON.toJSONString(ResultUtil.runErr());
        }
    }




    @ResponseBody
    @PostMapping("/base/order/reassign_")
    @ApiOperation(value = "提交改派申请", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，3=城际，4=小件物流-同城，5=小件物流-跨城，6=包车）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(value = "改派支付方式（1=微信，2=支付宝，3=余额）", name = "payType", required = false, dataType = "int"),
            @ApiImplicitParam(value = "改派原因", name = "reason", required = true, dataType = "string"),
            @ApiImplicitParam(value = "备注", name = "remark", required = false, dataType = "string"),
    })
    public String reassign_(Reassign reassign, Integer uid){
        try {
            ResultUtil resultUtil = reassignService.saveData(reassign, uid, 3);
            return JSON.toJSONString(resultUtil);
        }catch (SystemException s){
            return JSON.toJSONString(ResultUtil.error(s.getMsg()));
        } catch (Exception e){
            e.printStackTrace();
            return JSON.toJSONString(ResultUtil.runErr());
        }
    }


    @ResponseBody
    @PostMapping("/base/order/test")
    public String test(String phoneA, String phoneB){
        try {
            Map<String, String> map = chinaMobileUtil.midAxbBindSend(phoneA, phoneB, 28);
            System.err.println(JSON.toJSONString(map));
        }catch (Exception e){
            e.printStackTrace();
            return "";
        }
        return null;
    }

    @ResponseBody
    @PostMapping("/base/order/test_")
    public String test(String bindId){
        try {
            Map<String, String> map = chinaMobileUtil.midAxbUnBindSend(bindId);
        }catch (Exception e){
            e.printStackTrace();
            return "";
        }
        return null;
    }


    /**
     * 司机确认费用（车载端）不管之前数据状态直接修改到待支付（流程断网情况的处理流程）
     * @param orderId
     * @param orderType
     * @param type
     * @param travelFee
     * @param lon
     * @param lat
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/confirmFees$")
    @ApiOperation(value = "司机确认费用（车载端）不管之前数据状态直接修改到已完成（流程断网情况的处理流程）", tags = {"司机端-车载端"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（2=出租车）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(value = "支付方式（1=OK平台收款）", name = "type", required = true, dataType = "int"),
            @ApiImplicitParam(value = "行程费用", name = "travelFee", required = false, dataType = "double"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil confirmFees$(Integer orderId, Integer orderType, Integer type, Double travelFee, Double lon, Double lat){
        try{
            return orderService.confirmFees$(orderId, orderType, type, travelFee, lon, lat);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }


    @ResponseBody
    @PostMapping("/api/order/queryVoiceBroadcast")
    @ApiOperation(value = "接单后获取语音播报内容", tags = {"司机端-首页"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车，2=出租车，3=城际，4=小件物流-同城，5=小件物流-跨城）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(value = "当前位置经度", name = "lon", required = true, dataType = "string"),
            @ApiImplicitParam(value = "当前位置纬度", name = "lat", required = true, dataType = "string"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil queryVoiceBroadcast(Integer orderId, Integer orderType, String lon, String lat){
        try {
            String s = orderService.queryVoiceBroadcast(orderId, orderType, lon, lat);
            return ResultUtil.success(s);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }




    /**
     * 手动确认订单完成
     * @param orderId
     * @param orderType
     * @return
     */
    @ResponseBody
    @PostMapping("/api/order/completeOrder")
    @ApiOperation(value = "手动确认订单完成", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型(1=专车，2=出租车)", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil completeOrder(Integer orderId, Integer orderType){
        try {
            return orderService.completeOrder(orderId, orderType);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }



    @ResponseBody
    @PostMapping("/api/order/queryMoneyInfo")
    @ApiOperation(value = "获取订单费用明细", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "订单类型（1=专车）", name = "orderType", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil<MoneyInfoWarpper> queryMoneyInfo(Integer orderId, Integer orderType){
        try {
            Map<String, Object> map = orderService.queryMoneyInfo(orderId, orderType);
            return ResultUtil.success(MoneyInfoWarpper.getMoneyInfoWarpper(map));
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }

    @ResponseBody
    @PostMapping("/api/order/fillInPickUpCode")
    @ApiOperation(value = "验证小件物流取件码", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "取件码", name = "pickUpCode", required = true, dataType = "string"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil fillInPickUpCode(Integer orderId, String pickUpCode){
        try {
            return orderLogisticsService.fillInPickUpCode(orderId, pickUpCode);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }

    @ResponseBody
    @PostMapping("/api/order/makeUpTheDifference")
    @ApiOperation(value = "设置小件物流差价", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(value = "差价金额", name = "difference", required = true, dataType = "double"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil makeUpTheDifference(Integer orderId, Double difference){
        try {
            return orderLogisticsService.makeUpTheDifference(orderId, difference);
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }

    @ResponseBody
    @PostMapping("/api/order/sendVerificationCode")
    @ApiOperation(value = "小件物流发送收货码", tags = {"司机端-服务中"}, notes = "")
    @ApiImplicitParams({
            @ApiImplicitParam(value = "订单id", name = "orderId", required = true, dataType = "int"),
            @ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
    })
    public ResultUtil sendVerificationCode(Integer orderId){
        try {
            orderLogisticsService.sendVerificationCode(orderId);
            return ResultUtil.success();
        }catch (Exception e){
            e.printStackTrace();
            return ResultUtil.runErr();
        }
    }
}