package com.ibeetl.admin.console.service;

import cn.hutool.json.JSONUtil;
import cn.jiguang.common.ClientConfig;
import cn.jiguang.common.resp.APIConnectionException;
import cn.jiguang.common.resp.APIRequestException;
import cn.jpush.api.JPushClient;
import cn.jpush.api.push.model.Platform;
import cn.jpush.api.push.model.PushPayload;
import cn.jpush.api.push.model.audience.Audience;
import cn.jpush.api.push.model.notification.Notification;
import com.alibaba.fastjson.JSON;
import com.ibeetl.admin.console.dao.*;
import com.ibeetl.admin.console.model.OrderModel;
import com.ibeetl.admin.console.model.OrderOperationLogModel;
import com.ibeetl.admin.console.model.SysAddressLevelModel;
import com.ibeetl.admin.console.model.UserModel;
import com.ibeetl.admin.console.rabbitmq.MqConstants;
import com.ibeetl.admin.console.rabbitmq.MqUtil;
import com.ibeetl.admin.console.util.DateUtil;
import com.ibeetl.admin.console.util.DoubleUtil;
import com.ibeetl.admin.console.util.HttpClientUtils;
import com.ibeetl.admin.core.entity.CoreUser;
import com.ibeetl.admin.core.entity.XzxCityPartner;
import com.ibeetl.admin.core.service.CorePlatformService;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.formula.functions.T;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
public class OrderManageService {

    static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    static SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    @Autowired
    XzxCityPartnerService cityPartnerService;
    private final Logger log = LoggerFactory.getLogger(this.getClass());
    @Autowired
    OrderManageDao dao;

    @Autowired
    RedisService redisService;

    @Autowired
    CuserConsoleDao cuserConsoleDao;

    @Autowired
    ComplaintConsoleDao complaintConsoleDao;

    @Autowired
    SettingConsoleDao settingConsoleDao;

    @Autowired
    CorePlatformService platformService;

    @Autowired
    PayConsoleDao payConsoleDao;
    @Autowired
    CuserConsoleService cuserConsoleService;

    @Autowired
    MqUtil mqUtil;

    final Base64 base64 = new Base64();
    /**
     * 统计
     * @return
     */
    public Map<String, Object> queryStaticData(){
        // 入库后的数据
        List<Map<String, Object>> dmap = dao.queryStaticData(1);
        List<Map<String, Object>> tmap = dao.queryStaticDataToday(sdf.format(new Date()) + " 00:00:00", sdf.format(new Date()) + " 23:59:59",null, 1);
        // 入库前的数据b
        List<Map<String, Object>> bdmap = dao.queryStaticData(2);
        List<Map<String, Object>> btmap = dao.queryStaticDataToday(sdf.format(new Date()) + " 00:00:00", sdf.format(new Date()) + " 23:59:59",null,2);
        // 计算前后的差值
        // 总的
        List<Map<String, Object>> flist = subValue(dmap, bdmap);
        // 今天的
        List<Map<String, Object>> todayList = subValue(tmap, btmap);


        Map<String, Object> m = new HashMap<>();
        m.put("afterTotal", flist);
        m.put("afterTodayToday", todayList);
        return m;
    }

    /**
     * 统计详情
     * @param startTime
     * @param endTime
     */
    public Map<String, Object> queryDetailList(String startTime, String endTime, String storageUserName, String receiverName, String page, String limit){
        int p = Integer.parseInt(page)-1;
        p = p * Integer.parseInt(limit);

        if(!StringUtils.isEmpty(storageUserName)){
            storageUserName = new String(Base64.encodeBase64(storageUserName.getBytes()));
        }
        /*if(!StringUtils.isEmpty(receiverName)){
            receiverName = new String(Base64.encodeBase64(receiverName.getBytes()));
        }*/
        int count = dao.queryDetailListCount(startTime, endTime, storageUserName, receiverName, "1");
        List<Map<String, Object>> list = dao.queryDetailList(startTime, endTime, storageUserName, receiverName, "1", p, Integer.parseInt(limit));

        List<Map<String, Object>> beforeList = dao.queryDetailList(startTime, endTime, storageUserName, receiverName, "2", p, Integer.parseInt(limit));

        list = subValue2(list, beforeList);

        Map<String, Object> map = new HashMap<>();
        map.put("count", count);
        map.put("data", list);
        return map;
    }

    /**
     * 还是统计
     * @param startTime
     * @param endTime
     * @param receiverphone
     * @return
     */
    public Map<String, Object> queryDetailTotal(String startTime, String endTime, String receiverphone){
        List<Map<String, Object>> tmap = dao.queryStaticDataToday(startTime, endTime, receiverphone, 1);
        List<Map<String, Object>> btmap = dao.queryStaticDataToday(startTime, endTime, receiverphone,2);
        List<Map<String, Object>> todayList = subValue(tmap, btmap);
        Map<String, Object> m = new HashMap<>();
        m.put("afterTotal", todayList);
        m.put("beforeTotal", btmap);
        m.put("afterTotalx", tmap);
        return m;
    }

