package com.smartor.service.impl;

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

import com.github.pagehelper.util.StringUtil;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.smartor.domain.*;
import com.smartor.domain.DTO.DetailTraceDealDTO;
import com.smartor.domain.VO.DetailTraceDealVO;
import com.smartor.domain.VO.SatisfactionExceptConfigQuestionReqVO;
import com.smartor.mapper.ServiceSubtaskDetailMapper;
import com.smartor.mapper.ServiceSubtaskDetailTraceMapper;
import com.smartor.mapper.SvyLibScriptCategoryMapper;
import com.smartor.mapper.SvyLibTemplateScriptMapper;
import com.smartor.service.*;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 随访任务异常记录跟踪Service业务层处理
 *
 * @author lihu
 * @date 2026-03-24
 */
@Service
public class ServiceSubtaskDetailTraceServiceImpl implements IServiceSubtaskDetailTraceService {
    @Autowired
    private ServiceSubtaskDetailTraceMapper serviceSubtaskDetailTraceMapper;

    @Autowired
    private ServiceSubtaskDetailMapper serviceSubtaskDetailMapper;

    @Autowired
    private ISvyLibScriptCategoryService iSvyLibScriptCategoryService;

    @Autowired
    private SvyLibScriptCategoryMapper svyLibScriptCategoryMapper;

    @Autowired
    private ISvyLibTemplateScriptService isvyLibTemplateScriptService;

    @Autowired
    private IIvrLibaScriptAssortService iIvrLibaScriptAssortService;

    @Autowired
    private IIvrLibaTemplateScriptService iIvrLibaTemplateScriptService;

    /**
     * 查询随访任务异常记录跟踪
     *
     * @param id 随访任务异常记录跟踪主键
     * @return 随访任务异常记录跟踪
     */
    @Override
    public ServiceSubtaskDetailTrace selectServiceSubtaskDetailTtraceById(Long id) {
        return serviceSubtaskDetailTraceMapper.selectServiceSubtaskDetailTtraceById(id);
    }

    /**
     * 查询随访任务异常记录跟踪列表
     *
     * @param serviceSubtaskDetailTrace 随访任务异常记录跟踪
     * @return 随访任务异常记录跟踪
     */
    @Override
    public List<ServiceSubtaskDetailTrace> selectServiceSubtaskDetailTtraceList(ServiceSubtaskDetailTrace serviceSubtaskDetailTrace) {
        return serviceSubtaskDetailTraceMapper.selectServiceSubtaskDetailTtraceList(serviceSubtaskDetailTrace);
    }

    @Override
    public List<DetailTraceDealDTO> tracedeallist(DetailTraceDealVO detailTraceDealVO) {
        // 获取所有需要处理的记录
        List<ServiceSubtaskDetailTrace> tracedeallist = serviceSubtaskDetailTraceMapper.tracedeallist(detailTraceDealVO);

        // 按 questiontext 分组
        Map<String, List<ServiceSubtaskDetailTrace>> groupByQuestion = tracedeallist.stream()
                .filter(t -> t.getQuestiontext() != null)
                .collect(Collectors.groupingBy(ServiceSubtaskDetailTrace::getQuestiontext));

        List<DetailTraceDealDTO> detailTraceDealDTOList = new ArrayList<>();
        for (Map.Entry<String, List<ServiceSubtaskDetailTrace>> entry : groupByQuestion.entrySet()) {
            List<ServiceSubtaskDetailTrace> group = entry.getValue();
            DetailTraceDealDTO dto = new DetailTraceDealDTO();

            // 问题内容
            dto.setQuestiontext(entry.getKey());

            // 负责科室（去重）
            List<Map<String, Object>> responsibleDept = group.stream()
                    .filter(t -> t.getTodeptcode() != null)
                    .collect(Collectors.collectingAndThen(
                            Collectors.toMap(
                                    ServiceSubtaskDetailTrace::getTodeptcode,
                                    t -> {
                                        Map<String, Object> deptMap = new HashMap<>();
                                        deptMap.put("deptName", t.getTodeptname());
                                        deptMap.put("deptCode", t.getTodeptcode());
                                        return deptMap;
                                    },
                                    (existing, replacement) -> existing
                            ),
                            map -> new ArrayList<>(map.values())
                    ));
            dto.setResponsibleDept(responsibleDept);

            // 有效填写数：通过组内的 scriptid 去 service_subtask_detail 表查询
            List<Long> scriptIds = group.stream()
                    .map(ServiceSubtaskDetailTrace::getScriptid)
                    .filter(Objects::nonNull)
                    .distinct()
                    .collect(Collectors.toList());
            long effectiveFillNum = 0L;
            if (CollectionUtils.isNotEmpty(scriptIds)) {
                ServiceSubtaskDetail query = new ServiceSubtaskDetail();
                query.setDelFlag("0");
                for (Long scriptId : scriptIds) {
                    query.setScriptid(scriptId);
                    List<ServiceSubtaskDetail> details = serviceSubtaskDetailMapper.selectServiceSubtaskDetailList(query);
                    effectiveFillNum += CollectionUtils.isEmpty(details) ? 0 : details.size();
                }
            }

            // 异常填写数 = 当前分组的 List 数量
            long exceptionFillNum = group.size();

            Map<String, Object> fillSituation = new HashMap<>();
            fillSituation.put("effectiveFillNum", effectiveFillNum);
            fillSituation.put("exceptionFillNum", exceptionFillNum);
            dto.setFillSituation(fillSituation);

            // 异常问题处理数量：从 handleFlag 统计
            long yesDeal = group.stream().filter(t -> "1".equals(t.getHandleFlag())).count();
            long noDeal = group.stream().filter(t -> !"1".equals(t.getHandleFlag())).count();
            Map<String, Object> exceptionQuesNum = new HashMap<>();
            exceptionQuesNum.put("yesDeal", yesDeal);
            exceptionQuesNum.put("noDeal", noDeal);
            exceptionQuesNum.put("all", exceptionFillNum);
            dto.setExceptionQuesNum(exceptionQuesNum);

            // 最新处理人和处理时间（取 handleTime 最新的一条）
            group.stream()
                    .filter(t -> t.getHandleTime() != null)
                    .max(Comparator.comparing(ServiceSubtaskDetailTrace::getHandleTime))
                    .ifPresent(latest -> {
                        dto.setHandleBy(latest.getHandleBy());
                        dto.setHandleTime(latest.getHandleTime());
                    });

            detailTraceDealDTOList.add(dto);
        }

        return detailTraceDealDTOList;
    }

