package com.kiisoo.ic.generalize.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.api.R;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.kiisoo.ic.customer.entity.OpSellerCustomerRelation;
import com.kiisoo.ic.customer.mapper.OpSellerCustomerRelationDOMapper;
import com.kiisoo.ic.generalize.bean.*;
import com.kiisoo.ic.generalize.entity.*;
import com.kiisoo.ic.generalize.mapper.OrganizationalMemberMapper;
import com.kiisoo.ic.generalize.mapper.PoiCustomerContactDataStatMapper;
import com.kiisoo.ic.generalize.mapper.RetailCompanyMapper;
import com.kiisoo.ic.store.entity.PoiStore;
import com.kiisoo.ic.store.entity.PoiStoreStaff;
import com.kiisoo.ic.store.mapper.PoiStoreDOMapper;
import com.kiisoo.ic.store.mapper.PoiStoreStaffDOMapper;
import com.kiisoo.ic.system.entity.PrivilageRoleDO;
import com.kiisoo.ic.system.entity.PrivilageUserDO;
import com.kiisoo.ic.system.enums.RoleEnum;
import com.kiisoo.ic.system.mapper.PrivilageUserDOMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @ClassName: RetailCompanyService
 * @Description:
 * @Auther: Caps
 * @Date: 2020/4/15 0015 11:08
 * @Version:
 */
@Service
public class RetailCompanyService {

    /**
     * 区域
     */
    static final Integer LEVEL_REGION = 1;
    /**
     * 零售公司
     */
    static final Integer LEVEL_COMPANY = 2;
    /**
     * 客户
     */
    static final Integer LEVEL_CUSTOMER = 3;

    private RetailCompanyMapper retailCompanyMapper;

    private OrganizationalMemberMapper organizationalMemberMapper;

    private OpSellerCustomerRelationDOMapper opSellerCustomerRelationDOMapper;

    private PoiCustomerContactDataStatMapper poiCustomerContactDataStatMapper;

    private PoiStoreDOMapper poiStoreDOMapper;

    private PrivilageUserDOMapper privilageUserDOMapper;

    private PoiStoreStaffDOMapper poiStoreStaffDOMapper;

    @Autowired
    public RetailCompanyService(RetailCompanyMapper retailCompanyMapper, OrganizationalMemberMapper organizationalMemberMapper, OpSellerCustomerRelationDOMapper opSellerCustomerRelationDOMapper, PoiCustomerContactDataStatMapper poiCustomerContactDataStatMapper, PoiStoreDOMapper poiStoreDOMapper, PrivilageUserDOMapper privilageUserDOMapper, PoiStoreStaffDOMapper poiStoreStaffDOMapper) {
        this.retailCompanyMapper = retailCompanyMapper;
        this.organizationalMemberMapper = organizationalMemberMapper;
        this.opSellerCustomerRelationDOMapper = opSellerCustomerRelationDOMapper;
        this.poiCustomerContactDataStatMapper = poiCustomerContactDataStatMapper;
        this.poiStoreDOMapper = poiStoreDOMapper;
        this.privilageUserDOMapper = privilageUserDOMapper;
        this.poiStoreStaffDOMapper = poiStoreStaffDOMapper;
    }


    /**
     * 找到用户公司
     *
     * @param parentId 父区域id
     * @param userId   用户id
     * @param level    等级
     * @return
     */
    public List<PrivilageOrganizational> getUserOrg(Long parentId, long userId, int level) {

        QueryWrapper<PrivilageOrganizationalMember> wrapper1 = new QueryWrapper<>();
        wrapper1.eq("user_id", userId);
        PrivilageOrganizational p = new PrivilageOrganizational();
        List<PrivilageOrganizationalMember> pm = organizationalMemberMapper.selectList(wrapper1);
        QueryWrapper<PrivilageOrganizational> wrapper = new QueryWrapper<>();
        if (check(userId)) {
            wrapper.eq("level", level).eq("type", 2).eq("status", 1);
            return retailCompanyMapper.selectList(wrapper);
        }
        if (pm.isEmpty()) {
            return new ArrayList<>();
        } else {
            wrapper.eq("type", 2).eq("status", 1).eq("level", level).
                    in("id", pm.stream().map(PrivilageOrganizationalMember::getOrgId).
                            collect(Collectors.toList()));
            if (null != parentId) {
                wrapper.eq("parent_id", parentId);
            }
            return retailCompanyMapper.selectList(wrapper);
        }
    }

