package com.xzx.gc.user.service;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import com.xzx.gc.common.constant.Constants;
import com.xzx.gc.common.constant.OrderEnum;
import com.xzx.gc.common.constant.PayEnum;
import com.xzx.gc.common.utils.BusinessUtil;
import com.xzx.gc.common.utils.DateUtils;
import com.xzx.gc.entity.*;
import com.xzx.gc.model.order.OrderReportDetailDto;
import com.xzx.gc.model.order.OrderReportDto;
import com.xzx.gc.user.mapper.AccountMapper;
import com.xzx.gc.user.mapper.AddressLevelInfoMapper;
import com.xzx.gc.user.mapper.OrderMapper;
import com.xzx.gc.user.mapper.PayRequestMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

@Service
@Transactional
@Slf4j
public class OrderReportService {

    @Autowired
    private OrderMapper orderMapper;


    @Autowired
    private BusinessUtil businessUtil;

    @Autowired
    private PayRequestMapper payRequestMapper;

    @Autowired
    private AccountMapper accountMapper;
    
    @Autowired
    private AddressLevelInfoMapper addressLevelInfoMapper;

    @Autowired
    private FenceService fenceService;

    @Autowired
    private AccountService accountService;

    @Autowired
    private CityPartnerService cityPartnerService;

    @Autowired
    private AddressService addressService;

    @Autowired
    private PartnerGaodeService partnerGaodeService;


