package com.yd.oss.service.service.impl;

import cn.afterturn.easypoi.excel.ExcelExportUtil;
import cn.afterturn.easypoi.excel.entity.ExportParams;
import cn.afterturn.easypoi.excel.entity.enmus.ExcelType;
import cn.afterturn.easypoi.excel.entity.params.ExcelExportEntity;
import com.alibaba.fastjson.JSON;
import com.yd.oss.feign.dto.ExportParam;
import com.yd.oss.feign.dto.ExportResult;
import com.yd.oss.feign.dto.SheetExportConfig;
import com.yd.oss.feign.request.MultiSheetExportRequest;
import com.yd.oss.service.dto.OssUploadFileResDto;
import com.yd.oss.service.service.ExcelExportService;
import com.yd.oss.service.service.OssService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.lang.reflect.Field;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

/**
 * excel导出实现类
 */
@Slf4j
@Service
public class ExcelExportServiceImpl implements ExcelExportService {

    // 注入OSS服务，用于文件上传
    @Autowired
    private OssService ossService;

    /**
     *
     * 导出Excel并上传到OSS
     * @param dataList 需要导出的数据列表
     * @param exportParam 导出参数配置
     * @param entityClass 实体类类型
     * @return 导出结果
     */
    @Override
    public ExportResult exportAndUploadToOss(List<?> dataList, ExportParam exportParam, Class<?> entityClass) {
        log.info("导出Excel并上传到OSS:dataList,{}", JSON.toJSONString(dataList));
        log.info("导出Excel并上传到OSS:exportParam,{}", JSON.toJSONString(exportParam));
        log.info("导出Excel并上传到OSS:entityClass,{}", JSON.toJSONString(entityClass));
        // 添加参数校验
        if (exportParam == null) {
            return ExportResult.error("导出参数不能为空");
        }
        if (CollectionUtils.isEmpty(exportParam.getFieldNames())) {
            return ExportResult.error("导出字段列表不能为空");
        }

        // 声明输出流和工作簿变量，用于后续资源关闭
        ByteArrayOutputStream outputStream = null;
        Workbook workbook = null;

        try {
            // 根据实体类字段和导出参数构建Excel导出列配置
            List<ExcelExportEntity> entityList = buildExportEntities(exportParam.getFieldNames(), entityClass);

            // 将数据列表转换为Map结构，便于EasyPOI处理
            List<Map<String, Object>> dataMapList = buildDataMapList(dataList, exportParam.getFieldNames(), entityClass);

            // 添加空数据检查
            if (CollectionUtils.isEmpty(dataMapList)) {
                // 创建一个空数据的Map，确保至少有表头
                dataMapList = new ArrayList<>();
                Map<String, Object> emptyMap = new HashMap<>();
                for (String fieldName : exportParam.getFieldNames()) {
                    emptyMap.put(fieldName, "");
                }
                dataMapList.add(emptyMap);
            }

            // 检查entityList是否为空
            if (CollectionUtils.isEmpty(entityList)) {
                return ExportResult.error("导出列配置不能为空");
            }

            // 创建字节数组输出流，用于将Excel数据写入内存
            outputStream = new ByteArrayOutputStream();
            // 设置导出参数：无标题、工作表名称为sheet1、使用XSSF格式（支持.xlsx）
            ExportParams params = new ExportParams(null, "sheet1", ExcelType.XSSF);

            // 确保params不为null
            if (params == null) {
                params = new ExportParams();
            }

            // 使用EasyPOI导出Excel到工作簿
            workbook = ExcelExportUtil.exportExcel(params, entityList, dataMapList);
            // 检查workbook是否创建成功
            if (workbook == null) {
                return ExportResult.error("Excel工作簿创建失败");
            }
            // 将工作簿内容写入输出流
            workbook.write(outputStream);

            // 获取Excel文件的字节数组和文件大小
            byte[] excelBytes = outputStream.toByteArray();
            long fileSize = excelBytes.length;

            // 根据参数决定是否上传到OSS
            if (Boolean.TRUE.equals(exportParam.getUploadToOss())) {
                // 将字节数组转换为输入流，供OSS上传使用
                ByteArrayInputStream inputStream = new ByteArrayInputStream(excelBytes);

                // 生成包含时间戳的文件名，避免重复
                String fileName = generateExcelFileName(exportParam.getFileName());

                // 调用OSS服务上传文件到云端存储
                OssUploadFileResDto uploadResult = ossService.uploadFile(
                        inputStream,        // Excel文件输入流
                        fileName,           // 生成的文件名
                        "",                 // 存储桶名称（空字符串表示使用默认存储桶）
                        "",                 // 上传用户标识（空字符串表示匿名或系统用户）
                        "excel",             // 文件分类类型，对应OSS文件夹目录
                        ""
                );

                // 返回成功结果，包含文件URL和大小信息
                return ExportResult.success(uploadResult.getUrl(), fileSize);
            } else {
                // 如果不需要上传到OSS，仅返回文件大小信息
                return ExportResult.success(null, fileSize);
            }

        } catch (Exception e) {
            // 打印异常堆栈，便于调试和问题排查
            e.printStackTrace();
            // 返回错误结果，包含异常信息
            return ExportResult.error("导出失败: " + e.getMessage());
        } finally {
            // 资源清理块，确保工作簿和输出流正确关闭
            try {
                // 关闭工作簿，释放内存资源
                if (workbook != null) {
                    workbook.close();
                }
                // 关闭输出流，释放系统资源
                if (outputStream != null) {
                    outputStream.close();
                }
            } catch (Exception e) {
                // 打印资源关闭时的异常信息
                e.printStackTrace();
            }
        }
    }