    /**
     * 查询所有的大区信息
     */
    public List<PrivilageOrganizational> listOfBigRetailCompany(long userId) {
        QueryWrapper<PrivilageOrganizationalMember> wrapper1 = new QueryWrapper<>();
        wrapper1.eq("user_id", userId);
        List<PrivilageOrganizationalMember> pm = organizationalMemberMapper.selectList(wrapper1);
        QueryWrapper<PrivilageOrganizational> wrapper = new QueryWrapper<>();
        if (check(userId)) {
            wrapper.eq("type", 2).eq("level", 1).eq("status", 1);
            return retailCompanyMapper.selectList(wrapper);
        }
        if (pm.isEmpty()) {
            return new ArrayList<>();
        } else {
            wrapper.eq("type", 2).eq("level", 1).eq("status", 1).in("id", pm.stream().map(PrivilageOrganizationalMember::getOrgId).collect(Collectors.toList()));
            return retailCompanyMapper.selectList(wrapper);
        }
    }

    public boolean check(long userId) {
        //根据userId查询角色
        PrivilageRoleDO p = privilageUserDOMapper.selecctRoleByUserId(userId);
        if (p.getCode().equals(RoleEnum.ROLE_CODE_GLY.getRoleCode()) || p.getCode().equals(RoleEnum.ROLE_CODE_ALL_YYRY.getRoleCode())) {
            return true;
        } else {
            return false;
        }
    }


    /**
     * 查询所有的组织数据信息
     */
    public List<PrivilageOrganizational> listOfRetailOrg(long userId, Long regionId, Long companyId, Long customerId) {
        QueryWrapper<PrivilageOrganizationalMember> wrapper1 = new QueryWrapper<>();
        wrapper1.eq("user_id", userId);
        List<PrivilageOrganizationalMember> pm = organizationalMemberMapper.selectList(wrapper1);
        if (check(userId)) {
            return retailCompanyMapper.selectList(null);
        }
        if (pm.isEmpty()) {
            return new ArrayList<>();
        } else {
            List<Long> orgIds = pm.stream().map(PrivilageOrganizationalMember::getOrgId).collect(Collectors.toList());
            List<PrivilageOrganizationalRelationVO> orgRelationList = retailCompanyMapper.selectAllOrgListByOrgIds(orgIds, regionId, companyId, customerId);
            //所以组织list
            List<PrivilageOrganizational> tmpOrgList = new ArrayList<>();
            orgRelationList.forEach(orgRelationVO -> {
                PrivilageOrganizational regionDO = new PrivilageOrganizational();
                regionDO.setId(orgRelationVO.getRegionId());
                regionDO.setName(orgRelationVO.getRegion());
                regionDO.setLevel((long) LEVEL_REGION);
                regionDO.setParentId(0L);
                PrivilageOrganizational companyDO = new PrivilageOrganizational();
                companyDO.setId(orgRelationVO.getCompanyId());
                companyDO.setName(orgRelationVO.getCompany());
                companyDO.setLevel((long) LEVEL_COMPANY);
                companyDO.setParentId(orgRelationVO.getRegionId());
                PrivilageOrganizational customerDO = new PrivilageOrganizational();
                customerDO.setId(orgRelationVO.getCustomerId());
                customerDO.setName(orgRelationVO.getCustomer());
                customerDO.setLevel((long) LEVEL_CUSTOMER);
                customerDO.setParentId(orgRelationVO.getCompanyId());
                tmpOrgList.add(regionDO);
                tmpOrgList.add(companyDO);
                tmpOrgList.add(customerDO);
            });
            List<PrivilageOrganizational> orgList = tmpOrgList.stream().distinct().collect(Collectors.toList());
            return orgList;
        }
    }

