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.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.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.permissions.PermissionService;
import com.alibaba.fastjson.JSON;
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.ArrayList;
import java.util.List;
import java.util.Objects;
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 IprPersonService iprPersonService;
    private AssoProjectPersonService assoProjectPersonService;
    private 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) {
                //邮箱存在
                iprPersonId = iprPerson.getId();
                assoId = iprPerson.getAssoAccountId();
            } else {
                PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
                String personId = personnelVO.getId();
                Integer tenantId = personnelVO.getTenantId();

                IprPerson iprPerson1 = new IprPerson();
                iprPerson1.setName(updateMatchCasePersonDTO.getName());
                iprPerson1.setEmail(email);
                // type asso remark
                iprPerson1.setType(type);
                iprPerson1.setAssoAccountId(assoAccountId);
                iprPerson1.setRemark(remark);

                iprPerson1.setIfDefault(false);
                iprPerson1.setCreateId(personId);
                iprPerson1.setTenantId(tenantId);
                iprPerson1.insert();
                iprPersonId = iprPerson1.getId();
            }
        } else {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "邮箱不能为空");
        }
        updateMatchCasePersonDTO.setName(name);
        // new
        updateMatchCasePersonDTO.setType(type);
        updateMatchCasePersonDTO.setIprPersonId(iprPersonId);
        MatchCasePerson matchCasePerson = this.addMatchCasePersonDB(updateMatchCasePersonDTO, assoId);
        if (type != null && type.equals(2)) {
            this.updateReportAgency(updateMatchCasePersonDTO.getReportId());
        }
        return matchCasePerson.getId();
    }

    public void updateReportAgency(Integer projectId) {
        LambdaQueryWrapper<MatchCasePerson> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(MatchCasePerson::getProjectId, projectId);
        MatchCasePerson matchCasePerson = this.getOne(queryWrapper1, false);
        Integer iprPersonId = matchCasePerson.getIprPersonId();
        IprPerson iprPerson = iprPersonService.getById(iprPersonId);
        String name = iprPerson.getName();

        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ReportProject::getProjectId, projectId);
        ReportProject reportProject = reportProjectService.getById(projectId);
        if (reportProject != null) {
            Integer actType = reportProject.getActType();
            //主动类型  专利权人代理所
            if (actType != null && actType.equals(1)) {
                String rightHolderAgency = reportProject.getRightHolderAgency();
                reportProject.setRightHolderAgency(rightHolderAgency + "," + name);
            } else {//被动类型 请求人代理所
                String applicantAgency = reportProject.getApplicantAgency();
                reportProject.setApplicantAgency(applicantAgency + "," + name);
            }
            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();

        //更新
        if (id != null) {
            matchCasePerson = this.getById(id);
            if (matchCasePerson != null) {
                matchCasePerson.setIprPersonId(updateMatchCasePersonDTO.getIprPersonId());
                matchCasePerson.updateById();
                if (assoId != null) {
                    //assoId取消关联
                    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.setId(null);
            matchCasePerson.insert();
        }
        if (assoAccountId != null) {
            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(createIds)) {
            try {
                String res = permissionService.getPersonnelByIdsFromPCS(createIds);
                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(personnel.getPersonnelName());
                queryMatchCasePersonVO.setAccountUserName(personnel.getPersonnelUserName());
            }
            queryMatchCasePersonVOS.add(queryMatchCasePersonVO);
        }
    }


    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) {
        for (Integer id : ids) {
            MatchCasePerson matchCasePerson = this.getById(id);
            Integer iprPersonId = matchCasePerson.getIprPersonId();
            Integer type = matchCasePerson.getType();
            Integer projectId = matchCasePerson.getProjectId();

            IprPerson iprPerson = iprPersonService.getById(iprPersonId);
            Integer assoId = iprPerson.getAssoAccountId();
            if (assoId != null) {
                //assoId取消关联
                LambdaQueryWrapper<AssoProjectPerson> assoProjectPersonLambdaQueryWrapper = new LambdaQueryWrapper<>();
                assoProjectPersonLambdaQueryWrapper.eq(AssoProjectPerson::getProjectId, projectId)
                        .eq(AssoProjectPerson::getRole, 1)
                        .eq(AssoProjectPerson::getPersonId, assoId);
                assoProjectPersonService.remove(assoProjectPersonLambdaQueryWrapper);
            }
            // 如果删除的是代理所
            if (type != null && type.equals(2)) {
                LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(ReportProject::getProjectId, projectId);
                ReportProject reportProject = reportProjectService.getOne(queryWrapper, false);
                if (reportProject != null) {
                    Integer actType = reportProject.getActType();
                    // 主动类型
                    if (actType != null && actType.equals(1)) {

                    } else { // 被动类型

                    }
                }
            }

        }
        this.removeBatchByIds(ids);
    }

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



}