    /**
     * 多Sheet导出并上传到OSS
     * @param request
     * @return
     */
    @Override
    public ExportResult exportMultiSheetAndUploadToOss(MultiSheetExportRequest request) {
        log.info("导出多Sheet Excel: {}", JSON.toJSONString(request));

        // 1. 参数校验
        if (request == null || CollectionUtils.isEmpty(request.getSheets())) {
            return ExportResult.error("Sheet配置不能为空");
        }

        Workbook workbook = null;
        ByteArrayOutputStream outputStream = null;

        try {
            // 2. 创建主工作簿（XSSF格式支持.xlsx）
            workbook = new XSSFWorkbook();

            // 3. 遍历每个Sheet配置
            for (SheetExportConfig config : request.getSheets()) {
                String sheetName = config.getSheetName();
                List<String> fieldNames = config.getFieldNames();

                if (StringUtils.isBlank(sheetName) || CollectionUtils.isEmpty(fieldNames)) {
                    return ExportResult.error("Sheet名称和字段列表不能为空");
                }

                // 3.1 加载实体类（如果传了类名）
                Class<?> entityClass = null;
                if (StringUtils.isNotBlank(config.getEntityClassName())) {
                    try {
                        entityClass = Class.forName(config.getEntityClassName());
                    } catch (ClassNotFoundException e) {
                        log.warn("加载实体类失败: {}", config.getEntityClassName());
                    }
                }

                // 3.2 构建列配置
                List<ExcelExportEntity> entityList = buildExportEntities(fieldNames, entityClass);
                if (CollectionUtils.isEmpty(entityList)) {
                    return ExportResult.error("Sheet [" + sheetName + "] 列配置为空");
                }

                // 3.3 构建数据
                List<Map<String, Object>> dataMapList = buildDataMapList(config.getDataList(), fieldNames, entityClass);
                if (CollectionUtils.isEmpty(dataMapList)) {
                    // 空数据时创建一行空值，保证表头显示
                    dataMapList = new ArrayList<>();
                    Map<String, Object> emptyMap = new HashMap<>();
                    for (String fieldName : fieldNames) {
                        emptyMap.put(fieldName, "");
                    }
                    dataMapList.add(emptyMap);
                }

                // 3.4 利用EasyPOI生成单个Sheet的工作簿
                ExportParams params = new ExportParams(null, sheetName, ExcelType.XSSF);
                Workbook tempWb = ExcelExportUtil.exportExcel(params, entityList, dataMapList);

                // 3.5 将临时工作簿中的Sheet复制到主工作簿
                Sheet tempSheet = tempWb.getSheetAt(0);
                Sheet newSheet = workbook.createSheet(sheetName);
                copySheet(tempSheet, newSheet);

                // 关闭临时工作簿释放资源
                tempWb.close();
            }

            // 4. 将主工作簿写入字节数组
            outputStream = new ByteArrayOutputStream();
            workbook.write(outputStream);
            byte[] excelBytes = outputStream.toByteArray();
            long fileSize = excelBytes.length;

            // 5. 上传至OSS（根据配置）
            Boolean uploadToOss = request.getUploadToOss() != null ? request.getUploadToOss() : true;
            if (uploadToOss) {
                ByteArrayInputStream inputStream = new ByteArrayInputStream(excelBytes);
                String fileName = generateExcelFileName(request.getFileName());
                OssUploadFileResDto uploadResult = ossService.uploadFile(
                        inputStream,
                        fileName,
                        "",
                        "",
                        "excel",
                        ""
                );
                return ExportResult.success(uploadResult.getUrl(), fileSize);
            } else {
                return ExportResult.success(null, fileSize);
            }

        } catch (Exception e) {
            log.error("多Sheet导出失败", e);
            return ExportResult.error("多Sheet导出失败: " + e.getMessage());
        } finally {
            // 6. 资源清理
            try {
                if (workbook != null) {
                    workbook.close();
                }
                if (outputStream != null) {
                    outputStream.close();
                }
            } catch (Exception e) {
                log.error("关闭资源异常", e);
            }
        }
    }

