package com.smartor.service.impl;

import java.time.LocalDate;
import java.time.ZoneOffset;
import java.util.*;

import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.DtoConversionUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.smartor.domain.*;
import com.smartor.mapper.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.smartor.service.IPatMedInhospService;
import org.springframework.transaction.annotation.Transactional;

/**
 * 患者住院记录Service业务层处理
 *
 * @author smartor
 * @date 2023-03-04
 */
@Slf4j
@Service
public class PatMedInhospServiceImpl implements IPatMedInhospService {
    @Autowired
    private PatMedInhospMapper patMedInhospMapper;

    @Autowired
    private PatArchiveMapper patArchiveMapper;

    @Autowired
    private TemplateDeptMapper templateDeptMapper;

    @Autowired
    private PatArchiveImportMapper patArchiveImportMapper;

    @Autowired
    private Icd10AssociationMapper icd10AssociationMapper;

    @Autowired
    private SvyTaskTemplateMapper svyTaskTemplateMapper;
    @Autowired
    private IvrTaskTemplateMapper ivrTaskTemplateMappte;

    @Autowired
    private ServiceTaskMapper serviceTaskMapper;

    @Autowired
    private ServiceSubtaskMapper serviceSubtaskMapper;
    @Autowired
    private SysUserDeptMapper sysUserDeptMapper;

    //记录长期任务基础信息
    List<IvrLibaTemplate> libaTemplates = new ArrayList<>();
    List<IvrTaskTemplate> ivrTaskTemplates = new ArrayList<>();
    List<ServiceTask> serviceTaskList = new ArrayList<>();

    /**
     * 查询患者住院记录
     *
     * @param inhospid 患者住院记录主键
     * @return 患者住院记录
     */
    @Override
    public PatMedInhosp selectPatMedInhospByInhospid(Long inhospid) {
        return patMedInhospMapper.selectPatMedInhospByInhospid(inhospid);
    }

    /**
     * 查询患者住院记录列表
     *
     * @param patMedInhosp 患者住院记录
     * @return 患者住院记录
     */
    @Override
    public List<PatMedInhosp> selectPatMedInhospList(PatMedInhosp patMedInhosp) {
        return patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
    }

    /**
     * 查询当前登陆人自己（病区、部门）的患者住院记录列表
     *
     * @param patMedInhospVO
     * @return
     */
    public List<PatMedInhosp> selectPatMedInhospListByCondition(PatMedInhospVO patMedInhospVO) {
        return patMedInhospMapper.selectPatMedInhospListByCondition(patMedInhospVO);
    }


    @Override
    public PatMedInhosp getDeptCodeByPatId(PatMedInhosp patMedInhosp) {
        List<PatMedInhosp> patMedInhosps = selectPatMedInhospList(patMedInhosp);
        if (!org.springframework.util.CollectionUtils.isEmpty(patMedInhosps)) {

            if (patMedInhosp.getInhospstate().equals("0")) {
                //先去掉时间为空的
                patMedInhosps.removeIf(PatMedInhosp -> PatMedInhosp.getStarttime() == null);
                Collections.sort(patMedInhosps, Comparator.comparing(PatMedInhosp::getStarttime).reversed());
            } else if (patMedInhosp.getInhospstate().equals("1")) {
                //先去掉时间为空的
                patMedInhosps.removeIf(PatMedInhosp -> PatMedInhosp.getEndtime() == null);
                Collections.sort(patMedInhosps, Comparator.comparing(PatMedInhosp::getEndtime).reversed());
            }
        }
        if (patMedInhosps != null && patMedInhosps.size() > 0) return patMedInhosps.get(0);
        else return null;
    }

