package com.smartor.service.impl;

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

import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.DtoConversionUtils;
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.stereotype.Service;
import com.smartor.service.IPatMedOperationService;

/**
 * 患者手术记录Service业务层处理
 *
 * @author lihu
 * @date 2025-02-21
 */
@Slf4j
@Service
public class PatMedOperationServiceImpl implements IPatMedOperationService {
    @Autowired
    private PatMedOperationMapper patMedOperationMapper;
    @Autowired
    private PatArchiveMapper patArchiveMapper;
    @Autowired
    private ServiceTaskoperMapper serviceTaskoperMapper;
    @Autowired
    private ServiceTaskMapper serviceTaskMapper;
    @Autowired
    private ServiceSubtaskMapper serviceSubtaskMapper;

    /**
     * 查询患者手术记录
     *
     * @param id 患者手术记录主键
     * @return 患者手术记录
     */
    @Override
    public PatMedOperation selectPatMedOperationById(Long id) {
        return patMedOperationMapper.selectPatMedOperationById(id);
    }

    /**
     * 查询患者手术记录列表
     *
     * @param patMedOperation 患者手术记录
     * @return 患者手术记录
     */
    @Override
    public List<PatMedOperation> selectPatMedOperationList(PatMedOperation patMedOperation) {
        return patMedOperationMapper.selectPatMedOperationList(patMedOperation);
    }

    /**
     * 新增患者手术记录
     *
     * @param patMedOperation 患者手术记录
     * @return 结果
     */
    @Override
    public int insertPatMedOperation(PatMedOperation patMedOperation) {
        patMedOperation.setCreateTime(DateUtils.getNowDate());
        return patMedOperationMapper.insertPatMedOperation(patMedOperation);
    }

    /**
     * 修改患者手术记录
     *
     * @param patMedOperation 患者手术记录
     * @return 结果
     */
    @Override
    public int updatePatMedOperation(PatMedOperation patMedOperation) {
        patMedOperation.setUpdateTime(DateUtils.getNowDate());
        return patMedOperationMapper.updatePatMedOperation(patMedOperation);
    }

    /**
     * 批量删除患者手术记录
     *
     * @param ids 需要删除的患者手术记录主键
     * @return 结果
     */
    @Override
    public int deletePatMedOperationByIds(Long[] ids) {
        return patMedOperationMapper.deletePatMedOperationByIds(ids);
    }

    /**
     * 删除患者手术记录信息
     *
     * @param id 患者手术记录主键
     * @return 结果
     */
    @Override
    public int deletePatMedOperationById(Long id) {
        return patMedOperationMapper.deletePatMedOperationById(id);
    }

    @Override
    public int dealOperationInfo() {
        PatMedOperation patMedOperation = new PatMedOperation();
        //获取需要出院随访，未处理的数据
        patMedOperation.setCheckFlag("0");
        List<PatMedOperation> patMedOperations = patMedOperationMapper.selectPatMedOperationList(patMedOperation);
        log.error("dealOperationInfo需要处理的手术信息：{}", patMedOperations);

        for (PatMedOperation patMedOperation1 : patMedOperations) {
            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedOperation1.getPatid());
            try {
                //根据患者所在科室，获取该手术编码对应的长期任务
                ServiceTaskoper serviceTaskoper = new ServiceTaskoper();
                serviceTaskoper.setLongtask(1L);
                serviceTaskoper.setOpcode(patMedOperation1.getOpcode());
                List<ServiceTaskoper> serviceTaskopers = serviceTaskoperMapper.selectServiceTaskoperList(serviceTaskoper);
                //如果部门模板为空（暂定，将出入院表的check_flag设置为2  ，long_task_reason 记录原因）
                if (CollectionUtils.isEmpty(serviceTaskopers) || serviceTaskopers.size() == 0) {
                    patMedOperation1.setCheckFlag("2");
                    patMedOperation1.setLongTaskReason("该手术编码，未配置长期任务;");
                    patMedOperationMapper.updatePatMedOperation(patMedOperation1);
                    continue;
                } else if (serviceTaskopers.size() > 1) {
                    //如果查询出多个任务，那就取第一个，并在患者备注一下
                    List<Long> taskIds = serviceTaskopers.stream().map(ServiceTaskoper::getTaskId).collect(Collectors.toList());
                    patMedOperation1.setLongTaskReason("该手术编码，有多个随访长期任务:" + taskIds);
                    patMedOperationMapper.updatePatMedOperation(patMedOperation1);
                    ServiceTaskoper serviceTaskoper1 = serviceTaskopers.get(0);
                    serviceTaskopers = new ArrayList<>();
                    serviceTaskopers.add(serviceTaskoper1);
                }

                writeInSubTask(serviceTaskopers.get(0).getTaskId(), true, patMedOperation1, patArchive);

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员处理出异常了：{}", e.getMessage());
            }
        }

