package com.engine.secret.service.impl;

import com.alibaba.fastjson.JSON;
import com.engine.core.impl.Service;
import com.engine.secret.entity.unpack.DataConfig;
import com.engine.secret.entity.unpack.DataConfigDetail;
import com.engine.secret.entity.unpack.FileConfig;
import com.engine.secret.exception.CustomizeRunTimeException;
import com.engine.secret.service.QualificationApplicationService;
import com.engine.secret.util.ModeUtil;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.wbi.util.Util;
import net.lingala.zip4j.ZipFile;
import net.lingala.zip4j.model.FileHeader;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;
import weaver.conn.RecordSet;
import weaver.file.ImageFileManager;
import weaver.formmode.IgnoreCaseHashMap;

import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.*;

/**
 * @author:dxfeng
 * @createTime: 2024/08/29
 * @version: 1.0
 */
public class QualificationApplicationServiceImpl extends Service implements QualificationApplicationService {

    private static String CONFIG_TABLE_NAME = "uf_bmj_sjjxpz";
    private static String CONFIG_DETAIL_TABLE_NAME = "uf_bmj_sjjxpz_dt1";
    private static String FILE_DETAIL_TABLE_NAME = "uf_bmj_sjjxpz_dt2";

    @Override
    public Map<String, Object> parsingFiles(Map<String, Object> param) {
        try {
            String imageId = Util.null2String(param.get("imageId"));
            if (StringUtils.isBlank(imageId)) {
                throw new CustomizeRunTimeException("文件获取失败,请确认文件是否上传");
            }
            Map<String, Object> returnMap = new HashMap<>();
            // 根据文件id获取文件流
            ImageFileManager manager = new ImageFileManager();
            manager.getImageFileInfoById(Integer.parseInt(imageId));
            manager.getImageFileName();
            InputStream inputStream = manager.getInputStream();

            Path tempZipFile = Files.createTempFile("temp", ".zip");
            Files.copy(inputStream, tempZipFile, StandardCopyOption.REPLACE_EXISTING);

            String password = "zizhi102!";
            //解压文件，处理压缩包
            unzipWithPassword(tempZipFile, Paths.get("output"), password);


            return returnMap;
        } catch (Exception e) {
            throw new CustomizeRunTimeException("文件解析失败", e);
        }
    }