    /**
     * 复制Sheet内容（从临时工作簿复制到主工作簿）
     * 注：此处只复制值和基础格式（列宽、行高），不复制复杂样式以简化逻辑
     */
    private void copySheet(Sheet srcSheet, Sheet destSheet) {
        // 复制列宽
        int maxCol = 0;
        for (int i = 0; i <= srcSheet.getLastRowNum(); i++) {
            Row row = srcSheet.getRow(i);
            if (row != null && row.getLastCellNum() > maxCol) {
                maxCol = row.getLastCellNum();
            }
        }
        for (int i = 0; i < maxCol; i++) {
            destSheet.setColumnWidth(i, srcSheet.getColumnWidth(i));
        }

        // 复制行
        for (int i = 0; i <= srcSheet.getLastRowNum(); i++) {
            Row srcRow = srcSheet.getRow(i);
            Row destRow = destSheet.createRow(i);
            if (srcRow == null) {
                continue;
            }
            destRow.setHeight(srcRow.getHeight());

            for (int j = 0; j < srcRow.getLastCellNum(); j++) {
                Cell srcCell = srcRow.getCell(j);
                Cell destCell = destRow.createCell(j);
                if (srcCell == null) {
                    continue;
                }
                // 复制单元格值
                switch (srcCell.getCellType()) {
                    case STRING:
                        destCell.setCellValue(srcCell.getStringCellValue());
                        break;
                    case NUMERIC:
                        if (DateUtil.isCellDateFormatted(srcCell)) {
                            destCell.setCellValue(srcCell.getDateCellValue());
                        } else {
                            destCell.setCellValue(srcCell.getNumericCellValue());
                        }
                        break;
                    case BOOLEAN:
                        destCell.setCellValue(srcCell.getBooleanCellValue());
                        break;
                    case FORMULA:
                        destCell.setCellFormula(srcCell.getCellFormula());
                        break;
                    case BLANK:
                        break;
                    default:
                        destCell.setCellValue("");
                        break;
                }
                // 可选择性复制样式（此处忽略以提升性能）
            }
        }
    }

    /**
     * 生成Excel文件名（包含时间戳）
     * @param baseName 基础文件名
     * @return 生成的文件名
     */
    private String generateExcelFileName(String baseName) {
        // 如果基础文件名为空，使用默认文件名
        if (StringUtils.isBlank(baseName)) {
            baseName = "export_data";
        }

        // 去除已有文件扩展名，确保统一使用.xlsx格式
        if (baseName.contains(".")) {
            baseName = baseName.substring(0, baseName.lastIndexOf('.'));
        }

        // 生成时间戳，格式为年月日_时分秒
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        // 组合基础文件名、时间戳和文件扩展名
        return baseName + "_" + timestamp + ".xlsx";
    }

    /**
     * 构建导出列实体配置
     * @param fieldNames 字段名称列表
     * @param entityClass 实体类类型
     * @return Excel导出列配置列表
     */
    private List<ExcelExportEntity> buildExportEntities(List<String> fieldNames, Class<?> entityClass) {
        // 创建导出列配置列表
        List<ExcelExportEntity> entityList = new ArrayList<>();
        // 获取实体类字段的注解映射（字段名->Excel列名）
        Map<String, String> fieldAnnotationMap = null;
        if (!Objects.isNull(entityClass)) {
            fieldAnnotationMap = getFieldAnnotations(entityClass);
        }

        // 遍历所有需要导出的字段
        for (String fieldName : fieldNames) {
            // 检查字段是否存在于注解映射中
            if (!Objects.isNull(fieldAnnotationMap) && fieldAnnotationMap.containsKey(fieldName)) {
                //传入了entityClass实体类型
                // 创建Excel导出列实体：参数1为Excel列标题，参数2为实体字段名
                ExcelExportEntity entity = new ExcelExportEntity(fieldAnnotationMap.get(fieldName), fieldName);
                // 将列配置添加到列表
                entityList.add(entity);
            }else {
                //没有传入entityClass实体类型，那就取fieldNames做为ExcelExportEntity参数1和参数2值
                // 创建Excel导出列实体：参数1为Excel列标题，参数2为实体字段名
                ExcelExportEntity entity = new ExcelExportEntity(fieldName, fieldName);
                // 将列配置添加到列表
                entityList.add(entity);
            }
        }
        return entityList;
    }