    /**
     * 查询所有的零售公司信息
     */
    public List<PrivilageOrganizational> listOfRetailCompany(long userId, Long bigRegionId) {
        if (bigRegionId == null || bigRegionId == 0L) {
            bigRegionId = null;
        }
        QueryWrapper<PrivilageOrganizationalMember> wrapper1 = new QueryWrapper<>();
        wrapper1.eq("user_id", userId);
        List<PrivilageOrganizationalMember> pm = organizationalMemberMapper.selectList(wrapper1);
        QueryWrapper<PrivilageOrganizational> wrapper = new QueryWrapper<>();
        if (check(userId)) {
            wrapper.eq("type", 2).eq("level", 2).eq("status", 1);
            return retailCompanyMapper.selectList(wrapper);
        }
        if (pm.isEmpty()) {
            return new ArrayList<>();
        } else {
            wrapper.eq("type", 2).eq("level", 2).eq("status", 1).in("id", pm.stream().map(PrivilageOrganizationalMember::getOrgId).collect(Collectors.toList()));
            if (bigRegionId != null) {
                wrapper.eq("parent_id", bigRegionId);
            }
            return retailCompanyMapper.selectList(wrapper);
        }
    }

    /**
     * 查询零售公司下的店铺
     *
     * @param orgId 零售公司id
     * @return 门店信息
     */
    public List<PoiStore> selectShopByCompany(Long orgId) {
        //查询客户
        Set<Long> companyIds = new HashSet<>();
        companyIds.add(orgId);
        Set<Long> customerIds = retailCompanyMapper.selectChildList(companyIds);
        return poiStoreDOMapper.selectShopByCustomerIds(new ArrayList<>(customerIds));
    }

    /**
     * 查询零售公司下的店铺
     *
     * @param bigRegionId 零售公司id
     * @return 门店信息
     */
    public List<PoiStore> selectShopByBigRegion(Long bigRegionId) {
        //查询零售公司
        Set<Long> bigRegionIds = new HashSet<>();
        bigRegionIds.add(bigRegionId);
        Set<Long> companyIds = retailCompanyMapper.selectChildList(bigRegionIds);
        //查询客户
        Set<Long> customerIds = retailCompanyMapper.selectChildList(companyIds);
        return poiStoreDOMapper.selectShopByCustomerIds(new ArrayList<>(customerIds));
    }


    /**
     * 查询客户公司下的店铺
     *
     * @param orgId 零售公司id
     * @return 门店信息
     */
    public List<PoiStore> selectCustomerShopByCompany(Long orgId) {
        return poiStoreDOMapper.selectCustomerShopByCompany(orgId);
    }

    /**
     * 查询零售公司下的店铺
     *
     * @param shopId 零售公司id
     * @return 门店信息
     */
    public List<PrivilageUserDO> selectSellerByShop(Long shopId) {
        return poiStoreDOMapper.selectSellerByShop(shopId);
    }