    /**
     * 查询回收员的订单详细，每一单里面多少东西
     * @param startTime
     * @param endTime
     * @param phone
     */
    public Map<String, Object> queryUserOrderNo(String startTime, String endTime, String phone, String page, String limit){
        int p = Integer.parseInt(page)-1;
        p = p * Integer.parseInt(limit);
        List<Map<String, Object>> map = dao.queryUserOrderNo(startTime, endTime, phone, p, Integer.parseInt(limit), 1);
        int count = dao.queryUserOrderNoCount(startTime, endTime, phone, 1);

        List<Map<String, Object>> list = new ArrayList<>();
        for(Map<String, Object> m : map){
            Map<String, Object> mx = new HashMap<>();
            mx.put("receiveTime", m.get("storageTime"));
            mx.put("storageId", m.get("storageId"));
            mx.put("data", dao.queryTotalForOrderNo(m.get("storageId").toString(), "1"));
            list.add(mx);
        }

        // 查询未入库之前的

        List<Map<String, Object>> beforeMap = dao.queryUserOrderNo(startTime, endTime, phone, p, Integer.parseInt(limit), 2);
        List<Map<String, Object>> beforeList = new ArrayList<>();
        for(Map<String, Object> m : beforeMap){
            String orderIds = dao.queryOrderIdsByStorageId(m.get("storageId").toString());
            String[] ids = orderIds.split(",");
             Map<String, Object> mx = new HashMap<>();
            mx.put("receiveTime", m.get("storageTime"));
            mx.put("storageId", m.get("storageId"));
            //mx.put("data", dao.queryTotalForOrderNo(m.get("storageId").toString(), "2"));
            mx.put("data", dao.queryTotalOrderItemByIds(ids,m.get("storageId").toString()));
            beforeList.add(mx);
        }

        //
        List<Object> listSum = new ArrayList<>();
        for(Map<String, Object> m : list){
            Map<String, Object> mSum = new HashMap<>();
            List<Map<String, Object>> anlist =  (List<Map<String, Object>>)m.get("data");
            mSum.put("receiveTime", m.get("receiveTime"));
            mSum.put("storageId", m.get("storageId"));
            if(m.get("storageId")==null){
                mSum.put("afterData", anlist);
                listSum.add(mSum);
                break;
            }
            String strorageId = m.get("storageId").toString();
            for(Map<String, Object> mx : beforeList){
                if(strorageId.equals(mx.get("storageId").toString())){
                    List<Map<String, Object>> bnlist =  (List<Map<String, Object>>)mx.get("data");
                    mSum.put("afterData", anlist);
                    mSum.put("before", bnlist);
                    listSum.add(mSum);
                    break;
                }
            }
        }
        // list = subValue3(list, beforeList);
        Map<String, Object> m = new HashMap<>();
        m.put("count", count);
        m.put("data", listSum);
        m.put("code", 0);
        return m;
    }

    /**
     * 根据订单好查询订单详细
     * @param orderNo
     * @return
     */
    public List<Map<String, Object>> queryOrderByOrderno(String orderNo){
        return dao.queryOrderByOrderno(orderNo);
    }


