/**
 * @ProjectName: 智慧评标-主观分助手
 * @Package: com.zhpb.gdyd_zhpb_zgf.utils
 * @ClassName: FilePathOrganizer
 * @Description: 文件路径整理工具类，将文件路径按照公司、文件类型（技术文件、商务文件、报价文件）进行分组
 * @Author: 张志锋
 * @Date: 2025-10-31
 * @Version: 1.0
 * @Copyright: © 2025 智慧评标-主观分助手
 */
package com.zhpb.gdyd_zhpb_zgf.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;

/**
 * 文件路径整理工具类
 * 将文件路径按照公司、文件类型进行分组
 */
public class FilePathOrganizer {

    private static final Logger logger = LoggerFactory.getLogger(FilePathOrganizer.class);

    /**
     * 文件类型映射
     */
    private static final Map<String, String> FILE_TYPE_MAP = new HashMap<>();
    
    static {
        FILE_TYPE_MAP.put("技术文件", "技术文件");
        FILE_TYPE_MAP.put("商务文件", "商务文件");
        FILE_TYPE_MAP.put("报价文件", "报价文件");
    }

    /**
     * 整理文件路径，按照公司和文件类型分组
     * 
     * @param filePaths 文件路径列表
     * @return 整理后的JSON结构：{"公司1": {"技术文件": [...], "商务文件": [...]}}
     */
    public static Map<String, Map<String, List<String>>> organizeByCompanyAndType(List<String> filePaths) {
        // 结果：Map<公司名, Map<文件类型, List<文件路径>>>
        Map<String, Map<String, List<String>>> result = new LinkedHashMap<>();
        
        logger.info("开始整理文件路径，共 {} 个文件", filePaths.size());

        for (String filePath : filePaths) {
            try {
                logger.debug("处理文件路径: {}", filePath);
                // 统一处理路径分隔符（Windows和Linux兼容）
                String normalizedPath = filePath.replace('\\', '/');
                
                // 从路径中提取关键信息
                // 路径结构: .../extracts/项目目录/公司名_xxx/文件类型-xxx/投标文件/结果文件/文件名.pdf
                String[] pathSegments = normalizedPath.split("/");
                
                String companyName = null;
                String fileType = null;
                
                // 从后往前查找文件类型和公司名
                for (int i = pathSegments.length - 1; i >= 0; i--) {
                    String segment = pathSegments[i];
                    
                    // 查找文件类型（技术文件、商务文件、报价文件）
                    // 支持匹配：技术文件、技术文件-2507161938、技术文件-xxx等形式
                    if (fileType == null) {
                        for (String type : FILE_TYPE_MAP.keySet()) {
                            // 精确匹配或包含文件类型关键词（注意：先精确匹配，再匹配带横线的）
                            if (segment.equals(type) || segment.startsWith(type + "-") || 
                                (segment.length() >= type.length() && segment.substring(0, type.length()).equals(type))) {
                                fileType = FILE_TYPE_MAP.get(type);
                                logger.debug("从路径段 '{}' 中识别出文件类型: {}", segment, fileType);
                                break;
                            }
                        }
                    }
                    
                    // 查找公司名（在文件类型之前的一个包含"公司"的段）
                    if (fileType != null && companyName == null && i > 0) {
                        String prevSegment = pathSegments[i - 1];
                        if (prevSegment.contains("公司") || prevSegment.contains("企业") || 
                            prevSegment.contains("有限") || prevSegment.contains("股份") ||
                            prevSegment.contains("集团") || prevSegment.contains("物流") ||
                            prevSegment.contains("供应链") || prevSegment.contains("科技") ||
                            prevSegment.contains("管理")) {
                            // 去掉后缀如"_虚拟标段_标包1_文件"
                            // 提取公司名：找到包含"公司"、"企业"、"有限"、"股份"的部分，但保留完整公司名
                            String[] parts = prevSegment.split("_");
                            StringBuilder companyBuilder = new StringBuilder();
                            boolean foundCompanyKeyword = false;
                            
                            // 改进逻辑：完整保留包含公司关键词的所有部分
                            for (String part : parts) {
                                // 如果是项目相关后缀，停止
                                if (part.contains("虚拟") || part.contains("标段") || 
                                    part.contains("标包") || part.contains("文件") ||
                                    part.matches("\\d+")) {
                                    // 如果已经找到了公司关键词，说明后面的都是后缀，停止
                                    if (foundCompanyKeyword) {
                                        break;
                                    }
                                    // 如果还没找到公司关键词，这个部分可能不是公司名的一部分，跳过
                                    continue;
                                }
                                
                                // 添加部分到公司名
                                if (companyBuilder.length() > 0) {
                                    companyBuilder.append("_");
                                }
                                companyBuilder.append(part);
                                
                                // 检查是否包含公司关键词
                                if (part.contains("公司") || part.contains("企业") || 
                                    part.contains("有限") || part.contains("股份")) {
                                    foundCompanyKeyword = true;
                                }
                            }
                            
                            // 如果成功构建了公司名，使用它；否则使用第一个部分（不含后缀）
                            if (companyBuilder.length() > 0) {
                                companyName = companyBuilder.toString();
                                // 如果公司名以"_"结尾，去掉最后一个"_"
                                if (companyName.endsWith("_")) {
                                    companyName = companyName.substring(0, companyName.length() - 1);
                                }
                            } else {
                                // 如果构建失败，尝试使用第一个非后缀部分
                                for (String part : parts) {
                                    if (!part.contains("虚拟") && !part.contains("标段") && 
                                        !part.contains("标包") && !part.contains("文件")) {
                                        companyName = part;
                                        break;
                                    }
                                }
                                if (companyName == null) {
                                    companyName = prevSegment.split("_")[0];
                                }
                            }
                            
                            logger.debug("从路径段 '{}' 中识别出公司名: {}", prevSegment, companyName);
                            break;
                        }
                    }
                }

                // 如果仍然没找到，使用更宽松的匹配
                if (companyName == null || fileType == null) {
                    // 重新搜索，使用更宽松的条件
                    for (int i = 0; i < pathSegments.length; i++) {
                        String segment = pathSegments[i];
                        
                        // 查找文件类型（支持精确匹配或包含）
                        if (fileType == null) {
                            for (String type : FILE_TYPE_MAP.keySet()) {
                                // 精确匹配或包含文件类型关键词
                                if (segment.equals(type) || segment.startsWith(type + "-") || segment.startsWith(type)) {
                                    fileType = FILE_TYPE_MAP.get(type);
                                    break;
                                }
                            }
                        }
                        
                        // 查找公司名（包含中文且可能包含公司关键词）
                        if (fileType != null && companyName == null && i > 0) {
                            String prevSegment = pathSegments[i - 1];
                            // 如果上一段包含中文且不是项目目录（不包含project-）
                            if (!prevSegment.contains("project-") && 
                                prevSegment.matches(".*[\\u4e00-\\u9fa5].*")) {
                                // 改进处理：尝试提取完整公司名（去掉后缀）
                                String[] parts = prevSegment.split("_");
                                StringBuilder companyBuilder = new StringBuilder();
                                
                                for (String part : parts) {
                                    // 如果是项目相关后缀，停止
                                    if (part.contains("虚拟") || part.contains("标段") || 
                                        part.contains("标包") || part.contains("文件")) {
                                        break;
                                    }
                                    
                                    if (companyBuilder.length() > 0) {
                                        companyBuilder.append("_");
                                    }
                                    companyBuilder.append(part);
                                    
                                    // 如果遇到公司关键词，可能已经找到了完整的公司名
                                    if (part.contains("公司") || part.contains("企业") || 
                                        part.contains("有限") || part.contains("股份")) {
                                        // 继续查找，看是否还有后续部分（如"管理有限公司"）
                                        // 但如果有"虚拟"、"标段"等后缀，则停止
                                    }
                                }
                                
                                if (companyBuilder.length() > 0) {
                                    companyName = companyBuilder.toString();
                                    if (companyName.endsWith("_")) {
                                        companyName = companyName.substring(0, companyName.length() - 1);
                                    }
                                } else {
                                    // 如果构建失败，使用第一个部分
                                    companyName = parts[0];
                                    if (companyName.length() < 2) {
                                        companyName = prevSegment; // 如果太短，使用完整段
                                    }
                                }
                                
                                logger.debug("从宽松匹配中识别出公司名: {} -> {}", prevSegment, companyName);
                                break;
                            }
                        }
                    }
                }

                // 如果仍然没找到，使用默认值
                if (companyName == null || companyName.trim().isEmpty()) {
                    companyName = "未知公司";
                    logger.warn("无法从路径中提取公司名: {}", filePath);
                }
                
                if (fileType == null) {
                    fileType = "其他文件";
                    logger.warn("无法从路径中提取文件类型: {}", filePath);
                }

                // 添加到结果中
                result.computeIfAbsent(companyName, k -> new LinkedHashMap<>())
                      .computeIfAbsent(fileType, k -> new ArrayList<>())
                      .add(filePath);
                
                logger.debug("文件已分类: 公司={}, 类型={}, 文件={}", companyName, fileType, 
                        java.nio.file.Paths.get(filePath).getFileName().toString());

            } catch (Exception e) {
                logger.error("处理文件路径失败: {}, 错误: {}", filePath, e.getMessage(), e);
            }
        }
        
        // 统计信息
        logger.info("文件整理完成，共识别出 {} 个公司", result.size());
        for (Map.Entry<String, Map<String, List<String>>> entry : result.entrySet()) {
            String companyName = entry.getKey();
            Map<String, List<String>> fileTypes = entry.getValue();
            int totalFiles = fileTypes.values().stream().mapToInt(List::size).sum();
            logger.info("公司: {}, 总文件数: {}, 类型分布: {}", companyName, totalFiles, 
                    fileTypes.entrySet().stream()
                        .map(e -> e.getKey() + "(" + e.getValue().size() + ")")
                        .collect(java.util.stream.Collectors.joining(", ")));
        }

        // 确保每个公司都有完整的文件类型结构（技术文件、商务文件、报价文件），即使为空也显示空数组
        List<String> requiredFileTypes = Arrays.asList("技术文件", "商务文件", "报价文件");
        for (Map.Entry<String, Map<String, List<String>>> entry : result.entrySet()) {
            String companyName = entry.getKey();
            Map<String, List<String>> companyFiles = entry.getValue();
            for (String requiredType : requiredFileTypes) {
                // 如果缺少某个文件类型，添加空数组
                if (!companyFiles.containsKey(requiredType)) {
                    companyFiles.put(requiredType, new ArrayList<>());
                    logger.debug("为公司 '{}' 补充缺失的文件类型: {}", companyName, requiredType);
                }
            }
        }

        return result;
    }
}