    /**
     * 新增随访任务异常记录跟踪
     *
     * @param serviceSubtaskDetailTrace 随访任务异常记录跟踪
     * @return 结果
     */
    @Override
    public int insertServiceSubtaskDetailTtrace(ServiceSubtaskDetailTrace serviceSubtaskDetailTrace) {
        serviceSubtaskDetailTrace.setCreateTime(DateUtils.getNowDate());
        return serviceSubtaskDetailTraceMapper.insertServiceSubtaskDetailTtrace(serviceSubtaskDetailTrace);
    }

    /**
     * 修改随访任务异常记录跟踪
     *
     * @param serviceSubtaskDetailTrace 随访任务异常记录跟踪
     * @return 结果
     */
    @Override
    public int updateServiceSubtaskDetailTtrace(ServiceSubtaskDetailTrace serviceSubtaskDetailTrace) {
        serviceSubtaskDetailTrace.setUpdateTime(DateUtils.getNowDate());
        return serviceSubtaskDetailTraceMapper.updateServiceSubtaskDetailTtrace(serviceSubtaskDetailTrace);
    }

    /**
     * 批量删除随访任务异常记录跟踪
     *
     * @param ids 需要删除的随访任务异常记录跟踪主键
     * @return 结果
     */
    @Override
    public int deleteServiceSubtaskDetailTtraceByIds(Long[] ids) {
        return serviceSubtaskDetailTraceMapper.deleteServiceSubtaskDetailTtraceByIds(ids);
    }

    /**
     * 删除随访任务异常记录跟踪信息
     *
     * @param id 随访任务异常记录跟踪主键
     * @return 结果
     */
    @Override
    public int deleteServiceSubtaskDetailTtraceById(Long id) {
        return serviceSubtaskDetailTraceMapper.deleteServiceSubtaskDetailTtraceById(id);
    }