    /**
     * 查询所有零售公司的推广数据
     *
     * @param startTime 日期
     * @param endTime   日期
     * @param orgId     零售公司
     * @return 零售公司的推广数据
     */
    public OrganizationVO generalizeOfRetail(String startTime, String endTime, Long orgId, int pageNum, int pageSize) {
        //零售公司信息
        QueryWrapper<PrivilageOrganizational> wrapper = new QueryWrapper<>();
        wrapper.eq("type", 2).eq("level",2).eq("status", 1);
        if (orgId != null) {
            wrapper.eq("id", orgId);
        }

        PageHelper.startPage(pageNum, pageSize);
        List<PrivilageOrganizational> listOfOrg = retailCompanyMapper.selectList(wrapper);

        List<RetailOrganizationalVO> list = new ArrayList<>();
        listOfOrg.parallelStream().forEach(org -> {
            RetailOrganizationalVO organizationalVO = new RetailOrganizationalVO();
            organizationalVO.setRetailCompany(org.getName());

            //查询零售公司的门店
            List<PoiStore> list1 = selectShopByCompany(org.getId());
            List<Long> stores = list1.stream().map(PoiStore::getId).collect(Collectors.toList());
            //组织成员
            QueryWrapper<PrivilageOrganizationalMember> wrapper1 = new QueryWrapper<>();
            wrapper1.eq("org_id", org.getId());
            List<PrivilageOrganizationalMember> memberList = organizationalMemberMapper.selectList(wrapper1);
            //组织成员的客户个数
            QueryWrapper<OpSellerCustomerRelation> wrapper2 = new QueryWrapper<>();
            wrapper2.in("user_id", memberList.stream().map(PrivilageOrganizationalMember::getUserId).collect(Collectors.toList()));
            List<OpSellerCustomerRelation> opRelations = memberList.size() == 0 ? new ArrayList<>() : opSellerCustomerRelationDOMapper.selectList(wrapper2);
            long count = opRelations.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();
            organizationalVO.setAllCustomer((int) count);
            //组织成员的客户有效个数
            QueryWrapper<OpSellerCustomerRelation> wrapper4 = new QueryWrapper<>();
            wrapper4.in("user_id", memberList.stream().map(PrivilageOrganizationalMember::getUserId).collect(Collectors.toList()));
            wrapper4.eq("type", 1);
            List<OpSellerCustomerRelation> opRelations1 = memberList.size() == 0 ? new ArrayList<>() : opSellerCustomerRelationDOMapper.selectList(wrapper4);
            long countAble = opRelations1.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();
            organizationalVO.setEffectiveCustomer((int) countAble);

            //计算新增客户数据
            newCustomerUser(startTime, endTime, organizationalVO, memberList.stream().map(PrivilageOrganizationalMember::getUserId).collect(Collectors.toList()));

            //被拉黑的客户数
            QueryWrapper<PoiCustomerContactDataStat> wrapper3 = new QueryWrapper<>();
            if (stores.isEmpty()) {
                stores.add(-1L);
            }
            wrapper3.in("store_id", stores);
            List<PoiCustomerContactDataStat> dataStats = poiCustomerContactDataStatMapper.selectList(wrapper3);
            long allAge = dataStats.stream().mapToLong(PoiCustomerContactDataStat::getNegativeFeedbackCnt).sum();

            organizationalVO.setDelCustomer((int) allAge);
            organizationalVO.setDelRate(check(allAge, count));
            list.add(organizationalVO);
        });
        OrganizationVO vo = new OrganizationVO();
        //总条数
        if (listOfOrg.size() > 0) {
            vo.setDataVOS(list);
            Page<PrivilageOrganizational> pageList = (Page<PrivilageOrganizational>) listOfOrg;
            long totalSize = pageList.getTotal();
            vo.setSizeNum(totalSize);
        } else {
            return new OrganizationVO();
        }
        return vo;
    }

    /**
     * 计算新增客户数和新增有效客户数
     *
     * @param startTime        开始时间
     * @param endTime          结束时间
     * @param organizationalVO 封装实体
     */
    private void newCustomerUser(String startTime, String endTime, DataVO organizationalVO, List<Long> userIds) {
        if(userIds.size() == 0){
            return;
        }
        //最初时间的总客户人数
        QueryWrapper<OpSellerCustomerRelation> wrapper2 = new QueryWrapper<>();
        wrapper2.in("user_id", userIds);
        wrapper2.lt("create_time", startTime);
        List<OpSellerCustomerRelation> opRelations = opSellerCustomerRelationDOMapper.selectList(wrapper2);
        long count = opRelations.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();
        //最初时间的有效总客户人数
        wrapper2.in("user_id", userIds);
        wrapper2.eq("type", 1);
        wrapper2.lt("create_time", startTime);
        List<OpSellerCustomerRelation> opRelations2 = opSellerCustomerRelationDOMapper.selectList(wrapper2);
        long count2 = opRelations2.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();
        //最后时间的总客户人数
        QueryWrapper<OpSellerCustomerRelation> wrapper3 = new QueryWrapper<>();
        wrapper3.in("user_id", userIds);
        wrapper3.lt("create_time", endTime);
        List<OpSellerCustomerRelation> opRelationsEnd = opSellerCustomerRelationDOMapper.selectList(wrapper3);
        long countEnd = opRelationsEnd.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();
        //最后时间的有效总客户人数
        wrapper3.in("user_id", userIds);
        wrapper3.eq("type", 1);
        wrapper3.lt("create_time", endTime);
        List<OpSellerCustomerRelation> opRelationsEnd2 = opSellerCustomerRelationDOMapper.selectList(wrapper3);
        long countEnd2 = opRelationsEnd2.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();

        //计算两个时间间隔用于计算平均值
        LocalDate start = LocalDate.parse(startTime);
        LocalDate end = LocalDate.parse(endTime);
        long days = end.until(start, ChronoUnit.DAYS);

        organizationalVO.setNewCustomer((int) (countEnd - count));
        organizationalVO.setNewEffectiveCustomer((int) (countEnd2 - count2));
        organizationalVO.setAvgNewCustomer(check(countEnd - count, days));
        organizationalVO.setAvgNewEffectiveCustomer(check(countEnd2 - count2, days));
    }

