package com.diagbot.facade;

import com.diagbot.client.PushNewServiceClient;
import com.diagbot.dto.PushBaseDTO;
import com.diagbot.dto.PushDTO;
import com.diagbot.dto.PushNewDTO;
import com.diagbot.dto.PushPlanDTO;
import com.diagbot.dto.WordCrfDTO;
import com.diagbot.enums.DiagnoseTypeEnum;
import com.diagbot.enums.DiseasePushTypeEnum;
import com.diagbot.enums.RedisEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.process.PushProcess;
import com.diagbot.util.CoreUtil;
import com.diagbot.util.ListUtil;
import com.diagbot.util.ParamUtil;
import com.diagbot.util.RedisUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.vo.PushNewVO;
import com.diagbot.vo.PushPlanVO;
import com.diagbot.vo.PushVO;
import com.diagbot.vo.StandConvert;
import com.google.common.collect.Lists;
import io.github.lvyahui8.spring.facade.DataFacade;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * @Description: 推送facade
 * @author: zhoutg
 * @time: 2018/8/6 9:11
 */
@Component
public class PushFacade {

    @Autowired
    PushProcess pushProcess;
    @Autowired
    CommonFacade commonFacade;
    @Autowired
    NeoFacade neoFacade;
    @Autowired
    FollowupPlanInfoFacade followupPlanInfoFacade;
    @Autowired
    TranHospitalInfoFacade tranHospitalInfoFacade;
    @Autowired
    PushNewServiceClient pushNewServiceClient;
    @Autowired
    RedisUtil redisUtil;

    /**
     * 推送fac(兼容新版和5.0)
     *
     * @param pushVO
     * @return
     */
    public PushDTO pushFac(PushVO pushVO) {
        String pushVersion = redisUtil.getByKeyAndField(RedisEnum.pushVersion.getName(),
                RedisEnum.hospitalId_.getName() + pushVO.getHospitalId());
        if (StringUtil.isNotBlank(pushVersion) && "old".equals(pushVersion)) {
            // 使用5.0推送
            return processAggreate(pushVO);
        } else {
            // 使用新版推送
            return pushNewFac(pushVO);
        }
    }

    public PushDTO processAggreate(PushVO pushVo) {
        // 年龄容错处理
        if (pushVo.getAgeNum() == null) {
            pushVo.setAgeNum(CoreUtil.convertAge(pushVo.getAge()));
        }
        PushDTO pushDTO = new PushDTO();
        Integer pushMode = tranHospitalInfoFacade.getPushMode(pushVo.getHospitalId());
        //全科推送，走5.0
        if (pushMode.equals(DiseasePushTypeEnum.gp.getKey())) {
            pushDTO = this.pushFacIcss(pushVo);
        } else if (pushMode.equals(DiseasePushTypeEnum.specialty.getKey())) {
            //专科推送，走6.0
            //pushDTO = this.pushFac(pushVo);
            // 2021/2/22 同老楼确认专科也走5.0
            pushDTO = this.pushFacIcss(pushVo);
        }

        return pushDTO;
    }

    /**
     * 推送调icss5.0接口
     *
     * @param pushVo
     * @return
     */
    public PushDTO pushFacIcss(PushVO pushVo) {
        Map<String, Object> debug = new LinkedHashMap<>();
        long pushStart = System.currentTimeMillis();
        PushDTO pushDTO = pushProcess.processIcss(pushVo);
        CoreUtil.getDebugStr(pushStart, "推送耗时", debug);
        pushDTO.setDebug(debug);
        return pushDTO;
    }

    /**
     * 推送业务6.0
     *
     * @param
     * @return
     */
    public PushDTO pushNewFac(PushVO pushVo) {
        PushDTO pushDTO = new PushDTO();
        Map<String, Object> debug = new LinkedHashMap<>();

        // 模型处理数据
        long start = System.currentTimeMillis();
        WordCrfDTO wordCrfDTO = commonFacade.crf_process(pushVo);
        CoreUtil.getDebugStr(start, "模型处理耗时", debug);

        // 标准词转换
        long standStart = System.currentTimeMillis();
        StandConvert standConvert = commonFacade.dataTypeGet(wordCrfDTO);
        Map<String, Map<String, String>> standConvertMap = neoFacade.standConvertCrf(standConvert);
        commonFacade.dataTypeSet(wordCrfDTO, standConvertMap);
        CoreUtil.getDebugStr(standStart, "标准词转换耗时", debug);
        ParamUtil.dealLis(wordCrfDTO.getLis());

        // 是否有界面诊断
        boolean hasDiseaseFlag = ListUtil.isNotEmpty(wordCrfDTO.getDiag()) ? true : false;

        // 无界面诊断，走诊断依据和大数据推理
        if (!hasDiseaseFlag) {
            try {
                Map<String, Object> invokeParams = new HashMap<>();
                invokeParams.put("wordCrfDTO", wordCrfDTO);
                invokeParams.put("pushNewVO", generatePushVo(wordCrfDTO));
                pushDTO = DataFacade.get("pushAll", invokeParams, PushDTO.class);
            } catch (Exception e) {
                throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "推送服务出错" + e.getMessage());
            }
            // 诊断去重、合并处理
            dealDisease(pushDTO);
        }

