package cn.cslg.pas.service.report;

import cn.cslg.pas.common.model.cronModel.Personnel;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.report.*;
import cn.cslg.pas.common.model.cronModel.SystemFile;
import cn.cslg.pas.common.model.report.MailMessageDTO;
import cn.cslg.pas.common.model.report.QueryMatchCasePersonVO;
import cn.cslg.pas.common.model.report.UpdateIprPersonDTO;
import cn.cslg.pas.common.model.report.UpdateMatchCasePersonDTO;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.domain.business.AssoProjectPerson;
import cn.cslg.pas.domain.business.ReportProject;
import cn.cslg.pas.domain.business.Project;
import cn.cslg.pas.domain.business.ReportProject;
import cn.cslg.pas.domain.report.AssoIprReportType;
import cn.cslg.pas.domain.report.IprPerson;
import cn.cslg.pas.exception.ExceptionEnum;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.service.business.AssoProjectPersonService;
import cn.cslg.pas.service.business.ReportProjectService;
import cn.cslg.pas.service.business.ProjectService;
import cn.cslg.pas.service.business.ReportProjectService;
import cn.cslg.pas.service.permissions.PermissionService;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import cn.cslg.pas.domain.report.MatchCasePerson;
import cn.cslg.pas.mapper.report.MatchCasePersonMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @author admin
 * @description 针对表【match_case_person(配案人员)】的数据库操作Service实现
 * @createDate 2024-12-24 13:56:43
 */
@Service
@RequiredArgsConstructor
public class MatchCasePersonService extends ServiceImpl<MatchCasePersonMapper, MatchCasePerson> {
    private final LoginUtils loginUtils;
    private final CacheUtils cacheUtils;
    @Autowired
    @Lazy
    private SendReportMailService sendReportMailService;

    @Autowired
    @Lazy
    private IprPersonService iprPersonService;
    private final AssoProjectPersonService assoProjectPersonService;
    private final ReportProjectService reportProjectService;
    private final PermissionService permissionService;