    private void newCustomerStore(String startTime, String endTime, DataVO organizationalVO, List<Long> storeIds) {
        //最初时间的总客户人数
        QueryWrapper<OpSellerCustomerRelation> wrapper2 = new QueryWrapper<>();
        wrapper2.in("store_id", storeIds);
        wrapper2.lt("create_time", startTime);
        List<OpSellerCustomerRelation> opRelations = opSellerCustomerRelationDOMapper.selectList(wrapper2);
        long count = opRelations.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();
        //最初时间的有效总客户人数
        wrapper2.in("store_id", storeIds);
        wrapper2.eq("type", 1);
        wrapper2.lt("create_time", startTime);
        List<OpSellerCustomerRelation> opRelations2 = opSellerCustomerRelationDOMapper.selectList(wrapper2);
        long count2 = opRelations2.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();
        //最后时间的总客户人数
        QueryWrapper<OpSellerCustomerRelation> wrapper3 = new QueryWrapper<>();
        wrapper3.in("store_id", storeIds);
        wrapper3.lt("create_time", endTime);
        List<OpSellerCustomerRelation> opRelationsEnd = opSellerCustomerRelationDOMapper.selectList(wrapper3);
        long countEnd = opRelationsEnd.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();
        //最后时间的有效总客户人数
        wrapper3.in("store_id", storeIds);
        wrapper3.eq("type", 1);
        wrapper3.lt("create_time", endTime);
        List<OpSellerCustomerRelation> opRelationsEnd2 = opSellerCustomerRelationDOMapper.selectList(wrapper3);
        long countEnd2 = opRelationsEnd2.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();

        //计算两个时间间隔用于计算平均值
        LocalDate start = LocalDate.parse(startTime);
        LocalDate end = LocalDate.parse(endTime);
        long days = end.until(start, ChronoUnit.DAYS);

        organizationalVO.setNewCustomer((int) (countEnd - count));
        organizationalVO.setNewEffectiveCustomer((int) (countEnd2 - count2));
        organizationalVO.setAvgNewCustomer(check(countEnd - count, days));
        organizationalVO.setAvgNewEffectiveCustomer(check(countEnd2 - count2, days));
    }

    /**
     * 除法计算
     *
     * @param l1 被除数
     * @param l2 除数
     * @return 值
     */
    public Integer check(Long l1, Long l2) {
        if (l2 == null || l1 == null || l2 == 0) {
            return 0;
        } else {
            return Math.round((l1 / l2) * 100);
        }
    }