    @Override
    public Map<String, Object> getSatisfactionExceptConfigQuestion(SatisfactionExceptConfigQuestionReqVO questionReqVO) {
        // 初始化结果集
        Map<String, Object> result = new HashMap<>();

        if (StringUtils.isEmpty(questionReqVO.getScriptType()) || questionReqVO.getScriptType().equals("1")) {
            List<Map<String, Object>> voicetDataList = new ArrayList<>();
            //获取满意度的分类
            IvrLibaScriptAssort ivrLibaScriptAssort = new IvrLibaScriptAssort();
            ivrLibaScriptAssort.setType("myd");
            if (!StringUtils.isEmpty(questionReqVO.getType())) ivrLibaScriptAssort.setType(questionReqVO.getType());
            List<IvrLibaScriptAssortVO> ivrLibaScriptAssortVOS = iIvrLibaScriptAssortService.selectIvrLibaScriptAssortList(ivrLibaScriptAssort);
            List<Long> assortIdList = Optional.ofNullable(ivrLibaScriptAssortVOS).filter(list -> !list.isEmpty()).map(list -> list.stream().map(IvrLibaScriptAssortVO::getId).collect(Collectors.toList())).orElse(Collections.emptyList());

            //用来记录满意度的所有问题
            List<IvrLibaTemplateScript> ivrLibaTemplateScriptList = new ArrayList<>();
            if (CollectionUtils.isNotEmpty(assortIdList)) {
                for (Long assortId : assortIdList) {
                    IvrLibaTemplateScript ivrLibaTemplateScript = new IvrLibaTemplateScript();
                    ivrLibaTemplateScript.setScriptAssortid(assortId);
                    List<IvrLibaTemplateScript> ivrLibaTemplateScripts = iIvrLibaTemplateScriptService.selectIvrLibaTemplateScriptList(ivrLibaTemplateScript);
                    ivrLibaTemplateScriptList.addAll(ivrLibaTemplateScripts);
                }
                for (IvrLibaTemplateScript ivrLibaTemplateScript : ivrLibaTemplateScriptList) {
                    Map<String, Object> voicetData = new HashMap<>();
                    voicetData.put("questionId", ivrLibaTemplateScript.getId());
                    voicetData.put("libtemplateid", ivrLibaTemplateScript.getTemplateid());
                    voicetData.put("questionContent", ivrLibaTemplateScript.getScriptContent());
                    voicetData.put("questionTopic", ivrLibaTemplateScript.getScriptTopic());
                    voicetData.put("questionType", ivrLibaTemplateScript.getScriptType());
                    voicetData.put("categoryName", ivrLibaTemplateScript.getScriptAssortname());
                    voicetData.put("categoryId", ivrLibaTemplateScript.getScriptAssortid());
                    voicetDataList.add(voicetData);
                }
            }
            //语音数据返回集合
            result.put("voiceDataList", voicetDataList);
        }

        if (StringUtils.isEmpty(questionReqVO.getScriptType()) || questionReqVO.getScriptType().equals("2")) {
            List<Map<String, Object>> questionnaireDataList = new ArrayList<>();
            //获取满意度的分类
            SvyLibScriptCategory svyLibScriptCategory = new SvyLibScriptCategory();
            svyLibScriptCategory.setType("myd");
            if (!StringUtils.isEmpty(questionReqVO.getType())) svyLibScriptCategory.setType(questionReqVO.getType());
            List<SvyLibScriptCategory> svyLibScriptCategoryVOS = svyLibScriptCategoryMapper.selectSvyLibScriptCategoryList(svyLibScriptCategory);
            List<Long> assortIdList = Optional.ofNullable(svyLibScriptCategoryVOS).filter(list -> !list.isEmpty()).map(list -> list.stream().map(SvyLibScriptCategory::getId).collect(Collectors.toList())).orElse(Collections.emptyList());

            //用来记录满意度的所有问题
            List<SvyLibTemplateScript> svyLibTemplateScriptList = new ArrayList<>();
            if (CollectionUtils.isNotEmpty(assortIdList)) {
                for (Long categoryid : assortIdList) {
                    SvyLibTemplateScript svyLibTemplateScript = new SvyLibTemplateScript();
                    svyLibTemplateScript.setCategoryid(categoryid);
                    List<SvyLibTemplateScript> svyLibTemplateScripts = isvyLibTemplateScriptService.selectSvyLibTemplateScriptList(svyLibTemplateScript);
                    svyLibTemplateScriptList.addAll(svyLibTemplateScripts);
                }
                for (SvyLibTemplateScript svyLibTemplateScript : svyLibTemplateScriptList) {
                    Map<String, Object> voicetData = new HashMap<>();
                    voicetData.put("questionId", svyLibTemplateScript.getId());
                    voicetData.put("libtemplateid", svyLibTemplateScript.getSvyid());
                    voicetData.put("questionContent", svyLibTemplateScript.getScriptContent());
                    voicetData.put("questionTopic", svyLibTemplateScript.getScriptTopic());
                    voicetData.put("questionType", svyLibTemplateScript.getScriptType());
                    voicetData.put("categoryName", svyLibTemplateScript.getCategoryName());
                    voicetData.put("categoryId", svyLibTemplateScript.getCategoryid());
                    questionnaireDataList.add(voicetData);
                }
            }
            //问卷数据返回集合
            result.put("questionnaireDataList", questionnaireDataList);
        }
        return result;
    }
}