    /**
     * 根据订单好查询订单详细
     * @param orderModel
     * @return
     */
    public Map<String, Object> queryOrderByOrderno(OrderModel orderModel){
        String orderNo = orderModel.getOrderId();
        int page = orderModel.getPage();
        int limit = orderModel.getLimit();
        Map<String,Object> result = new HashMap<>();
        int p = page-1;
        p = p * limit;
        List<Map<String, Object>> list = dao.queryOrderPageByOrderno(orderNo,p,limit);
        String address="无配送地址";
        String addressArea = "";
        String remark ="";
        String reserveTime="";
        if(null!=list&&list.size()>0){
            Map<String, Object> pmap = list.get(0);
            if(null!=pmap.get("address")){
                address = pmap.get("address").toString();
            }
            if(null!=pmap.get("addressArea")){
                addressArea = pmap.get("addressArea").toString();
            }
            if(null!=pmap.get("reserveTime")){
                reserveTime = pmap.get("reserveTime").toString();
            }
            if(null!=pmap.get("remark")){
                remark = pmap.get("remark").toString();
            }
        }
        result.put("count",dao.queryOrderCountByOrderno(orderNo));
        result.put("code",0);
        result.put("data",list);
        result.put("address",address);
        result.put("addressArea",addressArea);
        result.put("remark",remark);
        result.put("reserveTime",reserveTime);

        return result;
    }
    //-------------------------------------------------------------
    /**
     * 计算差值1
     * @param tmap
     * @param btmap
     * @return
     */
    List<Map<String, Object>> subValue(List<Map<String, Object>> tmap, List<Map<String, Object>> btmap){
        List<Map<String, Object>> flist = new ArrayList<>();
        for(Map<String, Object> atm : tmap){
            String cvn = atm.get("configValueName").toString();
            double amoney = Double.parseDouble(atm.get("money").toString());
            double aweight = Double.parseDouble(atm.get("weight").toString());
            for(Map<String, Object> btm : btmap){
                Map<String, Object> fm = new HashMap<>();
                if(cvn.equals(btm.get("configValueName"))){
                    fm.put("configValueName", btm.get("configValueName"));
                    fm.put("moneySub", Double.parseDouble(btm.get("money").toString()) - amoney);
                    fm.put("weightSub", Double.parseDouble(btm.get("weight").toString()) - aweight);
                    flist.add(fm);
                    break;
                }
            }
        }
        for (Map<String, Object> m : flist){
            String cvn = m.get("configValueName").toString();
            for(Map<String, Object> atm : tmap){
                if(cvn.equals(atm.get("configValueName"))){
                    atm.put("moneySub", m.get("moneySub"));
                    atm.put("weightSub", m.get("weightSub"));
                    break;
                }
            }
        }
        return tmap;
    }
    /**
     * 计算差值2
     * @param tmap
     * @param btmap
     * @return
     */
    List<Map<String, Object>> subValue2(List<Map<String, Object>> tmap, List<Map<String, Object>> btmap){
        List<Map<String, Object>> flist = new ArrayList<>();
        String cvn = "--";
        for(Map<String, Object> atm : tmap){

            if(null!=atm.get("receiverName")){
                cvn  = atm.get("receiverName").toString();
            }
            double amoney = Double.parseDouble(atm.get("money").toString());
            double aweight = Double.parseDouble(atm.get("weight").toString());
            for(Map<String, Object> btm : btmap){
                Map<String, Object> fm = new HashMap<>();
                if(null!=btm.get("receiverName")){
                    if(cvn.equals(btm.get("receiverName"))){
                        fm.put("receiverName", btm.get("receiverName"));
                        fm.put("moneySub", Double.parseDouble(btm.get("money").toString()) - amoney);
                        fm.put("weightSub", Double.parseDouble(btm.get("weight").toString()) - aweight);
                        flist.add(fm);
                        break;
                    }
                }else{
                    if(cvn.equals("--")&&atm.get("receiverPhone").equals(btm.get("receiverPhone"))){
                        fm.put("receiverName", btm.get("receiverName"));
                        fm.put("moneySub", Double.parseDouble(btm.get("money").toString()) - amoney);
                        fm.put("weightSub", Double.parseDouble(btm.get("weight").toString()) - aweight);
                        fm.put("receiverPhone", btm.get("receiverPhone"));
                        flist.add(fm);
                        break;
                    }
                    continue;
                }

            }
        }
        for (Map<String, Object> m : flist){
            if(null!=m.get("receiverName")){
                cvn = m.get("receiverName").toString();
            }
            for(Map<String, Object> atm : tmap){
                if(null!=m.get("receiverName")){
                    if(cvn.equals(atm.get("receiverName"))){
                        atm.put("moneySub", m.get("moneySub"));
                        atm.put("weightSub", m.get("weightSub"));
                        break;
                    }
                }else{
                    if(m.get("receiverPhone").equals(atm.get("receiverPhone"))){
                        atm.put("moneySub", m.get("moneySub"));
                        atm.put("weightSub", m.get("weightSub"));
                        break;
                    }
                    continue;
                }

            }
        }
        return tmap;
    }
    /**
     * 计算差值3
     * @param tmap
     * @param btmap
     * @return
     */
    List<Map<String, Object>> subValue3(List<Map<String, Object>> tmap, List<Map<String, Object>> btmap){
        List<Map<String, Object>> flist = new ArrayList<>();
        for(Map<String, Object> atm : tmap){
            List<Map<String, Object>> anm = (List<Map<String, Object>>)atm.get("data");
            for(Map<String, Object> anmx : anm){
                if(anmx.get("storageId") == null) {
                    break;
                }
                String cvn = anmx.get("storageId").toString();
                for(Map<String, Object> mx : btmap){
                    List<Map<String, Object>> x = (List<Map<String, Object>>)mx.get("data");
                    Map<String, Object> fm = new HashMap<>();
                    for(Map<String, Object> bx : x){
                        if(cvn.equals(bx.get("storageId"))){
                            fm.put("storageId", mx.get("storageId"));
                            fm.put("moneySub", Double.parseDouble(bx.get("money").toString()) - Double.parseDouble(anmx.get("money").toString()));
                            fm.put("weightSub", Double.parseDouble(bx.get("weight").toString()) - Double.parseDouble(anmx.get("weight").toString()));
                            flist.add(fm);
                            break;
                        }
                    }
                }
            }
        }
        for (Map<String, Object> m : flist){
            String cvn = m.get("storageId").toString();
            for(Map<String, Object> atm : tmap){
                if(cvn.equals(atm.get("storageId"))){
                    List<Map<String, Object>> x = (List<Map<String, Object>>)atm.get("data");
                    for(Map<String, Object> bx : x){
                        bx.put("moneySub", m.get("moneySub"));
                        bx.put("weightSub", m.get("weightSub"));
                        break;
                    }
                }
            }
        }

        return tmap;
    }
    //////////上门回收//////////////////////////////////////////////////////////////////////////////////