    /**
     * 根据合伙人查询
     * @param partnerId
     * @return
     */
    public OrderReportDto findByPartneId(String partnerId){
        OrderReportDto orderReportDto = new OrderReportDto();
        //回收总金额
        BigDecimal recyleMoney = BigDecimal.ZERO;
        //今日回收总金额
        BigDecimal recyleMoneyToday = BigDecimal.ZERO;
        //昨日回收总金额
        BigDecimal recyleMoneyYesterday = BigDecimal.ZERO;
        //今日下单总用户量数
        int orderUserNumToday = 0;
        //昨日下单总用户量数
        int orderUserNumYesterday = 0;
        //下单总用户量数
        int orderUserNum = 0;
        //未提现总额
        BigDecimal notWithdrawalrecyleMoney = BigDecimal.ZERO;
        //已提现总额
        BigDecimal withdrawalrecyleMoney = BigDecimal.ZERO;


        //当前时间
        DateTime nowData = DateUtil.parse(DateUtil.now(), DateUtils.DATE_FORMAT_YMD);

        //已完成订单
        List<OrderInfo> collect1=new ArrayList<>();

        //所有订单
        List<OrderInfo> orderInfos = orderMapper.findDetailByPartned(partnerId);
        if (CollUtil.isNotEmpty(orderInfos)) {
            List<OrderInfo> collect = removeRepeatUser(orderInfos);
            orderUserNum =collect.size();

            //去重用户订单列表
            for (OrderInfo orderInfo : collect) {
                String createTime = orderInfo.getCreateTime();
                DateTime parse3 = DateUtil.parse(createTime, DateUtils.DATE_FORMAT_YMD);

                //当天下单用户量
                if (DateUtil.isSameDay(parse3, nowData)) {
                    orderUserNumToday = orderUserNumToday + 1;
                }

                //昨天下单用户量
                long l2 = DateUtil.betweenDay(parse3, nowData, true);
                if (l2 == 1) {
                    orderUserNumYesterday = orderUserNumYesterday + 1;
                }
            }


            //订单已完成的列表按完成时间升序
            collect1 = orderInfos.stream().filter(x -> x.getOrderStatus().equals(OrderEnum.完成.getValue())||x.getOrderStatus().equals(OrderEnum.入库中.getValue())||x.getOrderStatus().equals(OrderEnum.待入库.getValue())).collect(Collectors.toList());
                List<OrderInfo> collect2 = collect1.stream().sorted(Comparator.comparing(OrderInfo::getCompleteTime)).collect(Collectors.toList());

            //订单已完成的列表
            for (OrderInfo orderInfo : collect2) {
                BigDecimal money = Convert.toBigDecimal(orderInfo.getMoney());
                recyleMoney = NumberUtil.add(money, recyleMoney);
                String completeTime = orderInfo.getCompleteTime();
                DateTime parse = DateUtil.parse(completeTime, DateUtils.DATE_FORMAT_YMD);

                //今日回收金额
                if (DateUtil.isSameDay(parse, nowData)) {
                    recyleMoneyToday = NumberUtil.add(money, recyleMoneyToday);
                }
                //昨天回收金额
                long l = DateUtil.betweenDay(parse, nowData, true);
                if (l == 1) {
                    recyleMoneyYesterday = NumberUtil.add(money, recyleMoneyYesterday);
                }
            }

        }

        String recyleMoneyTodayAvg = Constants.MONEY_INIT.toString();
        //回收日均金额  回收总金额/ （当前时间-最早回收时间）
        recyleMoneyTodayAvg=getMoneyAvg(collect1,nowData);




        //回收日环比计算方法： (本日回收金额/昨日回收金额 — 1 )× 100%  正值为增长率  负值为下降率
        String RecyleRatio = getRecyleRatio(recyleMoneyYesterday,recyleMoneyToday);

        //日均下单用户量
        int orderUserNumTodayAvg=getNumAvg(orderInfos,nowData);

        //下单用户量日环比
        String orderUserRatio = getOrderUserRatio(orderUserNumYesterday,orderUserNumToday);

        //已提现金额 查询交易记录表
//        PayRequestInfo payInf = new PayRequestInfo();
//        payInf.setPayType(PayEnum.提现.getValue());
//        payInf.setStatus(PayEnum.已审核完成.getValue());
//        List<PayRequestInfo> select = payRequestMapper.select(payInf);
//        if (CollUtil.isNotEmpty(select)) {
//            for (PayRequestInfo payInfo : select) {
//                withdrawalrecyleMoney = NumberUtil.add(withdrawalrecyleMoney, Convert.toBigDecimal(payInfo.getMoney()));
//            }
//        }
//
//        //未提现 查询所有账户
//        Example example = new Example(AccountInfo.class);
//        Example.Criteria criteria = example.createCriteria();
//        criteria.andEqualTo("delFlag", 0);
//        List<AccountInfo> accountInfos = accountMapper.selectByExample(example);
//        for (AccountInfo accountInfo : accountInfos) {
//            String money = accountInfo.getMoney();
//            if (StrUtil.isBlank(money)) {
//                money = Convert.toStr(Constants.MONEY_INIT);
//            }
//            notWithdrawalrecyleMoney = NumberUtil.add(notWithdrawalrecyleMoney, Convert.toBigDecimal(money));
//        }


        //获取合伙人名称
        String partnerName = cityPartnerService.findById(Convert.toInt(partnerId)).getPartnerName();


        //未提现金额
        List<OrderInfo> accountInfos = findNotWithdraw(partnerId);
        double sum = accountInfos.stream().mapToDouble(x -> Convert.toDouble(x.getMoney())).sum();
        notWithdrawalrecyleMoney=businessUtil.changeMul(String.valueOf(sum));


        //返回数据
        orderReportDto.setPartnerName(partnerName);
        orderReportDto.setOrderUserNumTodayAvg(orderUserNumTodayAvg);
        orderReportDto.setOrderUserRatio(orderUserRatio);
        orderReportDto.setRecyleRatio(RecyleRatio);
        orderReportDto.setRecyleMoneyTodayAvg(recyleMoneyTodayAvg);
        orderReportDto.setRecyleMoney(businessUtil.changeMoney(Convert.toStr(recyleMoney)));
        orderReportDto.setRecyleMoneyToday(businessUtil.changeMoney(Convert.toStr(recyleMoneyToday)));
        orderReportDto.setOrderUserNum(orderUserNum);
        orderReportDto.setOrderUserNumToday(orderUserNumToday);
        orderReportDto.setDate(DateUtil.today());
        orderReportDto.setNotWithdrawalMoney(businessUtil.changeMoney(Convert.toStr(notWithdrawalrecyleMoney)));
        orderReportDto.setWithDrawalMoney(businessUtil.changeMoney(Convert.toStr(withdrawalrecyleMoney)));

        return orderReportDto;
    }


