package com.panzhihua.service_community.service.impl;

import static java.util.Objects.isNull;
import static java.util.Objects.nonNull;
import static org.apache.commons.lang3.StringUtils.isNotBlank;
import static org.apache.commons.lang3.StringUtils.isNotEmpty;

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

import javax.annotation.Resource;

import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
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.model.dtos.community.fms.AddTeamMemberDTO;
import com.panzhihua.common.model.dtos.community.fms.DeleteTeamMemberDTO;
import com.panzhihua.common.model.dtos.community.fms.EditTeamMemberDTO;
import com.panzhihua.common.model.dtos.community.fms.PageTeamMemberDTO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.community.fms.CascadeCommVO;
import com.panzhihua.common.model.vos.community.fms.ComFmsTeamMemberExportExcelVO;
import com.panzhihua.common.model.vos.community.fms.ComFmsTeamMemberImportExcelVO;
import com.panzhihua.common.model.vos.community.fms.ComFmsTeamMemberImportMistakeExcelVO;
import com.panzhihua.common.model.vos.community.fms.ComFmsTeamMemberVO;
import com.panzhihua.common.service.user.UserService;
import com.panzhihua.service_community.dao.ComFmsTeamDAO;
import com.panzhihua.service_community.dao.ComFmsTeamMemberDAO;
import com.panzhihua.service_community.dao.ComFmsTeamMemberRelationDAO;
import com.panzhihua.service_community.dao.ComFmsTeamTypeDAO;
import com.panzhihua.service_community.entity.ComFmsTeam;
import com.panzhihua.service_community.entity.ComFmsTeamMember;
import com.panzhihua.service_community.entity.ComFmsTeamMemberRelation;
import com.panzhihua.service_community.entity.ComFmsTeamType;
import com.panzhihua.service_community.service.ComFmsTeamMemberService;

import cn.hutool.core.util.IdcardUtil;

/**
 * 五微服务-团队成员(ComFmsTeamMember)表服务实现类
 *
 * @author makejava
 * @since 2022-02-11 13:35:56
 */
