package com.gkhy.fourierSpecialGasMonitor.schedule;

import com.gkhy.fourierSpecialGasMonitor.Application;
import com.gkhy.fourierSpecialGasMonitor.commons.enums.ResultCode;
import com.gkhy.fourierSpecialGasMonitor.commons.enums.SystemCacheKeyEnum;
import com.gkhy.fourierSpecialGasMonitor.commons.exception.BusinessException;
import com.gkhy.fourierSpecialGasMonitor.config.file.ReportFilePathConfig;
import com.gkhy.fourierSpecialGasMonitor.entity.*;
import com.gkhy.fourierSpecialGasMonitor.service.*;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.poi.ooxml.POIXMLDocument;
import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellReference;
import org.apache.poi.xddf.usermodel.chart.*;
import org.apache.poi.xddf.usermodel.text.XDDFTextBody;
import org.apache.poi.xwpf.usermodel.*;
import org.openxmlformats.schemas.drawingml.x2006.main.CTTextBody;
import org.redisson.api.RBucket;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.*;
import java.lang.reflect.Field;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author Mr.huang
 * @decription
 * @date 2023/8/11 13:25
 */
@Component
public class DailyReportSchedule {

    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");

    private static final DateTimeFormatter reportNameFormatter = DateTimeFormatter.ofPattern("yyyy_MM_dd");

    private static final DateTimeFormatter execformatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    private static final DateTimeFormatter lineChartXDataDisplay = DateTimeFormatter.ofPattern("HH:mm");

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    private static int serialNumber = 4;

    @Autowired
    private GasWarnLogService gasWarnLogService;

    @Autowired
    private GasConcentrationService gasConcentrationService;

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private RegionService regionService;

    @Autowired
    private ReportFilePathConfig reportFilePathConfig;

    @Autowired
    private GasFluxService gasFluxService;

    @Autowired
    private MonitorDailyReportService monitorDailyReportService;

    @Autowired
    private GasCategoryService gasCategoryService;