        // 通过诊断反推
        long reverseStart = System.currentTimeMillis();
        pushProcess.process(pushDTO, pushVo, wordCrfDTO);
        CoreUtil.getDebugStr(reverseStart, "反推业务耗时", debug);

        CoreUtil.getDebugStr(start, "总计耗时", debug);
        CoreUtil.getDebugObject("数据", debug, wordCrfDTO);
        pushDTO.getDebug().putAll(debug);
        return pushDTO;
    }

    /**
     * 诊断去重、合并处理
     * @param pushDTO
     */
    public void dealDisease(PushDTO pushDTO) {
        Map<String, List<PushBaseDTO>> dis = pushDTO.getDis();
        List<PushBaseDTO> possibleUnion = Lists.newArrayList(); // 可能诊断 = 确诊 + 拟诊 + 大数据推送诊断
        List<PushBaseDTO> definite = dis.get(DiagnoseTypeEnum.definite.getName()); // 确诊
        List<PushBaseDTO> protocol = dis.get(DiagnoseTypeEnum.protocol.getName()); // 拟诊
        List<PushBaseDTO> bigDataPush = dis.get(DiagnoseTypeEnum.bigDataPush.getName()); // 大数据推送诊断
        // 合并可能诊断
        if (ListUtil.isNotEmpty(definite)) {
            possibleUnion.addAll(definite);
        }
        if (ListUtil.isNotEmpty(protocol)) {
            possibleUnion.addAll(protocol);
        }
        if (ListUtil.isNotEmpty(bigDataPush)) {
            possibleUnion.addAll(bigDataPush);
        }
        // 去重
        if (ListUtil.isNotEmpty(possibleUnion)) {
            List<String> diseaseNameList = Lists.newArrayList();
            Iterator<PushBaseDTO> it = possibleUnion.iterator();
            while (it.hasNext()) {
                PushBaseDTO bean = it.next();
                if (diseaseNameList.contains(bean.getName())) {
                    it.remove();
                } else {
                    diseaseNameList.add(bean.getName());
                }
            }
            // 添加可能诊断
            dis.put(DiagnoseTypeEnum.possibleUnion.getName(), possibleUnion);
            // 如果需要删除诊断，就用以下代码
            // dis.put(DiagnoseTypeEnum.possibleUnion.getName(), BeanUtil.listCopyTo(possibleUnion, PushDTO.class));
        }
    }

    /**
     * 生成新版推送入参
     *
     * @param wordCrfDTO
     * @return
     */
    public PushNewVO generatePushVo(WordCrfDTO wordCrfDTO) {
        PushNewVO pushNewVO = new PushNewVO();
        pushNewVO.setChief(wordCrfDTO.getChief());
        pushNewVO.setPresent(wordCrfDTO.getSymptom());
        pushNewVO.setAge(wordCrfDTO.getAgeNum());
        pushNewVO.setSex(wordCrfDTO.getSex());
        String pushType = redisUtil.getByKeyAndField(RedisEnum.hospitalPushType.getName(), String.valueOf(wordCrfDTO.getHospitalId()));
        if (StringUtil.isNotBlank(pushType)) {
            pushNewVO.setHospitalType(pushType);
        }
        return pushNewVO;
    }

    /**
     * 手术随访计划（持续检验检查）推送
     *
     * @param pushPlanVO
     * @return
     */
    public PushPlanDTO pushPlan(PushPlanVO pushPlanVO) {
        Map<String, Object> debug = new LinkedHashMap<>();
        long l1 = System.currentTimeMillis();
        PushPlanDTO pushPlanDTO = new PushPlanDTO();
        if (pushPlanVO.getOperationName() != null) {
            WordCrfDTO wordCrfDTO = new WordCrfDTO();
            wordCrfDTO.setOperationName(pushPlanVO.getOperationName());
            // 标准词转换
            long standStart = System.currentTimeMillis();
            StandConvert standConvert = commonFacade.dataTypeGet(wordCrfDTO);
            Map<String, Map<String, String>> standConvertMap = neoFacade.standConvertCrf(standConvert);
            commonFacade.dataTypeSet(wordCrfDTO, standConvertMap);
            CoreUtil.getDebugStr(standStart, "标准词转换耗时", debug);
            // 推送随访计划
            long pushStart = System.currentTimeMillis();
            pushPlanDTO = followupPlanInfoFacade.getFollowUpPlans(pushPlanVO.getOperationName(), pushPlanVO.getHospitalId());
            CoreUtil.getDebugStr(pushStart, "推送耗时", debug);
            pushPlanDTO.setDebug(debug);
        }
        CoreUtil.getDebugStr(l1, "本次调用总计耗时", debug);

        return pushPlanDTO;
    }

    /**
     * 测试新版推送
     *
     * @param pushNewVO
     * @return
     */
    public PushNewDTO testPushFac(PushNewVO pushNewVO) {
        return pushNewServiceClient.pushNew(pushNewVO);
    }

}