package com.boyue.hasfj.service.impl;

import java.util.List;
import java.io.File;
import com.boyue.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import com.boyue.hasfj.mapper.HtmlPagesMapper;
import com.boyue.hasfj.domain.HtmlPages;
import com.boyue.hasfj.service.IHtmlPagesService;
import com.boyue.common.utils.StringUtils;
import com.boyue.common.utils.file.FileUtils;
import com.boyue.common.exception.ServiceException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

/**
 * 司法局法律规定、典型案例、单下载Service业务层处理
 * 
 * @author boyue
 * @date 2025-05-28
 */
@Service
public class HtmlPagesServiceImpl implements IHtmlPagesService 
{
    private static final Logger log = LoggerFactory.getLogger(HtmlPagesServiceImpl.class);

    @Autowired
    private HtmlPagesMapper htmlPagesMapper;
    
    @Value("${boyue.profile}")
    private String uploadPath;

    /**
     * 查询司法局法律规定、典型案例、单下载
     * 
     * @param id 司法局法律规定、典型案例、单下载主键
     * @return 司法局法律规定、典型案例、单下载
     */
    @Override
    public HtmlPages selectHtmlPagesById(Long id)
    {
        return htmlPagesMapper.selectHtmlPagesById(id);
    }
    
    /**
     * 根据formatId查询司法局法律规定、典型案例、单下载
     *
     * @param formatId 访问ID
     * @return 司法局法律规定、典型案例、单下载
     */
    @Override
    public HtmlPages selectHtmlPagesByFormatId(String formatId)
    {
        if (StringUtils.isEmpty(formatId))
        {
            return null;
        }
        return htmlPagesMapper.selectHtmlPagesByFormatId(formatId);
    }

    /**
     * 查询司法局法律规定、典型案例、单下载列表
     * 
     * @param htmlPages 司法局法律规定、典型案例、单下载
     * @return 司法局法律规定、典型案例、单下载
     */
    @Override
    public List<HtmlPages> selectHtmlPagesList(HtmlPages htmlPages)
    {
        return htmlPagesMapper.selectHtmlPagesList(htmlPages);
    }
    
    /**
     * 根据页面类型查询列表
     *
     * @param pageType 页面类型
     * @return 司法局法律规定、典型案例、单下载集合
     */
    @Override
    public List<HtmlPages> selectHtmlPagesListByType(String pageType)
    {
        return htmlPagesMapper.selectHtmlPagesListByType(pageType);
    }

    /**
     * 新增司法局法律规定、典型案例、单下载
     * 
     * @param htmlPages 司法局法律规定、典型案例、单下载
     * @return 结果
     */
    @Override
    public int insertHtmlPages(HtmlPages htmlPages)
    {
        // 验证多附件格式
        validateMultiAttachments(htmlPages);
        
        htmlPages.setCreateTime(DateUtils.getNowDate());
        return htmlPagesMapper.insertHtmlPages(htmlPages);
    }

    /**
     * 修改司法局法律规定、典型案例、单下载
     * 
     * @param htmlPages 司法局法律规定、典型案例、单下载
     * @return 结果
     */
    @Override
    public int updateHtmlPages(HtmlPages htmlPages)
    {
        // 验证多附件格式
        validateMultiAttachments(htmlPages);
        
        htmlPages.setUpdateTime(DateUtils.getNowDate());
        return htmlPagesMapper.updateHtmlPages(htmlPages);
    }

    /**
     * 更新页面浏览次数（增加专门的方法处理浏览次数更新）
     *
     * @param id 页面ID
     * @return 结果
     */
    @Override
    public int updateHtmlPagesViewCount(Long id)
    {
        if (id == null || id <= 0) {
            return 0;
        }
        return htmlPagesMapper.updateHtmlPagesViewCount(id);
    }

    /**
     * 批量删除司法局法律规定、典型案例、单下载
     * 
     * @param ids 需要删除的司法局法律规定、典型案例、单下载主键
     * @return 结果
     */
    @Override
    public int deleteHtmlPagesByIds(Long[] ids)
    {
        return htmlPagesMapper.deleteHtmlPagesByIds(ids);
    }

