package com.estate.expert.admin.service.impl;

import com.estate.expert.admin.component.fuzzy.FuzzyApiComponent;
import com.estate.expert.admin.component.fuzzy.FuzzyApiRequest;
import com.estate.expert.admin.domain.business.device.Device;
import com.estate.expert.admin.domain.business.device.DeviceType;
import com.estate.expert.admin.domain.common.request.PageReq;
import com.estate.expert.admin.domain.common.response.PageResp;
import com.estate.expert.admin.domain.exam.eval.fuzzy.*;
import com.estate.expert.admin.domain.exam.record.error.ErrorRecord;
import com.estate.expert.admin.domain.exam.task.check.CheckTask;
import com.estate.expert.admin.domain.standard.expert.Expert;
import com.estate.expert.admin.domain.standard.expert.matrix.CompareMatrix;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
import com.estate.expert.admin.service.eval.EvalFuzzyService;
import com.estate.expert.admin.service.eval.EvalServiceImpl;
import com.estate.expert.admin.service.expert.DeviceExpertService;
import com.estate.expert.admin.service.expert.ExpertService;
import com.estate.expert.admin.service.expert.SysExpertService;
import com.estate.expert.admin.utils.tree.TreeNode;
import com.estate.expert.admin.utils.tree.helper.TreeHelper;
import lombok.extern.log4j.Log4j2;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * 模糊评价服务实现
 */
@Service
@Log4j2
public class EvalFuzzyServiceImpl extends EvalServiceImpl<EvalFuzzyResult, EvalFuzzyResultDto, EvalFuzzyResultInfo, FuzzyResult> implements EvalFuzzyService {

    @Resource
    private EvalFuzzyResultRepository repository;

    @Resource
    private FuzzyApiComponent fuzzyApi;

    @Override
    public PageResp<EvalFuzzyResultInfo> list(Integer clientId, List<Integer> planIds, List<Integer> taskIds,
                                              LocalDateTime startDate, LocalDateTime endDate, PageReq pageReq) {
        var page = repository.list(clientId, planIds, taskIds, startDate, endDate, pageReq.toPageRequest());
        return PageResp.of(page, page.getContent());
    }

    @Override
    public EvalFuzzyResult getByCheckTaskId(Integer checkTaskId) {
        return repository.getFirstByTaskIdAndDeleted(checkTaskId, false);
    }

    @Override
    public boolean enableByPass() {
        return true;
    }


    private final int BASE_LEVEL = 4; // 从这个层开始计算

    /**
     * 模糊算法
     *
     * 计算检查分项（第三级）
     * 1x1的矩阵 比较矩阵
     *
     * 从隶属度矩阵查找当前检查分项的隶属度
     * 权重，计算上一级的时候产生
     *
     * largelist用于上一级的输入，隶属度矩阵
     */
    // 根据专家的模型，构建评分树
    @Override
    protected FuzzyResult evaluate(Expert expert, SysExpertService expertService, List<ErrorRecord> records, List<String> byPassPaths){
        // 初始化问题映射表
        var problemMap = initProblemMap(expert, expertService);
        // 根据专家的模型，构建评分树
        var result = initSysResult(expert, expertService);
        return commonEvaluate(expert, expertService, problemMap, result, records, byPassPaths);
    }

    @Override
    protected FuzzyResult evaluate(Expert expert, DeviceType deviceType, DeviceExpertService expertService, List<ErrorRecord> errorRecords, List<String> byPassPaths) {     // 初始化问题映射表
        var deviceScoreResult = initDeviceResult(deviceType, expert, expertService);
        var problemMap = initDeviceProblemMap(deviceType, expert, expertService);
        return commonEvaluate(expert, expertService, problemMap, deviceScoreResult, errorRecords, byPassPaths);
    }

    @Override
    protected EvalFuzzyResult saveResult(CheckTask checkTask, FuzzyResult sysRes, Map<Integer, FuzzyResult> devResMap, List<Device> devices) {
        if(sysRes != null && sysRes.root() != null)
            checkTask.setSystemFuzzy(sysRes.root().getData().getResp().getRiskPoint());
        else
            checkTask.setSystemFuzzy(null);

        var deviceFuzzyMap = new TreeMap<Integer, Float>();
        devResMap.forEach((key, value) -> {
            if(value != null && value.root() != null) {
                deviceFuzzyMap.put(key, value.root().getData().getResp().getRiskPoint());
            }
        });
        checkTask.setDeviceFuzzyMap(deviceFuzzyMap);
        return add(null , new EvalFuzzyResult(checkTask, sysRes, devResMap));
    }