    /**
     * 查询出入院人次
     *
     * @param patMedReq
     * @return
     */
    @Override
    public PatMedRes selectPatMedInhospListCount(PatMedReq patMedReq) {
        PatMedRes patMedRes = null;
        // 获取当前登陆人的部门权限
        if (org.springframework.util.CollectionUtils.isEmpty(patMedReq.getDeptcodeList())) {
            Long userId = SecurityUtils.getUserId();
            List<SysDept> sysDepts = sysUserDeptMapper.selectDeptListByUserId(userId);
            List<String> deptCode = new ArrayList<>();
            for (SysDept sysDept : sysDepts) {
                deptCode.add(sysDept.getDeptId().toString());
            }
            patMedReq.setDeptcodeList(deptCode);
            patMedRes = patMedInhospMapper.selectPatMedInhospCount(patMedReq);
        }
        return patMedRes;
    }

    /**
     * 新增患者住院记录
     *
     * @param patMedInhosp 患者住院记录
     * @return 结果
     */
    @Override
    public int insertPatMedInhosp(PatMedInhosp patMedInhosp) {
        patMedInhosp.setCreateTime(DateUtils.getNowDate());
        patMedInhosp.setUpdateTime(DateUtils.getNowDate());
        return patMedInhospMapper.insertPatMedInhosp(patMedInhosp);
    }

    /**
     * 修改患者住院记录
     *
     * @param patMedInhosp 患者住院记录
     * @return 结果
     */
    @Override
    public int updatePatMedInhosp(PatMedInhosp patMedInhosp) {
        patMedInhosp.setUpdateTime(DateUtils.getNowDate());
        return patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
    }

    /**
     * 批量删除患者住院记录
     *
     * @param inhospids 需要删除的患者住院记录主键
     * @return 结果
     */
    @Override
    public int deletePatMedInhospByInhospids(Long[] inhospids) {
        return patMedInhospMapper.deletePatMedInhospByInhospids(inhospids);
    }

    /**
     * 删除患者住院记录信息
     *
     * @param inhospid 患者住院记录主键
     * @return 结果
     */
    @Override
    public int deletePatMedInhospByInhospid(Long inhospid) {
        return patMedInhospMapper.deletePatMedInhospByInhospid(inhospid);
    }

    /**
     * 删除患者住院记录信息
     *
     * @param inhospno 患者住院编码
     * @return 结果
     */
    @Override
    public int deletePatMedInhospByInhospno(String inhospno) {
        return patMedInhospMapper.deletePatMedInhospByInhospno(inhospno);
    }


