package com.ruoyi.web.controller.smartor;

import com.alibaba.fastjson.JSON;
import com.github.pagehelper.ISelect;
import com.ruoyi.common.annotation.AddOrgId;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.HttpStatus;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.entity.SysUserDept;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.enums.PreachFormEnum;
import com.ruoyi.common.enums.SendStateEnum;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.*;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.common.utils.reflect.ReflectUtils;
import com.ruoyi.quartz.service.ICollectHISService;
import com.ruoyi.quartz.task.RyTask;
import com.ruoyi.system.service.ISysConfigService;
import com.ruoyi.system.service.ISysUserDeptService;
import com.ruoyi.satisfaction.api.SatisfactionExportBundle;
import com.ruoyi.satisfaction.api.SatisfactionFacade;
import com.smartor.domain.*;
import com.smartor.domain.VO.*;
import com.smartor.domain.entity.ServiceSubtaskEntity;
import com.smartor.service.IServiceSubtaskRecordService;
import com.smartor.service.IServiceSubtaskService;
import com.smartor.service.IServiceTaskService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.time.LocalDate;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import com.ruoyi.template.domain.VO.HeLibraryCountVO;
import static com.ruoyi.common.utils.SecurityUtils.getLoginUser;

/**
 * 单一任务（随访）Controller
 *
 * @author ruoyi
 * @date 2024-02-02
 */