    /**
     * 获取今日回收完成的列表
     * @param orderInfos
     * @return
     */
    public List<OrderInfo> getTodayCompleteOrderList(List<OrderInfo> orderInfos){
        List<OrderInfo> list=new ArrayList<>();
        //筛选订单已完成的列表
        List<OrderInfo> collect1 = orderInfos.stream().filter(x -> x.getOrderStatus().equals(OrderEnum.完成.getValue())||x.getOrderStatus().equals(OrderEnum.入库中.getValue())||x.getOrderStatus().equals(OrderEnum.待入库.getValue())).collect(Collectors.toList());
        //当前时间
        DateTime nowData = DateUtil.parse(DateUtil.now(), DateUtils.DATE_FORMAT_YMD);
        //订单已完成的列表
        for (OrderInfo orderInfo : collect1) {
            //今日回收金额
            String completeTime = orderInfo.getCompleteTime();
            DateTime parse = DateUtil.parse(completeTime, DateUtils.DATE_FORMAT_YMD);
            if (DateUtil.isSameDay(parse, nowData)) {
                list.add(orderInfo);
            }
        }
        return list;
    }


    /**
     * 根据日期筛选订单
     * 0：今日 1：近3日 2：近10日 3：近1月 4：近3月 5：近6月
     * @param orderInfos
     * @param timeType
     * @return
     */
    public List<OrderInfo> getCompleteOrderListByTime(List<OrderInfo> orderInfos,Integer timeType){
        List<OrderInfo> list=new ArrayList<>();
        //筛选订单已完成的列表
        List<OrderInfo> collect1 = orderInfos.stream().filter(x -> x.getOrderStatus().equals(OrderEnum.完成.getValue())||x.getOrderStatus().equals(OrderEnum.入库中.getValue())||x.getOrderStatus().equals(OrderEnum.待入库.getValue())).collect(Collectors.toList());
        //当前时间
        DateTime nowData = DateUtil.parse(DateUtil.now(), DateUtils.DATE_FORMAT_YMD);

        if(timeType==null){
            return collect1;
        }
        //订单已完成的列表
        for (OrderInfo orderInfo : collect1) {
            //今日回收金额
            String completeTime = orderInfo.getCompleteTime();
            DateTime parse = DateUtil.parse(completeTime, DateUtils.DATE_FORMAT_YMD);

            if(timeType==0){
                //当天
                if (DateUtil.isSameDay(parse, nowData)) {
                    list.add(orderInfo);
                }
            }else if(timeType==1){
                //近3日
                if(DateUtil.betweenDay(parse,nowData,true)<=3){
                    list.add(orderInfo);
                }
            }else if(timeType==2){
                //近10日
                if(DateUtil.betweenDay(parse,nowData,true)<=10){
                    list.add(orderInfo);
                }
            }else if(timeType==3){
                //近1月
                if(DateUtil.betweenMonth(parse,nowData,true)<=1){
                    list.add(orderInfo);
                }
            }else if(timeType==4){
                //近3月
                if(DateUtil.betweenMonth(parse,nowData,true)<=3){
                    list.add(orderInfo);
                }
            }else if(timeType==5){
                //近6月
                if(DateUtil.betweenMonth(parse,nowData,true)<=6){
                    list.add(orderInfo);
                }
            }



        }
        return list;
    }