    /**
     * 查询门店推广数据
     *
     * @param startTime 日期
     * @param endTime   日期
     * @param orgId     零售公司id
     * @param shopId    门店id
     * @param pageNum   页码
     * @param pageSize  页面显示个数
     * @return 门店推广数据
     */
    public OrganizationVO generalizeOfStore(String startTime, String endTime, Long orgId, Long shopId, int pageNum, int pageSize) {
        //根据零售公司查询门店
        PageHelper.startPage(pageNum, pageSize);
        List<CompanyStoreDO> list = retailCompanyMapper.selectShopIdByRetail(orgId, shopId);

        List<Long> shopIds = list.stream().map(CompanyStoreDO::getShopId).collect(Collectors.toList());
        //查询所有的店铺信息
        QueryWrapper<PoiStore> poiStoreQueryWrapper = new QueryWrapper<>();
        poiStoreQueryWrapper.in("id", shopIds);
        List<PoiStore> list2 = shopIds.size() == 0 ? new ArrayList<>() : poiStoreDOMapper.selectList(poiStoreQueryWrapper);

        Map<Long, PoiStore> map = list2.stream().collect(Collectors.toMap(PoiStore::getId, p -> p));

        //所有的导购客户个数
        List<Map<String, Object>> map1 = shopIds.size() == 0 ? new ArrayList<>() : opSellerCustomerRelationDOMapper.selectAllCustomerShop(shopIds);
        Map<Long, Object> collect = map1 == null ? new HashMap<>() : map1.stream().collect(Collectors.toMap(m -> Long.parseLong(m.get("store_id").toString()), m1 -> m1.get("count")));

        List<Map<String, Object>> map2 = shopIds.size() == 0 ? new ArrayList<>() : opSellerCustomerRelationDOMapper.selectAllCustomerShop1(shopIds);
        Map<Long, Object> collect1 = map2 == null ? new HashMap<>() : map2.stream().collect(Collectors.toMap(m -> Long.parseLong(m.get("store_id").toString()), m1 -> m1.get("count")));
        List<StoreOrganizationalVO> list1 = new ArrayList<>();

        list.stream().parallel().forEach(li -> {
            QueryWrapper<PrivilageOrganizational> wrapperx = new QueryWrapper<>();
            wrapperx.eq("id",li.getParentId()).eq("level",2).last("limit 1");
            PrivilageOrganizational privilageOrganizational = retailCompanyMapper.selectOne(wrapperx);

            StoreOrganizationalVO storeOrganizationalVO = new StoreOrganizationalVO();
            long count = 0;
            //查询所有的客户
            count = collect.get(li) == null ? 0 : Long.parseLong(collect.get(li).toString());
            long countAble = 0;
            //查询所有的有效客户
            countAble = collect1.get(li) == null ? 0 : Long.parseLong(collect1.get(li).toString());
            //计算新客户数据
            newCustomerStore(startTime, endTime, storeOrganizationalVO, Collections.singletonList(li.getShopId()));
            //查询店铺的名称
            PoiStore poiStore = map.get(li.getShopId());

            //被拉黑的客户数
            QueryWrapper<PoiCustomerContactDataStat> wrapper3 = new QueryWrapper<>();
            wrapper3.eq("store_id", li.getShopId());
            List<PoiCustomerContactDataStat> dataStats = poiCustomerContactDataStatMapper.selectList(wrapper3);
            long allAge = dataStats.stream().mapToLong(PoiCustomerContactDataStat::getNegativeFeedbackCnt).sum();

            storeOrganizationalVO.setShopName(poiStore == null ? null : poiStore.getName());
            storeOrganizationalVO.setShopCode(poiStore == null ? null : poiStore.getCode());
            storeOrganizationalVO.setAllCustomer((int) count);
            storeOrganizationalVO.setEffectiveCustomer((int) countAble);
            storeOrganizationalVO.setDelCustomer((int) allAge);
            storeOrganizationalVO.setCompanyName(privilageOrganizational.getName());
            storeOrganizationalVO.setDelRate(check(allAge, count));
            list1.add(storeOrganizationalVO);
        });
        OrganizationVO vo = new OrganizationVO();
        //总条数
        if (list.size() > 0) {
            vo.setDataVOS(list1);
            Page<CompanyStoreDO> pageList = (Page<CompanyStoreDO>) list;
            long totalSize = pageList.getTotal();
            vo.setSizeNum(totalSize);
        } else {
            return new OrganizationVO();
        }
        return vo;
    }