    /**
     * 删除司法局法律规定、典型案例、单下载信息
     * 
     * @param id 司法局法律规定、典型案例、单下载主键
     * @return 结果
     */
    @Override
    public int deleteHtmlPagesById(Long id)
    {
        return htmlPagesMapper.deleteHtmlPagesById(id);
    }

    /**
     * 验证附件格式
     * 
     * @param htmlPages 页面对象
     */
    private void validateMultiAttachments(HtmlPages htmlPages)
    {
        if (htmlPages.getMultiAttachments() != null && !htmlPages.getMultiAttachments().trim().startsWith("["))
        {
            log.warn("附件格式不正确，将重置为空数组: {}", htmlPages.getMultiAttachments());
            htmlPages.setMultiAttachments("[]");
        }
    }

    /**
     * 导入数据
     * 
     * @param htmlPagesList 司法局法律规定、典型案例、单下载数据列表
     * @param updateSupport 是否更新已存在的数据
     * @param operName 操作人
     * @return 导入结果消息
     */
    @Override
    public String importHtmlPages(List<HtmlPages> htmlPagesList, boolean updateSupport, String operName)
    {
        if (StringUtils.isNull(htmlPagesList) || htmlPagesList.size() == 0)
        {
            throw new ServiceException("导入数据不能为空！");
        }
        int successNum = 0;
        int failureNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        for (HtmlPages htmlPages : htmlPagesList)
        {
            try
            {
                // 验证是否存在这个用户
                HtmlPages existHtmlPages = selectHtmlPagesByFormatId(htmlPages.getFormatId());
                if (StringUtils.isNull(existHtmlPages))
                {
                    htmlPages.setCreateBy(operName);
                    htmlPages.setCreateTime(DateUtils.getNowDate());
                    htmlPages.setUpdateBy(operName);
                    htmlPages.setUpdateTime(DateUtils.getNowDate());
                    // 设置默认值
                    if (htmlPages.getStatus() == null)
                    {
                        htmlPages.setStatus(1); // 默认启用
                    }
                    if (htmlPages.getSortOrder() == null)
                    {
                        htmlPages.setSortOrder(0L); // 默认排序值
                    }
                    if (htmlPages.getViewCount() == null)
                    {
                        htmlPages.setViewCount(0L); // 默认浏览量为0
                    }
                    if (StringUtils.isEmpty(htmlPages.getMultiAttachments()))
                    {
                        htmlPages.setMultiAttachments("[]"); // 默认附件为空数组
                    }
                    this.insertHtmlPages(htmlPages);
                    successNum++;
                    successMsg.append("<br/>" + successNum + "、页面标题 " + htmlPages.getTitle() + " 导入成功");
                }
                else if (updateSupport)
                {
                    htmlPages.setId(existHtmlPages.getId());
                    htmlPages.setUpdateBy(operName);
                    htmlPages.setUpdateTime(DateUtils.getNowDate());
                    this.updateHtmlPages(htmlPages);
                    successNum++;
                    successMsg.append("<br/>" + successNum + "、页面标题 " + htmlPages.getTitle() + " 更新成功");
                }
                else
                {
                    failureNum++;
                    failureMsg.append("<br/>" + failureNum + "、页面标题 " + htmlPages.getTitle() + " 已存在");
                }
            }
            catch (Exception e)
            {
                failureNum++;
                String msg = "<br/>" + failureNum + "、页面标题 " + htmlPages.getTitle() + " 导入失败：";
                failureMsg.append(msg + e.getMessage());
                log.error(msg, e);
            }
        }
        if (failureNum > 0)
        {
            failureMsg.insert(0, "很抱歉，导入失败！共 " + failureNum + " 条数据格式不正确，错误如下：");
            throw new ServiceException(failureMsg.toString());
        }
        else
        {
            successMsg.insert(0, "恭喜您，数据已全部导入成功！共 " + successNum + " 条，数据如下：");
        }
        return successMsg.toString();
    }
    