    /**
     * 解压ZIP文件
     *
     * @param zipFilePath
     * @param outputDir
     * @param password
     */
    private void unzipWithPassword(Path zipFilePath, Path outputDir, String password) {
        try {
            ZipFile zipFile = new ZipFile(zipFilePath.toFile());
            if (zipFile.isEncrypted()) {
                zipFile.setPassword(password.toCharArray());
            }
            // 遍历并解压所有文件
            zipFile.extractAll(outputDir.toString());

            // 遍历 ZIP 内文件（可选）
            List<FileHeader> fileHeaders = zipFile.getFileHeaders();

            // 获取压缩包解析后的根目录
            Optional<String> commonRoot = fileHeaders.stream()
                    .map(FileHeader::getFileName)
                    .filter(path -> !path.trim().isEmpty())
                    .map(path -> path.split("/")[0])
                    .distinct()
                    .reduce((a, b) -> a.equals(b) ? a : null);
            String rootPath = commonRoot.orElse("");

            // TODO 测试 后续删除
            Map<String, FileHeader> fileHeaderMap = new HashMap<>();
            for (FileHeader header : fileHeaders) {
                if (header.isDirectory()) {
                    continue;
                }
                System.out.println("文件: " + header.getFileName());
                fileHeaderMap.put(header.getFileName(), header);
            }

            // 获取数据文件，用于后续数据解析
            String jsonFileName = StringUtils.isBlank(rootPath) ? "(database)data.json" : rootPath + "/(database)data.json";
            FileHeader jsonFileHeader = zipFile.getFileHeader(jsonFileName);
            if (jsonFileHeader != null) {
                // 离线端方式
                offline(zipFile, jsonFileHeader);
            }

            // TODO 兼容其他方式


        } catch (IOException e) {
            if (e.getMessage().contains("Wrong password")) {
                System.err.println("密码错误");
            } else {
                e.printStackTrace();
            }
        } finally {
            try {
                Files.deleteIfExists(zipFilePath);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 离线解析方式
     *
     * @param zipFile
     * @param jsonFileHeader
     * @throws JsonProcessingException
     */
    private void offline(ZipFile zipFile, FileHeader jsonFileHeader) throws JsonProcessingException {
        // 解析JSON文件
        String jsonContent = parseJsonContent(zipFile, jsonFileHeader);
        ObjectMapper mapper = new ObjectMapper();
        JsonNode rootNode = mapper.readTree(jsonContent);
        List<DataConfig> dataConfigList = getDataConfig("0");

        if (CollectionUtils.isNotEmpty(dataConfigList)) {
            // 遍历配置，读取配置文件，并插入数据
            for (DataConfig dataConfig : dataConfigList) {
                String mainTableName = dataConfig.getMainTableName();
                String rootPath = dataConfig.getRootPath();
                // 字段对照关系
                List<DataConfigDetail> fieldDetailList = dataConfig.getDetailList();
                // 获取明细表相关信息
                List<DataConfig> childDataConfigList = dataConfig.getChildDataConfig();
                List<FileConfig> fileList = dataConfig.getFileList();

                if (CollectionUtils.isNotEmpty(fieldDetailList)) {
                    if (StringUtils.isNotBlank(rootPath)) {
                        if (rootPath.contains("[*]")) {
                            rootPath = rootPath.replace("[*]", "");
                            JsonNode jsonNode = rootNode.at(rootPath);
                            if (null == jsonNode) {
                                throw new CustomizeRunTimeException("数据解析失败，未找到对应字段:[" + rootPath + "]");
                            }
                            if (!jsonNode.isArray()) {
                                throw new CustomizeRunTimeException("数据解析失败，未找到对应字段集合:[" + rootPath + "]");
                            }
                            for (JsonNode node : jsonNode) {
                                int billId = insertMainTable(node, mainTableName, fieldDetailList);
                                if (billId < 0) {
                                    continue;
                                }
                                dealDetailData(rootNode, billId, childDataConfigList);
                                // TODO 更新文件信息

                            }
                        } else {
                            JsonNode jsonNode = rootNode.at(rootPath);
                            int billId = insertMainTable(jsonNode, mainTableName, fieldDetailList);
                            if (billId < 0) {
                                continue;
                            }
                            dealDetailData(rootNode, billId, childDataConfigList);
                        }
                    } else {
                        int billId = insertMainTable(rootNode, mainTableName, fieldDetailList);
                        if (billId < 0) {
                            continue;
                        }
                        dealDetailData(rootNode, billId, childDataConfigList);
                    }
                }


            }
        }
    }

    /**
     * 处理明细表数据
     *
     * @param rootNode
     * @param mainId
     * @param childDataConfigList
     */
    private void dealDetailData(JsonNode rootNode, int mainId, List<DataConfig> childDataConfigList) {
        if (CollectionUtils.isEmpty(childDataConfigList)) {
            return;
        }
        for (DataConfig childDataConfig : childDataConfigList) {
            String detailTableName = childDataConfig.getDetailTableName();
            // 获取字段对照关系数据
            List<DataConfigDetail> fieldList = childDataConfig.getDetailList();
            String rootPath = childDataConfig.getRootPath();
            if (StringUtils.isNotBlank(rootPath)) {
                if (rootPath.contains("[*]")) {
                    rootPath = rootPath.replace("[*]", "");
                    JsonNode jsonNode = rootNode.at(rootPath);
                    if (null == jsonNode) {
                        throw new CustomizeRunTimeException("数据解析失败，未找到对应字段:[" + rootPath + "]");
                    }
                    if (!jsonNode.isArray()) {
                        throw new CustomizeRunTimeException("数据解析失败，未找到对应字段集合:[" + rootPath + "]");
                    }
                    for (JsonNode node : jsonNode) {
                        insertDetailTable(node, detailTableName, mainId, fieldList);
                    }
                } else {
                    JsonNode jsonNode = rootNode.at(rootPath);
                    insertDetailTable(jsonNode, detailTableName, mainId, fieldList);

                }
            } else {
                insertDetailTable(rootNode, detailTableName, mainId, fieldList);
            }
        }
    }

    /**
     * 构建主表数据,插入数据并返回数据ID
     *
     * @param jsonNode
     * @param mainTableName
     * @param fieldList
     * @return
     */
    private int insertMainTable(JsonNode jsonNode, String mainTableName, List<DataConfigDetail> fieldList) {
        Map<String, Object> insertMap = new IgnoreCaseHashMap<>();

        for (DataConfigDetail fieldDetail : fieldList) {
            String fieldName = fieldDetail.getFieldName();
            String path = fieldDetail.getPath();
            String condition = fieldDetail.getCondition();
            JsonNode atNode = jsonNode.at(path);
            if (null != atNode) {
                String value = atNode.asText();
                // 判断是否满足条件
                if (StringUtils.isNotBlank(condition) && !value.equals(condition)) {
                    return -1;
                }
                insertMap.put(fieldName, value);
            }
        }

        int size = insertMap.size();
        if (size == 0) {
            return -1;
        }
        String uuid = UUID.randomUUID().toString();
        insertMap.put("modeuuid", uuid);
        int formModeId = ModeUtil.getModeIdByTableName(mainTableName);
        insertMap.put("formmodeid", formModeId);
        // 构建主表数据插入基本字段
        // TODO  ModeUtil.buildModeInsertFields(insertMap, user.getUID());
        // 插入数据
        // TODO  ModeUtil.insertData(insertMap, mainTableName);
        // 数据权限重构,返回数据ID
        // TODO  return ModeUtil.refreshRight(uuid, mainTableName, formModeId, user.getUID());
        System.out.println("insertMainTable: " + JSON.toJSONString(insertMap));
        return 1;
    }

    /**
     * 插入明细表数据
     *
     * @param jsonNode
     * @param detailTableName
     * @param mainId
     * @param fieldList
     */
    private void insertDetailTable(JsonNode jsonNode, String detailTableName, int mainId, List<DataConfigDetail> fieldList) {
        Map<String, Object> insertMap = new IgnoreCaseHashMap<>();

        for (DataConfigDetail fieldDetail : fieldList) {
            String fieldName = fieldDetail.getFieldName();
            String path = fieldDetail.getPath();
            String condition = fieldDetail.getCondition();
            JsonNode atNode = jsonNode.at(path);
            if (null != atNode) {
                String value = atNode.asText();
                // 判断是否满足条件
                if (StringUtils.isNotBlank(condition) && !value.equals(condition)) {
                    return;
                }
                insertMap.put(fieldName, value);
            }
        }


        int size = insertMap.size();
        if (size == 0) {
            return;
        }
        insertMap.put("mainId", mainId);
        System.out.println("insertDetailTable: " + JSON.toJSONString(insertMap));
        // 插入数据
        // TODO ModeUtil.insertData(insertMap, detailTableName);
    }


    /**
     * 获取数据配置
     *
     * @param type
     * @return
     */
    private List<DataConfig> getDataConfig(String type) {
        // 获取离线包的先关配置
        List<DataConfig> dataConfigList = new ArrayList<>();
        RecordSet rs = new RecordSet();
        // TODO 表名，字段名待确定
        rs.executeQuery("select * from " + CONFIG_TABLE_NAME + " where xrbbm is not null and xrbbm !='' and  sjbly  = ?", type);
        while (rs.next()) {
            DataConfig dataConfig = new DataConfig();
            dataConfig.setId(rs.getString("id"));
            dataConfig.setMainTableName(rs.getString("xrbbm"));
            dataConfig.setDetailTableName(rs.getString("xrbmxb"));
            dataConfig.setRootPath(rs.getString("gjd"));
            // 获取字段对照关系数据
            List<DataConfigDetail> detailList = getDetailList(dataConfig.getId());
            dataConfig.setDetailList(detailList);
            dataConfig.setFileList(getFileList(dataConfig.getId()));
            // 获取明细表相关信息
            String detailTableName = dataConfig.getDetailTableName();
            if (StringUtils.isNotBlank(detailTableName)) {
                List<DataConfig> childDataConfig = getChildDataConfig(detailTableName, type);
                dataConfig.setChildDataConfig(childDataConfig);
            }

            dataConfigList.add(dataConfig);
        }
        return dataConfigList;
    }

    /**
     * 获取关联的明细表配置
     *
     * @param detailTableName
     * @param type
     * @return
     */
    private List<DataConfig> getChildDataConfig(String detailTableName, String type) {
        String[] detailNameArray = detailTableName.split(",");
        List<DataConfig> dataConfigList = new ArrayList<>();

        for (String dtName : detailNameArray) {
            RecordSet rs = new RecordSet();
            // TODO 表名，字段名待确定
            rs.executeQuery("select * from " + CONFIG_TABLE_NAME + " where (xrbbm is null or xrbbm ='') and  xrbmxb = ? and  sjbly  = ?", dtName, type);
            while (rs.next()) {
                DataConfig dataConfig = new DataConfig();
                dataConfig.setId(rs.getString("id"));
                dataConfig.setMainTableName(rs.getString("xrbbm"));
                dataConfig.setDetailTableName(rs.getString("xrbmxb"));
                dataConfig.setRootPath(rs.getString("gjd"));
                // 获取字段对照关系数据
                List<DataConfigDetail> detailList = getDetailList(dataConfig.getId());
                dataConfig.setDetailList(detailList);
                dataConfig.setFileList(getFileList(dataConfig.getId()));
                dataConfigList.add(dataConfig);
            }
        }
        return dataConfigList;
    }


    /**
     * 获取字段对照关系
     *
     * @param mainId
     * @return
     */
    private List<DataConfigDetail> getDetailList(String mainId) {
        List<DataConfigDetail> detailList = new ArrayList<>();
        RecordSet rs = new RecordSet();
        rs.executeQuery("select * from " + CONFIG_DETAIL_TABLE_NAME + " where mainId = ?", mainId);
        while (rs.next()) {
            // TODO 表名，字段名待确定
            detailList.add(DataConfigDetail.builder().fieldName(rs.getString("zdm")).path(rs.getString("wjbs")).condition(rs.getString("tj")).build());
        }
        return detailList;
    }

    /**
     * 获取文件对照关系
     *
     * @param mainId
     * @return
     */
    private List<FileConfig> getFileList(String mainId) {
        List<FileConfig> fileList = new ArrayList<>();
        RecordSet rs = new RecordSet();
        rs.executeQuery("select * from " + FILE_DETAIL_TABLE_NAME + " where mainId = ?", mainId);
        while (rs.next()) {
            // TODO 表名，字段名待确定
            fileList.add(FileConfig.builder().filedName(rs.getString("zdm")).fileId(rs.getString("wjbs")).isFilled(rs.getString("bzwj")).build());
        }
        return fileList;
    }


    /**
     * 获取JSON文件内容
     *
     * @param zipFile
     * @param header
     * @return
     */
    private static String parseJsonContent(ZipFile zipFile, FileHeader header) {
        ObjectMapper mapper = new ObjectMapper();
        try (InputStream is = zipFile.getInputStream(header)) {
            JsonNode rootNode = mapper.readTree(is);
            return rootNode.toPrettyString();
        } catch (Exception e) {
            throw new CustomizeRunTimeException(e);
        }
    }


}