/**
 * @ProjectName: 智慧评标-主观分助手
 * @Package: com.zhpb.gdyd_zhpb_zgf.service.impl
 * @ClassName: FileTypeServiceImpl
 * @Description: 文件类型服务实现类
 * @Author: 张志锋
 * @Date: 2025-11-01
 * @Version: 1.0
 * @Copyright: © 2025 智慧评标-主观分助手
 */
package com.zhpb.gdyd_zhpb_zgf.service.impl;

import com.zhpb.gdyd_zhpb_zgf.entity.mysql.FileType;
import com.zhpb.gdyd_zhpb_zgf.repository.mysql.FileTypeRepository;
import com.zhpb.gdyd_zhpb_zgf.service.FileTypeService;
import com.alibaba.fastjson2.JSON;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import jakarta.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * 文件类型服务实现类
 */
@Service
public class FileTypeServiceImpl implements FileTypeService {

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

    @Autowired
    private FileTypeRepository fileTypeRepository;

    /**
     * 初始化默认文件类型
     */
    @PostConstruct
    public void initDefaultFileTypes() {
        try {
            // 投标文件
            createOrGetFileType("投标文件", "投标相关的文件，包括投标书、报价单等", 
                    new String[]{"投标", "标书", "报价", "tender", "bid"}, 100);
            
            // 采购文件
            createOrGetFileType("采购文件", "采购相关的文件，包括采购计划、采购需求等", 
                    new String[]{"采购", "purchase", "procurement"}, 90);
            
            // 结果文件
            createOrGetFileType("结果文件", "评标结果、评审结果等相关文件", 
                    new String[]{"结果", "评审", "评标", "result", "review", "evaluation"}, 80);
            
            // 合同文件
            createOrGetFileType("合同文件", "合同相关的文件", 
                    new String[]{"合同", "contract", "agreement"}, 70);
            
            // 技术文件
            createOrGetFileType("技术文件", "技术方案、技术规范等相关文件", 
                    new String[]{"技术", "technical", "specification", "规范"}, 60);
            
            // 商务文件
            createOrGetFileType("商务文件", "商务相关的文件", 
                    new String[]{"商务", "business", "commercial"}, 50);
            
            logger.info("默认文件类型初始化完成");
        } catch (Exception e) {
            logger.error("初始化默认文件类型失败: {}", e.getMessage(), e);
        }
    }

    /**
     * 创建或获取文件类型（带关键词）
     */
    private FileType createOrGetFileType(String typeName, String description, String[] keywords, Integer priority) {
        String typeCode = generateTypeCode(typeName);
        
        Optional<FileType> existing = fileTypeRepository.findByTypeCode(typeCode);
        if (existing.isPresent()) {
            return existing.get();
        }

        FileType fileType = new FileType();
        fileType.setTypeCode(typeCode);
        fileType.setTypeName(typeName);
        fileType.setDescription(description);
        fileType.setKeywords(JSON.toJSONString(keywords != null ? List.of(keywords) : new ArrayList<>()));
        fileType.setPriority(priority != null ? priority : 0);
        fileType.setEnabled(true);

        fileTypeRepository.save(fileType);
        logger.info("创建文件类型: {} (code: {})", typeName, typeCode);
        return fileType;
    }

    @Override
    @Transactional
    public FileType identifyFileType(String fileName, String filePath) {
        if (fileName == null) {
            fileName = "";
        }
        if (filePath == null) {
            filePath = "";
        }

        // 合并文件名和路径用于匹配
        String searchText = (fileName + " " + filePath).toLowerCase();

        // 获取所有启用的文件类型，按优先级排序
        List<FileType> enabledTypes = fileTypeRepository.findByEnabledOrderByPriorityDesc(true);

        // 遍历匹配关键词
        for (FileType fileType : enabledTypes) {
            if (fileType.getKeywords() != null && !fileType.getKeywords().isEmpty()) {
                try {
                    List<String> keywords = JSON.parseArray(fileType.getKeywords(), String.class);
                    for (String keyword : keywords) {
                        if (keyword != null && !keyword.isEmpty() && searchText.contains(keyword.toLowerCase())) {
                            logger.debug("文件类型识别成功: {} -> {} (匹配关键词: {})", fileName, fileType.getTypeName(), keyword);
                            return fileType;
                        }
                    }
                } catch (Exception e) {
                    logger.warn("解析文件类型关键词失败: {}", e.getMessage());
                }
            }
        }

        // 如果无法识别，返回null或创建一个"未知类型"
        logger.debug("无法识别文件类型: {}", fileName);
        return null;
    }

    @Override
    @Transactional
    public FileType createOrGetFileType(String typeName, String description) {
        // 先尝试通过名称查找，避免重复创建
        Optional<FileType> existingByName = fileTypeRepository.findByTypeName(typeName);
        if (existingByName.isPresent()) {
            logger.debug("通过名称找到已存在的文件类型: {} -> ID={}", typeName, existingByName.get().getId());
            return existingByName.get();
        }
        
        // 如果不存在，创建新文件类型
        return createOrGetFileType(typeName, description, null, 0);
    }

    @Override
    public FileType getFileTypeByCode(String typeCode) {
        return fileTypeRepository.findByTypeCode(typeCode).orElse(null);
    }

    /**
     * 从类型名称生成类型代码
     * 对于中文名称，使用拼音首字母或直接使用名称的哈希值作为后缀
     */
    private String generateTypeCode(String typeName) {
        if (typeName == null || typeName.isEmpty()) {
            return "unknown";
        }
        
        // 先转换为小写并替换空格
        String code = typeName.toLowerCase().replaceAll("\\s+", "_");
        
        // 检查是否包含中文字符
        boolean hasChinese = code.matches(".*[\\u4e00-\\u9fa5].*");
        
        if (hasChinese) {
            // 如果包含中文，使用名称的哈希值作为代码（确保唯一性）
            // 使用typeName的哈希值，避免不同中文名称生成相同代码
            int hash = Math.abs(typeName.hashCode());
            // 对于常见的中文文件类型，使用固定映射
            if (typeName.contains("技术")) {
                return "technical_file";
            } else if (typeName.contains("商务")) {
                return "business_file";
            } else if (typeName.contains("报价")) {
                return "quotation_file";
            } else if (typeName.contains("投标")) {
                return "tender_file";
            } else if (typeName.contains("采购")) {
                return "purchase_file";
            } else if (typeName.contains("结果")) {
                return "result_file";
            } else {
                // 其他中文名称使用哈希值
                return "file_type_" + hash;
            }
        } else {
            // 不包含中文，直接移除非字母数字下划线字符
            return code.replaceAll("[^a-z0-9_]", "");
        }
    }
}