    /**
     * 今日下单用户
     * @param orderInfos
     * @return
     */
    public List<OrderInfo> getTodayOrderUserList(List<OrderInfo> orderInfos){
        //当前时间
        DateTime nowData = DateUtil.parse(DateUtil.now(), DateUtils.DATE_FORMAT_YMD);
        List<OrderInfo> list=new ArrayList<>();
        List<OrderInfo> collect = removeRepeatUser(orderInfos);
        //去重用户订单列表
        for (OrderInfo orderInfo : collect) {
            String createTime = orderInfo.getCreateTime();
            DateTime parse3 = DateUtil.parse(createTime, DateUtils.DATE_FORMAT_YMD);

            //当天下单用户量
            if (DateUtil.isSameDay(parse3, nowData)) {
                list.add(orderInfo);
            }
        }
        return list;
    }

    public List<OrderInfo> getOrderUserListByTime(List<OrderInfo> orderInfos,Integer timeType){
        //当前时间
        DateTime nowData = DateUtil.parse(DateUtil.now(), DateUtils.DATE_FORMAT_YMD);
        List<OrderInfo> list=new ArrayList<>();
        List<OrderInfo> collect = removeRepeatUser(orderInfos);

        if(timeType==null){
            return collect;
        }

        //去重用户订单列表
        for (OrderInfo orderInfo : collect) {
            String createTime = orderInfo.getCreateTime();
            DateTime parse = DateUtil.parse(createTime, DateUtils.DATE_FORMAT_YMD);

            if(timeType==0){
                //当天
                if (DateUtil.isSameDay(parse, nowData)) {
                    list.add(orderInfo);
                }
            }else if(timeType==1){
                //近3日
                if(DateUtil.betweenDay(parse,nowData,true)<=3){
                    list.add(orderInfo);
                }
            }else if(timeType==2){
                //近10日
                if(DateUtil.betweenDay(parse,nowData,true)<=10){
                    list.add(orderInfo);
                }
            }else if(timeType==3){
                //近1月
                if(DateUtil.betweenMonth(parse,nowData,true)<=1){
                    list.add(orderInfo);
                }
            }else if(timeType==4){
                //近3月
                if(DateUtil.betweenMonth(parse,nowData,true)<=3){
                    list.add(orderInfo);
                }
            }else if(timeType==5){
                //近6月
                if(DateUtil.betweenMonth(parse,nowData,true)<=6){
                    list.add(orderInfo);
                }
            }
        }
        return list;
    }

    /**
     * 设置金额和数目 以及日均金额 和下单人数
     * @param list
     * @param areaName
     * @param money
     */
    public void setMoneyOrNum(List<OrderReportDetailDto> list, String areaName, String areaId, BigDecimal money, int level){
        //是否存在当前区域标识
        boolean flag=false;
        for (OrderReportDetailDto orderReportDetailDto : list) {
            String areaId1 = orderReportDetailDto.getAreaId();
            if(areaId1.equals(areaId)){
                if(money!=null){
                    orderReportDetailDto.setMoney(businessUtil.changeMoney(Convert.toStr(NumberUtil.add(money,Convert.toBigDecimal(orderReportDetailDto.getMoney())))));
                }
                orderReportDetailDto.setNum(1+orderReportDetailDto.getNum());
                flag=true;
                break;
            }
        }

        if(!flag){
            OrderReportDetailDto orderReportDetailDto=new OrderReportDetailDto();
            orderReportDetailDto.setAreaName(areaName);
            orderReportDetailDto.setAreaId(areaId);
            orderReportDetailDto.setMoney(Convert.toStr(money,Convert.toStr(Constants.MONEY_INIT)));
            orderReportDetailDto.setNum(1);
            orderReportDetailDto.setLevel(level);
            list.add(orderReportDetailDto);
        }
    }


