package com.zt.life.modules.mainPart.taskReliability.service;

import com.zt.common.service.BaseService;
import com.zt.life.modules.mainPart.basicInfo.dao.ParamDataDao;
import com.zt.life.modules.mainPart.basicInfo.dao.XhProductModelDao;
import com.zt.life.modules.mainPart.basicInfo.model.ParamData;
import com.zt.life.modules.mainPart.basicInfo.model.XhProductModel;
import com.zt.life.modules.mainPart.taskReliability.dao.*;
import com.zt.life.modules.mainPart.taskReliability.dto.TaskModelCheckResult;
import com.zt.life.modules.mainPart.taskReliability.model.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.zt.common.db.query.QueryFilter;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;


/**
 * task
 *
 * @author zt generator 
 * @since 1.0.0 2024-03-15
 */
@Service
public class TaskService  extends BaseService<TaskDao, Task> {

    @Autowired
    private OperatConditModelDao operatConditModelDao;
    @Autowired
    private ModelNodeAlgorithmDao modelNodeAlgorithmDao;
    @Autowired
    private ModelRbdDao modelRbdDao;
    @Autowired
    private XhProductModelDao xhProductModelDao;
    @Autowired
    private ParamDataDao paramDataDao;
    @Autowired
    private TaskBinoParamDao taskBinoParamDao;

    /**
     * 分页查询
     *
     * @param queryFilter
     * @return
     */
    public List<Task> page(QueryFilter queryFilter) {
        return baseDao.getList(queryFilter.getQueryParams());
    }

    /**
     * 删除
     *
     * @param ids
     */
    public void delete(Long[] ids) {
        super.deleteLogic(ids);
    }

    public List<Task> getTaskList(Long productId) {
        return  baseDao.getTaskList(productId);
    }