    /**
     * 删除附件
     *
     * @param attachmentUrl 附件URL
     * @return 删除结果
     */
    @Override
    public boolean deleteAttachment(String attachmentUrl) {
        if (StringUtils.isEmpty(attachmentUrl)) {
            return false;
        }
        
        log.info("删除附件: {}", attachmentUrl);
        
        // 处理URL格式问题
        String processedUrl = attachmentUrl;
        
        // 处理URL中可能存在的双斜杠问题
        if (processedUrl.contains("://")) {
            final int baseUrlPart = processedUrl.indexOf("://") + 3;
            processedUrl = processedUrl.substring(0, baseUrlPart) +
                    processedUrl.substring(baseUrlPart).replace("//", "/");
        }
        
        // 提取相对路径
        String relativePath = null;
        
        // 格式1: 包含/profile/的完整URL
        if (processedUrl.contains("/profile/")) {
            final int pathIndex = processedUrl.indexOf("/profile/");
            if (pathIndex >= 0) {
                relativePath = processedUrl.substring(pathIndex + 9); // 9是'/profile/'的长度
            }
        }
        
        // 格式2: 包含年月日格式的路径
        if (relativePath == null) {
            java.util.regex.Matcher yearMatch = java.util.regex.Pattern.compile("/(\\d{4}/\\d{2}/\\d{2}/[^/]+)$").matcher(processedUrl);
            if (yearMatch.find()) {
                relativePath = yearMatch.group(1);
            }
        }
        
        // 格式3: files/master/路径格式
        if (relativePath == null && processedUrl.contains("/files/master/")) {
            final int pathIndex = processedUrl.indexOf("/files/master/");
            if (pathIndex >= 0) {
                relativePath = processedUrl.substring(pathIndex + 1); // 保留files/master/前缀
            }
        }
        
        // 如果提取到了相对路径，进行进一步处理
        if (relativePath != null) {
            // 检查是否为年份格式的路径，如果是且不包含files/master前缀，则添加
            if (relativePath.matches("^\\d{4}/\\d{2}/\\d{2}/.*") && !relativePath.contains("files/master")) {
                relativePath = "files/master/" + relativePath;
            }
            
            log.info("提取的相对路径: {}", relativePath);
            return deleteFileByPath(relativePath);
        }
        
        // 如果以上方法都无法提取路径，则直接尝试删除
        log.info("无法提取相对路径，尝试直接删除: {}", processedUrl);
        File file = new File(uploadPath + File.separator + processedUrl);
        if (file.exists() && file.isFile()) {
            boolean result = file.delete();
            log.info("直接删除文件结果: {}", result ? "成功" : "失败");
            return result;
        }
        
        log.warn("找不到文件: {}", processedUrl);
        return false;
    }

    /**
     * 根据路径删除文件
     *
     * @param path 文件路径
     * @return 删除结果
     */
    @Override
    public boolean deleteFileByPath(String path) {
        if (StringUtils.isEmpty(path)) {
            return false;
        }
        
        log.info("根据路径删除文件: {}", path);
        
        // 处理路径格式，确保正斜杠格式
        String processedPath = path;
        if (path.contains("\\")) {
            processedPath = path.replace("\\", "/");
        }
        
        // 确保没有连续的双斜杠（除了http://这种协议部分）
        if (processedPath.contains("://")) {
            String[] parts = processedPath.split("://", 2);
            String protocolPart = parts[0] + "://";
            String pathPart = parts[1].replace("//", "/");
            processedPath = protocolPart + pathPart;
        } else {
            processedPath = processedPath.replace("//", "/");
        }
        
        // 构建完整文件路径
        String fullPath = uploadPath + File.separator + processedPath;
        log.info("完整文件路径: {}", fullPath);
        
        // 规范化路径
        fullPath = fullPath.replace("/", File.separator);
        
        File file = new File(fullPath);
        if (file.exists() && file.isFile()) {
            boolean result = file.delete();
            log.info("删除文件结果: {}", result ? "成功" : "失败");
            return result;
        }
        
        // 如果找不到文件，可能是因为路径问题，尝试直接在upload目录下查找
        String fileName = new File(processedPath).getName();
        try {
            Files.walk(Paths.get(uploadPath))
                .filter(Files::isRegularFile)
                .filter(p -> p.getFileName().toString().equals(fileName))
                .forEach(p -> {
                    try {
                        Files.deleteIfExists(p);
                        log.info("通过文件名查找并删除: {}", p);
                    } catch (IOException e) {
                        log.error("删除文件失败: {}", p, e);
                    }
                });
            return true;
        } catch (IOException e) {
            log.error("搜索文件失败", e);
        }
        
        log.warn("找不到文件: {}", fullPath);
        return false;
    }
}