    public void setMoneyOrNum(List<OrderReportDetailDto> list,String areaId,String areaName,BigDecimal money){
        //是否存在当前区域标识
        boolean flag=false;
        for (OrderReportDetailDto orderReportDetailDto : list) {
            String areaId1 = orderReportDetailDto.getAreaId();
            if(areaId1.equals(areaId)){
                if(money!=null){
                    orderReportDetailDto.setMoney(businessUtil.changeMoney(Convert.toStr(NumberUtil.add(money,Convert.toBigDecimal(orderReportDetailDto.getMoney())))));
                }
                orderReportDetailDto.setNum(1+orderReportDetailDto.getNum());
                flag=true;
                break;
            }
        }

        if(!flag){
            OrderReportDetailDto orderReportDetailDto=new OrderReportDetailDto();
            orderReportDetailDto.setAreaName(areaName);
            orderReportDetailDto.setAreaId(areaId);
            orderReportDetailDto.setMoney(Convert.toStr(money,Convert.toStr(Constants.MONEY_INIT)));
            orderReportDetailDto.setNum(1);
            list.add(orderReportDetailDto);
        }
    }



    /**
     * 获取省市区报表详情
     * @param list
     * @param level
     * @param areaId
     * @return
     */
    public List<OrderReportDetailDto>  getDetail(List<OrderInfo> list,int level,String areaId){
        List<OrderReportDetailDto> list2=new ArrayList<>();
        for (OrderInfo orderInfo : list) {
            //所在区域
            String townId = orderInfo.getTownId();

            if(StrUtil.isBlank(townId)){
                AddressInfo byUserId = addressService.findByUserId(orderInfo.getUserId());
                if(byUserId!=null&&StrUtil.isNotBlank(byUserId.getTownshipId())){
                    townId=byUserId.getTownshipId();
                }
            }

            BigDecimal money = Convert.toBigDecimal(orderInfo.getMoney());
            if(StrUtil.isNotBlank(townId)){
                AddressLevelInfo addressLevelInfo=new AddressLevelInfo();
                addressLevelInfo.setLevel3Id(townId);
                AddressLevelInfo addressLevelInfo1 = addressLevelInfoMapper.selectOne(addressLevelInfo);
                if(addressLevelInfo1!=null){
                    String level1Name = addressLevelInfo1.getLevel1Name();
                    String level1Id = addressLevelInfo1.getLevel1Id();
                    String level2Name = addressLevelInfo1.getLevel2Name();
                    String level2Id = addressLevelInfo1.getLevel2Id();
                    String level3Name = addressLevelInfo1.getLevel3Name();
                    String level3Id = addressLevelInfo1.getLevel3Id();
                    if(level==1){
                        //只需要查询省份
                        setMoneyOrNum(list2,level1Name,level1Id,money,level);
                    }else if(level==2){
                        //查询省下所有市
                        if(level1Id.equals(areaId)){
                           setMoneyOrNum(list2,level2Name,level2Id,money,level);
                        }
                    } else if(level==3){
                        //查询市下所有区
                        if(level2Id.equals(areaId)){
                           setMoneyOrNum(list2,level3Name,level3Id,money,level);
                        }
                    }
                }
            }else {
                log.warn("存在省市区id为空的订单:{}", orderInfo.getOrderId());
            }
        }
        return list2;
    }


    /**
     * 根据合伙人查找当前用户未提现的列表
     * @param partnerId
     * @return
     */
    public List<OrderInfo> findNotWithdraw(String partnerId){
        //未提现 查询所有账户
        List<OrderInfo> accountInfos = accountMapper.findArea();
        for (Iterator<OrderInfo> iterator = accountInfos.iterator(); iterator.hasNext(); ) {
            OrderInfo accountInfo =  iterator.next();
            //针对用户将地址删光的情况
            if(StrUtil.isBlank(accountInfo.getTownId())){
                AddressInfo byUserId = addressService.findByUserId(accountInfo.getUserId());
                if(byUserId==null||StrUtil.isBlank(byUserId.getTownshipId())){
                    log.warn("用户：{}出现不可能的地址为空的情况",accountInfo.getUserId());
                    iterator.remove();
                    continue;
                }
                accountInfo.setTownId(byUserId.getTownshipId());
                accountInfo.setTownShipName(byUserId.getTownshipName());
                accountInfo.setLongitude(byUserId.getLongitude());
                accountInfo.setLatitude(byUserId.getLatitude());
            }

            PartnerGaode byTownId = partnerGaodeService.findByTownId(accountInfo.getTownId());
            if(byTownId==null||!byTownId.getPartnerId().equals(partnerId)){
                iterator.remove();
            }
        }
        return accountInfos;
    }


