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.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 IvrLibaTemplateMapper ivrLibaTemplateMapper;

    @Autowired
    private IvrTaskTemplateMapper ivrTaskTemplateMapper;

    @Autowired
    private Icd10AssociationMapper icd10AssociationMapper;

    @Autowired
    private SvyTaskTemplateMapper svyTaskTemplateMapper;

    @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);
    }


    @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;
            SvyTaskTemplate svyTaskTemplate = new SvyTaskTemplate();
            svyTaskTemplate.setDeptCode(patMedInhosp1.getLeaveldeptcode());
            svyTaskTemplate.setLongTemp(1);
            List<SvyTaskTemplate> svyTaskTemplates = svyTaskTemplateMapper.selectSvyTaskTemplateList(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.setTemplateid(stt.getId());
            serviceSubtask.setTemplatename(stt.getSvyname());
            serviceSubtask.setPatid(patArchive.getId());
            serviceSubtask.setSendname(patArchive.getName());
            serviceSubtask.setPhone(patArchive.getTelcode());
            serviceSubtask.setSex(patArchive.getSex());
            serviceSubtask.setAge(patArchive.getAge());
            serviceSubtask.setSendstate(2L);
            serviceSubtask.setServiceType("2");
            serviceSubtask.setServiceform(serviceTask.getPreachform());
            serviceSubtask.setHospType("2");
            //设置发送时间
            Date newDate = addDays(patMedInhosp1.getEndtime(), stt.getSendDay());
            serviceSubtask.setLongSendTime(newDate);
            //患者发送时间
            if (StringUtils.isNotEmpty(remark)) {
                serviceSubtask.setSendstate(4L);
                serviceSubtask.setRemark(remark);
                serviceSubtask.setResult("error");
                serviceSubtask.setFinishtime(new Date());
                //不执行
                serviceSubtask.setSendstate(4L);
            } else if (patArchive.getNotrequiredFlag().equals("4")) {
                //人不在了，或者其它原因，也不能随访
                serviceSubtask.setSendstate(4L);
                serviceSubtask.setRemark(patArchive.getNotrequiredreason());
                serviceSubtask.setResult("error");
                serviceSubtask.setFinishtime(new Date());
            }
            serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);
            //将check_flag改成1（已处理）
            PatMedInhosp patMedInhosp2 = new PatMedInhosp();
            patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
            patMedInhosp2.setCheckFlag("1");
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
        }
        return 1;
    }

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

        return patMedInhospMapper.getDeptRanking(patMedReq);
    }

    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();
    }

}