    private FuzzyResult commonEvaluate(Expert expert, ExpertService expertService,
            TreeMap<Integer, Boolean> problemMap, FuzzyResult result,
                                       List<ErrorRecord> records, List<String> byPassPaths){
        // 遍历错误记录，将隐患数量累加到对应的节点上
        count(problemMap, result, records, byPassPaths);

        // 标记要参与评分的节点
        mark(result);

        // 剪枝，只计算头3层
        result = prune(result);
        if(result.getContent() == null)
            return null;

        // 从专家中获取隶属度和判断矩阵
        update(result, expert, expertService);

        // 调用模糊计算API，去更新整个树的分值
        TreeHelper.travel(result.root(), this::computeNode);

        // 对个别需要显示的数值进行更新，便于前端展示
        prettyDisplay(result);

//        TreeHelper.printTree(result.root());
        return result;
    }

    /**
     * 标记节点，用于裁剪不需要参与计算的节点
     */
    private void mark(FuzzyResult result) {
        TreeHelper.travel(result.root(), (node) -> {
            // 只去更新非叶子节点的include属性
            if(node.getChildren().isEmpty())
                return;

            // 如果有子节点参与评分，当前节点也参与评分
            boolean include = false;
            for (var child : node.getChildren().values()) {
                if(child.getData().isInclude())
                    include = true;
            }
            node.getData().setInclude(include);
        });
    }

    // 对个别需要显示的数值进行更新，便于前端展示
    private void prettyDisplay(FuzzyResult result) {
        TreeHelper.travel(result.root(), (node) -> {
            var fuzzyValue = node.getData();
            // totalErrorCounts = errorCounts + childErrorCounts
//            fuzzyValue.setTotalErrorCounts(Stream.of(0,1,2,3)
//                    .map(i -> fuzzyValue.getErrorCounts()[i] + fuzzyValue.getChildErrorCounts()[i])
//                    .mapToInt(Integer::intValue)
//                    .toArray());
            fuzzyValue.setMembershipList(fuzzyValue.getResp().getLargeList());
            fuzzyValue.setRiskLevel(FuzzyRiskLevel.values()[5 - fuzzyValue.getResp().getRiskInterval()]);
            fuzzyValue.setScore(fuzzyValue.getResp().getRiskPoint());

            // 由于从第4层开算
            if(node.getDepth() >= BASE_LEVEL)
                return;

            // 更新权重显示
            int i = 0;
            var children = node.getChildren().values().stream().toList();
            for(var child : children) {
                child.getData().setWeight(fuzzyValue.getResp().getWeight()[i]);
                i++;
            }
        });
    }

    private void computeNode(TreeNode<FuzzyValue> node)
    {
//        log.info(node.getName());
        var fuzzyValue = node.getData();
        var compareMatrix = fuzzyValue.getCompareMatrix();

        float[][] membershipData;
        float[] subRiskPoint = new float[node.getChildren().size()];
        if(node.getChildren().isEmpty() || node.getDepth() == BASE_LEVEL) {
            membershipData = new float[][]{fuzzyValue.getMembershipList()};
            subRiskPoint = new float[0];
        }else {
            membershipData = node.getChildren().values().stream()
                    .map(child -> child.getData().getResp().getLargeList())
                    .toArray(float[][]::new);

            int i = 0;
            for(var child : node.getChildren().values()) {
                subRiskPoint[i] = child.getData().getResp().getRiskPoint();
                i++;
            }
        }

        // 调用fuzzyAPI，计算检查得分
        var request = FuzzyApiRequest.builder()
                .n(compareMatrix.getN())
                .membership_data(membershipData)
                .index(compareMatrix.getIndexCols())
                .compare_matrix_data(compareMatrix.getValues())
                .sub_riskpoint(subRiskPoint)
                .num_experts(1)
                .build();

//        log.info("node: {}, request : {}", node.getNamePath(), request);
//        log.info("path: {}, depth : {}", node.getPath(), node.getDepth());
        var response = fuzzyApi.call(request);
        fuzzyValue.setResp(response);
    }