    /**
     * 获取围栏报表详情
     * @param list
     * @return
     */
    public List<OrderReportDetailDto>  getDetail(List<OrderInfo> list,int type){
        List<OrderReportDetailDto> list2=new ArrayList<>();
        BigDecimal sumMoney=BigDecimal.ZERO;
        for (OrderInfo orderInfo : list) {
            //所在围栏
            String townId = orderInfo.getTownId();
            if(StrUtil.isBlank(townId)){
                townId=Constants.DEFAULT_ID;
            }
            String townName=orderInfo.getTownShipName();
            if(StrUtil.isBlank(townName)){
                Fence byId = fenceService.findById(Convert.toInt(townId));
                if(byId!=null) {
                    townName = byId.getFenceName();
                }else {
                    townName="其他";
                }
            }
            BigDecimal money = Convert.toBigDecimal(orderInfo.getMoney());
            setMoneyOrNum(list2,townId,townName,money);
            sumMoney=NumberUtil.add(sumMoney,money);
        }

        //设置总金额
        for (OrderReportDetailDto orderReportDetailDto : list2) {
            orderReportDetailDto.setAllNum(list.size());
            orderReportDetailDto.setAlloney(sumMoney.toString());
            orderReportDetailDto.setMoneyDouble(Convert.toDouble(orderReportDetailDto.getMoney()));
        }


        //兼容没数据的围栏显示
//        if(CollUtil.isEmpty(list2)) {
//            List<Fence> all = fenceService.findByPartnerId(partnerId);
//            if (CollUtil.isNotEmpty(all)) {
//                for (Fence fence : all) {
//                    Integer id = fence.getId();
//                    String fenceName = fence.getFenceName();
//                    OrderReportDetailDto orderReportDetailDto = new OrderReportDetailDto();
//                    orderReportDetailDto.setAreaName(fenceName);
//                    orderReportDetailDto.setAreaId(id.toString());
//                    orderReportDetailDto.setMoney(Constants.MONEY_INIT.toString());
//                    orderReportDetailDto.setMoneyDouble(Convert.toDouble(orderReportDetailDto.getMoney()));
//                    orderReportDetailDto.setNum(0);
//                    orderReportDetailDto.setAlloney(Constants.MONEY_INIT.toString());
//                    list2.add(orderReportDetailDto);
//
//                }
//            }
//        }else {
//            List<Fence> all = fenceService.findByPartnerId(partnerId);
//            if (CollUtil.isNotEmpty(all)) {
//                for (Fence fence : all) {
//                    Integer id = fence.getId();
//                    String fenceName = fence.getFenceName();
//                    long count = list2.stream().filter(x -> x.getAreaId().equals(id.toString())).count();
//                    if(count==0) {
//                        OrderReportDetailDto orderReportDetailDto = new OrderReportDetailDto();
//                        orderReportDetailDto.setAreaName(fenceName);
//                        orderReportDetailDto.setAreaId(id.toString());
//                        orderReportDetailDto.setMoney(Constants.MONEY_INIT.toString());
//                        orderReportDetailDto.setMoneyDouble(Convert.toDouble(orderReportDetailDto.getMoney()));
//                        orderReportDetailDto.setNum(0);
//                        orderReportDetailDto.setAlloney(Constants.MONEY_INIT.toString());
//                        list2.add(orderReportDetailDto);
//                    }
//
//                }
//            }
//        }

//        list2=CollUtil.sort(list2,Comparator.comparing(OrderReportDetailDto::getAreaId).reversed());
        if(type==1) {
            list2 = CollUtil.sort(list2, Comparator.comparingDouble(OrderReportDetailDto::getMoneyDouble).reversed());
        }else if(type==2){
            list2 = CollUtil.sort(list2, Comparator.comparing(OrderReportDetailDto::getNum).reversed());
        }
        return list2;
    }


