package com.panzhihua.service_community.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.google.common.collect.Lists;
import com.panzhihua.common.constants.Constants;
import com.panzhihua.common.model.dtos.community.cluster.PageClusterMemberDto;
import com.panzhihua.common.model.dtos.community.cluster.admin.AddClusterMemberAdminDto;
import com.panzhihua.common.model.dtos.community.cluster.admin.EditClusterMemberAdminDto;
import com.panzhihua.common.model.dtos.community.cluster.admin.PageClusterMemberAdminDto;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.cluster.admin.ClusterMemberNationVo;
import com.panzhihua.common.model.vos.community.cluster.admin.ComClusterMemberExcelErrorVO;
import com.panzhihua.common.model.vos.community.cluster.admin.ComClusterMemberExcelVO;
import com.panzhihua.common.model.vos.community.cluster.admin.PageClusterMemberAdminVo;
import com.panzhihua.service_community.dao.ComClusterOrganizationMapper;
import com.panzhihua.service_community.dao.ComClusterOrganizationMemberMapper;
import com.panzhihua.service_community.model.dos.ComClusterOrganizationDO;
import com.panzhihua.service_community.model.dos.ComClusterOrganizationMemberDO;
import com.panzhihua.service_community.service.ComClusterOrganizationMemberService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

/**
 * @author lyq
 * @date  2021-09-23 16:44:00
 * describe 群团组织成员表服务实现类
 */
@Slf4j
@Service
public class ComClusterOrganizationMemberServiceImpl extends ServiceImpl<ComClusterOrganizationMemberMapper, ComClusterOrganizationMemberDO> implements ComClusterOrganizationMemberService {

    @Resource
    private ComClusterOrganizationMapper comClusterOrganizationMapper;

    /**
     * 群团组织成员列表-小程序分页查询
     * @param pageClusterMemberDto  请求参数
     * @return  群团组织成员列表
     */
    @Override
    public R pageClusterMemberApplets(PageClusterMemberDto pageClusterMemberDto){
        return R.ok(this.baseMapper.pageClusterMemberApplets(new Page(pageClusterMemberDto.getPageNum(),pageClusterMemberDto.getPageSize()),pageClusterMemberDto));
    }

    /**
     * 分页查询群团组织成员列表
     * @param pageClusterMemberAdminDto 请求参数
     * @return  群团组织成员列表
     */
    @Override
    public R pageClusterMemberAdmin(PageClusterMemberAdminDto pageClusterMemberAdminDto){
        return R.ok(this.baseMapper.pageClusterMemberAdmin(new Page(pageClusterMemberAdminDto.getPageNum(),pageClusterMemberAdminDto.getPageSize()),pageClusterMemberAdminDto));
    }

    /**
     * 新增群团组织成员
     * @param addClusterMemberAdminDto  请求参数
     * @return  新增结果
     */
    @Override
    public R addClusterMemberAdmin(AddClusterMemberAdminDto addClusterMemberAdminDto){

        ComClusterOrganizationMemberDO organizationMemberDO = this.baseMapper.selectOne(new QueryWrapper<ComClusterOrganizationMemberDO>()
                .lambda().eq(ComClusterOrganizationMemberDO::getIdCard,addClusterMemberAdminDto.getIdCard())
                .eq(ComClusterOrganizationMemberDO::getIsDel,ComClusterOrganizationMemberDO.isOk.no)
                .eq(ComClusterOrganizationMemberDO::getCommunityId,addClusterMemberAdminDto.getCommunityId()));
        if(organizationMemberDO != null){
            return R.fail("该身份证号已存在，不可重复添加");
        }
        organizationMemberDO = new ComClusterOrganizationMemberDO();
        BeanUtils.copyProperties(addClusterMemberAdminDto,organizationMemberDO);
        organizationMemberDO.setCreateAt(new Date());
        if(this.baseMapper.insert(organizationMemberDO) > 0){
            return R.ok("添加成功");
        }
        return R.fail("添加失败");
    }