    @Override
    public int dealOutHospInfo() {
        PatMedInhosp patMedInhosp = new PatMedInhosp();
        //获取未处理的数据
        patMedInhosp.setCheckFlag("0");
        patMedInhosp.setInhospstate("1");
        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        log.error("dealOutHospInfo需要处理的出院患者信息：{}", patMedInhosps);
        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
            //根据患者所在科室，获取该科室的长期任务模板
            Long taskid = null;
            //通过deptCode获取关联的长期任务模板
            TemplateDept templateDept = new TemplateDept();
            templateDept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
            templateDept.setLongTemp(1);
            templateDept.setType(21L);
            List<TemplateDept> templateDepts = templateDeptMapper.selectTemplateDeptList(templateDept);
            //根据获取的长期任务模板ID，获取任务模板详情
            List<IvrTaskTemplate> ivrTaskTemplates = new ArrayList<>();
            if (CollectionUtils.isNotEmpty(templateDepts)) {
                for (TemplateDept templateDept1 : templateDepts) {
                    IvrTaskTemplate ivrTaskTemplate = ivrTaskTemplateMappte.selectIvrTaskTemplateByID(templateDept1.getTempid());
                    if (ObjectUtils.isNotEmpty(ivrTaskTemplate)) ivrTaskTemplates.add(ivrTaskTemplate);
                }
            }
            //如果部门模板为空（暂定，将出入院表的check_flag设置为2  ，long_task_reason 记录原因）
            if (CollectionUtils.isEmpty(ivrTaskTemplates) || ivrTaskTemplates.size() == 0) {
                patMedInhosp1.setCheckFlag("2");
                patMedInhosp1.setLongTaskReason("该患者所在科室，未配置任务模板");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                continue;
            }

            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
            //给个remark(用来做是否要给发送时间标识)
            String remark = null;
            //定义一个模板变量，用与临时保存一下找出来的模板
            IvrTaskTemplate stt = null;
            if (CollectionUtils.isNotEmpty(ivrTaskTemplates) && ivrTaskTemplates.size() == 1) {
                stt = ivrTaskTemplates.get(0);
                taskid = ivrTaskTemplates.get(0).getTaskid();

            } else if (CollectionUtils.isNotEmpty(ivrTaskTemplates) && ivrTaskTemplates.size() > 1) {
                //通过患者的疾病去找模板
                if (StringUtils.isNotEmpty(patMedInhosp1.getIcd10code())) {
                    aa:
                    for (IvrTaskTemplate ivrTaskTemplate1 : ivrTaskTemplates) {
                        //通过基础模板ID获取关联的疾病code
                        Icd10Association icd10Association = new Icd10Association();
                        icd10Association.setType(5L);
                        icd10Association.setOutid(ivrTaskTemplate1.getId());
                        List<Icd10Association> icd10Associations = icd10AssociationMapper.selectIcd10AssociationList(icd10Association);
                        if (CollectionUtils.isEmpty(icd10Associations)) {
                            //如能模板的疾病为空，则是本科室的通用默认模板
                            stt = ivrTaskTemplate1;
                            taskid = stt.getTaskid();
                            continue;
                        } else {
                            //如能模板的疾病不为空，则是用匹配到疾病的模板（如果匹配出来多个模板，只用第一个）
                            for (Icd10Association icd10Association1 : icd10Associations) {
                                if (patMedInhosp1.getIcd10code().equals(icd10Association1.getIcd10code())) {
                                    stt = ivrTaskTemplate1;
                                    taskid = stt.getTaskid();
                                    break aa;
                                }
                            }
                        }
                    }
                    //如果循环完，stt还是为空，则该科室没有默认模板
                    if (Objects.isNull(stt)) {
                        //在出入院表记录一下该患者状态（该科室没有模板，所以无法在子任务里生成任务，所以任务是失败是的，chect_flag=2）
                        patMedInhosp1.setCheckFlag("2");
                        patMedInhosp1.setLongTaskReason("无法匹配到该科室模板，该科室也无默认模板");
                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                        continue;
                    }
                } else {
                    //为空的话，直接用科室的通用模板的任务ID，该患者直接往子任务表里插入，但不要执行，需要人工干（将不能执行的原因备注好）
                    for (IvrTaskTemplate ivrTaskTemplate1 : ivrTaskTemplates) {
                        //通过基础模板ID获取关联的疾病code
                        Icd10Association icd10Association = new Icd10Association();
                        icd10Association.setType(5L);
                        icd10Association.setOutid(ivrTaskTemplate1.getId());
                        //找出该科室的通用模板
                        List<Icd10Association> icd10Associations = icd10AssociationMapper.selectIcd10AssociationList(icd10Association);
                        if (CollectionUtils.isEmpty(icd10Associations)) {
                            stt = ivrTaskTemplate1;
                            //不配置发送时间
                            remark = "患者入院疾病为空";
                            //在出入院表记录一下该患者状态（该科室是有疾病为空的模板，所以可以在子任务里生成任务，所以任务是成功的，chect_flag=1）
                            patMedInhosp1.setCheckFlag("1");
                            patMedInhosp1.setLongTaskReason("患者入院疾病为空，已找到科室模板");
                            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                            continue;
                        }
                    }
                    if (Objects.isNull(stt)) {
                        //在出入院表记录一下该患者状态（该科室没有模板，所以无法在子任务里生成任务，所以任务是失败是的，chect_flag=2）
                        patMedInhosp1.setCheckFlag("2");
                        patMedInhosp1.setLongTaskReason("患者入院疾病为空，未找到科室模板");
                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                        continue;
                    }
                }
            }

            ServiceTask serviceTask = serviceTaskMapper.selectServiceTaskByTaskid(taskid);
            ServiceSubtask serviceSubtask = DtoConversionUtils.sourceToTarget(serviceTask, ServiceSubtask.class);
            serviceSubtask.setTaskid(serviceTask.getTaskid());
            if (StringUtils.isNotEmpty(stt.getLibtemplateid()))
                serviceSubtask.setLibtemplateid(Long.valueOf(stt.getLibtemplateid()));
            serviceSubtask.setNurseId(patMedInhosp1.getNurseId());
            serviceSubtask.setNurseName(patMedInhosp1.getNurseName());
            serviceSubtask.setDrcode(patMedInhosp1.getDrcode());
            serviceSubtask.setDrname(patMedInhosp1.getDrname());
            serviceSubtask.setDeptname(patMedInhosp1.getLeaveldeptname());
            serviceSubtask.setTemplateid(stt.getId());
            serviceSubtask.setTemplatename(stt.getTemplateName());
            serviceSubtask.setPatid(patArchive.getId());
            serviceSubtask.setSendname(patArchive.getName());
            serviceSubtask.setSfzh(patArchive.getIdcardno());
            serviceSubtask.setPhone(patArchive.getTelcode());
            serviceSubtask.setSex(patArchive.getSex());
            serviceSubtask.setAge(patArchive.getAge());
            serviceSubtask.setSendstate(2L);
            serviceSubtask.setStarttime(patMedInhosp1.getStarttime());
            serviceSubtask.setEndtime(patMedInhosp1.getEndtime());
            serviceSubtask.setServiceType("2");
            serviceSubtask.setPreachform(serviceTask.getPreachform());
            serviceSubtask.setHospType("2");
            serviceSubtask.setCreateTime(new Date());
            serviceSubtask.setUpdateTime(new Date());
            serviceSubtask.setCreateBy(patMedInhosp1.getNurseName());
            serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getLeavehospitaldistrictcode());
            serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());
            //设置发送时间
            Date newDate = addDays(patMedInhosp1.getEndtime(), stt.getSendDay());
            serviceSubtask.setLongSendTime(newDate);
            //患者发送时间
            if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) {
                remark = patArchive.getNotrequiredreason();
                serviceSubtask.setRemark(remark);
                serviceSubtask.setResult("error");
                serviceSubtask.setFinishtime(new Date());
                //不执行
                serviceSubtask.setSendstate(4L);
            }

            //在新增之前，先通过患者ID，sendstate=2查询一下，在所有长期任务中，是不是还有该患者待执行的任务，有的话,比较之前的endtime是否小于当前的endtaime,如果之前的小于现在的，则直接将之前的停掉（原因再入院）
            ServiceSubtaskVO subtask = new ServiceSubtaskVO();
            subtask.setPatid(patArchive.getId());
            subtask.setSendstate(2L);
            List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
            log.error("该患者待执行的任务:{}", selectServiceSubtaskList);
            if (CollectionUtils.isNotEmpty(selectServiceSubtaskList) && selectServiceSubtaskList.size() > 0) {
                for (ServiceSubtask serviceSubtask1 : selectServiceSubtaskList) {
                    if (Objects.isNull(serviceSubtask1.getLongSendTime())) {
                        //不是长期任务，不处理
                        continue;
                    }
                    if (serviceSubtask1.getEndtime().before(serviceSubtask.getEndtime())) {
                        //如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
                        serviceSubtask1.setSendstate(4L);
                        serviceSubtask1.setRemark("患者再入院");
                        serviceSubtask1.setResult("error");
                        serviceSubtask1.setFinishtime(new Date());
                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
                    } else {
                        //相反,则将当有的数据停掉
                        serviceSubtask.setResult("error");
                        serviceSubtask.setFinishtime(new Date());
                        serviceSubtask.setSendstate(4L);
                        serviceSubtask.setRemark("患者再入院");
                    }
                }
            }

            serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
            //将check_flag改成1（已处理）
            PatMedInhosp patMedInhosp2 = new PatMedInhosp();
            patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
            patMedInhosp2.setCheckFlag("1");
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
        }

        //获取未处理在院的数据(如果刚刚出院的患者数据的出院时间,在下面查询出的入院时间之前,那之前的出院患者的数据,也得停掉,因为又入院了)
        patMedInhosp.setCheckFlag("0");
        patMedInhosp.setInhospstate("0");
        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        if (CollectionUtils.isNotEmpty(patMedInhospList) && patMedInhospList.size() > 0) {
            for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
                //获取当前入院患者的待执行的出院子任务随访信息
                ServiceSubtaskVO subtask = new ServiceSubtaskVO();
                subtask.setPatid(patMedInhosp1.getPatid());
                subtask.setSendstate(2L);
                List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
                log.error("入院的患者待执行的任务:{}", selectServiceSubtaskList);
                if (CollectionUtils.isNotEmpty(selectServiceSubtaskList) && selectServiceSubtaskList.size() > 0) {
                    for (ServiceSubtask serviceSubtask1 : selectServiceSubtaskList) {
                        if (Objects.isNull(serviceSubtask1.getLongSendTime())) {
                            //不是长期任务，不处理
                            continue;
                        }
                        if (serviceSubtask1.getEndtime().before(patMedInhosp1.getStarttime())) {
                            //如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
                            serviceSubtask1.setSendstate(4L);
                            serviceSubtask1.setRemark("患者再入院");
                            serviceSubtask1.setResult("error");
                            serviceSubtask1.setFinishtime(new Date());
                            serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
                            patMedInhosp1.setCheckFlag("1");
                        }
                    }
                }
                //将患入的入院数据设置为已处理
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            }
        }

        return 1;
    }