    @Scheduled(cron = "0 0 2 * * ?") //每天两点执行一次
//    @Scheduled(cron = "0 0/1 * * * ? ")    // 分钟
    @Async(value = "SocketTaskExecutor")
    public void generateDailyReport() {
        LocalDateTime now = LocalDateTime.now();
        String startTime = now.format(execformatter);
        RBucket<List<GasCategory>> bucket = redissonClient.getBucket(SystemCacheKeyEnum.KEY_GAS_CATEGORY.getKey());
        List<GasCategory> gasCategories = bucket.get();
        serialNumber = 4;
        logger.info("【##】开始生成日报 ,时间："+startTime);
        OPCPackage opcPackage = null;
        //加载文档
        logger.info("【##】获取模版并创建相关文件");
        XWPFDocument doc = null;
        try {
            ClassLoader classLoader = Application.class.getClassLoader();
            InputStream originalFileInputStream = classLoader.getResourceAsStream("template/dailyReportTemplate.docx");
            String copyFileUrl = reportFilePathConfig.getDcPath()+"temp/dailyReportTemplate.docx";
            File file = new File(copyFileUrl);
            if (!file.exists()){
                try {
                    // 获取文件所在的文件夹路径
                    String folderPath = file.getParent();
                    // 创建文件夹（包括父目录）
                    File folder = new File(folderPath);
                    if (!folder.exists()){
                        folder.mkdirs();
                    }
                    file.createNewFile();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            FileOutputStream copyFileOutputStream = new FileOutputStream(copyFileUrl);
            IOUtils.copy(originalFileInputStream, copyFileOutputStream);
            opcPackage = POIXMLDocument.openPackage(copyFileUrl);

            //FileInputStream originalFileInputStream = new FileInputStream("src/main/resources/template/dailyReportTemplate.docx");
            //FileOutputStream copyFileOutputStream = new FileOutputStream("src/main/resources/temp/dailyReportTemplate.docx");
            //// 创建副本文件
            //IOUtils.copy(originalFileInputStream, copyFileOutputStream);
            //opcPackage = POIXMLDocument.openPackage("src/main/resources/temp/dailyReportTemplate.docx");
            doc = new XWPFDocument(opcPackage);
        } catch (IOException e) {
            e.printStackTrace();
        }
        logger.info("【##】获取相关数据，并填充数据");
        Map<String, Object> map = dataMap(gasCategories);
        List<XWPFParagraph> paragraphList = doc.getParagraphs();
        for (XWPFParagraph par : paragraphList) {
            //获取段落的文本对象
            List<XWPFRun> runs = par.getRuns();
            for (XWPFRun run : runs) {
                //获取文本的值
                String text = run.getText(0);
                //遍历map
                for (Map.Entry<String, Object> entry : map.entrySet()) {
                    //获取map的key
                    String key = entry.getKey();
                    //判断文本的值和map的key，文本中是否有和key一样的占位符
                    if (text != null && text.indexOf(key) != -1) {
                        //获取对应key的value
                        Object value = entry.getValue();
                        //把文本的内容，key替换为value
                        text = text.replace(key, value.toString());
                        //把替换好的文本内容，保存到当前这个文本对象
                        run.setText(text, 0);
                    }
                }
            }
        }
        logger.info("【##】生成相关文件信息，保存相关文件");
        String format = now.format(reportNameFormatter);
        String fileName = "富城能源气体监测日报"+format+".docx";
        String fileurl = reportFilePathConfig.getDcPath()+fileName;
        File file = new File(fileurl);
        if (!file.exists()){
            try {
                // 获取文件所在的文件夹路径
                String folderPath = file.getParent();
                // 创建文件夹（包括父目录）
                File folder = new File(folderPath);
                if (!folder.exists()){
                    folder.mkdirs();
                }
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        try {
            doc.write(fileOutputStream);
            fileOutputStream.close();
            opcPackage.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        List<GasConcentration> gasConcentrations = gasConcentrationService.listDatabyTimeSlot(LocalDateTime.of(now.minusDays(1).toLocalDate(), LocalTime.MIN)
                ,  LocalDateTime.of(now.minusDays(1).toLocalDate(), LocalTime.MAX));
        // 绘制折线图
        logger.info("【##】 开始绘制折线图 ");
        if (!CollectionUtils.isEmpty(gasConcentrations)) {
            List<GasCategory> gasCategoryForReport = gasCategoryService.findGasCategoryForReport();
            for (int i = 0; i < gasCategoryForReport.size(); i++) {
                String series = gasCategories.get(i).getMolecularFormula() + "浓度观测结果";
                String title = gasCategories.get(i).getMolecularFormula();
                drawLineChart(gasConcentrations, fileurl, series, title, gasCategories.get(i).getMolecularFormula(), i);
            }
        }
        //List<GasFlux> gasFluxes = gasFluxService.listYesterday();
        List<GasFlux> gasFluxes = gasFluxService.listYesterdayTenAmToSixPm();
        List<Integer> areaNum = gasFluxes.stream().map(GasFlux::getAreaId).distinct().sorted().collect(Collectors.toList());

        List<Region> allRegion = regionService.findAll();
        if (CollectionUtils.isEmpty(allRegion))
            throw new BusinessException(this.getClass(), ResultCode.SYSTEM_ERROR_DATABASE_FAIL.getCode(),"区域信息为空");
        Map<Integer, String> regionMap = allRegion.stream()
                .collect(Collectors.toMap(Region::getId, Region::getName));
        // 绘制柱状图
        if (!CollectionUtils.isEmpty(gasFluxes)) {
//            for (int j = 0; j < gasCategories.size(); j++) {
//                for (int i = 1; i <= areaNum.size(); i++) {
//                    //for (int j = 0; j < 20; j++) {
//                    int finalI = i;
//                    List<GasFlux> gasFluxesByArea = gasFluxes.stream().filter(gasFlux -> gasFlux.getAreaId() == finalI)
//                            .collect(Collectors.toList());
//                    drawBarChart(gasFluxesByArea, fileurl, regionMap.get(i), gasCategories.get(j).getMolecularFormula(), i, j + 1);
//                }
//            }
            logger.info("【##】 开始绘制柱状图");
                for (int i = 0; i < areaNum.size(); i++) {
                    //for (int j = 0; j < 20; j++) {
                    int finalI = areaNum.get(i);
                    List<GasFlux> gasFluxesByArea = gasFluxes.stream().filter(gasFlux -> gasFlux.getAreaId() == finalI)
                            .collect(Collectors.toList());
                    drawBarChart(gasFluxesByArea, fileurl, regionMap.get(areaNum.get(i)), gasCategories.get(0).getMolecularFormula(), areaNum.get(i), 1);
                }
        }
        logger.info("保存相关信息到数据库");
        String endTime = LocalDateTime.now().format(execformatter);
        long execTime = ChronoUnit.SECONDS.between(now, LocalDateTime.now());
        MonitorDailyReport report = new MonitorDailyReport();
        report.setName(fileName);
        report.setGmtCreate(now);
        report.setEndTime(LocalDateTime.now());
        report.setFileUrl(reportFilePathConfig.getUrlRootPath()+fileName);
        MonitorDailyReport save = monitorDailyReportService.save(report);
        if (save == null)
            throw new BusinessException(this.getClass(), ResultCode.SYSTEM_ERROR_DATABASE_FAIL,"日常报表保存失败");
        logger.info("【##】日报生成成功!!! ,时间："+endTime+",所耗时间: "+execTime+"s");
    }

    /**
     * @decription 画柱形图
     * @author Mr.huang
     */
    public void drawBarChart(List<GasFlux> gasFluxes,String fileurl,String series,String molecularFormula,Integer i,Integer j) {
        List<String> collect = gasFluxes.stream()
                .map(gasFlux -> gasFlux.getTime().format(lineChartXDataDisplay))
                .collect(Collectors.toList());
        String[] x2 = collect.toArray(new String[collect.size()]);
        String fieldName = "gasValue";
        if (j<10){
            fieldName = fieldName + "0" + j;
        }else {
            fieldName = fieldName + j;
        }
        final String fieldTempName = fieldName;
        Double[] n = gasFluxes.stream().map(obj -> {
            try {
                Field field = obj.getClass().getDeclaredField(fieldTempName);
                field.setAccessible(true);
                return field.get(obj);
            } catch (NoSuchFieldException | IllegalAccessException e) {
                logger.info("柱状图反射获取字段值异常");
                return null;
            }
        }).collect(Collectors.toList()).toArray(new Double[gasFluxes.size()]);

        String templatePath = fileurl;
        XWPFDocument doc=null;
        InputStream is = null;
        try{
            is = new FileInputStream(new File(templatePath));
            doc = new XWPFDocument(is);
        } catch (Exception e){
            System.out.println(e);
        }
        //区域名称
        String[] series2 = {series};//
        //y轴
        List<Number[]> value2 = new ArrayList<>();//每一条折现图，第二个表1条
        value2.add(n);

        List<XWPFChart> charts = doc.getCharts();
        serialNumber++;
        for (int k = 0; k < charts.size(); k++) {
            XWPFChart xwpfChart = charts.get(k);
            XDDFTitle xddfTitletitle = xwpfChart.getTitle();
            if (xddfTitletitle != null) {
                XDDFTextBody body = xddfTitletitle.getBody();
                CTTextBody xmlObject = body.getXmlObject();
                String tt = xmlObject.toString(); //图表的标题
                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                try {
                    DocumentBuilder builder = factory.newDocumentBuilder();
                    // 解析 XML 字符串
                    org.w3c.dom.Document document = builder.parse(new ByteArrayInputStream(tt.getBytes()));
                    // 获取根元素 <a:r>
                    Element root = document.getDocumentElement();
                    // 获取包含文本的 <a:t> 元素
                    Element aT = (Element) root.getElementsByTagName("a:t").item(0);
                    // 获取 <a:t> 元素的文本内容 获取标题具体内容
                    String value = aT.getTextContent();
                    String chartTitle = "图"+serialNumber+" "+i+"号厂区排放"+molecularFormula+"通量反演结果";
                    if ((j+"-"+i).equals(value)) {
                        drawBarChartExec(charts.get(k), series2, x2, value2, chartTitle,molecularFormula);
                    }
                } catch (ParserConfigurationException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (SAXException e) {
                    e.printStackTrace();
                }
            }
        }
        try (FileOutputStream fos = new FileOutputStream(templatePath)) {
            doc.write(fos);
            doc.close();
            is.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public void drawLineChart(List<GasConcentration> gasConcentrations,String fileurl,String series,String title,String molecularFormula,Integer i) {
        List<String> collect = gasConcentrations.stream()
                .map(gasConcentration -> gasConcentration.getTime().format(lineChartXDataDisplay))
                .collect(Collectors.toList());
        String[] x2 = collect.toArray(new String[collect.size()]);
        String fieldName = "gasValue";
        i = i+1;
        if (i<10){
            fieldName = fieldName + "0" + i;
        }else {
            fieldName = fieldName + i;
        }
        final String fieldTempName = fieldName;
        Double[] n = gasConcentrations.stream().map(obj -> {
            try {
                Field field = obj.getClass().getDeclaredField(fieldTempName);
                field.setAccessible(true);
                return field.get(obj);
            } catch (NoSuchFieldException | IllegalAccessException e) {
                e.printStackTrace();
                return null;
            }
        }).collect(Collectors.toList()).toArray(new Double[gasConcentrations.size()]);

        String templatePath = fileurl;
        XWPFDocument doc=null;
        InputStream is = null;
        try{
            is = new FileInputStream(new File(templatePath));
            doc = new XWPFDocument(is);
        } catch (Exception e){
            System.out.println(e);
        }
        String[] series2 = {"图" + (i)+" "+series};//

        String title2=title;
        //y轴
        List<Number[]> value2 = new ArrayList<>();
        value2.add(n);

        //
        List<XWPFChart> charts = doc.getCharts();
        for (int j = 0; j < charts.size(); j++) {
            XWPFChart xwpfChart = charts.get(j);
            XDDFTitle xddfTitletitle = xwpfChart.getTitle();
            if (xddfTitletitle != null) {
                XDDFTextBody body = xddfTitletitle.getBody();
                CTTextBody xmlObject = body.getXmlObject();
                String tt = xmlObject.toString(); //图表的标题
                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                try {
                    DocumentBuilder builder = factory.newDocumentBuilder();
                    // 解析 XML 字符串
                    org.w3c.dom.Document document = builder.parse(new ByteArrayInputStream(tt.getBytes()));
                    // 获取根元素 <a:r>
                    Element root = document.getDocumentElement();
                    // 获取包含文本的 <a:t> 元素
                    Element aT = (Element) root.getElementsByTagName("a:t").item(0);
                    // 获取 <a:t> 元素的文本内容 获取标题具体内容
                    String value = aT.getTextContent();
                    if (molecularFormula.equals(value)) {
                        drawLineChartExec(charts.get(j), series2, x2, value2, title2);
                    }
                } catch (ParserConfigurationException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (SAXException e) {
                    e.printStackTrace();
                }
            }
        }
        try (FileOutputStream fos = new FileOutputStream(templatePath)) {
            doc.write(fos);
            doc.close();
            is.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


//    public void drawBarChartExec(XWPFChart chart, String[] series, String[] categories,
//                                  List<Number[]> values, String chartTitle,String molecularFormula) {
//        final List<XDDFChartData> data = chart.getChartSeries();
//
//        final XDDFBarChartData line = (XDDFBarChartData) data.get(0);//这里一般获取第一个,我们这里是折线图就是XDDFLineChartData
//        line.getCategoryAxis().setTitle(chartTitle);
//        line.getValueAxes().get(0).setTitle(molecularFormula+" Emission Rate (ug/m^2/s)");
//        final int numOfPoints = categories.length;
//
//        final String categoryDataRange = chart.formatRange(new CellRangeAddress(1, numOfPoints, 0, 0));
//
//        final XDDFDataSource<?> categoriesData = XDDFDataSourcesFactory.fromArray(categories, categoryDataRange, 0);
//        for (int i = 0; i < values.size(); i++) {
//            final String valuesDataRange = chart.formatRange(new CellRangeAddress(1, numOfPoints, i + 1, i + 1));
//            Number[] value = values.get(i);
//            final XDDFNumericalDataSource<? extends Number> valuesData = XDDFDataSourcesFactory.fromArray(value, valuesDataRange, i + 1);
//            XDDFChartData.Series ser;//图表中的系列
//            ser = line.getSeries().get(i);
//            ser.replaceData(categoriesData, valuesData);
//            CellReference cellReference = chart.setSheetTitle(series[i], 1);//修改系列标题
//            ser.setTitle(series[i], cellReference);
//        }
//        chart.plot(line);
//        chart.setTitleText("");//折线图标题
//        chart.setTitleOverlay(false);
//    }

    public void drawBarChartExec(XWPFChart chart, String[] series, String[] categories,
                                 List<Number[]> values, String chartTitle, String molecularFormula) {
        // 1. 基础参数非空校验
        if (chart == null) {
            logger.error("绘制柱状图失败：图表对象（chart）为null");
            return;
        }
        if (series == null || series.length == 0) {
            logger.error("绘制柱状图失败：系列名称（series）为空或长度为0");
            return;
        }
        if (categories == null || categories.length == 0) {
            logger.error("绘制柱状图失败：分类轴数据（categories）为空或长度为0");
            return;
        }
        if (values == null || values.isEmpty()) {
            logger.error("绘制柱状图失败：数值数据（values）为空或长度为0");
            return;
        }
        // 校验系列数与数值列表长度一致
        if (series.length != values.size()) {
            logger.error("绘制柱状图失败：系列数（{}）与数值列表长度（{}）不匹配", series.length, values.size());
            return;
        }

        try {
            // 2. 获取图表数据系列（防御性处理）
            List<XDDFChartData> data = chart.getChartSeries();
            if (data == null || data.isEmpty()) {
                logger.error("绘制柱状图失败：图表中未找到数据系列（data is empty）");
                return;
            }
            // 强制转换为柱状图数据（若类型不匹配会抛出ClassCastException，后续捕获）
            XDDFBarChartData barChartData = (XDDFBarChartData) data.get(0);

            // 3. 设置坐标轴标题（处理空字符串）
            barChartData.getCategoryAxis().setTitle(Objects.toString(chartTitle, "分类轴")); // 空标题时用默认值
            String valueAxisTitle = (molecularFormula != null ? molecularFormula : "气体") + " Emission Rate (ug/m^2/s)";
            barChartData.getValueAxes().get(0).setTitle(valueAxisTitle);

            // 4. 校验分类轴数据长度（numOfPoints必须≥1，否则范围无效）
            int numOfPoints = categories.length;
            if (numOfPoints < 1) {
                logger.error("绘制柱状图失败：分类轴数据长度（numOfPoints={}）小于1，无法生成有效范围", numOfPoints);
                return;
            }

            // 5. 生成分类轴数据范围（避免起止行颠倒）
            int startRow = 1;
            int endRow = numOfPoints;
            if (startRow > endRow) {
                logger.warn("分类轴数据范围起止行颠倒（{} > {}），自动修正", startRow, endRow);
                // 交换起止行（避免CellRangeAddress抛出异常）
                int temp = startRow;
                startRow = endRow;
                endRow = temp;
            }
            CellRangeAddress categoryRange = new CellRangeAddress(startRow, endRow, 0, 0);
            String categoryDataRange;
            try {
                categoryDataRange = chart.formatRange(categoryRange);
            } catch (Exception e) {
                logger.error("格式化分类轴数据范围失败：startRow={}, endRow={}, columns=[0,0]", startRow, endRow, e);
                return;
            }

            // 6. 处理分类轴数据源
            XDDFDataSource<?> categoriesData;
            try {
                categoriesData = XDDFDataSourcesFactory.fromArray(categories, categoryDataRange, 0);
            } catch (Exception e) {
                logger.error("创建分类轴数据源失败", e);
                return;
            }

            // 7. 循环处理每个系列的数值数据
            for (int i = 0; i < values.size(); i++) {
                // 校验当前系列的数值数组非空
                Number[] valueArray = values.get(i);
                if (valueArray == null) {
                    logger.warn("第{}个系列的数值数组为null，跳过处理", i);
                    continue;
                }
                // 校验数值数组长度与分类轴长度一致（否则图表可能显示异常）
                if (valueArray.length != numOfPoints) {
                    logger.warn("第{}个系列的数值长度（{}）与分类轴长度（{}）不匹配，可能导致图表异常",
                            i, valueArray.length, numOfPoints);
                }

                // 生成当前系列的数值范围
                CellRangeAddress valueRange = new CellRangeAddress(startRow, endRow, i + 1, i + 1);
                String valuesDataRange;
                try {
                    valuesDataRange = chart.formatRange(valueRange);
                } catch (Exception e) {
                    logger.error("格式化第{}个系列的数值范围失败：startRow={}, endRow={}, columns=[{},{}]",
                            i, startRow, endRow, i + 1, i + 1, e);
                    continue; // 跳过当前系列，处理下一个
                }

                // 创建数值数据源
                XDDFNumericalDataSource<? extends Number> valuesData;
                try {
                    valuesData = XDDFDataSourcesFactory.fromArray(valueArray, valuesDataRange, i + 1);
                } catch (Exception e) {
                    logger.error("创建第{}个系列的数值数据源失败", i, e);
                    continue;
                }

                // 更新系列数据（确保系列存在）
                List<XDDFChartData.Series> chartSeries = barChartData.getSeries();
                if (i >= chartSeries.size()) {
                    logger.error("第{}个系列不存在（图表仅包含{}个系列），跳过处理", i, chartSeries.size());
                    continue;
                }
                XDDFChartData.Series ser = chartSeries.get(i);
                ser.replaceData(categoriesData, valuesData);

                // 设置系列标题
                String seriesName = series[i] != null ? series[i] : "系列" + i; // 处理空标题
                try {
                    CellReference cellReference = chart.setSheetTitle(seriesName, 1);
                    ser.setTitle(seriesName, cellReference);
                } catch (Exception e) {
                    logger.error("设置第{}个系列标题（{}）失败", i, seriesName, e);
                    // 标题设置失败不影响数据，继续执行
                }
            }

            // 8. 绘制图表并清除标题
            chart.plot(barChartData);
            chart.setTitleText(""); // 清除图表标题
            chart.setTitleOverlay(false);

            logger.debug("柱状图绘制完成：标题={}, 系列数={}, 数据点数量={}", chartTitle, series.length, numOfPoints);

        } catch (ClassCastException e) {
            // 图表数据类型不匹配（如预期是柱状图，实际是折线图）
            logger.error("绘制柱状图失败：图表数据类型不匹配（预期XDDFBarChartData）", e);
        } catch (IndexOutOfBoundsException e) {
            // 坐标轴或系列索引越界（如getValueAxes()为空）
            logger.error("绘制柱状图失败：索引越界（可能坐标轴未初始化）", e);
        } catch (Exception e) {
            // 捕获其他未预期异常
            logger.error("绘制柱状图时发生未知异常", e);
        }
    }

    public void drawLineChartExec(XWPFChart chart, String[] series, String[] categories,
                               List<Number[]> values, String chartTitle) {
        final List<XDDFChartData> data = chart.getChartSeries();

        final XDDFLineChartData line = (XDDFLineChartData) data.get(0);//这里一般获取第一个,我们这里是折线图就是XDDFLineChartData

        final int numOfPoints = categories.length;

        //List<String> lineChartXDataDisplayDefault = Arrays.asList("00:00","01:00","02:00","03:00","04:00","05:00","06:00"
        //        ,"07:00","08:00","09:00",
        //        "10:00","11:00","12:00","13:00","19:00");
        //for (int i = 0; i < numOfPoints; i++) {
        //    if (!lineChartXDataDisplayDefault.contains(categories[i])) {
        //        categories[i] = ""; // 设置为空字符串，隐藏原有的标签
        //    }
        //}

        final String categoryDataRange = chart.formatRange(new CellRangeAddress(1, numOfPoints, 0, 0));

        final XDDFDataSource<?> categoriesData = XDDFDataSourcesFactory.fromArray(categories, categoryDataRange, 0);
        for (int i = 0; i < values.size(); i++) {
            final String valuesDataRange = chart.formatRange(new CellRangeAddress(1, numOfPoints, i + 1, i + 1));
            Number[] value = values.get(i);
            final XDDFNumericalDataSource<? extends Number> valuesData = XDDFDataSourcesFactory.fromArray(value, valuesDataRange, i + 1);
            XDDFChartData.Series ser;//图表中的系列
            ser = line.getSeries().get(i);
            ser.replaceData(categoriesData, valuesData);
            CellReference cellReference = chart.setSheetTitle(series[i], 1);//修改系列标题
            ser.setTitle(series[i], cellReference);
        }
        chart.plot(line);
        chart.setTitleText(chartTitle);//折线图标题
        chart.setTitleOverlay(false);
    }

    private Map<String, Object> dataMap(List<GasCategory> gasCategories){
        logger.info("【##】 生成相关数据");
        LocalDateTime now = LocalDateTime.now();
        String today = now.format(formatter);
        String yesterday = LocalDateTime.now().minusDays(1).format(formatter);
        //要替换的map，key为占位符，value为要被替换的值
        Map<String, Object> map = new HashMap<>();
        map.put("${today}", today);
        map.put("${yesterday}", yesterday);
        map.put("${generalradius}","1km");
        map.put("${generalradiu}","300m");

        List<GasWarnLog> gasWarnLogs = gasWarnLogService.listYesterday();
        if (!CollectionUtils.isEmpty(gasWarnLogs)){
            String warnInfo = "根据以上气体浓度变化曲线，各物种的浓度有如下特征：";
            for (int i = 0; i < gasWarnLogs.size(); i++) {
                LocalDateTime warnTime = gasWarnLogs.get(i).getWarnTime();
                String time = warnTime.format(execformatter);
                warnInfo = warnInfo + gasWarnLogs.get(i).getGasMolecularFormula()
                        +"("+gasWarnLogs.get(i).getGasName()+")浓度在"+time+" 出现"+gasWarnLogs.get(i).getGasThresholdName()
                        + "浓度达到:"+gasWarnLogs.get(i).getGasConcentration()+gasWarnLogs.get(i).getGasUnit() + ";   ";

            }
            map.put("${warn}",warnInfo);
        }else {
            map.put("${warn}","");
        }
        String fiveGas = "";
        String sixGas = "";
        for (int i = 0; i < 3; i++) {
            String name = gasCategories.get(i).getMolecularFormula()+"（"+gasCategories.get(i).getName()+"）";
            name = name + "、";
            if (i < 3){
                fiveGas = fiveGas + name;
                if (i == 2){
                    int index = fiveGas.lastIndexOf("、");
                    fiveGas =  fiveGas.substring(0, index)+"共三种";
                }
            }
            if (i < 3){
                sixGas = sixGas + name;
                if (i == 2){
                    int index = sixGas.lastIndexOf("、");
                    sixGas =  sixGas.substring(0, index)+"共三种";
                }
            }
        }
        map.put("${fiveGas}",fiveGas);
        map.put("${sixGas}",sixGas);
        return map;
    }
}