    /**
     * 设置日环比
     * @param list
     * @param listToday
     * @param listYesterday
     * @param type 1:回收金额日环比 2：下单用户日环比
     */
    public void setRatio( List<OrderReportDetailDto> list, List<OrderReportDetailDto> listToday,List<OrderReportDetailDto> listYesterday,int type){
        for (OrderReportDetailDto orderReportDetailDto : listToday) {
            String money = orderReportDetailDto.getMoney();
            int num = orderReportDetailDto.getNum();
            String areaId = orderReportDetailDto.getAreaId();
            for (OrderReportDetailDto orderReportDetailDto2 : listYesterday){
                String money2 = orderReportDetailDto2.getMoney();
                int num2 = orderReportDetailDto2.getNum();
                String areaId2 = orderReportDetailDto2.getAreaId();
                if(areaId2.equals(areaId)){
                    String recyleRatio = getRecyleRatio(Convert.toBigDecimal(money2), Convert.toBigDecimal(money));
                    String orderUserRatio = getOrderUserRatio(num2, num);
                    for (OrderReportDetailDto reportDetailDto : list) {
                        if(reportDetailDto.getAreaId().equals(areaId)){
                            if(type==1){
                                reportDetailDto.setRatio(recyleRatio);
                            }else if(type==2){
                                reportDetailDto.setRatio(orderUserRatio);
                            }

                            break;
                        }
                    }
                    break;
                }
            }
        }
    }

    /**
     * 获取回收金额日环比
     * @param recyleMoneyYesterday
     * @param recyleMoneyToday
     * @return
     */
    public String getRecyleRatio(BigDecimal recyleMoneyYesterday,BigDecimal  recyleMoneyToday){
        //回收日环比计算方法： (本日回收金额/昨日回收金额 — 1 )× 100%  正值为增长率  负值为下降率
        String RecyleRatio = "+0.00%";
        if (recyleMoneyYesterday.compareTo(BigDecimal.ZERO) != 0) {
            String s = Convert.toStr(NumberUtil.mul(NumberUtil.sub(NumberUtil.div(recyleMoneyToday, recyleMoneyYesterday), 1), 100));
            RecyleRatio = businessUtil.changeMoney(s) + "%";
        } else {
            RecyleRatio = "+100.00%";
        }
        return RecyleRatio;
    }

    /**
     * 获取下单用户日环比
     * @param orderUserNumYesterday
     * @param orderUserNumToday
     * @return
     */
    public String getOrderUserRatio(int orderUserNumYesterday,int  orderUserNumToday){
        //下单用户量日环比
        String orderUserRatio = "+0.00%";
        if (orderUserNumYesterday != 0) {
            String s = Convert.toStr(NumberUtil.mul(NumberUtil.sub(NumberUtil.div(orderUserNumToday, orderUserNumYesterday), 1), 100));
            orderUserRatio = businessUtil.changeMoney(s) + "%";
        } else {
            orderUserRatio = "+100.00%";
        }
        return orderUserRatio;
    }


    /**
     * 查看这个区域下的所有订单
     * @param areaId
     * @param level
     * @return
     */
    public List<OrderInfo> findByAreaAndLevel(List<OrderInfo> collect,String areaId,Integer level){
        AddressLevelInfo addressLevelInfo=new AddressLevelInfo();
        if(1==level){
            addressLevelInfo.setLevel1Id(areaId);
        }else if(2==level){
            addressLevelInfo.setLevel2Id(areaId);
        }else if(3==level){
            addressLevelInfo.setLevel3Id(areaId);
        }
        List<AddressLevelInfo> select = addressLevelInfoMapper.select(addressLevelInfo);
        if(CollUtil.isNotEmpty(select)){
            List<String> collect2 = select.stream().map(x -> x.getLevel3Id()).collect(Collectors.toList());
            List<OrderInfo> collect1 = collect.stream().filter(x -> StrUtil.isNotBlank(x.getTownId()) && collect2.contains(x.getTownId())).collect(Collectors.toList());
            return collect1;
        }
        return null;
    }


