package com.supervision.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.supervision.exception.BusinessException;
import com.supervision.model.*;
import com.supervision.model.Process;
import com.supervision.pojo.vo.AskPhysicalResultReqVO;
import com.supervision.vo.ask.ConfigPhysicalToolResVO;
import com.supervision.service.*;
import com.supervision.util.UserUtil;
import com.supervision.vo.ask.DiagnosisPhysicalRecordVo;
import com.supervision.vo.ask.AskPhysicalHistoryResVO;
import com.supervision.vo.ask.DiagnosisPrimaryVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

@Slf4j
@Service
@RequiredArgsConstructor
public class AskPhysicalServiceImpl implements AskPhysicalService {

    private final ConfigPhysicalLocationService locationService;

    private final ConfigPhysicalToolService toolService;

    private final DiseasePhysicalService diseasePhysicalService;

    private final DiagnosisPhysicalRecordService diagnosisPhysicalRecordService;

    private final ProcessService processService;

    private final DiagnosisPrimaryRelationService diagnosisPrimaryRelationService;

    private final DiagnosisPrimaryService diagnosisPrimaryService;

    private final DefaultPhysicalIndicatorService defaultPhysicalIndicatorService;

    @Override
    public List<ConfigPhysicalToolResVO> queryPhysicalToolList() {

        return toolService.queryPhysicalToolList();
    }

    @Override
    public DiagnosisPhysicalRecordVo queryAskPhysicalResult(AskPhysicalResultReqVO reqVO) {
        // 首先根据process_id查新到流程ID
        Process process = Optional.ofNullable(processService.getById(reqVO.getProcessId())).orElseThrow(() -> new BusinessException("未找到流程ID"));
        ConfigPhysicalTool tool = Optional.ofNullable(toolService.getById(reqVO.getToolId())).orElseThrow(() -> new BusinessException("工具不支持"));
        // 是否需要具体的部位,0否1是
        ConfigPhysicalLocation location = new ConfigPhysicalLocation();
        if (1 == tool.getRequireLocation()) {
            if (StrUtil.isBlank(reqVO.getLocationCode())) {
                throw new BusinessException("请选择对应的位置");
            } else {
                location = locationService.lambdaQuery().eq(ConfigPhysicalLocation::getCode, reqVO.getLocationCode()).last("limit 1")
                        .oneOpt().orElseGet(ConfigPhysicalLocation::new);
            }
        }
        ConfigPhysicalLocation finalLocation = location;
        DiseasePhysical result = diseasePhysicalService.lambdaQuery().eq(DiseasePhysical::getDiseaseId, process.getDiseaseId())
                .eq(DiseasePhysical::getToolId, tool.getId())
                .eq(StrUtil.isNotBlank(location.getId()), DiseasePhysical::getLocationId, location.getId()).last("limit 1")
                .oneOpt()
                .orElseGet(() -> queryDefaultPhysicalResult(tool.getId(), finalLocation.getId()));


        // 检查记录保存到数据库中
        DiagnosisPhysicalRecord diagnosisPhysicalRecord = new DiagnosisPhysicalRecord();
        diagnosisPhysicalRecord.setProcessId(process.getId());
        diagnosisPhysicalRecord.setPhysicalId(result.getId());
        diagnosisPhysicalRecord.setToolId(tool.getId());
        diagnosisPhysicalRecord.setLocationId(location.getId());
        // 首先查询异常结果,如果没有异常结果,则展示正常结果
        diagnosisPhysicalRecord.setResult(StrUtil.isNotBlank(result.getResult()) ? result.getResult() : result.getNormalResult());
        diagnosisPhysicalRecord.setCreateUserId(UserUtil.getUser().getCreateUserId());
        diagnosisPhysicalRecord.setUpdateUserId(UserUtil.getUser().getCreateUserId());
        diagnosisPhysicalRecord.insert();

        // 保存初步诊断
        if (CollUtil.isNotEmpty(reqVO.getPrimaryIdList())) {
            for (String primaryId : reqVO.getPrimaryIdList()) {
                DiagnosisPrimaryRelation diagnosisPrimaryRelation = new DiagnosisPrimaryRelation();
                diagnosisPrimaryRelation.setProcessId(process.getId());
                diagnosisPrimaryRelation.setPrimaryId(primaryId);
                diagnosisPrimaryRelation.setType(2);
                diagnosisPrimaryRelation.setRelationId(diagnosisPhysicalRecord.getId());
                diagnosisPrimaryRelation.insert();
            }
        }

        DiagnosisPhysicalRecordVo resVo = BeanUtil.toBean(diagnosisPhysicalRecord, DiagnosisPhysicalRecordVo.class);
        resVo.setLocationName(location.getLocationName());
        resVo.setToolName(tool.getToolName());
        return resVo;
    }