@Slf4j
@Api(description = "单一任务（随访宣教）")
@RestController
@RequestMapping("/smartor/serviceSubtask")
public class ServiceSubtaskController extends BaseController {
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        binder.setAutoGrowCollectionLimit(1024); // 或 2048、4096 等
    }

    @Autowired
    private IServiceSubtaskService serviceSubtaskService;

    /**
     * 满意度模块对外门面（常驻 Bean）。
     * <p>
     * 满意度相关数据（问题详情占比）只能通过它获取；满意度模块关闭时
     * 门面返回空结果并打 WARN，<b>不会</b>影响随访导出的其它内容。
     */
    @Autowired
    private SatisfactionFacade satisfactionFacade;

    @Autowired
    private IServiceTaskService serviceTaskService;

    @Autowired
    private ISysUserDeptService sysUserDeptService;

    @Autowired
    private IServiceSubtaskRecordService serviceSubtaskRecordService;

    @Autowired
    private ISysConfigService configService;

    @Autowired
    private RyTask ryTask;

    @Autowired
    private ICollectHISService collectHISService;

    @Value("${spring.profiles.active}")
    private String active;

    @Value("${localIP}")
    private String localIP;

    @Value("${req_path}")
    private String req_path;

    @Value("${isAdmin}")
    private List<Long> isAdmin;

    @Autowired
    private RedisCache redisCache;


    /**
     * 转移科室病区
     */
    @ApiOperation("转移科室病区")
    @PostMapping("/transferDept")
    public Map<String, Object> transferDept(@RequestBody TransferDeptVO transferDeptVO) {
        Integer i = serviceSubtaskService.transferDept(transferDeptVO);
        return success(i == 1 ? true : false);
    }


    /**
     * 查询患者随访信息
     */
    @ApiOperation("查询患者随访信息")
    @PostMapping("/patItem")
    public Map<String, Object> patItem(@RequestBody ServiceSubtaskVO serviceSubtaskVO) {
        serviceSubtaskVO.setPageNum(PageUtils.getOffset(serviceSubtaskVO.getPageNum(), serviceSubtaskVO.getPageSize()));
        List<ServiceSubtaskRes> serviceSubtaskList = null;
        LoginUser loginUser = getLoginUser();
        SysUser user = loginUser.getUser();
        serviceSubtaskVO.setOrgid(user.getOrgid());
        serviceSubtaskVO.setCampusid(user.getCampusid());
        ServiceSubtaskEntity serviceSubtaskEntity = null;
        if (serviceSubtaskVO != null) {
            serviceSubtaskEntity = DtoConversionUtils.sourceToTarget(serviceSubtaskVO, ServiceSubtaskEntity.class);
            serviceSubtaskEntity.setContinueContent(ObjectUtils.isNotEmpty(serviceSubtaskVO.getContinueContent()) ? serviceSubtaskVO.getContinueContent().toString() : null);
            serviceSubtaskList = serviceSubtaskService.patItem(serviceSubtaskEntity);
        }

        // 批量查 subtask_record，1次SQL替代循环中N次单独查
        List<Long> subtaskIds = serviceSubtaskList.stream().map(ServiceSubtaskRes::getId).filter(ObjectUtils::isNotEmpty).collect(Collectors.toList());
        Map<Long, List<ServiceSubtaskRecord>> recordMap = serviceSubtaskRecordService.selectRecordMapBySubtaskIds(subtaskIds);

        for (ServiceSubtaskRes serviceSubtask : serviceSubtaskList) {
            serviceSubtask.setServiceSubtaskRecordList(recordMap.getOrDefault(serviceSubtask.getId(), new ArrayList<>()));
        }

//      patItemCount 走Redis缓存版，避免每次全表聚合扫描
        Map<String, Object> map = getPatItemCountWithCache(serviceSubtaskEntity);
        map.put("serviceSubtaskList", serviceSubtaskList);
        List<Map<String, Object>> list = new ArrayList<>();
        list.add(map);

        // 直接从已有聚合结果推算total，避免去掉分页后再全量查一遍大表
        long total = 0L;
        try {
            total = map.get("total") != null ? ((Number) map.get("total")).longValue() : 0L;

        } catch (Exception e) {
            // 兜底：全量count
            serviceSubtaskEntity.setPageNum(null);
            serviceSubtaskEntity.setPageSize(null);
            List<ServiceSubtask> serviceSubtasks = serviceSubtaskService.selectServiceSubtaskList(serviceSubtaskEntity);
            total = CollectionUtils.isNotEmpty(serviceSubtasks) ? serviceSubtasks.size() : 0L;
        }

        return getDataTable3(total, list);
    }

    /**
     * 统计随访数据 -- cache版
     */
    @ApiOperation("统计随访数据")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/patItemCount")
    public Map<String, Object> patItemCount(@RequestBody ServiceSubtaskVO serviceSubtaskVO) {
        Map<String, Object> map = new HashMap<>();

        ServiceSubtaskEntity serviceSubtaskEntity = DtoConversionUtils.sourceToTarget(serviceSubtaskVO, ServiceSubtaskEntity.class);
        serviceSubtaskEntity.setContinueContent(ObjectUtils.isNotEmpty(serviceSubtaskVO.getContinueContent()) ? serviceSubtaskVO.getContinueContent().toString() : null);

        LoginUser loginUser = getLoginUser();
        Long userId = null;
        if (ObjectUtils.isNotEmpty(loginUser) && ObjectUtils.isNotEmpty(loginUser.getUser())) {
            userId = loginUser.getUser().getUserId();
        }
        if (ObjectUtils.isNotEmpty(userId)) {
            map = getPatItemCountWithCache(serviceSubtaskEntity);
        }

        map.put("code", HttpStatus.SUCCESS);
        return map;
    }

    /**
     * 导出单一任务列表
     */
    //@PreAuthorize("@ss.hasPermi('system:taskcall:export')")
    @Log(title = "单一任务", businessType = BusinessType.EXPORT)
    @PostMapping("/patItemExport")
    public void patItemExport(HttpServletResponse response, ServiceSubtaskVO serviceSubtaskVO) {
        LoginUser loginUser = getLoginUser();
        SysUser user = loginUser.getUser();
        serviceSubtaskVO.setOrgid(user.getOrgid());
        //与 /patItem 查询保持完全一致的机构+院区范围：
        //导出原先只设置 orgid，缺少 campusid，SQL 里就不会拼 and campusid = ?，
        //导致导出的数据包含其它院区的患者，出现“查询与导出数据不一致”
        serviceSubtaskVO.setCampusid(user.getCampusid());
        List<ServiceSubtaskRes> serviceSubtaskList = null;
        if (serviceSubtaskVO != null) {
           ServiceSubtaskEntity serviceSubtaskEntity = DtoConversionUtils.sourceToTarget(serviceSubtaskVO, ServiceSubtaskEntity.class);
            serviceSubtaskList = serviceSubtaskService.patItem(serviceSubtaskEntity);
        }
        List<ServiceSubtaskExport> serviceSubtaskExports = null;
        //满意度占比导出包：默认空包（没有可导出的患者时保持为空），有数据时由满意度门面填充
        SatisfactionExportBundle ratioBundle = SatisfactionExportBundle.empty();
        if (!CollectionUtils.isEmpty(serviceSubtaskList)) {
            serviceSubtaskExports = DtoConversionUtils.sourceToTarget(serviceSubtaskList, ServiceSubtaskExport.class);
            for (ServiceSubtaskExport serviceSubtaskExport : serviceSubtaskExports) {
                String pf = PreachFormEnum.getDescByCode(serviceSubtaskExport.getPreachform());
                serviceSubtaskExport.setPreachform(pf);
                if (serviceSubtaskExport.getSendstate() != null) {
                    String stName = SendStateEnum.getDescByCode("" + serviceSubtaskExport.getSendstate());
                    serviceSubtaskExport.setStName(stName);
                }

                //计算出院天数
                if (!Objects.isNull(serviceSubtaskExport.getEndtime())) {
                    Integer endDay = DateUtils.differentDaysByMillisecond(serviceSubtaskExport.getEndtime(), new Date());
                    serviceSubtaskExport.setEndDay(endDay);
                }
            }
            //问题详情占比：只统计本次导出的这批患者，数量=选该选项的患者数，比例=占该题作答人数
            //满意度模块化后：只通过满意度模块暴露的 api 包取数（导出包 = 行 + 行类型 + 图表构建器）；
            //模块关闭（satisfaction.enabled=false）时门面返回空导出包，导出照常完成（只是没有占比 Sheet）。
            List<Long> subtaskIds = new ArrayList<>();
            for (ServiceSubtaskRes serviceSubtaskRes : serviceSubtaskList) {
                if (serviceSubtaskRes.getId() != null) {
                    subtaskIds.add(serviceSubtaskRes.getId());
                }
            }
            ratioBundle = satisfactionFacade.getQuestionOptionRatioExport(subtaskIds, null);
        }


        ExcelUtil<ServiceSubtaskExport> util = new ExcelUtil<ServiceSubtaskExport>(ServiceSubtaskExport.class);
        //第三个Sheet：问题详情占比图表（按任务名称分组，一个任务一张柱状图）
        util.exportExcelTwoSheetWithChart(response, serviceSubtaskExports, "患者随访信息表单",
                ratioBundle.getRows(), "问题详情占比", ratioBundle.getRowClass(),
                ratioBundle.getChartBuilder());
    }

    /**
     * 查询患者随访信息
     */
    @ApiOperation("查询患者随访信息")
    //@PreAuthorize("@ss.hasPermi('system:taskcall:list')")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/patItemByCondition")
    public Map<String, Object> patItemByCondition(@RequestBody ServiceSubtaskVO serviceSubtaskVO) {
        List<ServiceSubtask> serviceSubtaskList = null;
        ServiceSubtaskEntity serviceSubtaskEntity = DtoConversionUtils.sourceToTarget(serviceSubtaskVO, ServiceSubtaskEntity.class);
        serviceSubtaskEntity.setContinueContent(ObjectUtils.isNotEmpty(serviceSubtaskVO.getContinueContent()) ? serviceSubtaskVO.getContinueContent().toString() : null);
        if (serviceSubtaskEntity != null) {
            serviceSubtaskEntity.setPageNum(PageUtils.getOffset(serviceSubtaskEntity.getPageNum(), serviceSubtaskEntity.getPageSize()));
            serviceSubtaskList = serviceSubtaskService.patItem2(serviceSubtaskEntity);
        }
        for (ServiceSubtask serviceSubtask : serviceSubtaskList) {
            ServiceSubtaskRecord serviceSubtaskRecord = new ServiceSubtaskRecord();
            serviceSubtaskRecord.setSubtaskId(serviceSubtask.getId());
            serviceSubtaskRecord.setTaskid(serviceSubtask.getTaskid().toString());
            serviceSubtask.setServiceSubtaskRecordList(serviceSubtaskRecordService.selectServiceSubtaskRecordList(serviceSubtaskRecord));
        }
//      patItemCount 调用redisCache记录统计数据
//      Map<String, Object> map = patItemCount(serviceSubtaskVO);
        Map<String, Object> map = serviceSubtaskService.patItemCount(serviceSubtaskEntity);

        map.put("serviceSubtaskList", serviceSubtaskList);
        List<Map<String, Object>> list = new ArrayList<>();
        list.add(map);
        //获取total
        long total = PageUtils.count(new ISelect() {
            @Override
            public void doSelect() {
                serviceSubtaskVO.setPageNum(null);
                serviceSubtaskVO.setPageSize(null);
                serviceSubtaskService.patItem2(serviceSubtaskEntity);
            }
        });
        return getDataTable3(total, list);
    }

    /**
     * 导出单一任务（随访宣教）列表
     */
    //@PreAuthorize("@ss.hasPermi('system:taskcall:export')")
    @Log(title = "单一任务（随访宣教）", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, ServiceSubtask serviceSubtask) {
        ServiceSubtaskEntity serviceSubtaskVO = DtoConversionUtils.sourceToTarget(serviceSubtask, ServiceSubtaskEntity.class);
        List<ServiceSubtask> list = serviceSubtaskService.selectServiceSubtaskList(serviceSubtaskVO);
        ExcelUtil<ServiceSubtask> util = new ExcelUtil<ServiceSubtask>(ServiceSubtask.class);
        util.exportExcel(response, list, "单一任务（随访）数据");
    }

    /**
     * 随访数据查询
     */
    @Log(title = "随访数据查询", businessType = BusinessType.EXPORT)
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/querySubtaskList")
    public AjaxResult querySubtaskList(@RequestBody ServiceSubtaskVO serviceSubtaskVO) {
        ServiceSubtaskEntity serviceSubtaskEntity = DtoConversionUtils.sourceToTarget(serviceSubtaskVO, ServiceSubtaskEntity.class);
        serviceSubtaskEntity.setContinueContent(ObjectUtils.isNotEmpty(serviceSubtaskVO.getContinueContent()) ? serviceSubtaskVO.getContinueContent().toString() : null);
        PageUtils.startPageByPost(serviceSubtaskEntity.getPageNum(), serviceSubtaskEntity.getPageSize());
        serviceSubtaskService.selectServiceSubtaskList(serviceSubtaskEntity);
        return success(serviceSubtaskService.selectServiceSubtaskList(serviceSubtaskEntity));
    }


    /**
     * 再次随访数据查询
     */
    //@PreAuthorize("@ss.hasPermi('system:taskcall:export')")
    @Log(title = "再次随访数据查询", businessType = BusinessType.EXPORT)
    @PostMapping("/querySubtaskListAgain")
    public TableDataInfo querySubtaskListAgain(@RequestBody ServiceSubtaskVO serviceSubtaskVO) {
        ServiceSubtaskEntity serviceSubtaskEntity = DtoConversionUtils.sourceToTarget(serviceSubtaskVO, ServiceSubtaskEntity.class);
        serviceSubtaskEntity.setContinueContent(ObjectUtils.isNotEmpty(serviceSubtaskVO.getContinueContent()) ? serviceSubtaskVO.getContinueContent().toString() : null);
        PageUtils.startPageByPost(serviceSubtaskEntity.getPageNum(), serviceSubtaskEntity.getPageSize());
        serviceSubtaskService.selectServiceSubtaskListAgain(serviceSubtaskEntity);
        return getDataTable(serviceSubtaskService.selectServiceSubtaskListAgain(serviceSubtaskEntity));
    }


    /**
     * 获取单一任务（随访）详细信息
     */
    //@PreAuthorize("@ss.hasPermi('system:taskcall:query')")
    @GetMapping(value = "/getInfo/{id}")
    public AjaxResult getInfo(@PathVariable("id") Long id) {
        return success(serviceSubtaskService.selectServiceSubtaskById(id));
    }

    /**
     * 根据疾病模糊查询
     */
    //@PreAuthorize("@ss.hasPermi('system:taskcall:query')")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping(value = "/getSubtaskByDiagname")
    public Map<String, Object> getSubtaskByDiagname(@RequestBody ServiceSubtask serviceSubtask) {
        LoginUser loginUser = getLoginUser();
        SysUser user = loginUser.getUser();
        serviceSubtask.setOrgid(user.getOrgid());
        serviceSubtask.setPageNum(PageUtils.getOffset(serviceSubtask.getPageNum(), serviceSubtask.getPageSize()));
        List<ServiceSubtask> serviceSubtaskList = serviceSubtaskService.selectServiceSubtaskByDiagname(serviceSubtask);
        Map<String, Object> rspData = new HashMap();
        rspData.put("code", HttpStatus.SUCCESS);
        rspData.put("msg", "查询成功");
        rspData.put("rows", serviceSubtaskList);

        serviceSubtask.setPageNum(null);
        serviceSubtask.setPageSize(null);
        List<ServiceSubtask> total = serviceSubtaskService.selectServiceSubtaskByDiagname(serviceSubtask);
        if (CollectionUtils.isNotEmpty(total)) rspData.put("total", total.size());
        else rspData.put("total", 0);
        return rspData;
    }


    /**
     * 随访历史记录导出
     */
    @Log(title = "随访历史记录导出", businessType = BusinessType.EXPORT)
    //第 0 个参数是 HttpServletResponse，注解取到它等于没生效（orgid/campusid 都没注入），
    //所以这里要用 paramIndex = 1 指向 ServiceSubtask，与查询接口 /getSubtaskByDiagname 保持同一范围
    @AddOrgId(field = "orgid", paramIndex = 1, campusField = "campusid")
    @PostMapping("/getSubtaskByDiagnameExport")
    public void getSubtaskByDiagnameExport(HttpServletResponse response, ServiceSubtask serviceSubtask) {
        LoginUser loginUser = getLoginUser();
        SysUser user = loginUser.getUser();
        serviceSubtask.setOrgid(user.getOrgid());
        serviceSubtask.setPageNum(PageUtils.getOffset(serviceSubtask.getPageNum(), serviceSubtask.getPageSize()));
        List<ServiceSubtask> subtaskList = serviceSubtaskService.selectServiceSubtaskByDiagname(serviceSubtask);
        List<ServiceSubtaskDiagname> serviceSubtaskDiagnameList = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(subtaskList))
            serviceSubtaskDiagnameList = serviceSubtaskService.convertToDiagnameList(subtaskList);
        ExcelUtil<ServiceSubtaskDiagname> util = new ExcelUtil<ServiceSubtaskDiagname>(ServiceSubtaskDiagname.class);

        if (active.equals("ls") || active.equals("druid")) {
            util.exportExcel(response, serviceSubtaskDiagnameList, LocalDate.now().getMonthValue() + "随访历史记录导出");
        } else {
            util.exportExcel(response, serviceSubtaskDiagnameList, "随访历史记录导出");
        }
    }

    /**
     * 新增或修改删除单一任务
     */
    @ApiOperation("新增或修改删除单一任务")
    //@PreAuthorize("@ss.hasPermi('system:task:add')")
    @Log(title = "单一任务（随访）", businessType = BusinessType.INSERT)
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/insertOrUpdateTask")
    public AjaxResult insertOrUpdateHeTask(@RequestBody ServiceTaskVO ivrTaskVO) {
        log.info("insertOrUpdateHeTask的入参为：{}", ivrTaskVO);
        LoginUser loginUser = getLoginUser();
        SysUser user = loginUser.getUser();
        ivrTaskVO.setCreateBy(user.getNickName());
        ivrTaskVO.setUpdateBy(user.getNickName());
        ivrTaskVO.setOrgid(user.getOrgid());
        if(StringUtils.isNotEmpty(user.getCampusid())){
            ivrTaskVO.setCampusid(user.getCampusid());
        }else {
            ivrTaskVO.setCampusid("1");
        }
        return success(serviceSubtaskService.insertOrUpdateTask(ivrTaskVO));
    }

    @ApiOperation("修改子任务")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/update")
    public AjaxResult update(@RequestBody ServiceSubtask serviceSubtask) {
        serviceSubtask.setUpdateBy(getLoginUser().getUser().getNickName());
        return toAjax(serviceSubtaskService.updateServiceSubtask(serviceSubtask));
    }

    @ApiOperation("修改子任务模板")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/updateTemplate")
    public AjaxResult updateTemplate(@RequestBody ServiceSubtaskTemplateVO serviceSubtaskTemplateVO) {
        serviceSubtaskTemplateVO.setUpdateBy(getLoginUser().getUser().getNickName());
        return toAjax(serviceSubtaskService.updateTemplate(serviceSubtaskTemplateVO));
    }

    @ApiOperation("新增子任务")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/addSubTask")
    public AjaxResult addSubTask(@RequestBody ServiceSubtask serviceSubtask) {
        SysUser user = getLoginUser().getUser();
        if (ObjectUtils.isNotEmpty(user)) serviceSubtask.setOrgid(user.getOrgid());
        if (ObjectUtils.isNotEmpty(user)) serviceSubtask.setCampusid(user.getCampusid());
        serviceSubtask.setCampusid(user.getCampusid());
        serviceSubtask.setCreateBy(user.getNickName());
        serviceSubtask.setUpdateBy(user.getNickName());
        return success(serviceSubtaskService.insertServiceSubtask(serviceSubtask));
    }

    @ApiOperation("患者再次随访")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/addSubTaskAgain")
    public AjaxResult addSubTaskAgain(@RequestBody ServiceSubtask serviceSubtask) {
        SysUser user = getLoginUser().getUser();
        if (ObjectUtils.isNotEmpty(user)) serviceSubtask.setOrgid(user.getOrgid());
        if (ObjectUtils.isNotEmpty(user)) serviceSubtask.setCampusid(user.getCampusid());
        return success(serviceSubtaskService.addSubTaskAgain(serviceSubtask));
    }

    /**
     * 根据条件查询任务信息
     */
    @ApiOperation("根据条件查询任务信息")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/queryTaskByCondition")
    public AjaxResult queryTaskByCondition(@RequestBody ServiceSubtaskVO serviceSubtaskVO) {
        //根据入参查询信息
        ServiceSubtask serviceSubtask = DtoConversionUtils.sourceToTarget(serviceSubtaskVO, ServiceSubtask.class);
        serviceSubtask.setContinueContent(ObjectUtils.isNotEmpty(serviceSubtaskVO.getContinueContent()) ? serviceSubtaskVO.getContinueContent().toString() : null);
        ServiceTaskVO ivrTaskVO = serviceSubtaskService.queryTaskByCondition(serviceSubtask);
        return success(ivrTaskVO);
    }

    /**
     * 电话回调任务(上海)
     */
    @ApiOperation("电话回调任务")
    @PostMapping("/phoneCallBack")
    public AjaxResult phoneCallBack(@RequestBody PhoneCallBackVO phoneCallBackVO) {
        serviceSubtaskService.phoneCallBack(phoneCallBackVO);
        return success();
    }

    @ApiOperation("电话ASR通话回调(雨绮)")
    @PostMapping("/phoneCallBackYQ")
    public PhoneCallBackYQVO phoneCallBackYQ(@RequestBody PhoneCallReqYQVO phoneCallReqYQVO) {
        log.info("电话ASR通话回调(雨绮) ？{}", phoneCallReqYQVO);
        PhoneCallBackYQVO phoneCallBackYQVO = serviceSubtaskService.phoneCallBackYQ(phoneCallReqYQVO);
        return phoneCallBackYQVO;
    }

    /**
     * 电话任务拉取(雨绮)
     */
    @ApiOperation("电话任务拉取(雨绮)")
    @PostMapping("/taskPull")
    public List<PullTaskVO> taskPull() {
        log.info("电话任务拉取(雨绮)");
        List<PullTaskVO> pullTaskVOList = serviceSubtaskService.taskPull();
        log.info("电话任务拉取数据(雨绮):{}", pullTaskVOList);
        return pullTaskVOList;
    }

    /**
     * 患者问题结果记录
     */
    @ApiOperation("患者问题结果记录（电话）")
    @PostMapping("/saveQuestionAnswerPhone")
    public AjaxResult saveQuestionAnswerPhone(@RequestBody ServiceSubTaskDetailReq serviceSubTaskDetailReq) {
//        SysUser user = getLoginUser().getUser();
//        serviceSubTaskDetailReq.setOrgid(user.getOrgid());
        log.info("患者问题结果记录(电话):{}", serviceSubTaskDetailReq);
        return toAjax(serviceSubtaskService.saveQuestionAnswerPhone(serviceSubTaskDetailReq));
    }

    /**
     * 通话记录回调
     */
    @ApiOperation("通话记录回调(上海)")
    @PostMapping("/recordAcceptshanghai")
    public AjaxResult recordAccepshanghait(@RequestBody ServiceSubTaskDetailReq serviceSubTaskDetailReq) {
        log.info("通话记录回调(上海):{}", serviceSubTaskDetailReq);
        return toAjax(serviceSubtaskService.saveQuestionAnswerPhone(serviceSubTaskDetailReq));
    }

    /**
     * 通话记录回调
     */
    @ApiOperation("通话记录回调(雨绮)")
    @PostMapping("/recordAccept")
    public AjaxResult recordAccept(@RequestBody PhoneCallRecordVO phoneCallRecordVO) {
        log.info("通话记录回调(雨绮):{}", phoneCallRecordVO);
        serviceSubtaskService.recordAccept(phoneCallRecordVO);
        return success();
    }

    /**
     * 获取每个月的随访、复诊量
     */
    @ApiOperation("获取每个月的随访、复诊量")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getSfFzInfoEveryMonth")
    public TableDataInfo getSfFzInfoEveryMonth(@RequestBody ServiceSubtaskCountReq serviceSubtaskCountReq) {
        return getDataTable(serviceSubtaskService.getSfFzInfoEveryMonth(serviceSubtaskCountReq));
    }

    /**
     * 获取随访统计比例
     */
    @ApiOperation("获取随访统计比例")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getSfStatistics")
    public Map<String, Object> getSfStatistics(@RequestBody ServiceSubtaskCountReq serviceSubtaskCountReq) {
        if (CollectionUtils.isEmpty(serviceSubtaskCountReq.getServiceType())) {
            return error("服务类型不能为空");
        }
        Integer offset = PageUtils.getOffset(serviceSubtaskCountReq.getPageNum(), serviceSubtaskCountReq.getPageSize());
        serviceSubtaskCountReq.setPageNum(offset);

        Integer statisticaltype = serviceSubtaskCountReq.getStatisticaltype();

        if (ObjectUtils.isNotEmpty(statisticaltype)) {
            SysUser user = getLoginUser().getUser();
            if (!isAdmin.contains(user.getUserId())) {
                if (statisticaltype == 1) {
                    if (CollectionUtils.isEmpty(serviceSubtaskCountReq.getLeavehospitaldistrictcodes())) {
                        //全部病区
                        List<String> leavehospitaldistrictcodes = null;
                        SysUserDept sysUserWard = new SysUserDept();
                        sysUserWard.setUserId(user.getUserId());
                        sysUserWard.setOrgid(user.getOrgid());
                        sysUserWard.setCampusid(user.getCampusid());
                        sysUserWard.setDeptType("2");
                        List<SysUserDept> wardList = sysUserDeptService.selectSysUserDeptList(sysUserWard);
                        if (CollectionUtils.isNotEmpty(wardList)) {
                            leavehospitaldistrictcodes = wardList.stream().map(SysUserDept::getDeptCode).collect(Collectors.toList());
                        }
                        serviceSubtaskCountReq.setLeavehospitaldistrictcodes(leavehospitaldistrictcodes);
                    }
                } else if (statisticaltype == 2) {
                    if (CollectionUtils.isEmpty(serviceSubtaskCountReq.getDeptcodes())) {
                        //全部科室
                        List<String> deptCodes = null;
                        SysUserDept sysUserDept = new SysUserDept();
                        sysUserDept.setUserId(user.getUserId());
                        sysUserDept.setOrgid(user.getOrgid());
                        sysUserDept.setCampusid(user.getCampusid());
                        sysUserDept.setDeptType("1");
                        List<SysUserDept> deptList = sysUserDeptService.selectSysUserDeptList(sysUserDept);
                        if (CollectionUtils.isNotEmpty(deptList)) {
                            deptCodes = deptList.stream().map(SysUserDept::getDeptCode).collect(Collectors.toList());
                        }
                        serviceSubtaskCountReq.setDeptcodes(deptCodes);
                    }
                }
            }
        }

        String followUpCountStyle = configService.selectConfigByKey("followUpCountStyle", serviceSubtaskCountReq.getOrgid());
        if (ObjectUtils.isNotEmpty(followUpCountStyle)) {
            serviceSubtaskCountReq.setFollowUpCountStyle(followUpCountStyle);
        } else {
            serviceSubtaskCountReq.setFollowUpCountStyle("1");
        }
        serviceSubtaskCountReq.setPageNum(null);
        serviceSubtaskCountReq.setPageSize(null);
        List<ServiceSubtaskStatistic> sfStatistics = serviceSubtaskService.getSfStatistics(serviceSubtaskCountReq);
        return getDataTable4(CollectionUtils.isEmpty(sfStatistics) ? sfStatistics.size() : 0, serviceSubtaskService.getSfStatistics(serviceSubtaskCountReq));
    }

    /**
     * 获取专病随访统计比例
     */
    @ApiOperation("获取专病随访统计比例")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getSpecialSfStatistics")
    public Map<String, Object> getSpecialSfStatistics(@RequestBody ServiceSubtaskCountReq serviceSubtaskCountReq) {
        if (CollectionUtils.isEmpty(serviceSubtaskCountReq.getServiceType())) {
            return error("服务类型不能为空");
        }
        Integer offset = PageUtils.getOffset(serviceSubtaskCountReq.getPageNum(), serviceSubtaskCountReq.getPageSize());
        serviceSubtaskCountReq.setPageNum(offset);

        String followUpCountStyle = configService.selectConfigByKey("followUpCountStyle", serviceSubtaskCountReq.getOrgid());
        if (ObjectUtils.isNotEmpty(followUpCountStyle)) {
            serviceSubtaskCountReq.setFollowUpCountStyle(followUpCountStyle);
        } else {
            serviceSubtaskCountReq.setFollowUpCountStyle("1");
        }
        serviceSubtaskCountReq.setPageNum(null);
        serviceSubtaskCountReq.setPageSize(null);
        List<ServiceSubtaskStatistic> sfStatistics = serviceSubtaskService.getSpecialSfStatistics(serviceSubtaskCountReq);
        return getDataTable4(CollectionUtils.isEmpty(sfStatistics) ? sfStatistics.size() : 0, serviceSubtaskService.getSpecialSfStatistics(serviceSubtaskCountReq));
    }

    /**
     * 获取随访统计比例
     */
    @ApiOperation("获取随访满意度统计")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getSfStatisticsJoy")
    public Map<String, Object> getSfStatisticsJoy(@RequestBody ServiceSubtaskCountReq serviceSubtaskCountReq) {
        if (CollectionUtils.isEmpty(serviceSubtaskCountReq.getServiceType())) {
            return error("服务类型不能为空");
        }
        return success(serviceSubtaskService.getSfStatisticsJoy(serviceSubtaskCountReq));
    }

    /**
     * 随访历史记录导出
     */
    //@PreAuthorize("@ss.hasPermi('system:taskcall:export')")
    @Log(title = "随访统计导出", businessType = BusinessType.EXPORT)
    @PostMapping("/getSfStatisticsExport")
    public void export(HttpServletResponse response, ServiceSubtaskCountReq serviceSubtaskCountReq) {
        List<ServiceSubtaskStatistic> sfStatistics = serviceSubtaskService.getSfStatisticsExport(serviceSubtaskCountReq);
        ExcelUtil<ServiceSubtaskStatistic> util = new ExcelUtil<ServiceSubtaskStatistic>(ServiceSubtaskStatistic.class);
        String sheetName = "";
        String fileName = "";
        if (active.equals("ls") || active.equals("druid")) {
            fileName = sheetName = LocalDate.now().getMonthValue() + "月出院随访统计表";
            util.exportExcelWithFileName(response, sfStatistics, sheetName, fileName);
        } else {
            sheetName = "随访统计导出";
            util.exportExcel(response, sfStatistics, sheetName);
        }
    }

    /**
     * 随访统计导出
     */
    @ApiOperation("服务统计查询-按时间维度统计出院/门诊随访数据")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getServiceStatistics")
    public AjaxResult getServiceStatistics(@RequestBody ServiceStatisticsRequest serviceStatisticsRequest) {
        SysUser user = getLoginUser().getUser();
        serviceStatisticsRequest.setOrgid(user.getOrgid());
        List<ServiceStatisticsResponse> serviceStatistics = serviceSubtaskService.getServiceStatistics(serviceStatisticsRequest);
        return success(serviceStatistics);
    }


    /**
     * 获取随访统计比例
     */
    @ApiOperation("获取随访满意度明细")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getSfStatisticsJoydetails")
    public AjaxResult getSfStatisticsJoydetails(@RequestBody ServiceSubtaskCountReq serviceSubtaskCountReq) {
        if (serviceSubtaskCountReq.getLeavehospitaldistrictcodes().size() == 0 && serviceSubtaskCountReq.getDeptcodes().size() == 0) {
            return error("科室或病区不能为空");
        }
        return success(serviceSubtaskService.getSfStatisticsJoydetails(serviceSubtaskCountReq));
    }

    /**
     * 获取随访统计超链接
     * dischargeCountInfo
     * followUpNeededAllInfo - sendstate != 4 (1,2,3,5,6,7)
     * nonFollowUpInfo - sendstate = 4
     * needFollowUpInfo - visitCount = 1 && sendstate != 4
     * pendingFollowUpInfo - visitCount = 1 && sendstate = 2
     * followUpSuccessInfo - visitCount = 1 && sendstate = 6
     * followUpFailInfo - visitCount = 1 && (sendstate = 5 || sendstate = 7)
     * manualInfo - visitCount = 1 && currentPreachForm = "1"
     * voiceInfo - visitCount = 1 && currentPreachForm = "3"
     * smsInfo - visitCount = 1 && currentPreachForm = "4"
     * wechatInfo - visitCount = 1 && currentPreachForm = "5"
     * abnormalInfo - visitCount = 1 && excep = "1"
     * needFollowUpAgainInfo - visitCount > 1 && sendstate != 4
     * pendingFollowUpAgainInfo -  visitCount > 1 && sendstate = 2
     * followUpSuccessAgainInfo - visitCount > 1 && sendstate =6
     * followUpFailAgainInfo - visitCount > 1 && (sendstate = 5 || sendstate = 7)
     * manualAgainInfo - visitCount > 1 && currentPreachForm = "1"
     * voiceAgainInfo - visitCount > 1 && currentPreachForm = "3"
     * smsAgainInfo - visitCount > 1 && currentPreachForm = "4"
     * wechatAgainInfo -  visitCount > 1 && currentPreachForm = "5"
     * abnormalAgainInfo- visitCount > 1 && excep = "1"
     * taskSituation1Info - taskSituation = 1
     * taskSituation2Info - taskSituation = 2
     * taskSituation3Info - taskSituation = 3
     * taskSituation4Info - taskSituation = 4
     * taskSituation5Info - taskSituation = 5
     * taskSituation6Info - taskSituation = 7
     * filterCountList - taskSituation = 6 && sendstate = 4
     *
     */
    @ApiOperation("获取随访统计超链接")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getSfStatisticsHyperlink")
    public AjaxResult getSfStatisticsHyperlink(@RequestBody ServiceSubtaskCountReq serviceSubtaskCountReq) {
        LoginUser loginUser = getLoginUser();
        String orgid = loginUser.getUser().getOrgid();
        String configKey = serviceSubtaskCountReq.getConfigKey();
        if (StringUtils.isNotEmpty(configKey)) {
            String configValue = configService.selectConfigByKey(configKey, orgid);
            serviceSubtaskCountReq.setConfigValue(configValue);
            if (StringUtils.isEmpty(configValue)) {
                String logInfo = "getSfStatisticsCount-参数 " + configKey + " 未配置, 请配置好后重试";
                log.error(logInfo);
                return error(logInfo);
            }
        }

        String followUpCountStyle = configService.selectConfigByKey("followUpCountStyle", orgid);
        if (ObjectUtils.isNotEmpty(followUpCountStyle)) {
            serviceSubtaskCountReq.setFollowUpCountStyle(followUpCountStyle);
        } else {
            serviceSubtaskCountReq.setFollowUpCountStyle("1");
        }
        return success(serviceSubtaskService.getSfStatisticsHyperlink(serviceSubtaskCountReq));
    }

    /**
     * 延续护理统计
     */
    @ApiOperation("延续护理统计")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getContinueNerseCount")
    public AjaxResult getContinueNerseCount(@RequestBody ServiceSubtaskCotinueCountVO serviceSubtaskCotinueCountVO) {
        SysUser user = getLoginUser().getUser();
        serviceSubtaskCotinueCountVO.setOrgid(user.getOrgid());
        serviceSubtaskCotinueCountVO.setCampusid(user.getCampusid());
        boolean hasDistrict = !CollectionUtils.isEmpty(serviceSubtaskCotinueCountVO.getLeavehospitaldistrictcodes());
        boolean hasDept = !CollectionUtils.isEmpty(serviceSubtaskCotinueCountVO.getDeptcodes());
        if (hasDistrict && hasDept) {
            return error("病区Code集合与科室Code集合互斥，不能同时传入");
        }
        return success(serviceSubtaskService.getContinueNurseCount(serviceSubtaskCotinueCountVO));
    }


    /**
     * 获取随访分类统计明细
     */
    @ApiOperation("获取随访分类统计明细")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getSfStatisticsCount")
    public Map<String, Object> getSfStatisticsCount(@RequestBody ServiceSubtaskCountReq serviceSubtaskCountReq) {
        if (CollectionUtils.isEmpty(serviceSubtaskCountReq.getServiceType())) {
            return error("服务类型不能为空");
        }
        String configKey = serviceSubtaskCountReq.getConfigKey();
        if (StringUtils.isNotEmpty(configKey)) {
            String configValue = configService.selectConfigByKey(configKey, serviceSubtaskCountReq.getOrgid());
            serviceSubtaskCountReq.setConfigValue(configValue);
            if (StringUtils.isEmpty(configValue)) {
                String logInfo = "getSfStatisticsCount-参数 " + configKey + " 未配置, 请配置好后重试";
                log.error(logInfo);
                return error(logInfo);
            }
        } else {
            String logInfo = "getSfStatisticsCount-参数configKey未传入, 请配置好后重试";
            log.error(logInfo);
            return error(logInfo);
        }
        List<ServiceSubtaskStatistic> serviceSubtaskStatistics = serviceSubtaskService.getSfStatisticsScript(serviceSubtaskCountReq);
        return success(serviceSubtaskStatistics);
    }

    @ApiOperation("获取随访分类统计明细详情")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/getSfStatisticsCountDetails")
    public AjaxResult getSfStatisticsCountDetails(@RequestBody ServiceSubtaskCountReq serviceSubtaskCountReq) {
        if (serviceSubtaskCountReq.getLeavehospitaldistrictcodes().size() == 0 && serviceSubtaskCountReq.getDeptcodes().size() == 0) {
            return error("科室或病区不能为空");
        }
        //复诊统计
        String configKey = serviceSubtaskCountReq.getConfigKey();
        if (StringUtils.isNotEmpty(configKey)) {
            String configValue = configService.selectConfigByKey(configKey, serviceSubtaskCountReq.getOrgid());
            if (StringUtils.isEmpty(configValue)) {
                String logInfo = "getSfStatisticsCountDetails-参数 " + configKey + " 未配置, 请配置好后重试";
                log.error(logInfo);
                return error(logInfo);
            }
            serviceSubtaskCountReq.setConfigValue(configValue);
        } else {
            String logInfo = "getSfStatisticsCountDetails-参数configKey未传入, 请配置好后重试";
            log.error(logInfo);
            return error(logInfo);
        }

        LoginUser loginUser = getLoginUser();
        String orgid = loginUser.getUser().getOrgid();
        serviceSubtaskCountReq.setOrgid(orgid);
        PageUtils.startPageByPost(serviceSubtaskCountReq.getPageNum(), serviceSubtaskCountReq.getPageSize());
        return success(serviceSubtaskService.getSfStatisticsScriptDetails(serviceSubtaskCountReq));
    }

    /**
     * 发送短信模板
     */
    @ApiOperation("发送短信模板")
    @PostMapping("/sendMsgTemplate")
    public Map<String, Object> sendMsgTemplate(@RequestBody List<PatArchiveSrmVO> patArchiveSrmVOS) {
        if (CollectionUtils.isEmpty(patArchiveSrmVOS)) {
            throw new BaseException("患者信息不能为空");
        }
        List<PatArchiveSrmVO> pasList = serviceSubtaskService.sendMsgTemplate(patArchiveSrmVOS);
        Map<String, Object> map = new HashMap<>();
        map.put("code", HttpStatus.SUCCESS);
        map.put("fail", CollectionUtils.isEmpty(pasList) ? null : pasList);
        return map;
    }

    /**
     * 统计任务各种状态的数量（优化版）
     *
     * @return Map<String, Object> 包含各状态统计数据
     * pendingVisitCount: 当前登录人截止今日待随访总量
     * failedVisitCount: 当前登录人随访任务失败总量
     * abnormalVisitVount: 当前登录人随访任务异常总量
     * allVisitCount: 当前登录人随访任务总量
     */
    @ApiOperation("获取当前用户随访数量统计")
    @PostMapping("/getCurrentUserServiceSubtaskCount")
    public Map<String, Object> getCurrentUserServiceSubtaskCount() {
        Map<String, Object> map = new HashMap<>();
        LoginUser loginUser = getLoginUser();
        SysUser sysUser = loginUser.getUser();
        SysUserDept sysUserDept = new SysUserDept();
        sysUserDept.setUserId(sysUser.getUserId());
        sysUserDept.setOrgid(sysUser.getOrgid());
        sysUserDept.setCampusid(sysUser.getCampusid());
        sysUserDept.setDeptType("1");
        List<SysUserDept> sysUserDepts = sysUserDeptService.selectSysUserDeptList(sysUserDept);
        SysUserDept sysUserWard = new SysUserDept();
        sysUserWard.setUserId(sysUser.getUserId());
        sysUserWard.setOrgid(sysUser.getOrgid());
        sysUserWard.setCampusid(sysUser.getCampusid());
        sysUserWard.setDeptType("2");
        List<SysUserDept> sysUserWards = sysUserDeptService.selectSysUserDeptList(sysUserWard);
        List<String> deptCodes = sysUserDepts.stream().map(SysUserDept::getDeptCode).collect(Collectors.toList());
        List<String> wardCodes = sysUserWards.stream().map(SysUserDept::getDeptCode).collect(Collectors.toList());
        ServiceSubtaskEntity entity = new ServiceSubtaskEntity();
        entity.setOrgid(sysUser.getOrgid());
        entity.setLeaveldeptcodes(deptCodes);
        entity.setLeavehospitaldistrictcodes(wardCodes);
        if (ObjectUtils.isNotEmpty(sysUser)) {
            if (!("admin").equals(sysUser.getUserName())) {
                if (ObjectUtils.isNotEmpty(sysUserWards) && ObjectUtils.isNotEmpty(sysUserDepts)) {
                    map = serviceSubtaskService.getCurrentUserServiceSubtaskCount(entity);
                }
            } else {
                map = serviceSubtaskService.getCurrentUserServiceSubtaskCount(entity);
            }
        }
        return map;
    }

    @ApiOperation("获取当前用户宣教数量统计")
    @PostMapping("/gethelibraryCount")
    public Map<String, Object> getHeLibraryCount(@RequestBody HeLibraryCountVO heLibraryCountVO) {
        log.info("获取当前用户宣教数量统计的入参为：{}", heLibraryCountVO);
        return serviceSubtaskService.getHeLibraryCount(heLibraryCountVO);
    }

    @ApiOperation("获取宣教统计超链接")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/gethelibraryCountHyperlink")
    public AjaxResult gethelibraryCountHyperlink(@RequestBody HeLibraryCountVO heLibraryCountVO) {
        return success(serviceSubtaskService.gethelibraryCountHyperlink(heLibraryCountVO));
    }

    /**
     * 手动发送问卷模板的短信功能
     *
     * @param subid
     * @return
     */
    @GetMapping(value = "/smsSubTask/{subid}")
    public Map<String, Object> smsSubTask(@PathVariable("subid") Long subid) {
        return serviceSubtaskService.smsSubTask(subid);
    }

    /**
     * 跳转中间页
     *
     * @param taskId
     * @return
     */
    @PostMapping(value = "/goSfRelay")
    public AjaxResult goSfRelay(@RequestParam("taskId") Long taskId, @RequestParam("deptcode") String deptcode, @RequestParam("leavehospitaldistrictcode") String leavehospitaldistrictcode) {
        String url = localIP + ":" + req_path + "/SfRelay?taskid=" + taskId;
        if (StringUtils.isNotEmpty(deptcode)) {
            url = url + "&deptcode=" + deptcode;
        }
        if (StringUtils.isNotEmpty(leavehospitaldistrictcode)) {
            url = url + "&leavehospitaldistrictcode=" + leavehospitaldistrictcode;
        }
        return AjaxResult.success(url);
    }

    /**
     * 扫码生成子任务
     *
     * @param serviceTask
     * @return
     */
    @PostMapping(value = "/scanGenerateSubtask")
    public AjaxResult scanGenerateSubtask(@RequestBody ServiceTask serviceTask) {
        return AjaxResult.success(serviceSubtaskService.scanGenerateSubtask(serviceTask));
    }

    @PostMapping("/syncMedInhospForShiyi")
    public AjaxResult syncMedInhospForShiyi(@RequestParam("startTime") String startTime, @RequestParam("endTime") String endTime) {
        // 立即返回，后台异步执行
        CompletableFuture.runAsync(() -> {
            collectHISService.syncMedInhosp(startTime, endTime);
        });
        return AjaxResult.success("同步任务已启动，请稍后查看结果");
    }

    @PostMapping("/syncMedInhospForShiyiYesterday")
    public AjaxResult syncMedInhospForShiyiYesterday() {
        // 立即返回，后台异步执行
        ryTask.collectHISYesterday();
        return AjaxResult.success("同步任务已启动，请稍后查看结果");
    }

    @PostMapping("/syncMedInhospForShiyiDaysBefore")
    public AjaxResult syncMedInhospForShiyiDaysBefore(@RequestParam("day") Long day) {
        // 立即返回，后台异步执行
        ryTask.collectHISDaysBefore(day);
        return AjaxResult.success("【collectHISDaysBefore】同步任务已启动，天数为" + day + "天，请稍后查看结果");
    }

    @PostMapping("/syncMedOperForShiyi")
    public AjaxResult syncMedOperForShiyi(@RequestParam("startTime") String startTime, @RequestParam("endTime") String endTime) {
        // 立即返回，后台异步执行
        CompletableFuture.runAsync(() -> {
            collectHISService.syncOper(startTime, endTime);
        });
        return AjaxResult.success("同步任务已启动，请稍后查看结果");
    }

    @PostMapping("/dealSubtaskDeadline")
    public AjaxResult dealSubtaskDeadline(@RequestParam("orgid") String orgid, @RequestParam("day") Integer day) {
        // 立即返回，后台异步执行
        ryTask.dealSubtaskDeadline(orgid, day);
        return AjaxResult.success("【dealSubtaskDeadline】同步任务已启动，天数为" + day + "天，请稍后查看结果");
    }

    @PostMapping("/sendExceptInfo")
    public AjaxResult sendExceptInfo() throws Exception {
        ryTask.sendExceptInfo();
        return AjaxResult.success("sendExceptInfo");
    }

    /**
     * 带Redis缓存的统计查询，供patItem和patItemCount共用，条件不变时直接命中缓存
     */
    private Map<String, Object> getPatItemCountWithCache(ServiceSubtaskEntity serviceSubtaskEntity) {
        Map<String, Object> map = new HashMap<>();
        LoginUser loginUser = getLoginUser();
        Long userId = null;
        if (ObjectUtils.isNotEmpty(loginUser) && ObjectUtils.isNotEmpty(loginUser.getUser())) {
            userId = loginUser.getUser().getUserId();
        }
        if (serviceSubtaskEntity.getSendstateView() != null) {
            //            1：待随访（1 被领取、2 待发送、3 已发送、5 发送失败、7、超时）；2：已完成（ 6 已完成）、3：无需随访（4 不执行）
            if (serviceSubtaskEntity.getSendstateView() == 1)
                serviceSubtaskEntity.setSendstates(new ArrayList<>(Arrays.asList(1L, 2L, 3L, 5L, 7L)));
            if (serviceSubtaskEntity.getSendstateView() == 2)
                serviceSubtaskEntity.setSendstates(new ArrayList<>(Arrays.asList(6L)));
            if (serviceSubtaskEntity.getSendstateView() == 3)
                serviceSubtaskEntity.setSendstates(new ArrayList<>(Arrays.asList(4L)));
        }
        if (ObjectUtils.isNotEmpty(userId)) {
            Map<String, Object> redisMap = redisCache.getCacheObject(userId + "patItemCount");
            Boolean redisFlag = false;
            if (MapUtils.isNotEmpty(redisMap)) {
                ServiceSubtaskEntity oldCondition = (ServiceSubtaskEntity) redisMap.get("searchCondition");
                if (ObjectUtils.isNotEmpty(oldCondition) && isSameCondition(oldCondition, serviceSubtaskEntity)) {
                    redisFlag = true;
                    map = redisMap;
                    redisCache.setCacheObject(userId + "patItemCount", map, 60, TimeUnit.MINUTES);
                }
            }
            if (!redisFlag) {
                map = serviceSubtaskService.patItemCount(serviceSubtaskEntity);
                map.put("searchCondition", serviceSubtaskEntity);
                redisCache.setCacheObject(userId + "patItemCount", map, 120, TimeUnit.MINUTES);
            }
        } else {
            map = serviceSubtaskService.patItemCount(serviceSubtaskEntity);
        }
        return map;
    }


    /**
     * 比较两个ServiceSubtaskVO的查询条件是否一致
     * 使用反射比较所有字段，排除分页参数和无关字段
     */
    private boolean isSameCondition(ServiceSubtaskEntity oldCondition, ServiceSubtaskEntity newCondition) {
        // 使用ReflectUtils的通用方法比较，排除分页参数等无关字段
        return ReflectUtils.equalsAllFields(oldCondition, newCondition,
                // 排除的字段：分页参数、序列化ID、时间戳等
                "pageNum", "pageSize", "serialVersionUID", "createBy", "createTime", "updateBy", "updateTime", "searchValue", "params");
    }


    @ApiOperation("获取统计数")
    @AddOrgId(field = "orgid", paramIndex = 0, campusField = "campusid")
    @PostMapping("/countByCondition")
    public Map<String, Object>  countByCondition(@RequestBody ServiceSubtaskEntity condition) {
        Map<String, Object> map = serviceSubtaskService.countByCondition(condition);
        return map;
    }
}