    /**
     * 获取回收日均金额
     * @param collect1  已完成订单
     * @param nowData
     * @return
     */
    public String getMoneyAvg(  List<OrderInfo> collect1,Date nowData){
        String recyleMoneyTodayAvg = Constants.MONEY_INIT.toString();
        if(CollUtil.isNotEmpty(collect1)) {
            List<OrderInfo> collect2 = collect1.stream().sorted(Comparator.comparing(OrderInfo::getCompleteTime)).collect(Collectors.toList());
            OrderInfo orderInfo2 = collect2.get(0);
            BigDecimal recyleMoney = Constants.MONEY_INIT;
            //订单已完成的列表
            for (OrderInfo orderInfo : collect2) {
                BigDecimal money = Convert.toBigDecimal(orderInfo.getMoney());
                recyleMoney = NumberUtil.add(money, recyleMoney);
            }
            //回收完成最早时间
            String recyleEarliestTime = orderInfo2.getCompleteTime();
            //回收日均金额  回收总金额/ （当前时间-最早回收时间）
            DateTime parseStart = DateUtil.parse(recyleEarliestTime, DateUtils.DATE_FORMAT_YMD);
            long l = DateUtil.betweenDay(parseStart, nowData, true);
            if (l == 0) {
                l = 1;
            }
            recyleMoneyTodayAvg = businessUtil.changeMoney(Convert.toStr(NumberUtil.div(recyleMoney, l)));
        }
        return recyleMoneyTodayAvg;
    }

    /**
     * 获取日均下单用户量
     * @param orderInfos 所有订单
     * @param nowData
     * @return
     */
    public int getNumAvg(List<OrderInfo> orderInfos,Date nowData){
        //日均下单用户量
        int orderUserNumTodayAvg = 0;
        if(CollUtil.isNotEmpty(orderInfos)) {
            ArrayList<OrderInfo> collect = orderInfos.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(OrderInfo::getCreateUserId))), ArrayList::new));
            int orderUserNum = collect.size();
            //下单最早时间
            Date orderEarliestTime = getOrderEarliestTime(orderInfos);
            long l = DateUtil.betweenDay(orderEarliestTime, nowData, true);
            if (l == 0) {
                l = 1;
            }
            orderUserNumTodayAvg = Convert.toInt(NumberUtil.div(orderUserNum, l));
        }
        return orderUserNumTodayAvg;
    }



    /**获取最早下单时间
     *
     * @param orderInfos 所有订单
     * @return
     */
    public Date getOrderEarliestTime(List<OrderInfo> orderInfos){
        Date orderEarliestTime=null;
        //所有订单
        for (OrderInfo orderInfo : orderInfos) {
            //获取最早下单时间
            String createTime = orderInfo.getCreateTime();
            DateTime parse3 = DateUtil.parse(createTime, DateUtils.DATE_FORMAT_YMD);
            if (orderEarliestTime == null) {
                orderEarliestTime = parse3;
            } else {
                int compare = DateUtil.compare(orderEarliestTime, parse3);
                if (compare > 0) {
                    orderEarliestTime = parse3;
                }
            }
        }
        return orderEarliestTime;
    }


    public List<OrderInfo> removeRepeatUser(List<OrderInfo> list){
//        ArrayList<OrderInfo> collect = list.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getCreateUserId() + ";" + DateUtil.parse(o.getCreateTime(), DateUtils.DATE_FORMAT_YMD).toString(DateUtils.DATE_FORMAT_YMD)))), ArrayList::new));
        return list;
    }
}