    /**
     * 对任务可靠性模型及其参数配置进行完整性检查，并指出以下5类错误：
     * 0）任务总时长未配置
     * 1）阶段时长未配置
     * 2）工况时长未配置
     * 3）工况模型树不完整
     * 4）建模未完成
     * 5）设备参数未配置
     * 可以对所有任务模型进行检查，也可以只检查入参指定的产品节点下的任务模型；前者适合在页面列表显示全体建模状态，后者适合对某任务进行仿真时的检查。
     * @param productId 产品节点ID（一般为总体）
     * @return 检查出的错误的List，长度为0表示没有错误，不会返回null
     */
    public List<TaskModelCheckResult> checkTaskModel(Long productId, Long taskModelId) {
        List<TaskModelCheckResult> checkResult = new ArrayList<>();
        List<XhProductModel> deviceUsedList = new ArrayList<>();    // 检查对象模型中使用到的所有设备

        // 1. 获取数据
        // 1.1 获取所有任务模型数据List
        List<Task> taskModelList = baseDao.getTaskModels(productId, taskModelId);
        // 1.2 获取所有任务模型阶段数据List
        List<TaskPhase> taskModelPhaseList = baseDao.getTaskModelPhases(productId, taskModelId);
        // 1.3 获取所有任务模型工况数据List
        List<TaskPhaseModel> taskModelPhaseModelList = baseDao.getTaskModelPhaseModels(productId, taskModelId);
        // 1.4 获取产品结构树结构数据
        List<XhProductModel> productTreeList = xhProductModelDao.getProductTree(productId);
        // 1.5 获取所有模型包含的节点数据
        List<ModelNodeAlgorithm> rbdNodeList = modelNodeAlgorithmDao.getRbdNodes();
        // 1.6 获取所有工况模型树数据List
        List<OperatConditModel> gkModelList = operatConditModelDao.getGKModelTrees(productId);
        // 1.7 获取所有RBD数据List
        Map<String, Object> mapFilter = new HashMap<>();
        mapFilter.put("productId", productId);
        List<ModelRbd> modelRbdList = modelRbdDao.getList(mapFilter);
        // 1.8 获取所有设备参数（含任务模型的二项分布参数）List
        List<ParamData> paramDataList = paramDataDao.getDeviceParams(productId);
        List<TaskBinoParam> binoParamList = taskBinoParamDao.getBinoParams(taskModelId);

        // 2. 检查每个任务模型的数据完整性（递归）
        for (Task taskModel : taskModelList) {
            if (null == taskModel.getTaskDuration() || 0.0 == taskModel.getTaskDuration()) {
                // 2.1 任务总时长未配置
                setTaskModelCheckResult(taskModel,
                        null,
                        null, null, null,
                        TaskModelCheckResult.CATEGORY_TASK_TIME, checkResult);
            }
            List<TaskPhase> phases = taskModelPhaseList.stream().filter(item ->
                    taskModel.getId().equals(item.getTaskId())).collect(Collectors.toList());
            for (TaskPhase phase : phases) {
                if (null == phase.getPhaseDurationRate() || 0.0 == phase.getPhaseDurationRate()) {
                    // 2.2 阶段时长未配置
                    setTaskModelCheckResult(taskModel,
                            phase,
                            null, null, null,
                            TaskModelCheckResult.CATEGORY_PHASE_TIME, checkResult);
                }
                List<TaskPhaseModel> phaseModels = taskModelPhaseModelList.stream().filter(item ->
                        phase.getId().equals(item.getPhaseId())).collect(Collectors.toList());
                if (phaseModels.size() <= 0) {
                    // 无工况模型数据
                    // 2.3 工况时长未配置
                    setTaskModelCheckResult(taskModel,
                            phase,
                            null, null, null,
                            TaskModelCheckResult.CATEGORY_GK_TIME, checkResult);
                } else {
                    // 有工况模型数据
                    List<TaskPhaseModel> phaseModelWithDurations = taskModelPhaseModelList.stream().filter(item ->
                            0.0 != item.getOperatConditDurationRate()).collect(Collectors.toList());
                    if (phaseModelWithDurations.size() <= 0) {
                        // 无工况模型被选用
                        // 2.3 工况时长未配置
                        for (TaskPhaseModel taskPhaseModel : phaseModels) {
                            setTaskModelCheckResult(taskModel,
                                    phase,
                                    taskPhaseModel,
                                    null, null,
                                    TaskModelCheckResult.CATEGORY_GK_TIME, checkResult);
                        }
                    } else {
                        // 有工况模型被选用，检查选用的工况模型
                        for (TaskPhaseModel taskPhaseModel : phaseModelWithDurations) {
                            // 首先找到顶层模型
                            List<OperatConditModel> gkModelTops = gkModelList.stream().filter(item ->
                                    taskPhaseModel.getOperatConditId().equals(item.getOperatConditId())
                                            && taskModel.getProductId().equals(item.getProductId())).collect(Collectors.toList());
                            if (gkModelTops.size() <= 0) {
                                // 无工况模型树根节点，即意味着无工况模型树
                                XhProductModel node = (XhProductModel) productTreeList.stream().filter(item ->
                                        taskModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
                                setTaskModelCheckResult(taskModel,
                                        phase,
                                        taskPhaseModel,
                                        null,
                                        node,
                                        TaskModelCheckResult.CATEGORY_GK_MODEL, checkResult);
                            } else {
                                // 有工况模型树，检查其完整性
//                                checkGkModel(taskModel, phase, taskPhaseModel, gkModelTops.get(0),
//                                        deviceUsedList, checkResult);
                            }
                        }
                    }
                }

            }
        }
        // 3. 返回检查结果
        return checkResult;

    }

    // 递归函数
    private void checkGkModel(Task taskModel,
                              TaskPhase phase,
                              TaskPhaseModel taskPhaseModel,
                              OperatConditModel gkModelTreeTop,
                              List<OperatConditModel> gkModelList,
                              List<ModelNodeAlgorithm> rbdNodeList,
                              List<XhProductModel> productTreeList,
                              List<XhProductModel> deviceUsedList,
                              List<TaskModelCheckResult> checkResult) {
        // 首先找到顶层模型
        List<OperatConditModel> gkModelTops = gkModelList.stream().filter(item ->
                taskPhaseModel.getOperatConditId().equals(item.getOperatConditId())
                        && taskModel.getProductId().equals(item.getProductId())).collect(Collectors.toList());
        if (gkModelTops.size() <= 0) {
            // 工况模型树不完整（顶层节点未配置模型）
            XhProductModel node = (XhProductModel) productTreeList.stream().filter(item ->
                    taskModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
            setTaskModelCheckResult(taskModel,
                    phase,
                    taskPhaseModel,
                    null,
                    node,
                    TaskModelCheckResult.CATEGORY_GK_MODEL, checkResult);
        }
    }

    private void setTaskModelCheckResult(Task taskModel,
                                         TaskPhase taskModelPhase,
                                         TaskPhaseModel taskModelPhaseModel,
                                         OperatConditModel gkModel,
                                         XhProductModel node,
                                         String category,
                                         List<TaskModelCheckResult> checkResult) {
        TaskModelCheckResult result = new TaskModelCheckResult();
        result.setCategory(category);
        result.setProductId(taskModel.getProductId());
        result.setTaskModelId(taskModel.getId());
        result.setTaskModelName(taskModel.getTaskName());
        switch(category) {
            case TaskModelCheckResult.CATEGORY_TASK_TIME:
                break;
            case TaskModelCheckResult.CATEGORY_PHASE_TIME:
                result.setTaskModelPhaseId(taskModelPhase.getId());
                result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
                break;
            case TaskModelCheckResult.CATEGORY_GK_TIME:
                result.setTaskModelPhaseId(taskModelPhase.getId());
                result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
                if (null != taskModelPhaseModel) {
                    result.setGkId(taskModelPhaseModel.getOperatConditId());
                    result.setGkName(taskModelPhaseModel.getOperatConditName());
                }
                break;
            case TaskModelCheckResult.CATEGORY_GK_MODEL:
                result.setTaskModelPhaseId(taskModelPhase.getId());
                result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
                result.setGkId(taskModelPhaseModel.getOperatConditId());
                result.setGkName(taskModelPhaseModel.getOperatConditName());
                result.setNodeId(node.getId());
                result.setNodeName(node.getName());
                break;
        }
        checkResult.add(result);
    }
}