    /**
     * 查询导购的推广数据
     *
     * @param startTime 日期
     * @param endTime   日期
     * @param orgId     零售哦给弄死id
     * @param shopId    门店id
     * @param sellerId  导购id
     * @param pageNum   页码
     * @param pageSize  页面个数
     * @return 导购的推广数据
     */
    public OrganizationVO generalizeOfSeller(String startTime, String endTime, Long orgId, Long shopId, Long sellerId, int pageNum, int pageSize) {
        //根据零售公司查询门店
        PageHelper.startPage(pageNum, pageSize);
        List<Long> sellerIds = retailCompanyMapper.selectSellerIdsByShop(orgId, shopId, sellerId);
        List<SellerOrganizationalVO> list = new ArrayList<>();

        //查询所有的店铺信息
        QueryWrapper<PrivilageUserDO> poiStoreQueryWrapper = new QueryWrapper<>();
        poiStoreQueryWrapper.in("id", sellerIds);
        List<PrivilageUserDO> list2 = privilageUserDOMapper.selectList(poiStoreQueryWrapper);

        Map<Long, PrivilageUserDO> map = list2.stream().collect(Collectors.toMap(PrivilageUserDO::getId, p -> p));

        //所有的导购客户个数
        List<Map<String, Object>> map1 = opSellerCustomerRelationDOMapper.selectAllCustomer(sellerIds);
        Map<Long, Object> collect = map1 == null ? new HashMap<>() : map1.stream().collect(Collectors.toMap(m -> Long.parseLong(m.get("user_id").toString()), m1 -> m1.get("count")));

        List<Map<String, Object>> map3 = opSellerCustomerRelationDOMapper.selectAllCustomer1(sellerIds);
        Map<Long, Object> collect1 = map3 == null ? new HashMap<>() : map3.stream().collect(Collectors.toMap(m -> Long.parseLong(m.get("store_id").toString()), m1 -> m1.get("count")));

        List<PoiStoreStaff> list1 = poiStoreStaffDOMapper.selectList(null);
        Map<Long, PoiStoreStaff> map2 = list1.stream().collect(Collectors.toMap(PoiStoreStaff::getId, p -> p));

        sellerIds.stream().parallel().forEach(seller -> {
            SellerOrganizationalVO sellerOrganizationalVO = new SellerOrganizationalVO();
            long count = 0;
            //查询所有的客户
            count = collect.get(seller) == null ? 0 : Long.parseLong(collect.get(seller).toString());
            long countAble = 0;
            countAble = collect1.get(seller) == null ? 0 : Long.parseLong(collect1.get(seller).toString());

            //查询导购信息
            PrivilageUserDO privilageUserDO = map.get(seller);
            PoiStoreStaff poiStoreStaff = map2.get(seller);
            //计算新客户数据
            newCustomerUser(startTime, endTime, sellerOrganizationalVO, Collections.singletonList(seller));
            //查询导购所属公司门店
            CompanyStoreDO companyStoreDO = poiStoreDOMapper.selectCompanyStore(seller);
            sellerOrganizationalVO.setShopName(companyStoreDO == null ? null : companyStoreDO.getShopName());
            sellerOrganizationalVO.setShopCode(companyStoreDO == null ? null : companyStoreDO.getShopCode());
            sellerOrganizationalVO.setSellerCode(poiStoreStaff == null ? null : poiStoreStaff.getStaffCode());
            sellerOrganizationalVO.setCompanyName(companyStoreDO == null ? null : companyStoreDO.getCompanyName());
            sellerOrganizationalVO.setSellerName(privilageUserDO == null ? null : privilageUserDO.getName());
            sellerOrganizationalVO.setAllCustomer((int) count);
            sellerOrganizationalVO.setEffectiveCustomer((int) countAble);
            list.add(sellerOrganizationalVO);
        });

        OrganizationVO vo = new OrganizationVO();
        //总条数
        if (sellerIds.size() > 0) {
            vo.setDataVOS(list);
            Page<Long> pageList = (Page<Long>) sellerIds;
            long totalSize = pageList.getTotal();
            vo.setSizeNum(totalSize);
        } else {
            return new OrganizationVO();
        }
        return vo;
    }

    /**
     * 找到最小公司集合
     */
    public void getMinCompany(Set<Long> companys, Set<Long> needs) {
        companys.forEach(item -> {
            getMinCompany(item, needs);
        });
    }

    /**
     * 找到最小公司集合
     */
    public void getMinCompany(Long company, Set<Long> needs) {
        QueryWrapper<PrivilageOrganizational> q = new QueryWrapper();
        q.eq("parent_id", company);
        List<PrivilageOrganizational> listOfOrg = retailCompanyMapper.selectList(q);
        Set<Long> companys = listOfOrg.stream().map(item -> item.getId()).collect(Collectors.toSet());
        if (companys.size() > 0) {
            getMinCompany(companys, needs);
        } else {
            needs.add(company);
        }
    }

}