    public Integer updateMatchCasePerson(UpdateMatchCasePersonDTO updateMatchCasePersonDTO) {
        String name = updateMatchCasePersonDTO.getName();
        String email = updateMatchCasePersonDTO.getEmail();
        Integer assoAccountId = updateMatchCasePersonDTO.getAssoAccountId();
        String remark = updateMatchCasePersonDTO.getRemark();

        Integer assoId = updateMatchCasePersonDTO.getAssoAccountId();
        // 1内部ipr 2代理所
        Integer type = updateMatchCasePersonDTO.getType();
        Integer iprPersonId = null;

        // 邮箱传入 即先添加ipr人员 再与报告关联
        // 判断邮箱是否存在
        // 邮箱不为空 则去新增ipr人员 并判断邮箱是否存在
        if (email != null) {
            Boolean isValid = this.isValidEmail(email);
            if (!isValid) {
                throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "邮箱格式不正确");
            }
            LambdaQueryWrapper<IprPerson> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(IprPerson::getEmail, email);
            IprPerson iprPerson = iprPersonService.getOne(queryWrapper, false);
            if (iprPerson != null) {
                if (!name.trim().equals(iprPerson.getName().trim()) || assoAccountId != iprPerson.getAssoAccountId()) {
                    throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "禁止修改已存在邮箱的相关信息！请前往联系邮箱处");
                }
                //邮箱存在
                iprPersonId = iprPerson.getId();
                assoId = iprPerson.getAssoAccountId();

            } else {
                PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
                String personId = personnelVO.getId();
                Integer tenantId = personnelVO.getTenantId();

                IprPerson newIprPerson = new IprPerson();
                newIprPerson.setName(updateMatchCasePersonDTO.getName());
                newIprPerson.setEmail(email);

                newIprPerson.setType(type);
                newIprPerson.setAssoAccountId(assoAccountId);
                newIprPerson.setRemark(remark);

                newIprPerson.setIfDefault(false);
                newIprPerson.setCreateId(personId);
                newIprPerson.setTenantId(tenantId);
                newIprPerson.insert();
                iprPersonId = newIprPerson.getId();
            }
        } else {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "邮箱不能为空");
        }
        updateMatchCasePersonDTO.setName(name);
        updateMatchCasePersonDTO.setType(type);
        updateMatchCasePersonDTO.setIprPersonId(iprPersonId);
        MatchCasePerson matchCasePerson = this.addMatchCasePersonDB(updateMatchCasePersonDTO, assoId);
        if (type != null) {
            this.updateReport(updateMatchCasePersonDTO.getReportId(), type);
        }
        MatchCasePerson matchCasePerson = this.addMatchCasePersonDB(updateMatchCasePersonDTO);
        sendReportMailService.sendMatchCasePersonMail(matchCasePerson.getProjectId(), name, email);
        return matchCasePerson.getId();
    }

    public void updateReport(Integer projectId, Integer type) {
        if (type != null) {
            LambdaQueryWrapper<MatchCasePerson> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(MatchCasePerson::getProjectId, projectId)
                    .eq(MatchCasePerson::getType, type);
            List<MatchCasePerson> matchCasePersons = this.list(queryWrapper1);

            String resultName = Optional.ofNullable(matchCasePersons)
                    .orElse(Collections.emptyList())// 空值安全处理
                    .stream()
                    .map(person -> {
                        IprPerson iprPerson = iprPersonService.getById(person.getIprPersonId());
                        return (iprPerson != null && iprPerson.getName() != null) ? iprPerson.getName() : "";
                    }) //对象转换
                    .filter(name -> !name.isEmpty()) // 过滤无效数据
                    .collect(Collectors.joining("、")); // 只能拼接

            LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ReportProject::getProjectId, projectId);
            ReportProject reportProject = reportProjectService.getOne(queryWrapper,false);
            if (reportProject != null) {
                if (type.equals(2)) { // 代理所
                    Integer actType = reportProject.getActType();
                    //主动类型  请求人代理所
                    if (actType != null && actType.equals(1)) {
                        reportProject.setApplicantAgency(resultName);
                    } else if (actType != null && actType.equals(0)) {//被动类型 专利权人代理所
                        reportProject.setRightHolderAgency(resultName);
                    }
                } else if (type.equals(1)) { // 内部ipr
                    reportProject.setActualPerson(resultName);
                }
                reportProject.updateById();
            }
        }
    }

    public MatchCasePerson addMatchCasePersonDB(UpdateMatchCasePersonDTO updateMatchCasePersonDTO, Integer assoId) {
        MatchCasePerson matchCasePerson = new MatchCasePerson();
        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        String personId = personnelVO.getId();
        Integer tenantId = personnelVO.getTenantId();
        Integer id = updateMatchCasePersonDTO.getId();
        Integer assoAccountId = updateMatchCasePersonDTO.getAssoAccountId();
        Integer type = updateMatchCasePersonDTO.getType();
        Integer iprPersonId = updateMatchCasePersonDTO.getIprPersonId();

        LambdaQueryWrapper<MatchCasePerson> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MatchCasePerson::getIprPersonId, iprPersonId);
        queryWrapper.eq(MatchCasePerson::getProjectId, updateMatchCasePersonDTO.getReportId());
        queryWrapper.eq(MatchCasePerson::getType, type);
        if (id != null) {
            queryWrapper.ne(MatchCasePerson::getId, id);
        }
        List<MatchCasePerson> matchCasePeople = this.list(queryWrapper);
        if (matchCasePeople != null && !matchCasePeople.isEmpty()) {
            String entityType = type.equals(2) ? "代理所" : "IPR";
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "该" + entityType + "已配案");
        }
        if (id != null) {
            matchCasePerson = this.getById(id);
            if (matchCasePerson != null) {
                matchCasePerson.setIprPersonId(updateMatchCasePersonDTO.getIprPersonId());
                matchCasePerson.updateById();
                if (assoId != null) {
//                    LambdaQueryWrapper<AssoProjectPerson> assoProjectPersonLambdaQueryWrapper = new LambdaQueryWrapper<>();
//                    assoProjectPersonLambdaQueryWrapper.eq(AssoProjectPerson::getProjectId, updateMatchCasePersonDTO.getReportId())
//                            .eq(AssoProjectPerson::getRole, 1)
//                            .eq(AssoProjectPerson::getPersonId, assoId);
//                    assoProjectPersonService.remove(assoProjectPersonLambdaQueryWrapper);
                }
            }
        } else {
            matchCasePerson.setProjectId(updateMatchCasePersonDTO.getReportId());
            matchCasePerson.setIprPersonId(updateMatchCasePersonDTO.getIprPersonId());
            matchCasePerson.setCreateId(personId);
            matchCasePerson.setTenantId(tenantId);
            matchCasePerson.setType(updateMatchCasePersonDTO.getType());
            matchCasePerson.setId(null);
            matchCasePerson.insert();
        }
        if (assoAccountId != null) {
            LambdaQueryWrapper<AssoProjectPerson> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(AssoProjectPerson::getProjectId, updateMatchCasePersonDTO.getReportId());
            queryWrapper1.eq(AssoProjectPerson::getRole, 1);
            queryWrapper1.eq(AssoProjectPerson::getPersonId, assoAccountId);
            List<AssoProjectPerson> assoProjectPersons = assoProjectPersonService.list(queryWrapper1);
            if (assoProjectPersons == null || assoProjectPersons.isEmpty()) {
                AssoProjectPerson assoProjectPerson = new AssoProjectPerson();
                assoProjectPerson.setRole(1);
                assoProjectPerson.setProjectId(updateMatchCasePersonDTO.getReportId());
                assoProjectPerson.setPersonId(String.valueOf(assoAccountId));
                assoProjectPerson.setCreateId(personId);
                assoProjectPerson.insert();
            }
        }
        return matchCasePerson;
    }

    public List<QueryMatchCasePersonVO> getReportMatchCasePerson(QueryMatchCasePersonDTO queryMatchCasePersonDTO) {
        Integer reportId = queryMatchCasePersonDTO.getReportId();
        Integer type = queryMatchCasePersonDTO.getType();

        List<QueryMatchCasePersonVO> queryMatchCasePersonVOS = new ArrayList<>();

        LambdaQueryWrapper<MatchCasePerson> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(MatchCasePerson::getProjectId, reportId);
        if (type != null) {
            queryWrapper.eq(MatchCasePerson::getType, type);
        }
        List<MatchCasePerson> matchCasePersons = this.list(queryWrapper);
        if (matchCasePersons != null && !matchCasePersons.isEmpty()) {
            for (MatchCasePerson matchCasePerson : matchCasePersons) {
                QueryMatchCasePersonVO queryMatchCasePersonVO = new QueryMatchCasePersonVO();
                BeanUtils.copyProperties(matchCasePerson, queryMatchCasePersonVO);
                queryMatchCasePersonVO.setReportId(matchCasePerson.getProjectId());
                Integer iprPersonId = matchCasePerson.getIprPersonId();
                IprPerson iprPerson = iprPersonService.getById(iprPersonId);
                if (iprPerson != null) {
                    queryMatchCasePersonVO.setName(iprPerson.getName());
                    queryMatchCasePersonVO.setEmail(iprPerson.getEmail());
                    queryMatchCasePersonVO.setAssoAccountId(iprPerson.getAssoAccountId());
                    queryMatchCasePersonVO.setRemark(iprPerson.getRemark());
                }
                queryMatchCasePersonVOS.add(queryMatchCasePersonVO);
            }
            this.loadQueryMatchCasePersonVOS(queryMatchCasePersonVOS);
        }
        return queryMatchCasePersonVOS;
    }


    public void loadQueryMatchCasePersonVOS(List<QueryMatchCasePersonVO> queryMatchCasePersonVOS) {
        List<String> personIds = new ArrayList<>();
        List<Personnel> personnels = new ArrayList<>();
        List<String> createIds = queryMatchCasePersonVOS.stream()
                .map(QueryMatchCasePersonVO::getCreateId)
                .collect(Collectors.toList());
        personIds.addAll(createIds);
        List<String> assoAccountStrIds = queryMatchCasePersonVOS.stream()
                .map(QueryMatchCasePersonVO::getAssoAccountId)//提取Integer
                .filter(Objects::nonNull)//过滤null值
                .map(String::valueOf)//转换为String
                .collect(Collectors.toList());
        personIds.addAll(assoAccountStrIds);
        if (!CollectionUtils.isEmpty(personIds)) {
            try {
                String res = permissionService.getPersonnelByIdsFromPCS(personIds);
                JSONObject jsonObject = JSON.parseObject(res);
                personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
            } catch (Exception e) {
                throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "人员查询错误");
            }
        }
        for (QueryMatchCasePersonVO queryMatchCasePersonVO : queryMatchCasePersonVOS) {
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(queryMatchCasePersonVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                queryMatchCasePersonVO.setCreateName(personnel.getPersonnelName());
            }

            Personnel assoAccount = personnels.stream()
                    .filter(item -> {
                        // 获取Integer类型的关联id
                        Integer targetId = queryMatchCasePersonVO.getAssoAccountId();
                        // 当目标id为空时 直接跳过匹配
                        if (targetId == null)  return false;
                        // 将Integer转换为String进行比较
                        return String.valueOf(targetId).equals(item.getId());
                    })
                    .findFirst()
                    .orElse(null);
            if (assoAccount != null) {
                queryMatchCasePersonVO.setAccountName(assoAccount.getPersonnelName());
                queryMatchCasePersonVO.setAccountUserName(assoAccount.getPersonnelUserName());
            }
        }
    }


    public Boolean isValidEmail(String email) {
        if ((email != null) && (!email.isEmpty())) {
            return Pattern.matches("^(\\w+([-.][A-Za-z0-9]+)*){3,18}@\\w+([-.][A-Za-z0-9]+)*\\.\\w+([-.][A-Za-z0-9]+)*$", email);
        }
        return false;
    }

    public void delete(List<Integer> ids) {
        if (ids != null && !ids.isEmpty()) {
            LambdaQueryWrapper<MatchCasePerson> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(MatchCasePerson::getId, ids);
            List<MatchCasePerson> matchCasePeople = this.list(queryWrapper);
            this.removeBatchByIds(ids);
            List<Integer> assoIds = new ArrayList<>();
            Integer projectId = null;
            for (MatchCasePerson matchCasePerson : matchCasePeople) {
                Integer iprPersonId = matchCasePerson.getIprPersonId();
                Integer type = matchCasePerson.getType();
                projectId = matchCasePerson.getProjectId();

                IprPerson iprPerson = iprPersonService.getById(iprPersonId);
                Integer assoId = iprPerson.getAssoAccountId();
                if (assoId != null) {
                    assoIds.add(assoId);
//                    //assoId取消关联
//                    LambdaQueryWrapper<AssoProjectPerson> assoProjectPersonLambdaQueryWrapper = new LambdaQueryWrapper<>();
//                    assoProjectPersonLambdaQueryWrapper.eq(AssoProjectPerson::getProjectId, projectId)
//                            .eq(AssoProjectPerson::getRole, 1)
//                            .eq(AssoProjectPerson::getPersonId, assoId);
//                    assoProjectPersonService.remove(assoProjectPersonLambdaQueryWrapper);
                }
                this.updateReport(projectId, type);
            }
        }
    }

    public void cancelConnect() {

    }

    public void deleteByIprIds(List<Integer> iprPersonIds) {
        LambdaQueryWrapper<MatchCasePerson> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(MatchCasePerson::getIprPersonId, iprPersonIds);
        this.remove(queryWrapper);
    }




}