    /**
     * 查询默认的体格检查结果
     */
    private DiseasePhysical queryDefaultPhysicalResult(String itemId, String locationId) {
        DiseasePhysical diseasePhysical = new DiseasePhysical();
        try {
            // 首先判断位置是否是空,如果位置是空,就查找不需要位置的默认值
            if (StrUtil.isBlank(locationId)) {
                DefaultPhysicalIndicator noLocationIndicator = defaultPhysicalIndicatorService.lambdaQuery().eq(DefaultPhysicalIndicator::getItemId, itemId).last("limit 1").one();
                if (ObjectUtil.isEmpty(noLocationIndicator)) {
                    diseasePhysical.setResult("无相关资讯");
                    return diseasePhysical;
                }
                diseasePhysical.setResult(noLocationIndicator.getIndicatorValue());
                return diseasePhysical;
            }
            // 如果位置不为空,则根据位置去找
            DefaultPhysicalIndicator locationPhysicalIndicator = defaultPhysicalIndicatorService.lambdaQuery().eq(DefaultPhysicalIndicator::getItemId, itemId)
                    .eq(DefaultPhysicalIndicator::getLocationId, locationId).last("limit 1").one();
            // 如果不为空,则返回结果
            if (ObjectUtil.isNotEmpty(locationPhysicalIndicator)) {
                diseasePhysical.setResult(locationPhysicalIndicator.getIndicatorValue());
                return diseasePhysical;
            }
            // 如果为空,则根据上级部位去查
            ConfigPhysicalLocation location = locationService.getById(locationId);
            if (ObjectUtil.isNotEmpty(location) && ObjectUtil.isNotEmpty(location.getParentId())) {
                DefaultPhysicalIndicator parentPhysicalIndicator = defaultPhysicalIndicatorService.lambdaQuery().eq(DefaultPhysicalIndicator::getItemId, itemId)
                        .eq(DefaultPhysicalIndicator::getLocationId, location.getParentId()).last("limit 1").one();
                // 如果不为空,则返回结果
                if (ObjectUtil.isNotEmpty(parentPhysicalIndicator)) {
                    diseasePhysical.setResult(parentPhysicalIndicator.getIndicatorValue());
                    return diseasePhysical;
                }
            }
            // 最终,返回未找到
            diseasePhysical.setResult("无相关资讯");
            return diseasePhysical;
        } catch (Exception e) {
            log.error("查询默认值错误", e);
            diseasePhysical.setResult("无相关资讯");
            return diseasePhysical;
        }
    }


    @Override
    public List<AskPhysicalHistoryResVO> queryAskPhysicalHistory(String processId) {
        List<AskPhysicalHistoryResVO> res = diagnosisPhysicalRecordService.queryAskPhysicalHistory(processId);
        // 这里把初步诊断的疾病名称填充进去
        List<DiagnosisPrimaryRelation> relationList = diagnosisPrimaryRelationService.lambdaQuery().eq(DiagnosisPrimaryRelation::getType, 2)
                .eq(DiagnosisPrimaryRelation::getProcessId, processId).list();
        Map<String, List<DiagnosisPrimaryRelation>> relationMap = relationList.stream().collect(Collectors.groupingBy(DiagnosisPrimaryRelation::getRelationId));

        // 找到process对应的所有的初步诊断
        List<DiagnosisPrimaryVO> diagnosisPrimaryVOS = diagnosisPrimaryService.queryAskPrimaryListByProcessId(processId);
        Map<String, String> diseaseNameMap = diagnosisPrimaryVOS.stream().collect(Collectors.toMap(DiagnosisPrimaryVO::getId, DiagnosisPrimaryVO::getPrimaryDiseaseName));
        for (AskPhysicalHistoryResVO node : res) {
            List<DiagnosisPrimaryRelation> temp = relationMap.get(node.getId());
            List<String> diseaseNameList = new ArrayList<>();
            if (CollUtil.isNotEmpty(temp)) {
                for (DiagnosisPrimaryRelation relation : temp) {
                    String diseaseName = diseaseNameMap.get(relation.getPrimaryId());
                    diseaseNameList.add(diseaseName);
                }
            }
            node.setDiseaseName(StrUtil.join(";", diseaseNameList));
        }
        return res;
    }


}