    /**
     * 编辑群团组织成员
     * @param editClusterMemberAdminDto 请求参数
     * @return  编辑结果
     */
    @Override
    public R editClusterMemberAdmin(EditClusterMemberAdminDto editClusterMemberAdminDto){
        ComClusterOrganizationMemberDO organizationMemberDO = this.baseMapper.selectById(editClusterMemberAdminDto.getId());
        if(organizationMemberDO == null){
            return R.fail("该组织成员不存在");
        }

        Integer count = this.baseMapper.selectCount(new QueryWrapper<ComClusterOrganizationMemberDO>().lambda()
                .eq(ComClusterOrganizationMemberDO::getCommunityId,editClusterMemberAdminDto.getCommunityId())
                .eq(ComClusterOrganizationMemberDO::getIdCard,editClusterMemberAdminDto.getIdCard())
                .eq(ComClusterOrganizationMemberDO::getIsDel,ComClusterOrganizationMemberDO.isOk.no)
                .ne(ComClusterOrganizationMemberDO::getId,editClusterMemberAdminDto.getId()));
        if(count > 0){
            return R.fail("该身份证号已存在，不可重复添加");
        }
        BeanUtils.copyProperties(editClusterMemberAdminDto,organizationMemberDO);
        organizationMemberDO.setUpdateAt(new Date());
        if(this.baseMapper.updateById(organizationMemberDO) > 0){
            return R.ok("编辑成功");
        }
        return R.fail("编辑失败");
    }

    /**
     * 删除群团组织成员
     * @param id    组织成员id
     * @return  删除结果
     */
    @Override
    public R deleteClusterMemberAdmin(Long id){
        ComClusterOrganizationMemberDO organizationMemberDO = new ComClusterOrganizationMemberDO();
        organizationMemberDO.setId(id);
        organizationMemberDO.setIsDel(ComClusterOrganizationMemberDO.isOk.yes);
        organizationMemberDO.setUpdateAt(new Date());
        if(this.baseMapper.updateById(organizationMemberDO) > 0){
            return R.ok("删除成功");
        }
        return R.fail("删除失败");
    }

    /**
     * 群团组织成员详情
     * @param id    组织成员id
     * @return  群团组织成员详情
     */
    @Override
    public R detailClusterMemberAdmin(Long id){
        ComClusterOrganizationMemberDO organizationMemberDO = this.baseMapper.selectById(id);
        if(organizationMemberDO == null){
            return R.fail("该组织成员不存在");
        }
        PageClusterMemberAdminVo memberAdminVo = new PageClusterMemberAdminVo();
        BeanUtils.copyProperties(organizationMemberDO,memberAdminVo);
        return R.ok(memberAdminVo);
    }

    /**
     * 查询系统民族列表
     * @return  民族列表
     */
    @Override
    public R memberNationListAdmin(){
        return R.ok(this.baseMapper.memberNationListAdmin(Constants.NATION_DICT_KEY));
    }