        return 1;
    }

    //将患者放到subtask中
    private void writeInSubTask(Long taskid, Boolean check, PatMedOperation patMedOperation1, PatArchive patArchive) {
        String longTaskReason = patMedOperation1.getLongTaskReason();
        if (StringUtils.isEmpty(longTaskReason)) longTaskReason = "";
//            Long taskid = std.getTaskId();
        ServiceTask st = new ServiceTask();
        st.setTaskid(taskid);
        st.setSendState(2L);
        List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);
        if (CollectionUtils.isEmpty(serviceTasks)) {
            log.error("该手术编码长期任务不存在,任务ID为：{}", taskid);
            patMedOperation1.setCheckFlag("2");
            patMedOperation1.setLongTaskReason(longTaskReason + " & 该手术编码长期任务不存在,任务ID为:" + taskid);
            patMedOperationMapper.updatePatMedOperation(patMedOperation1);
            return;
        }
        ServiceTask serviceTask = serviceTasks.get(0);

        //封装serviceSubtask
        ServiceSubtask serviceSubtask = boxedServiceSubtask(serviceTask, patMedOperation1, patArchive);
        int i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtask);

        if (i == 1) {
            //将check_flag改成1（已处理）
            PatMedOperation patMedOperation = new PatMedOperation();
            patMedOperation.setId(patMedOperation1.getId());
            patMedOperation.setCheckFlag("1");
            patMedOperationMapper.updatePatMedOperation(patMedOperation);
        } else {
            //生成子任务失败，
            log.error("生成子任务失败serviceSubtask为：{}", serviceSubtask);
            PatMedOperation patMedOperation = new PatMedOperation();
            patMedOperation.setId(patMedOperation1.getId());
            patMedOperation.setRemark("生成子任务失败");
            patMedOperationMapper.updatePatMedOperation(patMedOperation);
        }
    }

    //封装serviceSubtask
    private ServiceSubtask boxedServiceSubtask(ServiceTask serviceTask, PatMedOperation patMedOperation1, PatArchive patArchive) {
        ServiceSubtask serviceSubtask = DtoConversionUtils.sourceToTarget(serviceTask, ServiceSubtask.class);
        serviceSubtask.setTaskid(serviceTask.getTaskid());
        if (StringUtils.isNotEmpty(serviceTask.getLibtemplateid()))
            serviceSubtask.setLibtemplateid(Long.valueOf(serviceTask.getLibtemplateid()));
        serviceSubtask.setNurseId(patMedOperation1.getNurseId());
        serviceSubtask.setNurseName(patMedOperation1.getNurseName());
//        serviceSubtask.setInhospid(patMedOperation1.getInhospid());
        serviceSubtask.setDrcode(patMedOperation1.getDrcode());
        serviceSubtask.setDrname(patMedOperation1.getDrname());
        serviceSubtask.setDeptcode(patMedOperation1.getDeptcode());
        serviceSubtask.setDeptname(patMedOperation1.getDeptname());
        serviceSubtask.setTemplateid(serviceTask.getTemplateid());
        serviceSubtask.setTemplatename(serviceTask.getTemplatename());
        serviceSubtask.setPatid(patArchive.getId());
        serviceSubtask.setSendname(patArchive.getName());
        serviceSubtask.setSfzh(patArchive.getIdcardno());
        serviceSubtask.setPhone(patArchive.getTelcode());
        if (StringUtils.isBlank(patArchive.getTelcode())) serviceSubtask.setPhone(patArchive.getRelativetelcode());
        serviceSubtask.setSex(patArchive.getSex());
        serviceSubtask.setAge(patArchive.getAge());
        serviceSubtask.setSendstate(2L);
        serviceSubtask.setStarttime(patMedOperation1.getOpreqtime());
        serviceSubtask.setEndtime(patMedOperation1.getOpreqtime());
        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());
        //设置发送时间
        if (serviceTask.getSendDay() == null) serviceTask.setSendDay(1L);
        Date newDate = addDays(patMedOperation1.getOpreqtime(), serviceTask.getSendDay().intValue());
        serviceSubtask.setLongSendTime(newDate);
        //患者发送时间
        if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) {
            String remark = patArchive.getNotrequiredreason();
            serviceSubtask.setRemark(remark);
            serviceSubtask.setResult("error");
            serviceSubtask.setFinishtime(new Date());
            log.error("serviceSubtask888888的值为：{}",serviceSubtask);
            //不执行
            serviceSubtask.setSendstate(4L);
        }
        return serviceSubtask;
    }

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