    // 从专家中获取隶属度和判断矩阵
    private void update(FuzzyResult fuzzyResult, Expert expert, ExpertService expertService){
        TreeHelper.travel(fuzzyResult.root(), (node) -> {
            var path = node.getPath();
            var fuzzyValue = node.getData();

            // 只从第3层算
            if(node.getChildren().isEmpty() || node.getDepth() == BASE_LEVEL) {
                // 从专家中获取隶属度矩阵
                // 叶子节点，可以直接从专家中获取
                // 非叶子节点，需要由下级节点计算得到
                fuzzyValue.setMembershipList(expert.getMembershipMatrix().getData(fuzzyValue.getTotalErrorCounts()));
                fuzzyValue.setCompareMatrix(new CompareMatrix(new String[]{"空"}));
            }else{
                // 从专家中获取判断矩阵
                var indexCols = node.getChildren().values().stream().map(TreeNode::getName).toArray(String[]::new);
                var compareMatrix = expertService.getFuzzyMatrix(expert.getId(), path, indexCols);
                fuzzyValue.setCompareMatrix(compareMatrix);
            }
        });
    }

    private FuzzyResult initSysResult(Expert expert, ExpertService expertService) {
        var tree = expertService.getHierarchyTree(expert.getId());
        var root = TreeHelper.<HierarchyData, FuzzyValue>convertTree(tree.root(), (node, newNode) ->
                FuzzyValue.builder()
                        .build()
        );
        return new FuzzyResult(root);
    }

    private FuzzyResult initDeviceResult(DeviceType deviceType, Expert expert, DeviceExpertService expertService){
        var tree = expertService.getHierarchyTree(expert.getId());
        var root = TreeHelper.<HierarchyData, FuzzyValue>convertTree(tree.root(), (node, newNode) ->
                FuzzyValue.builder().build(), (n) -> {
            //删除掉非相关掉设备类型的节点
            return n.getDepth() != 1 || deviceType.hierarchyPath().equals(n.getPath());
        });

        return new FuzzyResult(root);
    }

    private void count(TreeMap<Integer, Boolean> problemMap, FuzzyResult result, List<ErrorRecord> records, List<String> byPassPaths) {
        // 遍历错误记录，将隐患数量累加到对应的节点上
        if(records != null) {
            records.forEach(errorRecord -> {
                var problem = errorRecord.getProblem();
                var ps = problemMap.get(problem.getId());

                // 如果问题不在模型中，不计算
                // 如果问题已经计算过，也不计算（同一问题的记录只计算一次）
                if (ps == null || ps)
                    return;

                problemMap.put(problem.getId(), true);

                // 计算隐患数量
                var node = result.get(problem.getHierarchyPath());
                node.getData().addError(errorRecord.getLevel());
                node.getData().setInclude(true);
            });
        }

        // 轮空项，如果设置了，则需要参与计算
        if(byPassPaths != null){
            byPassPaths.forEach(path -> {
                var node = result.get(path);
                if(node == null)
                    return;
                var scoreValue = node.getData();
                scoreValue.setInclude(true);
                node.setData(scoreValue);
            });
        }

        // 累加到上一级
        TreeHelper.travel(result.root(), (node) -> {
            var nodeData = node.getData();
            for(var child : node.getChildren().values()) {
                var childData = child.getData();
                for(var i = 0; i < 4; i++) {
                    nodeData.getChildErrorCounts()[i] += childData.getErrorCounts()[i] + childData.getChildErrorCounts()[i];
                }
            }
        });

        // 更新totalErrorCounts
        TreeHelper.travel(result.root(), (node) -> {
            var nodeData = node.getData();
            var t = new int[4];
            for(var i = 0; i < 4; i++) {
                t[i] = nodeData.getErrorCounts()[i] + nodeData.getChildErrorCounts()[i];
            }
            nodeData.setTotalErrorCounts(t);
        });
    }

    private FuzzyResult prune(FuzzyResult result) {
        var root = TreeHelper.pruneTree(result.root(), (node) -> {
//            var path = node.getPath();
//            var sumErrors = Arrays.stream(node.getData().getChildErrorCounts()).sum()
//                    + Arrays.stream(node.getData().getErrorCounts()).sum();
//            // 只显示前四级的节点，同时优化掉没有参与评分的节点
//            return sumErrors >= 0;
//            return node.getDepth() <= 5 && sumErrors >= 0;
            return node.getData().isInclude() ;
        });

        return new FuzzyResult(root);
    }
}