    /**
     * 群团组织成员导入
     * @param memberExcelList  导入数据
     * @param communityId   社区id
     * @param userId    操作用户id
     * @return  导入结果
     */
    @Override
    public R importClusterMember(List<ComClusterMemberExcelVO> memberExcelList, Long communityId, Long userId){

        //需要新增的数据
        List<ComClusterOrganizationMemberDO> saveList = Lists.newArrayList();
        //错误数据
        ArrayList<ComClusterMemberExcelErrorVO> mistakes = Lists.newArrayList();
        //查询当前社区现有的所有群团组织成员列表
        List<ComClusterOrganizationMemberDO> memberList = this.baseMapper.selectList(new QueryWrapper<ComClusterOrganizationMemberDO>().lambda()
                .eq(ComClusterOrganizationMemberDO::getCommunityId,communityId)
                .eq(ComClusterOrganizationMemberDO::getIsDel,ComClusterOrganizationMemberDO.isOk.no));
        HashMap<String, Object> memberMap = new HashMap<>();
        memberList.forEach(member -> {
            String key = member.getIdCard();
            memberMap.put(key, member);
        });

        //查询该社区现有的所有群团组织
        List<ComClusterOrganizationDO> clusterList = comClusterOrganizationMapper.selectList(new QueryWrapper<ComClusterOrganizationDO>().lambda()
                .eq(ComClusterOrganizationDO::getCommunityId,communityId).eq(ComClusterOrganizationDO::getIsDel,ComClusterOrganizationDO.isOk.no));
        HashMap<String, Object> clusterMap = new HashMap<>();
        clusterList.forEach(cluster -> {
            String key = cluster.getName();
            clusterMap.put(key, cluster);
        });

        List<ClusterMemberNationVo> nationList = this.baseMapper.memberNationListAdmin(Constants.NATION_DICT_KEY);
        HashMap<String, Object> nationMap = new HashMap<>();
        nationList.forEach(nation -> {
            String key = nation.getNationName();
            nationMap.put(key, nation.getNationCode());
        });
        Date nowDate = new Date();
        for (ComClusterMemberExcelVO memberExcel : memberExcelList) {
            Long clusterId = 0L;

            String nationCode = "";

            //判断成员是否已存在
            if(!isOnly(memberExcel.getIdCard(),memberMap)){
                ComClusterMemberExcelErrorVO memberExcelErrorVO = new ComClusterMemberExcelErrorVO();
                BeanUtils.copyProperties(memberExcel,memberExcelErrorVO);
                //判断该成员是否是已存在还是身份证号码重复
                ComClusterOrganizationMemberDO memberDO = (ComClusterOrganizationMemberDO)memberMap.get(memberExcel.getIdCard());
                if(memberDO.getName().equals(memberExcel.getName())){
                    memberExcelErrorVO.setError("该成员已存在");
                }else{
                    memberExcelErrorVO.setError("身份证号重复");
                }
                mistakes.add(memberExcelErrorVO);
                continue;
            }

            //判断组织是否存在
            if(isOnly(memberExcel.getClusterName(),clusterMap)){
                ComClusterMemberExcelErrorVO memberExcelErrorVO = new ComClusterMemberExcelErrorVO();
                BeanUtils.copyProperties(memberExcel,memberExcelErrorVO);
                memberExcelErrorVO.setError("该组织在本社区不存在");
                mistakes.add(memberExcelErrorVO);
                continue;
            }else{
                ComClusterOrganizationDO clusterDO = (ComClusterOrganizationDO)clusterMap.get(memberExcel.getClusterName());
                clusterId = clusterDO.getId();
            }

            //判断民族是否存在
            if(isOnly(memberExcel.getNation(),nationMap)){
                ComClusterMemberExcelErrorVO memberExcelErrorVO = new ComClusterMemberExcelErrorVO();
                BeanUtils.copyProperties(memberExcel,memberExcelErrorVO);
                memberExcelErrorVO.setError("您填写的民族不存在");
                mistakes.add(memberExcelErrorVO);
                continue;
            }else{
                nationCode = nationMap.get(memberExcel.getNation()).toString();
            }

            ComClusterOrganizationMemberDO clusterMember = new ComClusterOrganizationMemberDO();
            BeanUtils.copyProperties(memberExcel,clusterMember);
            clusterMember.setClusterId(clusterId);
            clusterMember.setNationCode(nationCode);
            clusterMember.setImageUrl(Constants.CLUSTER_MEMBER_DEFAULT_IMAGE_URL);
            clusterMember.setCreateAt(nowDate);
            clusterMember.setCommunityId(communityId);
            saveList.add(clusterMember);
            memberMap.put(clusterMember.getIdCard(),clusterMember);
        }
        //执行导入
        if(saveList.size() > 0){
           this.saveBatch(saveList);
        }
        //有错误，返回错误数据
        if(mistakes.size() > 0){
            return R.fail(mistakes);
        }
        return R.ok();
    }

    /**
     * 判重方法
     *
     * @param key
     *            主键
     * @param hashMap
     *            数据集
     * @return 存在即为false 不存在则为true
     */
    private boolean isOnly(String key, HashMap<String, Object> hashMap) {
        return ObjectUtils.isEmpty(hashMap.get(key));
    }

    /**
     * 群团组织导出数据查询
     * @param pageClusterMemberAdminDto 请求参数
     * @return  导出数据结果集
     */
    @Override
    public R exportClusterMember(PageClusterMemberAdminDto pageClusterMemberAdminDto){
        return R.ok(this.baseMapper.exportClusterMember(pageClusterMemberAdminDto));
    }
}