package com.supervision.service.impl;


import com.supervision.exception.BusinessException;
import com.supervision.model.*;
import com.supervision.model.Process;
import com.supervision.pojo.vo.*;
import com.supervision.service.*;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class AskDiagnosisResultServiceImpl implements AskDiagnosisResultService {

    private final DiagnosisResultService diagnosisResultService;

    private final DiagnosisPrimaryService diagnosisPrimaryService;

    private final ProcessService processService;

    private final PatientService patientService;

    private final DiseaseService diseaseService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void finishAsk(FinishAskReqVO reqVO) {
        // 首先保存诊断结果
        DiagnosisResult diagnosisResult = new DiagnosisResult();
        diagnosisResult.setProcessId(reqVO.getProcessId());
        // 最终诊断结果,从初步诊断中获取
        List<DiagnosisPrimary> list = diagnosisPrimaryService.lambdaQuery()
                .eq(DiagnosisPrimary::getProcessId, reqVO.getProcessId())
                .eq(DiagnosisPrimary::getDeleteFlag, 0)
                .list();
        diagnosisResult.setFinalDiagnosis(list.stream().map(DiagnosisPrimary::getPrimaryDiagnosisId).collect(Collectors.toList()));
        diagnosisResult.setTreatmentPlanType(reqVO.getTreatmentPlanType());
        diagnosisResult.setTreatmentPlan(reqVO.getTreatmentPlan());
        diagnosisResultService.save(diagnosisResult);
    }

    @Override
    public DiagnosisResultResVO queryDiagnosisResult(String processId) {
        // 首先查询到结果
        DiagnosisResult diagnosisResult = diagnosisResultService.lambdaQuery()
                .eq(DiagnosisResult::getProcessId, processId).last("limit 1").oneOpt().orElseThrow(() -> new BusinessException("未找到评估结果"));
        DiagnosisResultResVO diagnosisResultResVO = new DiagnosisResultResVO();
        diagnosisResultResVO.setId(processId);
        Process process = processService.getById(processId);
        Patient patient = patientService.getById(process.getPatientId());
        List<Disease> diseasesList = diseaseService.listByIds(patient.getDiseaseList());
        // 1.生成预期诊断结果
        ExpertDiagnosisResultResVO expertDiagnosisResultResVO = creatExpertDiagnosisResult(diagnosisResult, patient, diseasesList);
        diagnosisResultResVO.setExpertDiagnosisResult(expertDiagnosisResultResVO);
        // 2.生成初步诊断依据
        BasisPrimaryResultResVO basisPrimaryResultResVO = new BasisPrimaryResultResVO();

        basisPrimaryResultResVO.setPreliminaryDiagnosis(diseasesList.stream().map(Disease::getPreliminaryDiagnosis).collect(Collectors.toList()));
        // 根据record记录寻找符合初步诊断依据的项目
//        basisPrimaryResultResVO.setNodeList();
//
//
//        diagnosisResultResVO.setBasisPrimaryResultResVO();
//        diagnosisResultResVO.setBasisConfirmResultResVO();
//        diagnosisResultResVO.setBasisIdentificationResult();
//        diagnosisResultResVO.setFullCheck();
//        diagnosisResultResVO.setDealPlan();


        return null;
    }


    private ExpertDiagnosisResultResVO creatExpertDiagnosisResult(DiagnosisResult diagnosisResult, Patient patient, List<Disease> diseasesList) {
        ExpertDiagnosisResultResVO expertDiagnosisResultResVO = new ExpertDiagnosisResultResVO();
        expertDiagnosisResultResVO.setDiagnosis(patient.getExpectedDiagnosisResult());
        Set<String> expertDiseaseIdSet = diseasesList.stream().map(Disease::getId).collect(Collectors.toSet());
        List<Disease> userDiagnosisDiseaseList = diseaseService.listByIds(diagnosisResult.getFinalDiagnosis());
        // 用户的诊断
        expertDiagnosisResultResVO.setUserDiagnosisResult(userDiagnosisDiseaseList.stream().map(e -> {
            DiagnosisDiseaseResultNodeVO userNode = new DiagnosisDiseaseResultNodeVO();
            userNode.setDiseaseName(e.getDiseaseName());
            // 如果用户诊断在预期诊断里面,则正确,否则错误
            userNode.setCorrect(expertDiseaseIdSet.contains(e.getId()) ? 1 : 0);
            userNode.setDiseaseId(e.getId());
            return userNode;
        }).collect(Collectors.toList()));

        // 预期诊断
        expertDiagnosisResultResVO.setExpertDiagnosisResult(diseasesList.stream().map(e -> {
            DiagnosisDiseaseResultNodeVO node = new DiagnosisDiseaseResultNodeVO();
            node.setDiseaseName(e.getDiseaseName());
            node.setDiseaseId(e.getId());
            return node;
        }).collect(Collectors.toList()));
        return expertDiagnosisResultResVO;
    }
}