//问卷
//    @Override
//    public int dealOutHospInfo() {
//        PatMedInhosp patMedInhosp = new PatMedInhosp();
//        //获取未处理的数据
//        patMedInhosp.setCheckFlag("0");
//        patMedInhosp.setInhospstate("1");
//        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
//
//        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
//            //根据患者所在科室，获取该科室的长期任务模板
//            Long taskid = null;
//            //通过deptCode获取关联的长期任务模板
//            TemplateDept templateDept = new TemplateDept();
//            templateDept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
//            templateDept.setLongTemp(1);
//            templateDept.setType(11L);
//            List<TemplateDept> templateDepts = templateDeptMapper.selectTemplateDeptList(templateDept);
//            //根据获取的长期任务模板ID，获取任务模板详情
//            List<SvyTaskTemplate> svyTaskTemplates = new ArrayList<>();
//            if (CollectionUtils.isNotEmpty(templateDepts)) {
//                for (TemplateDept templateDept1 : templateDepts) {
//                    SvyTaskTemplate svyTaskTemplate = svyTaskTemplateMapper.selectSvyTaskTemplateBySvyid(templateDept1.getTempid());
//                    if (ObjectUtils.isNotEmpty(svyTaskTemplate)) svyTaskTemplates.add(svyTaskTemplate);
//                }
//            }
//            //如果部门模板为空（暂定，将出入院表的check_flag设置为2  ，long_task_reason 记录原因）
//            if (CollectionUtils.isEmpty(svyTaskTemplates) || svyTaskTemplates.size() == 0) {
//                patMedInhosp1.setCheckFlag("2");
//                patMedInhosp1.setLongTaskReason("该患者所在科室，未配置任务模板");
//                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//                continue;
//            }
//
//            //获取患者信息
//            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
//            //给个remark(用来做是否要给发送时间标识)
//            String remark = null;
//            //定义一个模板变量，用与临时保存一下找出来的模板
//            SvyTaskTemplate stt = null;
//            if (CollectionUtils.isNotEmpty(svyTaskTemplates) && svyTaskTemplates.size() == 1) {
//                stt = svyTaskTemplates.get(0);
//                taskid = svyTaskTemplates.get(0).getTaskid();
//
//            } else if (CollectionUtils.isNotEmpty(svyTaskTemplates) && svyTaskTemplates.size() > 1) {
//                //通过患者的疾病去找模板
//                if (StringUtils.isNotEmpty(patMedInhosp1.getIcd10code())) {
//                    aa:
//                    for (SvyTaskTemplate svyTaskTemplate1 : svyTaskTemplates) {
//                        //通过基础模板ID获取关联的疾病code
//                        Icd10Association icd10Association = new Icd10Association();
//                        icd10Association.setType(5L);
//                        icd10Association.setOutid(svyTaskTemplate1.getTemplateid());
//                        List<Icd10Association> icd10Associations = icd10AssociationMapper.selectIcd10AssociationList(icd10Association);
//                        if (CollectionUtils.isEmpty(icd10Associations)) {
//                            //如能模板的疾病为空，则是本科室的通用默认模板
//                            stt = svyTaskTemplate1;
//                            taskid = stt.getTaskid();
//                            continue;
//                        } else {
//                            //如能模板的疾病不为空，则是用匹配到疾病的模板（如果匹配出来多个模板，只用第一个）
//                            for (Icd10Association icd10Association1 : icd10Associations) {
//                                if (patMedInhosp1.getIcd10code().equals(icd10Association1.getIcd10code())) {
//                                    stt = svyTaskTemplate1;
//                                    taskid = stt.getTaskid();
//                                    break aa;
//                                }
//                            }
//                        }
//                    }
//                    //如果循环完，stt还是为空，则该科室没有默认模板
//                    if (Objects.isNull(stt)) {
//                        //在出入院表记录一下该患者状态（该科室没有模板，所以无法在子任务里生成任务，所以任务是失败是的，chect_flag=2）
//                        patMedInhosp1.setCheckFlag("2");
//                        patMedInhosp1.setLongTaskReason("无法匹配到该科室模板，该科室也无默认模板");
//                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//                        continue;
//                    }
//                } else {
//                    //为空的话，直接用科室的通用模板的任务ID，该患者直接往子任务表里插入，但不要执行，需要人工干（将不能执行的原因备注好）
//                    for (SvyTaskTemplate svyTaskTemplate1 : svyTaskTemplates) {
//                        //通过基础模板ID获取关联的疾病code
//                        Icd10Association icd10Association = new Icd10Association();
//                        icd10Association.setType(5L);
//                        icd10Association.setOutid(svyTaskTemplate1.getTemplateid());
//                        //找出该科室的通用模板
//                        List<Icd10Association> icd10Associations = icd10AssociationMapper.selectIcd10AssociationList(icd10Association);
//                        if (CollectionUtils.isEmpty(icd10Associations)) {
//                            stt = svyTaskTemplate1;
//                            //不配置发送时间
//                            remark = "患者入院疾病为空";
//                            //在出入院表记录一下该患者状态（该科室是有疾病为空的模板，所以可以在子任务里生成任务，所以任务是成功的，chect_flag=1）
//                            patMedInhosp1.setCheckFlag("1");
//                            patMedInhosp1.setLongTaskReason("患者入院疾病为空，已找到科室模板");
//                            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//                            continue;
//                        }
//                    }
//                    if (Objects.isNull(stt)) {
//                        //在出入院表记录一下该患者状态（该科室没有模板，所以无法在子任务里生成任务，所以任务是失败是的，chect_flag=2）
//                        patMedInhosp1.setCheckFlag("2");
//                        patMedInhosp1.setLongTaskReason("患者入院疾病为空，未找到科室模板");
//                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//                        continue;
//                    }
//                }
//            }
//
//            ServiceTask serviceTask = serviceTaskMapper.selectServiceTaskByTaskid(taskid);
//            ServiceSubtask serviceSubtask = DtoConversionUtils.sourceToTarget(serviceTask, ServiceSubtask.class);
//            serviceSubtask.setTaskid(serviceTask.getTaskid());
//            serviceSubtask.setLibtemplateid(stt.getTemplateid());
//            serviceSubtask.setNurseId(patMedInhosp1.getNurseId());
//            serviceSubtask.setNurseName(patMedInhosp1.getNurseName());
//            serviceSubtask.setDrcode(patMedInhosp1.getDrcode());
//            serviceSubtask.setDrname(patMedInhosp1.getDrname());
//            serviceSubtask.setDeptname(patMedInhosp1.getLeaveldeptname());
//            serviceSubtask.setTemplateid(stt.getId());
//            serviceSubtask.setTemplatename(stt.getSvyname());
//            serviceSubtask.setPatid(patArchive.getId());
//            serviceSubtask.setSendname(patArchive.getName());
//            serviceSubtask.setSfzh(patArchive.getIdcardno());
//            serviceSubtask.setPhone(patArchive.getTelcode());
//            serviceSubtask.setSex(patArchive.getSex());
//            serviceSubtask.setAge(patArchive.getAge());
//            serviceSubtask.setSendstate(2L);
//            serviceSubtask.setStarttime(patMedInhosp1.getStarttime());
//            serviceSubtask.setEndtime(patMedInhosp1.getEndtime());
//            serviceSubtask.setServiceType("2");
//            serviceSubtask.setPreachform(serviceTask.getPreachform());
//            serviceSubtask.setHospType("2");
//            serviceSubtask.setCreateTime(new Date());
//            serviceSubtask.setUpdateTime(new Date());
//            serviceSubtask.setCreateBy(patMedInhosp1.getNurseName());
//            serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getLeavehospitaldistrictcode());
//            serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());
//            //设置发送时间
//            Date newDate = addDays(patMedInhosp1.getEndtime(), stt.getSendDay());
//            serviceSubtask.setLongSendTime(newDate);
//            //患者发送时间
//            if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) {
//                remark = patArchive.getNotrequiredreason();
//                serviceSubtask.setRemark(remark);
//                serviceSubtask.setResult("error");
//                serviceSubtask.setFinishtime(new Date());
//                //不执行
//                serviceSubtask.setSendstate(4L);
//            }
//
//            //在新增之前，先通过患者ID，sendstate=2查询一下，在所有长期任务中，是不是还有该患者待执行的任务，有的话,比较之前的endtime是否小于当前的endtaime,如果之前的小于现在的，则直接将之前的停掉（原因再入院）
//            ServiceSubtaskVO subtask = new ServiceSubtaskVO();
//            subtask.setPatid(patArchive.getId());
//            subtask.setSendstate(2L);
//            List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
//            log.error("该患者待执行的任务:{}", selectServiceSubtaskList);
//            if (CollectionUtils.isNotEmpty(selectServiceSubtaskList) && selectServiceSubtaskList.size() > 0) {
//                for (ServiceSubtask serviceSubtask1 : selectServiceSubtaskList) {
//                    if (Objects.isNull(serviceSubtask1.getLongSendTime())) {
//                        //不是长期任务，不处理
//                        continue;
//                    }
//                    if (serviceSubtask1.getEndtime().before(serviceSubtask.getEndtime())) {
//                        //如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
//                        serviceSubtask1.setSendstate(4L);
//                        serviceSubtask1.setRemark("患者再入院");
//                        serviceSubtask1.setResult("error");
//                        serviceSubtask1.setFinishtime(new Date());
//                        serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
//                    } else {
//                        //相反,则将当有的数据停掉
//                        serviceSubtask.setResult("error");
//                        serviceSubtask.setFinishtime(new Date());
//                        serviceSubtask.setSendstate(4L);
//                        serviceSubtask.setRemark("患者再入院");
//                    }
//                }
//            }
//
//            serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
//            //将check_flag改成1（已处理）
//            PatMedInhosp patMedInhosp2 = new PatMedInhosp();
//            patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
//            patMedInhosp2.setCheckFlag("1");
//            patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
//        }
//
//        //获取未处理在院的数据(如果刚刚出院的患者数据的出院时间,在下面查询出的入院时间之前,那之前的出院患者的数据,也得停掉,因为又入院了)
//        patMedInhosp.setCheckFlag("0");
//        patMedInhosp.setInhospstate("0");
//        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
//        if (CollectionUtils.isNotEmpty(patMedInhospList) && patMedInhospList.size() > 0) {
//            for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
//                //获取当前入院患者的待执行的出院子任务随访信息
//                ServiceSubtaskVO subtask = new ServiceSubtaskVO();
//                subtask.setPatid(patMedInhosp1.getPatid());
//                subtask.setSendstate(2L);
//                List<ServiceSubtask> selectServiceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(subtask);
//                log.error("入院的患者待执行的任务:{}", selectServiceSubtaskList);
//                if (CollectionUtils.isNotEmpty(selectServiceSubtaskList) && selectServiceSubtaskList.size() > 0) {
//                    for (ServiceSubtask serviceSubtask1 : selectServiceSubtaskList) {
//                        if (Objects.isNull(serviceSubtask1.getLongSendTime())) {
//                            //不是长期任务，不处理
//                            continue;
//                        }
//                        if (serviceSubtask1.getEndtime().before(patMedInhosp1.getStarttime())) {
//                            //如果当前循环的子任务的出院时间在“准备新增的子任务”的出院时间之前，则将循环的子任务停掉
//                            serviceSubtask1.setSendstate(4L);
//                            serviceSubtask1.setRemark("患者再入院");
//                            serviceSubtask1.setResult("error");
//                            serviceSubtask1.setFinishtime(new Date());
//                            serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
//                        }
//                    }
//                }
//                //将患入的入院数据设置为已处理
//                patMedInhosp1.setCheckFlag("1");
//                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
//            }
//        }
//
//        return 1;
//    }

    /**
     * 获取出院，住院，门诊服务人次
     *
     * @param patMedReq
     * @return
     */
    @Override
    public List<PatMedRes> getDeptRanking(PatMedReq patMedReq) {

        return patMedInhospMapper.getDeptRanking(patMedReq);
    }

    @Override
    public List<PatMedInhosp> getDocAndPat(PatMedInhosp patMedInhosp) {
        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        if (StringUtils.isNotEmpty(patMedInhosp.getPatname()) || StringUtils.isNotEmpty(patMedInhosp.getNurseName()) || StringUtils.isNotEmpty(patMedInhosp.getDrname())) {
            //获取外部导入信息,并将外部患者放到patMedInhospList中
            PatArchiveImport patArchiveImport = new PatArchiveImport();
            if (StringUtils.isNotEmpty(patMedInhosp.getPatname())) {
                patArchiveImport.setName(patMedInhosp.getPatname());
            }
            if (StringUtils.isNotEmpty(patMedInhosp.getNurseName()))
                patArchiveImport.setCreateBy(patMedInhosp.getNurseName());
            if (StringUtils.isNotEmpty(patMedInhosp.getDrname()))
                patArchiveImport.setCreateBy(patMedInhosp.getDrname());
            List<PatArchiveImport> patArchiveImports = patArchiveImportMapper.selectPatArchiveImportList(patArchiveImport);
            if (CollectionUtils.isNotEmpty(patArchiveImports)) {
                for (PatArchiveImport patArchiveImport1 : patArchiveImports) {
                    PatMedInhosp patMedInhosp1 = new PatMedInhosp();
                    patMedInhosp1.setPatname(patArchiveImport1.getName());
                    patMedInhosp1.setSex(patArchiveImport1.getSex());
                    patMedInhosp1.setNurseName(patArchiveImport1.getCreateBy());
                    patMedInhosp1.setOutImport(1);
                    patMedInhosp1.setTelcode(patArchiveImport1.getTelcode());
                    patMedInhospList.add(patMedInhosp1);
                }
            }
        }

        return patMedInhospList;
    }

    private Date addDays(Date date, Integer days) {
        if (days == null) {
            days = 1;
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_MONTH, days);
        return calendar.getTime();
    }

}