package com.kiisoo.ic.generalize.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
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.RetailOrganizationalVO;
import com.kiisoo.ic.generalize.bean.SellerOrganizationalVO;
import com.kiisoo.ic.generalize.bean.StoreOrganizationalVO;
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.mapper.PoiStoreDOMapper;
import com.kiisoo.ic.system.entity.PrivilageUserDO;
import com.kiisoo.ic.system.mapper.PrivilageUserDOMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

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

    private RetailCompanyMapper retailCompanyMapper;

    private OrganizationalMemberMapper organizationalMemberMapper;

    private OpSellerCustomerRelationDOMapper opSellerCustomerRelationDOMapper;

    private PoiCustomerContactDataStatMapper poiCustomerContactDataStatMapper;

    private PoiStoreDOMapper poiStoreDOMapper;

    private PrivilageUserDOMapper privilageUserDOMapper;

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

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

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

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

    /**
     * 查询所有零售公司的推广数据
     * @param date 日期
     * @param orgId 零售公司
     * @return 零售公司的推广数据
     */
    public List<RetailOrganizationalVO> generalizeOfRetail(String date,Long orgId,int pageNum,int pageSize){
        //零售公司信息
        QueryWrapper<PrivilageOrganizational> wrapper = new QueryWrapper<>();
        wrapper.eq("type",1).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.forEach(org -> {
            //组织成员
            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 = opSellerCustomerRelationDOMapper.selectList(wrapper2);
            long count = opRelations.stream().map(OpSellerCustomerRelation::getCustomerId).distinct().count();
            List<Long> stores = opRelations.stream().map(OpSellerCustomerRelation::getStoreId).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();

            RetailOrganizationalVO organizationalVO = new RetailOrganizationalVO();
            organizationalVO.setRetailCompany(org.getName());
            organizationalVO.setAllCustomer((int) count);
            organizationalVO.setDelCustomer((int) allAge);
            list.add(organizationalVO);
        });

        return list;
    }

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

        List<StoreOrganizationalVO> list1 = new ArrayList<>();
        list.forEach(li -> {
            //查询所有的客户
            QueryWrapper<OpSellerCustomerRelation> wrapper = new QueryWrapper<>();
            wrapper.eq("store_id",li);
            long count = opSellerCustomerRelationDOMapper.selectCount(wrapper);

            //查询店铺的名称和区域的名称
            ShopRegionDO poiStore = poiStoreDOMapper.selectShopMsg(li);

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

            StoreOrganizationalVO storeOrganizationalVO = new StoreOrganizationalVO();
            storeOrganizationalVO.setShopName(poiStore.getShopName());
            storeOrganizationalVO.setRegion(poiStore.getRegionName());
            storeOrganizationalVO.setAllCustomer((int) count);
            storeOrganizationalVO.setDelCustomer((int) allAge);
            list1.add(storeOrganizationalVO);
        });
        return list1;
    }

    /**
     * 查询导购的推广数据
     * @param date 日期
     * @param orgId 零售哦给弄死id
     * @param shopId 门店id
     * @param sellerId 导购id
     * @param pageNum 页码
     * @param pageSize 页面个数
     * @return 导购的推广数据
     */
    public List<SellerOrganizationalVO> generalizeOfSeller(String date, 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<>();
        sellerIds.forEach(seller -> {
            //查询所有的客户
            QueryWrapper<OpSellerCustomerRelation> wrapper = new QueryWrapper<>();
            wrapper.eq("user_id",seller);
            long count = opSellerCustomerRelationDOMapper.selectCount(wrapper);

            //查询导购信息
            PrivilageUserDO privilageUserDO = privilageUserDOMapper.selectById(seller);

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

            //查询导购所属公司门店
            CompanyStoreDO companyStoreDO = poiStoreDOMapper.selectCompanyStore(seller);
            SellerOrganizationalVO sellerOrganizationalVO = new SellerOrganizationalVO();
            sellerOrganizationalVO.setShopName(companyStoreDO.getShopName());
            sellerOrganizationalVO.setCompanyName(companyStoreDO.getCompanyName());
            sellerOrganizationalVO.setSellerName(privilageUserDO.getName());
            sellerOrganizationalVO.setAllCustomer((int) count);
            sellerOrganizationalVO.setDelCustomer((int) allAge);
            list.add(sellerOrganizationalVO);
        });
        return list;
    }
}