package com.estate.expert.admin.initdata;

import com.estate.expert.admin.domain.standard.hierachy.Hierarchy;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
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.utils.tree.SimpleTreeRoot;
import com.estate.expert.admin.utils.tree.TreeNode;
import lombok.Builder;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.*;

import java.io.File;
import java.io.FileInputStream;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

@Builder
@Slf4j
public class ImportHierarchyJob {

    private UserService userService;

    private HierarchyService hierarchyService;

    public void importDepartments() {
        var root = new TreeNode<HierarchyData>("成都信立隆");
        root.addChild("技术部");
        root.addChild("人事部");
        root.addChild("设备部");
        root.addChild("后勤部");

        var hierarchy = new Hierarchy();
        hierarchy.setName("部门");
        hierarchy.setContent(new SimpleTreeRoot<>(root));
        hierarchyService.add(userService.getSystemUser(), hierarchy);
    }

    // 导入标准层级数据
    public void importSystemHierarchyData() {
        File rootFolder = new File(ImportUtil.docsRoot("/综合体系-标准-层级"));
        importHierarchy("综合体系", rootFolder, 0);
    }

    // 导入设备层级数据
    public void importDeviceHierarchyData() {
        File rootFolder = new File(ImportUtil.docsRoot("/设备体系-标准-层级"));
        importHierarchy("设备体系", rootFolder, 0);
    }

    // 导入实测实量层级数据
    public void importMeasureHierarchyData() {
        File rootFolder = new File(ImportUtil.docsRoot("/实测实量-标准-规则管理"));
        importHierarchy("实测实量体系", rootFolder, 1);
    }

    private void importHierarchy(String name, File folder, int mode) {
        var root = processFolder(folder, mode,null, null);
        var hierarchy = new Hierarchy();
        hierarchy.setName(name);
        hierarchy.setContent(new SimpleTreeRoot<>(root));
        hierarchyService.add(userService.getSystemUser(), hierarchy);
    }

    /**
    * 递归处理文件夹
     */
    private TreeNode<HierarchyData> processFolder(File folder, int mode,
                                                  TreeNode<HierarchyData> parent, Map<String, HierarchyData> dataMap) {
        var name = folder.getName();

        TreeNode<HierarchyData> node = null;
        if (parent == null) {
            node = new TreeNode<>(name, new HierarchyData(100f, 1f));
        } else {
            node = parent.addChild(name, dataMap.get(name));
        }

        var dm = mode == 0 ? loadHierarchyData(folder) : loadMeasureData(folder);
        for (var key : dm.keySet()) {
            var subFolder = new File(folder, key);
            if(!subFolder.exists()){
                log.error("未找到文件夹: {}", subFolder.getAbsolutePath());
                continue;
            }
            processFolder(subFolder, mode, node, dm);
        }
        return node;
    }

    /**
     * 从data.xlsx文件中读取层级数据
      */
    private Map<String, HierarchyData> loadHierarchyData(File folder) {
        // 读取 Excel 文件
        File excelFile = new File(folder, "data.xlsx");
        // Map<ID, name>
        SortedMap<String, HierarchyData> map = new TreeMap<>();

        if (excelFile.exists()) {
            try (FileInputStream fis = new FileInputStream(excelFile)) {
                Workbook workbook = WorkbookFactory.create(fis);
                Sheet sheet = workbook.getSheetAt(0);
                for (Row row : sheet) {
                    Cell levelNameCell = row.getCell(0);

                    String levelName = levelNameCell.getStringCellValue();
                    if (StringUtils.isBlank(levelName)) {
                        continue;
                    }

                    HierarchyData data = loadWeightData(row);

                    map.put(levelName, data);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return map;
    }

    private Map<String, HierarchyData> loadMeasureData(File folder) {
        // Map<ID, name>
        SortedMap<String, HierarchyData> map = new TreeMap<>();

        // 读取目录下的子目录
        var subFolders = folder.listFiles();
        if (subFolders == null) {
            return map;
        }
        for (File subFolder : subFolders) {
            if (subFolder.isDirectory()) {
                map.put(subFolder.getName(), null);
            }
        }
        return map;
    }

    private HierarchyData loadWeightData(Row row){
        Cell scoreCell = row.getCell(1);
        Cell weightCell = row.getCell(2);

        var score = Float.parseFloat(scoreCell.getStringCellValue());
        var weight = Float.parseFloat(weightCell.getStringCellValue());

        return new HierarchyData(score, weight);
    }
}