    /**
     * 获取字段注解映射（字段名->Excel列名）
     * @param entityClass 实体类类型
     * @return 字段注解映射表
     */
    private Map<String, String> getFieldAnnotations(Class<?> entityClass) {
        // 创建字段注解映射表
        Map<String, String> fieldAnnotationMap = new HashMap<>();
        // 获取实体类声明的所有字段
        Field[] fields = entityClass.getDeclaredFields();

        // 遍历所有字段
        for (Field field : fields) {
            // 获取字段上的Excel注解配置
            cn.afterturn.easypoi.excel.annotation.Excel excelAnnotation =
                    field.getAnnotation(cn.afterturn.easypoi.excel.annotation.Excel.class);
            // 如果字段有Excel注解，记录映射关系
            if (excelAnnotation != null) {
                // key: 字段名, value: Excel列名
                fieldAnnotationMap.put(field.getName(), excelAnnotation.name());
            }
        }
        return fieldAnnotationMap;
    }

//    /**
//     * 构建数据Map列表，将对象列表转换为EasyPOI所需的Map结构
//     * @param dataList 数据对象列表
//     * @param fieldNames 需要导出的字段名称列表
//     * @param entityClass 实体类类型
//     * @return 数据Map列表
//     */
//    private List<Map<String, Object>> buildDataMapList(List<?> dataList, List<String> fieldNames, Class<?> entityClass) {
//        // 创建数据Map列表
//        List<Map<String, Object>> dataMapList = new ArrayList<>();
//        if (CollectionUtils.isEmpty(dataList)) {
//            return dataMapList;
//        }
//        // 遍历数据列表中的每个对象
//        for (Object data : dataList) {
//            // 为每个对象创建字段-值的映射
//            Map<String, Object> map = new HashMap<>();
//            // 遍历所有需要导出的字段
//            for (String fieldName : fieldNames) {
//                try {
//                    // 通过反射获取字段对象
//                    Field field = entityClass.getDeclaredField(fieldName);
//                    // 设置字段可访问（突破private限制）
//                    field.setAccessible(true);
//                    // 将字段值放入Map，key为字段名，value为字段值
//                    map.put(fieldName, field.get(data));
//                } catch (Exception e) {
//                    // 如果获取字段值失败，设置为空字符串
//                    map.put(fieldName, "");
//                }
//            }
//            // 将当前对象的字段映射添加到列表
//            dataMapList.add(map);
//        }
//        return dataMapList;
//    }


    /**
     * 构建数据Map列表，将对象列表转换为EasyPOI所需的Map结构
     * @param dataList 数据对象列表
     * @param fieldNames 需要导出的字段名称列表
     * @param entityClass 实体类类型
     * @return 数据Map列表
     */
    private List<Map<String, Object>> buildDataMapList(List<?> dataList, List<String> fieldNames, Class<?> entityClass) {
        List<Map<String, Object>> dataMapList = new ArrayList<>();
        if (CollectionUtils.isEmpty(dataList)) {
            return dataMapList;
        }
        for (Object data : dataList) {
            Map<String, Object> map = new HashMap<>();
            // 判断是否为 Map 类型（Feign 反序列化结果）
            if (data instanceof Map) {
                Map<String, Object> dataMap = (Map<String, Object>) data;
                for (String fieldName : fieldNames) {
                    Object value = dataMap.get(fieldName);
                    map.put(fieldName, value != null ? value : "");
                }
            } else {
                // 原有的反射逻辑，适用于本地直接调用
                for (String fieldName : fieldNames) {
                    try {
                        Field field = entityClass.getDeclaredField(fieldName);
                        field.setAccessible(true);
                        map.put(fieldName, field.get(data));
                    } catch (Exception e) {
                        log.warn("字段 {} 获取失败: {}", fieldName, e.getMessage());
                        map.put(fieldName, "");
                    }
                }
            }
            dataMapList.add(map);
        }
        return dataMapList;
    }
}