@Service("comFmsTeamMemberService")
public class ComFmsTeamMemberServiceImpl extends ServiceImpl<ComFmsTeamMemberDAO, ComFmsTeamMember>
    implements ComFmsTeamMemberService {

    @Resource
    private ComFmsTeamDAO comFmsTeamDAO;
    @Resource
    private ComFmsTeamMemberRelationDAO comFmsTeamMemberRelationDAO;
    @Resource
    private ComFmsTeamTypeDAO comFmsTeamTypeDAO;
    @Resource
    private UserService userService;

    /**
     * 新增团队成员
     * @param addTeamMemberDTO
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R addFmsTeamMember(AddTeamMemberDTO addTeamMemberDTO) {
        String idCard = addTeamMemberDTO.getIdCard();
        if (isNotBlank(idCard) && !IdcardUtil.isValidCard(idCard)) {
            return R.fail("身份证号码有误");
        }
        List<Long> teamIds = addTeamMemberDTO.getTeamIds();
        List<ComFmsTeam> comFmsTeam = comFmsTeamDAO.selectBatchIds(teamIds);
        if (comFmsTeam.size() != teamIds.size() || comFmsTeam.stream().anyMatch(e -> !e.getCommunityId().equals(addTeamMemberDTO.getCommunityId()))) {
            return R.fail("团队id有误");
        }
        Integer countMember = this.baseMapper.countMember(addTeamMemberDTO.getCommunityId(),
                addTeamMemberDTO.getIdCard(), addTeamMemberDTO.getPhone());
        if (countMember > 0) {
            return R.fail("团队成员已存在，如需添加团队关系，请编辑该成员");
        }
        ComFmsTeamMember comFmsTeamMember = new ComFmsTeamMember();
        BeanUtils.copyProperties(addTeamMemberDTO, comFmsTeamMember);
        if (isNotBlank(idCard)) {
            comFmsTeamMember.setGender(IdcardUtil.getGenderByIdCard(idCard) == 1 ? 1 : 2);
        }
        this.baseMapper.insert(comFmsTeamMember);
        Long memberId = comFmsTeamMember.getId();
        if (nonNull(memberId)) {
            List<ComFmsTeamMemberRelation> teamMemberRelations = new ArrayList<>();
            List<List<Long>> cascadeIds = new ArrayList<>();
            teamIds.forEach(e -> {
                Long teamType = comFmsTeam.stream().filter(team -> team.getId().equals(e)).collect(Collectors.toList()).get(0).getTeamType();
                ComFmsTeamMemberRelation teamMemberRelation = new ComFmsTeamMemberRelation();
                teamMemberRelation.setTeamId(e);
                teamMemberRelation.setMemberId(memberId);
                teamMemberRelations.add(teamMemberRelation);
                cascadeIds.add(Arrays.asList(teamType, e));
            });
            int num = comFmsTeamMemberRelationDAO.insertBatch(teamMemberRelations);
            if (num > 0) {
                comFmsTeamMember.setCascadeIds(cascadeIds.toString());
                this.baseMapper.updateById(comFmsTeamMember);
                return R.ok();
            }
        }
        return R.fail("新增失败，请重新尝试");
    }

    /**
     * 编辑团队成员
     * @param editTeamMemberDTO
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R editFmsTeamMember(EditTeamMemberDTO editTeamMemberDTO) {
        String idCard = editTeamMemberDTO.getIdCard();
        if (isNotBlank(idCard) && !IdcardUtil.isValidCard(idCard)) {
            return R.fail("身份证号码有误");
        }
        List<Long> teamIds = editTeamMemberDTO.getTeamIds();
        List<ComFmsTeam> comFmsTeam = comFmsTeamDAO.selectBatchIds(teamIds);
        if (comFmsTeam.size() != teamIds.size() || comFmsTeam.stream().anyMatch(e -> !e.getCommunityId().equals(editTeamMemberDTO.getCommunityId()))) {
            return R.fail("团队id有误");
        }
        ComFmsTeamMember comFmsTeamMember = this.baseMapper.selectById(editTeamMemberDTO.getId());
        if (isNull(comFmsTeamMember)) {
            return R.fail("团队成员不存在");
        }
        Integer countMember = 0;
        if (!comFmsTeamMember.getPhone().equals(editTeamMemberDTO.getPhone())) {
            countMember = this.baseMapper.selectCount(new LambdaQueryWrapper<ComFmsTeamMember>()
                    .eq(ComFmsTeamMember::getCommunityId, editTeamMemberDTO.getCommunityId())
                    .eq(ComFmsTeamMember::getPhone, editTeamMemberDTO.getPhone()));
        }
        if (isNotBlank(idCard) && !idCard.equals(comFmsTeamMember.getIdCard())) {
            countMember = this.baseMapper.selectCount(new LambdaQueryWrapper<ComFmsTeamMember>()
                    .eq(ComFmsTeamMember::getCommunityId, editTeamMemberDTO.getCommunityId())
                    .eq(ComFmsTeamMember::getIdCard, editTeamMemberDTO.getIdCard()));
        }
        if (countMember > 0) {
            return R.fail("该手机号或身份证号已存在团队成员");
        }
        BeanUtils.copyProperties(editTeamMemberDTO, comFmsTeamMember);
        if (isNotBlank(idCard)) {
            comFmsTeamMember.setGender(IdcardUtil.getGenderByIdCard(idCard) == 1 ? 1 : 2);
        }
        comFmsTeamMemberRelationDAO.delete(new LambdaQueryWrapper<ComFmsTeamMemberRelation>()
                .eq(ComFmsTeamMemberRelation::getMemberId, editTeamMemberDTO.getId()));
        List<ComFmsTeamMemberRelation> teamMemberRelations = new ArrayList<>();
        List<List<Long>> cascadeIds = new ArrayList<>();
        teamIds.forEach(e -> {
            Long teamType = comFmsTeam.stream().filter(team -> team.getId().equals(e)).collect(Collectors.toList()).get(0).getTeamType();
            ComFmsTeamMemberRelation teamMemberRelation = new ComFmsTeamMemberRelation();
            teamMemberRelation.setTeamId(e);
            teamMemberRelation.setMemberId(editTeamMemberDTO.getId());
            teamMemberRelations.add(teamMemberRelation);
            cascadeIds.add(Arrays.asList(teamType, e));
        });
        comFmsTeamMemberRelationDAO.insertBatch(teamMemberRelations);
        comFmsTeamMember.setCascadeIds(cascadeIds.toString());
        int num = this.baseMapper.updateById(comFmsTeamMember);
        if (num > 0) {
            return R.ok();
        }
        return R.fail("编辑失败，请重新尝试");
    }

    /**
     * 删除团队成员
     * @param deleteTeamMemberDTO
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R deleteFmsTeamMember(DeleteTeamMemberDTO deleteTeamMemberDTO) {
        ComFmsTeamMember comFmsTeamMember = this.baseMapper.selectById(deleteTeamMemberDTO.getId());
        if (isNull(comFmsTeamMember)) {
            return R.fail("资源不存在");
        }
        if (!comFmsTeamMember.getCommunityId().equals(deleteTeamMemberDTO.getCommunityId())) {
            return R.fail("非本社区工作人员");
        }
        Integer count = comFmsTeamMemberRelationDAO.selectCount(new LambdaQueryWrapper<ComFmsTeamMemberRelation>()
                .eq(ComFmsTeamMemberRelation::getMemberId, deleteTeamMemberDTO.getId()));
        int num = comFmsTeamMemberRelationDAO.delete(new LambdaQueryWrapper<ComFmsTeamMemberRelation>()
                .eq(ComFmsTeamMemberRelation::getMemberId, deleteTeamMemberDTO.getId()).eq(ComFmsTeamMemberRelation::getTeamId, deleteTeamMemberDTO.getTeamId()));
        if (num > 0) {
            if (count == 1) {
                //只存在一个团队中直接删除
                this.baseMapper.deleteById(deleteTeamMemberDTO.getId());
                // 删除用户信息缓存
                userService.deleteUserCashByPhone(comFmsTeamMember.getPhone());
            } else {
                //存在多个团队中，删除与该团队关联
                ComFmsTeam fmsTeam = comFmsTeamDAO.selectById(deleteTeamMemberDTO.getTeamId());
                String cascadeIds = comFmsTeamMember.getCascadeIds();
                List<List> lists = JSONArray.parseArray(cascadeIds, List.class);
                List<List> collect = lists.stream().filter(e -> !e.toString().equals(Arrays.asList(fmsTeam.getTeamType(), fmsTeam.getId()).toString())).collect(Collectors.toList());
                comFmsTeamMember.setCascadeIds(collect.toString());
                this.baseMapper.updateById(comFmsTeamMember);
            }
            return R.ok();
        }
        return R.fail("删除失败，请重新尝试");
    }

    /**
     * 分页查询团队成员
     * @param pageTeamMemberDTO
     * @return
     */
    @Override
    public R pageFmsTeamMember(PageTeamMemberDTO pageTeamMemberDTO) {
        Page page = new Page<>();
        page.setSize(pageTeamMemberDTO.getPageSize());
        page.setCurrent(pageTeamMemberDTO.getPageNum());
        IPage<ComFmsTeamMemberVO> memberVOIPage = this.baseMapper.pageFmsTeamMember(page, pageTeamMemberDTO);
        List<ComFmsTeamMemberVO> records = memberVOIPage.getRecords();
        if (!records.isEmpty()) {
            records.forEach(e -> {
                String idCard = e.getIdCard();
                if (isNotEmpty(idCard)) {
                    e.setAge(IdcardUtil.getAgeByIdCard(idCard));
                }
            });
        }
        return R.ok(memberVOIPage);
    }

    /**
     * 微团队顶部统计
     * @param communityId
     * @return
     */
    @Override
    public R statisticsFmsTeamMember(Long communityId) {
        return R.ok(this.baseMapper.statisticsFmsTeamMember(communityId));
    }

    /**
     * 批量导入团队成员
     * @param voList
     * @param communityId
     * @param userId
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R listSaveFmsTeamMemberExcelVO(List<ComFmsTeamMemberImportExcelVO> voList, Long communityId, Long userId) {
        List<ComFmsTeamType> comFmsTeamTypes = comFmsTeamTypeDAO.selectList(new LambdaQueryWrapper<ComFmsTeamType>().eq(ComFmsTeamType::getCommunityId, communityId));
        List<ComFmsTeam> comFmsTeams = comFmsTeamDAO.selectList(new LambdaQueryWrapper<ComFmsTeam>().eq(ComFmsTeam::getCommunityId, communityId));
        List<ComFmsTeamMemberRelation> teamMemberRelations = new ArrayList<>();
        List<ComFmsTeamMemberImportMistakeExcelVO> mistakes = Lists.newArrayList();
        for (ComFmsTeamMemberImportExcelVO e : voList) {
            String teamType = e.getTeamType();
            String teamName = e.getTeamName();
            ComFmsTeamType fmsTeamType = comFmsTeamTypes.stream().filter(type -> type.getName().equals(teamType)).findFirst().orElse(null);
            if (isNull(fmsTeamType)) {
                ComFmsTeamMemberImportMistakeExcelVO mistake = new ComFmsTeamMemberImportMistakeExcelVO();
                BeanUtils.copyProperties(e, mistake);
                mistake.setMistake("团队类型有误，请填写正确的团队类型");
                mistakes.add(mistake);
                continue;
            }
            ComFmsTeam fmsTeam = comFmsTeams.stream().filter(team -> team.getName().equals(teamName)).findFirst().orElse(null);
            if (isNull(fmsTeam)) {
                ComFmsTeamMemberImportMistakeExcelVO mistake = new ComFmsTeamMemberImportMistakeExcelVO();
                BeanUtils.copyProperties(e, mistake);
                mistake.setMistake("团队名称有误，请填写正确的团队名称");
                mistakes.add(mistake);
                continue;
            }
            String idCard = e.getIdCard();
            Integer countMember = this.baseMapper.countMember(communityId, idCard, e.getPhone());
            if (countMember > 0) {
                ComFmsTeamMemberImportMistakeExcelVO mistake = new ComFmsTeamMemberImportMistakeExcelVO();
                BeanUtils.copyProperties(e, mistake);
                mistake.setMistake("团队成员已存在，如需添加团队关系，请编辑该成员");
                mistakes.add(mistake);
                continue;
            }
            ComFmsTeamMember comFmsTeamMember = new ComFmsTeamMember();
            comFmsTeamMember.setName(e.getTeamMember());
            comFmsTeamMember.setPhone(e.getPhone());
            comFmsTeamMember.setIdCard(idCard);
            if (isNotBlank(idCard)) {
                comFmsTeamMember.setGender(IdcardUtil.getGenderByIdCard(idCard) == 1 ? 1 : 2);
            }
            comFmsTeamMember.setCascadeIds(Arrays.asList(fmsTeamType.getId(), fmsTeam.getId()).toString());
            comFmsTeamMember.setCommunityId(communityId);
            comFmsTeamMember.setCreatedBy(userId);
            comFmsTeamMember.setUpdatedBy(userId);
            int num = this.baseMapper.insert(comFmsTeamMember);
            if (num > 0) {
                ComFmsTeamMemberRelation teamMemberRelation = new ComFmsTeamMemberRelation();
                teamMemberRelation.setMemberId(comFmsTeamMember.getId());
                teamMemberRelation.setTeamId(fmsTeam.getId());
                teamMemberRelations.add(teamMemberRelation);
            }
        }
        if (!teamMemberRelations.isEmpty()) {
            comFmsTeamMemberRelationDAO.insertBatch(teamMemberRelations);
        }
        return R.ok(mistakes);
    }

    /**
     * 团队人员导出
     * @param pageTeamMemberDTO
     * @return
     */
    @Override
    public R exportTeamMember(PageTeamMemberDTO pageTeamMemberDTO) {
        List<ComFmsTeamMemberExportExcelVO> memberExportExcelVOList = this.baseMapper.exportTeamMember(pageTeamMemberDTO);
        if (!memberExportExcelVOList.isEmpty()) {
            memberExportExcelVOList.forEach(e -> {
                if (isNotBlank(e.getIdCard())) {
                    e.setAge(IdcardUtil.getAgeByIdCard(e.getIdCard()) + "");
                } else {
                    e.setAge("未知");
                }
            });
        }
        return R.ok(memberExportExcelVOList);
    }

    /**
     * 级联查询团队服务人员
     * @param communityId
     * @return
     */
    @Override
    public R retrieveFmsTeamMemberCascade(Long communityId) {
        List<ComFmsTeamMemberVO> memberList = this.baseMapper.selectListByCommunityId(communityId);
        List<CascadeCommVO> cascade = null;
        if (!memberList.isEmpty()) {
            Map<Long, List<CascadeCommVO>> allMemberGroup = memberList.stream().map(e -> {
                CascadeCommVO cascadeCommVO = new CascadeCommVO();
                cascadeCommVO.setValue(e.getId());
                cascadeCommVO.setParentId(e.getTeamId());
                cascadeCommVO.setLabel(e.getName());
                return cascadeCommVO;
            }).collect(Collectors.groupingBy(CascadeCommVO::getParentId));
            List<ComFmsTeam> teamList = comFmsTeamDAO.selectBatchIds(allMemberGroup.keySet());
            if (!teamList.isEmpty()) {
                Map<Long, List<CascadeCommVO>> allTeamGroup = teamList.stream().map(e -> {
                    CascadeCommVO cascadeCommVO = new CascadeCommVO();
                    cascadeCommVO.setValue(e.getId());
                    cascadeCommVO.setParentId(e.getTeamType());
                    cascadeCommVO.setLabel(e.getName());
                    return cascadeCommVO;
                }).collect(Collectors.groupingBy(CascadeCommVO::getParentId));
                List<ComFmsTeamType> teamTypeList = comFmsTeamTypeDAO.selectBatchIds(allTeamGroup.keySet());
                if (!teamTypeList.isEmpty()) {
                    cascade = teamTypeList.stream().map(e -> {
                        CascadeCommVO cascadeCommVO = new CascadeCommVO();
                        cascadeCommVO.setValue(e.getId());
                        cascadeCommVO.setLabel(e.getName());
                        return cascadeCommVO;
                    }).collect(Collectors.toList());
                    cascade.forEach(e1 -> e1.setChildren(allTeamGroup.get(e1.getValue())));
                    cascade.forEach(e1 -> e1.getChildren().forEach(e2 -> e2.setChildren(allMemberGroup.get(e2.getValue()))));
                }
            }
        }
        return R.ok(cascade);
    }
}