    /**
     * 订单列表查询
     * @param orderStatus
     * @param startTime
     * @param endTime
     * @param page
     * @param limit
     * @return
     */
    public Map<String, Object> queryOrderList(String orderStatus, String name, String mobilePhone, String startTime, String endTime, String orderType, String page, String limit){
        int p = (Integer.parseInt(page) - 1) * Integer.parseInt(limit);
        List<Map<String, Object>> maps = dao.queryOrderList(orderStatus, startTime,name, mobilePhone, endTime, orderType, p, Integer.parseInt(limit));
        Map<String, Object> map = new HashMap<>();
        map.put("data", maps);
        map.put("count", dao.queryOrderListCount(orderStatus, startTime,name, mobilePhone, endTime, orderType));
        map.put("code", 0);
        return map;
    }

    public Map<String, Object> queryOrderApiList(OrderModel orderModel){
        List<String> partnerIds = cityPartnerService.queryPartnerByCurrent();
        String orderStatus = "1";
        int p = (orderModel.getPage() - 1) * orderModel.getLimit();
        String startTime = orderModel.getStartTime();
        String endTime = orderModel.getEndTime();
        if(null!=startTime&&!"".equals(startTime)){
            startTime = startTime+ " 00:00:00";
        }
        if(null!=endTime&&!"".equals(endTime)){
            endTime = endTime+ " 23:59:59";
        }
        orderModel.setStartTime(startTime);
        orderModel.setEndTime(endTime);
        OrderModel newOrderModel = new OrderModel();
        newOrderModel.setOrderStatus(orderModel.getOrderStatus());
        newOrderModel.setStartTime(startTime);
        newOrderModel.setName(orderModel.getName());
        newOrderModel.setEndTime(endTime);
        newOrderModel.setOrderType(orderModel.getOrderType());
        newOrderModel.setPage(p);
        newOrderModel.setLimit(orderModel.getLimit());
        newOrderModel.setCreateType(orderModel.getCreateType());
        newOrderModel.setOrderId(orderModel.getOrderId());
        newOrderModel.setPartnerIds(partnerIds);
        if(!StringUtils.isEmpty(orderModel.getNickName())){
            newOrderModel.setMobilePhone(orderModel.getNickName());
            newOrderModel.setNickName(new String(Base64.encodeBase64(orderModel.getNickName().getBytes())));
        }
        List<OrderModel> maps= new ArrayList<>();
        if(orderStatus.equals("1")){
            List<String> townIds = new ArrayList<>();
            townIds = dao.queryTownIdsByPartnerIds(partnerIds);
            if(null!=partnerIds&&partnerIds.size()>0){
                newOrderModel.setTownIds(townIds);
            }

            maps = dao.queryOrderByTownIdApiList(newOrderModel);
        }else{
             maps = dao.queryOrderApiList(newOrderModel);
        }

        for (OrderModel model:maps) {
            //查询订单区域属于哪个合伙人
            String townId = dao.queryOrderByPartnerId(model.getOrderId());
            String partnerId = dao.queryTownIdByPartnerId(townId);
            model.setPartnerId(partnerId);
            if(null!=model.getOrderMoney()&&!"".equals(model.getOrderMoney())){
                model.setOrderMoney(DoubleUtil.roundTwo(model.getOrderMoney()));
            }
            if(null!=model.getOrderWeight()&&!"".equals(model.getOrderWeight())){
                model.setOrderWeight(DoubleUtil.roundThree(model.getOrderWeight()));

            }
            if(!StringUtils.isEmpty(model.getNickName())) {
                try {
                    if(DateUtil.isBase64(model.getNickName())){
                        model.setNickName(new String(base64.decode(model.getNickName()), "UTF-8"));

                    }
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
            }
        }
        int count =0;
        if(orderStatus.equals("1")){

            count = dao.queryOrderByTownIdsApiListCount(newOrderModel);
        }else{
            count = dao.queryOrderApiListCount(newOrderModel);
        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", maps);
        map.put("count", count);
        map.put("code", 0);
        return map;
    }

    /**
     * 订单列表查询
     * @param orderStatus
     * @param startTime
     * @param endTime
     * @param page
     * @param limit
     * @return
     */
    public Map<String, Object> queryOrderApiList(String orderStatus, String name, String mobilePhone, String startTime, String endTime, String orderType, String page, String limit){
        int p = (Integer.parseInt(page) - 1) * Integer.parseInt(limit);
        List<Map<String, Object>> maps = dao.queryOrderList(orderStatus, startTime,name, mobilePhone, endTime, orderType, p, Integer.parseInt(limit));
        for (Map<String, Object> model1:maps) {
            model1.put("ordermoney",DoubleUtil.roundTwo(model1.get("ordermoney").toString()));
            model1.put("orderweight",DoubleUtil.roundThree(model1.get("orderweight").toString()));
        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", maps);
        map.put("count", dao.queryOrderListCount(orderStatus, startTime,name, mobilePhone, endTime, orderType));
        map.put("code", 0);
        return map;
    }

    /**
     * 根据用户类型查询用户列表
     * @param userType
     * @param nikeName
     * @param phone
     */
    public Map<String, Object> queryCuserByType(String userType, String nikeName, String phone, String page, String limit){
        int p = (Integer.parseInt(page) - 1) * Integer.parseInt(limit);
        List<Map<String, Object>> maps = cuserConsoleDao.queryCuserByTypeList(userType, nikeName, phone, p, Integer.parseInt(limit));
        for(Map<String, Object> m : maps){
            List<Map<String, Object>> scount = dao.queryStatusByCuserId(m.get("userId").toString());
            for(Map<String, Object> mx : scount){
                m.put("o"+mx.get("orderstatus").toString(), mx.get("count"));
            }
        }
        Map<String, Object> m = new HashMap<>();
        m.put("data", maps);
        m.put("count", cuserConsoleDao.queryCuserByTypeListCount(userType, nikeName, phone));
        m.put("code", 0);
        return m;
    }

    /**
     * 根据用户类型查询用户列表
     * @param orderModel
     */
    public Map<String, Object> queryCuserApiByType(OrderModel orderModel){
        String userType = orderModel.getUserType();
        String nickName=orderModel.getNickName();
        if(!StringUtils.isEmpty(nickName)) {
            nickName = new String(Base64.encodeBase64(nickName.getBytes()));
        }
        String phone =orderModel.getMobilePhone();
        int page = orderModel.getPage();
        int limit = orderModel.getLimit();
        int p = (page- 1) * limit;
        List<Map<String, Object>> maps = cuserConsoleDao.queryCuserByTypeList(userType, nickName,phone , p, limit);
        for(Map<String, Object> m : maps){
            List<Map<String, Object>> scount = dao.queryStatusByCuserId(m.get("userId").toString());
            int unFinishOrder = 0 ;
            int finishOrder = 0 ;
            //m.put("unFinishOrder",)
            for(Map<String, Object> mx : scount){
                if(mx.get("orderstatus").toString().equals("5")){
                    finishOrder = Integer.parseInt(mx.get("count").toString());
                }else if(mx.get("orderstatus").toString().equals("2")){
                    unFinishOrder = unFinishOrder+ Integer.parseInt(mx.get("count").toString());
                }else if(mx.get("orderstatus").toString().equals("3")){
                    unFinishOrder = unFinishOrder+ Integer.parseInt(mx.get("count").toString());
                }
            }
            m.put("unFinishOrder",unFinishOrder);
            m.put("finishOrder",finishOrder);
        }

        Map<String, Object> m = new HashMap<>();
        m.put("data", maps);
        m.put("count", cuserConsoleDao.queryCuserByTypeListCount(userType, nickName, phone));
        m.put("code", 0);
        return m;
    }

    public Map<String, Object> cancelOrderData(OrderModel orderModel){
        Map<String,Object> result = new HashMap<>();
        String orderId = orderModel.getOrderId();
        String cancelReasonName = orderModel.getCancelReasonName();
        int num = dao.updateOrderStatus1(orderId,"6");
        if(num>0){
            //修改取消原因
            int detailNum = dao.updateOrderDetailReData(orderId,cancelReasonName);
            String receiver = dao.queryOrderByOrderId(orderId);

            //修改缓存
            if(null!=receiver&&!"".equals(receiver)){
                Object obj = redisService.hmGet("xzx:order:orderNum",receiver);
                if(null!=obj){
                    int objNum = Integer.parseInt(obj.toString());
                    objNum =objNum-1;
                    redisService.hmSet("xzx:order:orderNum",receiver,objNum+"");

                }
            }

            String msg =  "您的订单"+orderId+"已经取消";
            String msg1 = "订单"+orderId+"已经取消";
            String userId = dao.queryUserIdByOrderId(orderId);
            payConsoleDao.insertMessage(msg,userId,"","1","取消订单",sdf1.format(new Date()));
            if(null!=receiver&&!"".equals(receiver)){
                payConsoleDao.insertMessage(msg1,receiver,"","1","取消订单",sdf1.format(new Date()));

            }

            result.put("code",0);
            result.put("orderId",orderId);
        }else{
            result.put("code",-1);
            result.put("orderId",orderId);

        }
        return result;
    }

    public Map<String, Object> queryStorageApiList(OrderModel orderModel){
        List<String> partnerIds = cityPartnerService.queryPartnerByCurrent();
        Map<String,Object> map = new HashMap<>();
        int p = (orderModel.getPage()- 1) * orderModel.getLimit();
        orderModel.setPage(p);
        String startTime = orderModel.getStartTime();
        String endTime = orderModel.getEndTime();
        if(null!=startTime&&!"".equals(startTime)){
            orderModel.setStartTime(startTime+" 00:00:00");
        }
        if(null!=endTime&&!"".equals(endTime)){
            orderModel.setEndTime(endTime+" 23:59:59");
        }
        orderModel.setPartnerIds(partnerIds);
        List<Map<String,Object>> list = dao.queryStorageApiList(orderModel);
        for (Map<String,Object> pmap:list) {
            String storageWeight = "0";
            String orderWeight = "0";
            String storageMoney = "0";
            String orderMoney = "0";
            if(null!=pmap.get("storageweight")){
                 storageWeight=pmap.get("storageweight").toString();
            }
            if(null!=pmap.get("recycleweight")){
                orderWeight=pmap.get("recycleweight").toString();
            }
            if(null!=pmap.get("storagemoney")){
                storageMoney=pmap.get("storagemoney").toString();
            }
            if(null!=pmap.get("recyclemoney")){
                orderMoney=pmap.get("recyclemoney").toString();
            }
            pmap.put("storageweight",DoubleUtil.roundThree(storageWeight));
            pmap.put("recycleweight",DoubleUtil.roundThree(orderWeight));
            pmap.put("storagemoney",DoubleUtil.roundTwo(storageMoney));
            pmap.put("recyclemoney",DoubleUtil.roundTwo(orderMoney));
            BigDecimal weightError1 = new BigDecimal(storageWeight).subtract(new BigDecimal(orderWeight));
            BigDecimal moneyError1=new BigDecimal(storageMoney).subtract(new BigDecimal(orderMoney));
            pmap.put("weightError",DoubleUtil.roundThree(weightError1.toString()));//重量误差
            pmap.put("moneyError",DoubleUtil.roundTwo(moneyError1.toString()));//重量误差

            if(null!=pmap.get("vehicleid")){
                String vehicleId = pmap.get("vehicleid").toString();
                BigDecimal batchError = new BigDecimal("0");
                BigDecimal weightError = new BigDecimal("0");
                String batchWeight = pmap.get("batchweight").toString();
                String emptyWeight = pmap.get("emptyweight").toString();
                batchError = new BigDecimal(batchWeight).subtract(new BigDecimal(emptyWeight));
                System.out.println("vehicleId==="+vehicleId);
                pmap.put("emptyWeight",DoubleUtil.roundThree(emptyWeight)); //空车
                pmap.put("batchWeight",DoubleUtil.roundThree(batchWeight));//载重
                pmap.put("batchError",DoubleUtil.roundThree(batchError.toString()));//核算
                //
            }else{
                pmap.put("emptyWeight","0"); //空车
                pmap.put("batchWeight","0");//载重
                pmap.put("batchError","0");//核算

            }
        }
        map.put("data",list);
        map.put("code",0);
        map.put("count",dao.queryStorageApiNum(orderModel));
        return map;
    }


    public Map<String, Object> queryStorageDetailApiList(OrderModel orderModel){
        Map<String, Object> map = new HashMap<>();
        List<Map<String,Object>> queryStorageDetailApiList = new ArrayList<>();
        int p = (orderModel.getPage()- 1) * orderModel.getLimit();
        int count = 0 ;
        String storageId = orderModel.getStorageId();
        String orderIds = dao.queryOrderIdsByStorageId(storageId);
        String[] orderids = orderIds.split(",");
        List<String> orderIdList = new ArrayList<>();
        for (String orderId:orderids) {
            orderIdList.add(orderId);
        }
        if(orderIdList.size()>0){
            if(null!=orderModel.getOrderType()){
                if(orderModel.getOrderType().equals("1")){
                    queryStorageDetailApiList = dao.queryStroageDetailPageByOrderno(orderIdList,storageId,p,orderModel.getLimit());
                    count = dao.queryStroageDetailCountByOrderno(orderIdList,storageId);
                }else{
                    queryStorageDetailApiList  = dao.queryStorageDetailApiList(orderIdList,p,orderModel.getLimit());
                    count = orderids.length;
                }
            }else{
                queryStorageDetailApiList  = dao.queryStorageDetailApiList(orderIdList,p,orderModel.getLimit());
                count = orderids.length;
            }
        }
        for (Map<String,Object> obj:queryStorageDetailApiList) {
            String ordermoney ="0";
            String orderweight ="0";
            String moneyerror="0";
            String weighterror="0";
            if(null!=obj.get("recyclemoney")&&!"".equals(obj.get("recyclemoney"))){
                obj.put("recycleMoney",DoubleUtil.roundTwo(obj.get("recyclemoney").toString()));
                moneyerror = new BigDecimal(obj.get("recyclemoney").toString()).subtract(new BigDecimal(obj.get("storagemoney").toString())).toString();
                obj.put("moneyerror",DoubleUtil.roundTwo(moneyerror));
                obj.put("storagemoney",DoubleUtil.roundTwo(obj.get("storagemoney").toString()));
            }
            if(null!=obj.get("recycleweight")&&!"".equals(obj.get("recycleweight"))){
                obj.put("recycleweight",DoubleUtil.roundThree(obj.get("recycleweight").toString()));
                weighterror = new BigDecimal(obj.get("recycleweight").toString()).subtract(new BigDecimal(obj.get("storageweight").toString())).toString();
                obj.put("weighterror",DoubleUtil.roundThree(weighterror));
                obj.put("storageweight",DoubleUtil.roundThree(obj.get("storageweight").toString()));
            }
            if(null!=obj.get("ordermoney")&&!"".equals(obj.get("ordermoney"))){
                ordermoney = obj.get("ordermoney").toString();
            }
            if(null!=obj.get("orderweight")&&!"".equals(obj.get("orderweight"))){
                orderweight = obj.get("orderweight").toString();
            }
            obj.put("ordermoney",DoubleUtil.roundTwo(ordermoney));
            obj.put("orderweight",DoubleUtil.roundThree(orderweight));
        }
        map.put("count",count);
        map.put("code",0);
        map.put("data",queryStorageDetailApiList);
        return map;
    }
    public Map<String,Object> updateApirecByOrderId(OrderModel orderModel,String appkey,String screct){
        //判断接单数量 修改回收员接单数+1
        Map<String,Object> map= new HashMap<>();
        String orderId = orderModel.getOrderId();
        String receiver = dao.queryOrderByOrderId(orderId);
        String oldTrid="";
        String newTrid="";
        String obj = dao.queryOrderReNum(orderModel.getUserId());
        if(null!=obj){
            int objNum = Integer.parseInt(obj);
            Map<String, Object> m = settingConsoleDao.queryOrderTotal();
            int configNum = Integer.parseInt(m.get("configValue").toString());
            objNum = objNum+1;
            if(objNum>configNum){
                map.put("code",-1);
                map.put("orderId",orderModel.getOrderId());
                map.put("msg","回收员超过自身可接单数量！");
                return map;
            }
        }
        String userId = orderModel.getUserId();
        int num = 0;
        //生成轨迹Id
        String url ="https://tsapi.amap.com/v1/track/trace/add";
        //key sid tid
        UserModel userModel = cuserConsoleService.queryUserOtherById(orderModel.getUserId());
        String partnerId = userModel.getPartnerId();
        XzxCityPartner partner = cityPartnerService.queryById(partnerId);
        String key = partner.getPartnerKey();
        String tid=userModel.getTerminalId();
        String sid = cityPartnerService.querySidByPid(partner.getId()+"","1");
        Map<String,String> map1 = new HashMap<>();
        String result1="";
        if(null!=key&&!"".equals(key)){
            map1.put("key",key);
            map1.put("sid",sid);
            map1.put("tid",tid);
            result1 = HttpClientUtils.doPost(url,map1);
        }else{
            return null;
        }
        Map maps1 = (Map) JSON.parse(result1);
        if(null!=maps1.get("data")){
            String data = maps1.get("data").toString();
            Map mapsHsy = (Map)JSON.parse(data);
            if(null!=mapsHsy.get("trid")){
                String trid = mapsHsy.get("trid").toString();
                num =  dao.updateApirecByOrderId(orderId,userId,trid);
                newTrid=trid;
            }
        }

        UserModel apirecUserModel = cuserConsoleDao.queryUserOtherApiById(userId,"2");
        int num1 =  dao.updateApirecDetailByOrderId(orderId,apirecUserModel.getMobilePhone(),apirecUserModel.getName());


        //发消息队列订单操作
        sendOperationLog(orderModel);
        //发消息给回收员1
        String message = "指派订单"+orderId+"给您,请准时到达现场";
        payConsoleDao.insertMessage(message,userId,"","1","指派订单",sdf1.format(new Date()));
        if(null!=receiver&&!"".equals(receiver)){
            UserModel uu = cuserConsoleService.queryUserOtherById(receiver);
            oldTrid = uu.getTerminalId();
            String message1 = "订单"+orderId+"已更换骑手";
            payConsoleDao.insertMessage(message1,receiver,"","1","订单变更",sdf1.format(new Date()));

        }
        //极光推送
        Map<String, String> newMap = new HashMap<>();
        newMap.put("traceIds", newTrid);
        Map<String, String> oldMap = new HashMap<>();
        newMap.put("traceIds", oldTrid);
        sendByAnroid("", "轨迹", newMap, Audience.alias(userId),appkey,screct);
        sendByAnroid("", "轨迹", oldMap, Audience.alias(receiver),appkey,screct);


        if(num>0){
            map.put("code",0);
            map.put("orderId",orderId);
        }else{
            map.put("code",-1);
            map.put("orderId",orderId);

        }
        return map;
    }

    private String sendByAnroid(String alert, String title, Map<String,String> extras, Audience audience,String appKey,String secret){

        Map<String,Object> map=new HashMap<>();
        map.put("alert",alert);
        map.put("title",title);
        map.put("extras",extras);
        map.put("audience",audience);
        try {
            PushPayload tag1 = PushPayload.newBuilder()
                    .setPlatform(Platform.android())
                    .setAudience(audience)
                    .setNotification(Notification.android(alert, title, extras))
                    .build();
            JPushClient jpushClient = new JPushClient(secret, appKey, null, ClientConfig.getInstance());
            //JPushClient jPushClient = Singleton.get(JPushClient.class);
            jpushClient.sendPush(tag1);
            log.info("极光推送成功:{}", JSONUtil.toJsonPrettyStr(map));
            return null;
        } catch (APIConnectionException | APIRequestException e) {
            log.error("极光推送失败：内容【"+JSONUtil.toJsonPrettyStr(map) +"】",e);
            return e.getMessage();
        }
    }
    private void sendOperationLog(OrderModel orderModel){
        OrderOperationLogModel operationLogModel = new OrderOperationLogModel();
        operationLogModel.setOrderId(orderModel.getOrderId());
        operationLogModel.setOperateContent("后台指派回收员");
        operationLogModel.setOrderStatus("2");
        operationLogModel.setOrderSecondStatus("1");
        operationLogModel.setOperateTime(sdf1.format(new Date()));
        //CoreUser user = platformService.getCurrentUser();
        operationLogModel.setOperateUserId(orderModel.getUserId());
        mqUtil.send(MqConstants.ORDER_OPERATION_LOG_QUEUE,operationLogModel);
        //
        redisService.remove("xzx:order:status:"+orderModel.getOrderId());
    }
    /**
     * 订单是待接单状态，后台直接指定接单员
     * @param orderId      订单好
     * @param receiveId    派单员ID
     * @param orderStatus  订单状态
     */
    public int updataOrderStatus(String flag, String orderId, String receiveId, String orderStatus,
                                 String complaintId, String complainPlan, String afterSleFlag){
        // 等于1,说明是投诉那边派单的，需要更新投诉表的数据
        if(flag.equals("1")){
            complaintConsoleDao.updateComplaintFlag(complaintId, complainPlan, afterSleFlag);
            return dao.updateOrderStatus(orderId, receiveId, orderStatus);
        }else{
            List<Map<String, Object>> map = dao.queryOrderByOrderno(orderId);
            if(map.size() ==0){
                return 0;
            }else {
                // 在更新前需要再次查询当前订单的状态是否为1
                if(map.get(0).get("orderStatus").equals("1")){
                    return dao.updateOrderStatus(orderId, receiveId, orderStatus);
                }else {
                    return 0;
                }
            }
        }
    }

    public List<SysAddressLevelModel> queryAdressArea(SysAddressLevelModel addressLevelModel){
        if(addressLevelModel.getType().equals("0")){
            return dao.queryProvince();
        }else if(addressLevelModel.getType().equals("1")){
            return dao.queryCityByProvinceId(addressLevelModel.getLevel1Id());
        }else if(addressLevelModel.getType().equals("2")){
            return dao.queryTownShipByCityId(addressLevelModel.getLevel2Id());
        }else{
            return null;
        }
    }

}