package com.estate.expert.admin.initdata;

import com.alibaba.fastjson.JSONObject;
import com.estate.expert.admin.domain.standard.expert.ExpertFunc;
import com.estate.expert.admin.domain.standard.expert.matrix.CompareMatrix;
import com.estate.expert.admin.domain.standard.expert.system.SysExpert;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
import com.estate.expert.admin.domain.standard.model.system.SysModel;
import com.estate.expert.admin.io.processor.impl.matrix.MembershipMatrixProcessor;
import com.estate.expert.admin.initdata.common.ImportUtil;
import com.estate.expert.admin.service.HierarchyService;
import com.estate.expert.admin.service.UserService;
import com.estate.expert.admin.service.expert.DeviceExpertService;
import com.estate.expert.admin.service.expert.SysExpertService;
import com.estate.expert.admin.service.model.DeviceModelService;
import com.estate.expert.admin.service.model.SystemModelService;
import com.estate.expert.admin.utils.tree.TreeNode;
import com.estate.expert.admin.utils.tree.TreeRoot;
import lombok.Builder;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.apache.poi.ss.usermodel.*;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

/**
 * 导入专家
 **/
@Builder
@Slf4j
public class ImportExpertJob {

    private HierarchyService hierarchyService;

    private SystemModelService systemModelService;

    private DeviceModelService deviceModelService;

    private DeviceExpertService deviceExpertService;

    private SysExpertService sysExpertService;

    private UserService userService;

    public void createDefaultExpert() {
        sysExpertService.createDefaultExpert();
        deviceExpertService.createDefaultExpert();
    }

    public void importSystemExpert() throws IOException {
        var model = systemModelService.getByName("衡泰专家");
        String path = ImportUtil.docsRoot("/衡泰专家/对比矩阵/");

        for (File file : FileUtils.listFiles(new File(path), new String[]{"xlsx"}, true)) {
            String expertName = file.getName().replace(".xlsx", "");
            var expert = loadExpert(expertName, ImportUtil.docsRoot("/衡泰专家"), model);
            expert.setName(expertName + "专家D");
            sysExpertService.add(userService.getSystemUser(), expert);
        }
    }

    private SysExpert loadExpert(String name, String rootPath, SysModel model) throws IOException {
        var expert = new SysExpert();
        expert.setName(name);
        expert.setModel(model);
        expert.setExpertInquiryWeight(1.0f);
        expert.setMatrixWeight(1.0f);
        expert.setMembershipWeight(1.0f);
        expert.setExpertFuncs(List.of(ExpertFunc.FUZZY_FUNC, ExpertFunc.SCORE_FUNC));

        var hierarchy = systemModelService.getHierarchyTree(model.getId());

        // 导入关键数据
        expert.setCompareMatrixMap(loadCompareMatrixMap(hierarchy,rootPath + "/对比矩阵/" + name + ".xlsx"));
        expert.setMembershipMatrix(new MembershipMatrixProcessor().loadFromWorkbook(rootPath + "/隶属度/" + name + ".xlsx"));
        return expert;
    }

    private Map<String, CompareMatrix> loadCompareMatrixMap(TreeRoot<HierarchyData> hierarchy, String filePath) {
        Map<String, CompareMatrix> fuzzyFuncMatrix = new TreeMap<>();
        try {
            FileInputStream fileInputStream = new FileInputStream(filePath);
            Workbook workbook = WorkbookFactory.create(fileInputStream);
            int numberOfSheets = workbook.getNumberOfSheets();
            for (int i = 0; i < numberOfSheets; i++) {
                var node = sheetNameToTreeNode(hierarchy, workbook.getSheetName(i));
                //print node children names
                var childrenNames =  node.getChildren().values().stream().map(TreeNode::getName).toList();
                log.info("node:{}", childrenNames);

                var data = loadSingleCompareMatrix(workbook, i);
                fuzzyFuncMatrix.put(node.getPath(), data);
            }
        } catch (Exception e) {
            log.error("read excel error, filePath:{}", filePath, e);
        }
        return fuzzyFuncMatrix;
    }

    TreeNode<HierarchyData> sheetNameToTreeNode(TreeRoot<HierarchyData> hierarchy, String sheetName){
        String[] split = sheetName.split("_");
        var hierarchyPath = "/" + split[1].replace("-", "/");
        return hierarchy.getByNamePath(hierarchyPath);
    }

    private CompareMatrix loadSingleCompareMatrix(Workbook workbook, int i) {
        // 该sheet的内容是level & 层级名称对应的下级层级的二维矩阵数据
        Sheet sheet = workbook.getSheetAt(i);
        // 读取0行的1列到n列的数据,拼成数组, 作为indexCols
        Row indexRow = sheet.getRow(0);
        int totalCols = indexRow.getLastCellNum();
        String[] indexCols = new String[totalCols-1];
        for (int m = 1; m < totalCols; m++) {
            indexCols[m-1] = indexRow.getCell(m).getStringCellValue();
        }
        log.info("indexCols:{}", JSONObject.toJSONString(indexCols));

        // 1行1列到n行n列的数据, 拼成二维数组, 作为matrix_values
        int totalRows = sheet.getLastRowNum();
        float[][] matrixValues = new float[totalRows][totalCols-1];
        for (int n = 1; n <= totalRows; n++) {
            Row dataRow = sheet.getRow(n);
            for (int k = 1; k < totalCols; k++) {
                Cell cell = dataRow.getCell(k);
                matrixValues[n - 1][k-1] = (float) cell.getNumericCellValue();
            }
        }
        log.info("matrixValues:{}", JSONObject.toJSONString(matrixValues));
        return new CompareMatrix(indexCols, matrixValues);
    }

    public void testLoadSingleFuzzyFuncMatrix() {
        String filePath = ImportUtil.docsRoot("/衡泰专家/对比矩阵/衡泰通用01.xlsx");
        try {
            FileInputStream fileInputStream = new FileInputStream(filePath);
            Workbook workbook = WorkbookFactory.create(fileInputStream);
            loadSingleCompareMatrix(workbook, 0);
        } catch (Exception e) {
            log.error("read excel error, filePath:{}", filePath, e);
        }
    }


}