package com.example.cattletends.controller;

import com.example.cattletends.common.Result;
import com.example.cattletends.dto.CattleDataDTO;
import com.example.cattletends.entity.CattleData;
import com.example.cattletends.service.CattleDataService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import javax.validation.Valid;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 牛只数据控制器
 */
@RestController
@RequestMapping("/api/cattle-data")
@Api(tags = "牛只数据管理", description = "牛只数据的CRUD接口")
public class CattleDataController {

    private final CattleDataService cattleDataService;
    private final com.example.cattletends.service.CattleProvinceService cattleProvinceService;
    private final com.example.cattletends.service.CattleNationalService cattleNationalService;
    private final com.example.cattletends.service.CattleBreedService cattleBreedService;
    private final com.example.cattletends.service.ProvinceDailyPriceService provinceDailyPriceService;

    /**
     * 构造器注入
     */
    public CattleDataController(CattleDataService cattleDataService,
                                 com.example.cattletends.service.CattleProvinceService cattleProvinceService,
                                 com.example.cattletends.service.CattleNationalService cattleNationalService,
                                 com.example.cattletends.service.CattleBreedService cattleBreedService,
                                 com.example.cattletends.service.ProvinceDailyPriceService provinceDailyPriceService) {
        this.cattleDataService = cattleDataService;
        this.cattleProvinceService = cattleProvinceService;
        this.cattleNationalService = cattleNationalService;
        this.cattleBreedService = cattleBreedService;
        this.provinceDailyPriceService = provinceDailyPriceService;
    }

    /**
     * 获取所有牛只数据（支持按省份或品种筛选，支持按日期查询）
     */
    @GetMapping
    @ApiOperation(value = "获取所有牛只数据", notes = "返回牛只数据的列表，支持按省份或品种筛选，支持按日期查询（格式：yyyy-MM-dd），默认查询今天的数据，按价格升序排序")
    public Result<List<CattleData>> getAllCattleData(
            @ApiParam(value = "省份（可选，如果提供则只返回该省份的数据）")
            @RequestParam(required = false) String province,
            @ApiParam(value = "品种（可选，如果提供则只返回该品种的数据）")
            @RequestParam(required = false) String type,
            @ApiParam(value = "日期（可选，格式：yyyy-MM-dd，如果提供则查询该日期的数据，不提供则查询今天的数据）")
            @RequestParam(required = false) String date) {
        List<CattleData> data;
        
        // 解析日期参数
        java.time.LocalDate parsedDate = null;
        if (date != null && !date.trim().isEmpty()) {
            try {
                parsedDate = java.time.LocalDate.parse(date.trim());
            } catch (Exception e) {
                System.err.println("日期格式错误: " + date + ", 错误: " + e.getMessage());
                return Result.error(400, "日期格式错误，请使用 yyyy-MM-dd 格式，例如：2025-12-04");
            }
        }
        
        // 优先按品种筛选
        if (type != null && !type.trim().isEmpty()) {
            data = cattleDataService.getCattleDataByType(type.trim(), parsedDate);
        } else if (province != null && !province.trim().isEmpty()) {
            // 其次按省份筛选
            data = cattleDataService.getCattleDataByProvince(province.trim(), parsedDate);
        } else {
            // 都不提供则返回所有数据
            data = cattleDataService.getAllCattleData(parsedDate);
        }
        return Result.success(data);
    }

    /**
     * 阿里云大屏接口 - 获取牛只数据（直接返回数据数组，不包含Result包装）
     */
    @GetMapping("/screen")
    @ApiOperation(value = "阿里云大屏接口", notes = "返回牛只数据数组，直接返回data数据，不包含Result包装。支持按省份或品种筛选，支持按日期查询（格式：yyyy-MM-dd），默认查询今天的数据，按价格升序排序")
    public List<CattleData> getCattleDataForScreen(
            @ApiParam(value = "省份（可选，如果提供则只返回该省份的数据）")
            @RequestParam(required = false) String province,
            @ApiParam(value = "品种（可选，如果提供则只返回该品种的数据）")
            @RequestParam(required = false) String type,
            @ApiParam(value = "日期（可选，格式：yyyy-MM-dd，如果提供则查询该日期的数据，不提供则查询今天的数据）")
            @RequestParam(required = false) String date) {
        // 解析日期参数
        java.time.LocalDate parsedDate = null;
        if (date != null && !date.trim().isEmpty()) {
            try {
                parsedDate = java.time.LocalDate.parse(date.trim());
            } catch (Exception e) {
                System.err.println("日期格式错误: " + date + ", 错误: " + e.getMessage());
                return new java.util.ArrayList<>(); // 返回空列表
            }
        }
        
        // 优先按品种筛选
        if (type != null && !type.trim().isEmpty()) {
            return cattleDataService.getCattleDataByType(type.trim(), parsedDate);
        } else if (province != null && !province.trim().isEmpty()) {
            // 其次按省份筛选
            return cattleDataService.getCattleDataByProvince(province.trim(), parsedDate);
        } else {
            // 都不提供则返回所有数据
            return cattleDataService.getAllCattleData(parsedDate);
        }
    }

    /**
     * 根据ID获取牛只数据
     */
    @GetMapping("/{id}")
    @ApiOperation(value = "根据ID获取牛只数据", notes = "根据主键ID查询单个牛只数据")
    public Result<CattleData> getCattleDataById(
            @ApiParam(value = "主键ID", required = true)
            @PathVariable Integer id) {
        CattleData data = cattleDataService.getCattleDataById(id);
        return Result.success(data);
    }

    /**
     * 批量导入牛只数据（Excel文件）
     * 注意：此接口必须在 @PostMapping 之前定义，避免路径冲突
     */
    @PostMapping("/import")
    @ApiOperation(value = "批量导入牛只数据", notes = "通过Excel文件批量导入牛只数据，自动截取所在产地到市级别，并自动创建品种")
    public Result<List<CattleData>> importCattleData(
            @ApiParam(value = "Excel文件", required = true)
            @RequestParam("file") MultipartFile file) {
        if (file.isEmpty()) {
            return Result.error(400, "文件不能为空");
        }

        try {
            List<CattleDataDTO> dataList = parseExcelFile(file);
            
            if (dataList == null || dataList.isEmpty()) {
                return Result.error(400, "Excel文件中没有有效数据，请检查文件格式");
            }
            
            // 自动创建品种
            java.util.Set<String> processedBreeds = new java.util.HashSet<>();
            for (CattleDataDTO dto : dataList) {
                if (dto.getType() != null && !dto.getType().trim().isEmpty()) {
                    String breedName = dto.getType().trim();
                    if (!processedBreeds.contains(breedName)) {
                        try {
                            com.example.cattletends.entity.CattleBreed existingBreed = cattleBreedService.getBreedByName(breedName);
                            if (existingBreed == null) {
                                cattleBreedService.createOrGetBreed(breedName);
                            }
                            processedBreeds.add(breedName);
                        } catch (Exception e) {
                            System.err.println("创建品种失败: " + breedName + ", 错误: " + e.getMessage());
                        }
                    }
                }
            }
            
            System.out.println("========== 开始导入数据，共 " + dataList.size() + " 条 ==========");
            com.example.cattletends.dto.ImportResult importResult = cattleDataService.batchImportCattleData(dataList);
            System.out.println("========== 导入完成: 新增 " + importResult.getNewCount() + " 条，更新 " + importResult.getUpdateCount() + " 条 ==========");
            
            // 更新品种的逻辑删除状态
            try {
                cattleBreedService.updateBreedDeleteStatus(processedBreeds);
            } catch (Exception e) {
                System.err.println("更新品种逻辑删除状态失败: " + e.getMessage());
            }
            
            String message = String.format("导入成功：新增 %d 条，更新 %d 条，共处理 %d 条数据",
                    importResult.getNewCount(), importResult.getUpdateCount(), importResult.getTotalCount());
            return Result.success(message, importResult.getDataList());
        } catch (Exception e) {
            System.err.println("========== 导入失败 ==========");
            System.err.println("异常类型: " + e.getClass().getName());
            System.err.println("异常信息: " + e.getMessage());
            e.printStackTrace();
            
            String errorMessage = e.getMessage();
            if (errorMessage == null || errorMessage.isEmpty()) {
                errorMessage = e.getClass().getSimpleName() + ": " + e.toString();
            }
            return Result.error(500, "导入失败：" + errorMessage);
        }
    }

    /**
     * 获取所有品种
     */
    @GetMapping("/breeds")
    @ApiOperation(value = "获取所有品种", notes = "返回所有品种列表")
    public Result<List<com.example.cattletends.entity.CattleBreed>> getAllBreeds() {
        List<com.example.cattletends.entity.CattleBreed> breeds = cattleBreedService.getAllBreeds();
        return Result.success(breeds);
    }

    /**
     * 获取所有省份数据
     */
    @GetMapping("/provinces")
    @ApiOperation(value = "获取省份数据", notes = "返回所有省份的存栏出栏数据和省份均价，按省份均价降序排序。支持通过province参数按省份查询")
    public Result<List<com.example.cattletends.entity.CattleProvince>> getAllProvinceData(
            @ApiParam(value = "省份名称（可选），如果提供则只返回该省份数据", required = false)
            @RequestParam(required = false) String province) {
        List<com.example.cattletends.entity.CattleProvince> data = cattleProvinceService.getAllProvinceData(province);
        return Result.success(data);
    }

    /**
     * 阿里云大屏接口 - 获取省份数据（直接返回数据数组，不包含Result包装）
     */
    @GetMapping("/provinces/screen")
    @ApiOperation(value = "阿里云大屏接口-省份数据", notes = "返回省份数据数组，直接返回data数据，不包含Result包装。按省份均价降序排序，支持通过province参数按省份查询")
    public List<com.example.cattletends.entity.CattleProvince> getProvinceDataForScreen(
            @ApiParam(value = "省份名称（可选），如果提供则只返回该省份数据", required = false)
            @RequestParam(required = false) String province) {
        return cattleProvinceService.getAllProvinceData(province);
    }

    /**
     * 根据省份名称获取省份数据
     */
    @GetMapping("/provinces/{province}")
    @ApiOperation(value = "根据省份名称获取省份数据", notes = "根据省份名称查询单个省份的存栏出栏数据")
    public Result<com.example.cattletends.entity.CattleProvince> getProvinceDataByName(
            @ApiParam(value = "省份名称", required = true)
            @PathVariable String province) {
        com.example.cattletends.entity.CattleProvince data = cattleProvinceService.getProvinceDataByName(province);
        return Result.success(data);
    }

    /**
     * 获取省份每日均价数据（支持按省份和日期查询）
     */
    @GetMapping("/province-daily-prices")
    @ApiOperation(value = "获取省份每日均价数据", notes = "返回省份的每日均价记录。支持通过province参数按省份查询，支持通过priceDate参数按日期查询（格式：yyyy-MM-dd）。如果同时提供province和priceDate，则返回该省份指定日期的价格；如果只提供priceDate，则返回所有省份指定日期的价格；如果只提供province，则返回该省份所有日期的价格；如果都不提供，则返回所有省份所有日期的价格，按日期降序排序")
    public Result<List<com.example.cattletends.entity.ProvinceDailyPrice>> getProvinceDailyPrices(
            @ApiParam(value = "省份名称（可选），如果提供则只返回该省份的每日均价数据", required = false)
            @RequestParam(required = false) String province,
            @ApiParam(value = "价格日期（可选），格式：yyyy-MM-dd，如果提供则只返回该日期的价格数据", required = false)
            @RequestParam(required = false) String priceDate) {
        System.out.println("========== 收到查询省份每日均价请求 ==========");
        System.out.println("省份参数: " + (province != null ? province : "全部"));
        System.out.println("日期参数: " + (priceDate != null ? priceDate : "全部"));
        
        List<com.example.cattletends.entity.ProvinceDailyPrice> data;
        
        // 解析日期参数
        java.time.LocalDate parsedDate = null;
        if (priceDate != null && !priceDate.trim().isEmpty()) {
            try {
                parsedDate = java.time.LocalDate.parse(priceDate.trim());
            } catch (Exception e) {
                System.err.println("日期格式错误: " + priceDate + ", 错误: " + e.getMessage());
                return Result.error(400, "日期格式错误，请使用 yyyy-MM-dd 格式，例如：2025-12-03");
            }
        }
        
        // 根据参数组合进行查询
        if (province != null && !province.trim().isEmpty() && parsedDate != null) {
            // 同时提供省份和日期：查询该省份指定日期的价格
            java.util.Optional<com.example.cattletends.entity.ProvinceDailyPrice> optional = 
                provinceDailyPriceService.getByProvinceAndPriceDate(province.trim(), parsedDate);
            if (optional.isPresent()) {
                data = java.util.Collections.singletonList(optional.get());
            } else {
                data = new java.util.ArrayList<>();
            }
            System.out.println("查询省份: " + province + ", 日期: " + parsedDate + ", 返回 " + (data != null ? data.size() : 0) + " 条记录");
        } else if (parsedDate != null) {
            // 只提供日期：查询所有省份指定日期的价格
            data = provinceDailyPriceService.getByPriceDate(parsedDate);
            System.out.println("查询日期: " + parsedDate + ", 返回 " + (data != null ? data.size() : 0) + " 条记录");
        } else if (province != null && !province.trim().isEmpty()) {
            // 只提供省份：查询该省份所有日期的价格
            data = provinceDailyPriceService.getByProvince(province.trim());
            System.out.println("查询省份: " + province + ", 返回 " + (data != null ? data.size() : 0) + " 条记录");
        } else {
            // 都不提供：查询所有省份所有日期的价格
            data = provinceDailyPriceService.getAll();
            System.out.println("查询全部省份, 返回 " + (data != null ? data.size() : 0) + " 条记录");
        }
        
        System.out.println("========== 查询完成 ==========");
        return Result.success(data);
    }

    /**
     * 获取全国总量数据
     * 自动从 cattleprovince 表计算总和
     */
    @GetMapping("/national")
    @ApiOperation(value = "获取全国总量数据", notes = "自动从省份数据表计算并返回全国年份存栏和出栏总量数据")
    public Result<com.example.cattletends.entity.CattleNational> getNationalData() {
        com.example.cattletends.entity.CattleNational data = cattleNationalService.getNationalData();
        if (data == null) {
            return Result.error(404, "全国总量数据不存在，请先导入省份数据");
        }
        return Result.success(data);
    }

    /**
     * 重新计算全国总量数据
     * 根据 cattleprovince 表中的所有省份数据重新计算总和
     */
    @PostMapping("/national/recalculate")
    @ApiOperation(value = "重新计算全国总量数据", notes = "根据 cattleprovince 表中的所有省份数据重新计算全国总量")
    public Result<com.example.cattletends.entity.CattleNational> recalculateNationalData() {
        com.example.cattletends.entity.CattleNational data = cattleNationalService.calculateAndUpdateNationalData();
        return Result.success("重新计算成功", data);
    }

    /**
     * 导入省份数据（Excel文件）
     * 导入15个省份的存栏出栏量和省份均价，并计算全国总量
     */
    @PostMapping("/import-province")
    @ApiOperation(value = "导入省份数据", notes = "导入15个省份的存栏出栏量和省份均价，自动计算全国总量")
    public Result<Map<String, Object>> importProvinceData(
            @ApiParam(value = "Excel文件", required = true)
            @RequestParam("file") MultipartFile file) {
        System.out.println("========== 收到导入省份数据请求 ==========");
        System.out.println("文件名: " + file.getOriginalFilename());
        System.out.println("文件大小: " + file.getSize());
        
        if (file.isEmpty()) {
            System.out.println("错误: 文件为空");
            return Result.error(400, "文件不能为空");
        }

        try {
            System.out.println("开始解析Excel文件...");
            List<com.example.cattletends.dto.ProvinceDataDTO> provinceDataList = parseProvinceExcelFile(file);
            System.out.println("解析完成，共 " + (provinceDataList != null ? provinceDataList.size() : 0) + " 条数据");
            
            if (provinceDataList == null || provinceDataList.isEmpty()) {
                System.out.println("错误: Excel文件中没有有效数据");
                return Result.error(400, "Excel文件中没有有效数据，请检查文件格式");
            }
            
            System.out.println("开始导入数据到数据库...");
            Map<String, Object> result = cattleProvinceService.importProvinceData(provinceDataList);
            System.out.println("导入完成: " + result);
            
            // 注意：不更新 province_daily_price 表的 price 字段
            // 该字段只通过牛只数据导入时的计算得出（计算该省份所有牛只数据的平均价格）
            System.out.println("========== 省份数据导入完成 ==========");
            System.out.println("注意：province_price 和 province_daily_price.price 字段只通过牛只数据导入时的计算得出");
            
            String message = String.format("导入成功：新增 %d 条，更新 %d 条，共处理 %d 条省份数据",
                    result.get("createCount"), result.get("updateCount"), result.get("totalCount"));
            return Result.success(message, result);
        } catch (Exception e) {
            System.err.println("========== 导入失败 ==========");
            System.err.println("异常类型: " + e.getClass().getName());
            System.err.println("异常信息: " + e.getMessage());
            e.printStackTrace(); // 打印完整堆栈信息
            
            String errorMessage = e.getMessage();
            if (errorMessage == null || errorMessage.isEmpty()) {
                errorMessage = e.getClass().getSimpleName() + ": " + e.toString();
            }
            return Result.error(500, "导入失败：" + errorMessage);
        }
    }

    /**
     * 创建牛只数据
     */
    @PostMapping
    @ApiOperation(value = "创建牛只数据", notes = "创建新的牛只数据记录")
    @ResponseStatus(HttpStatus.CREATED)
    public Result<CattleData> createCattleData(
            @ApiParam(value = "牛只数据信息", required = true)
            @Valid @RequestBody CattleDataDTO dto) {
        CattleData data = cattleDataService.createCattleData(dto);
        return Result.success("创建成功", data);
    }

    /**
     * 更新牛只数据
     */
    @PutMapping("/{id}")
    @ApiOperation(value = "更新牛只数据", notes = "根据ID更新牛只数据信息")
    public Result<CattleData> updateCattleData(
            @ApiParam(value = "主键ID", required = true)
            @PathVariable Integer id,
            @ApiParam(value = "牛只数据信息", required = true)
            @Valid @RequestBody CattleDataDTO dto) {
        CattleData data = cattleDataService.updateCattleData(id, dto);
        return Result.success("更新成功", data);
    }

    /**
     * 删除牛只数据
     */
    @DeleteMapping("/{id}")
    @ApiOperation(value = "删除牛只数据", notes = "根据ID删除牛只数据")
    public Result<Void> deleteCattleData(
            @ApiParam(value = "主键ID", required = true)
            @PathVariable Integer id) {
        cattleDataService.deleteCattleData(id);
        return Result.success("删除成功");
    }

    /**
     * 解析Excel文件
     */
    private List<CattleDataDTO> parseExcelFile(MultipartFile file) throws IOException {
        List<CattleDataDTO> dataList = new ArrayList<>();
        
        try (Workbook workbook = new XSSFWorkbook(file.getInputStream())) {
            Sheet sheet = workbook.getSheetAt(0);
            
            // 从第二行开始读取（第一行是表头）
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                Row row = sheet.getRow(i);
                if (row == null) {
                    continue;
                }

                CattleDataDTO dto = new CattleDataDTO();
                
                // Excel模板列顺序（根据图片）：
                // 列1（索引0）：日期
                // 列2（索引1）：品种
                // 列3（索引2）：省份
                // 列4（索引3）：地市
                // 列5（索引4）：价格(元/斤)
                
                // 读取日期（第1列，索引0）
                Cell timeCell = row.getCell(0);
                if (timeCell != null) {
                    LocalDateTime createTime = parseDateTime(timeCell);
                    dto.setCreateTime(createTime);
                }

                // 读取品种（第2列，索引1）
                Cell typeCell = row.getCell(1);
                if (typeCell != null) {
                    String breedName = getCellValueAsString(typeCell).trim();
                    dto.setType(breedName);
                }

                // 读取省份（第3列，索引2），完全按照表格内容，不做截取
                Cell provinceCell = row.getCell(2);
                if (provinceCell != null) {
                    String province = getCellValueAsString(provinceCell).trim();
                    dto.setProvince(province);
                }

                // 读取地市（第4列，索引3），截取到"市"
                Cell locationCell = row.getCell(3);
                if (locationCell != null) {
                    String location = getCellValueAsString(locationCell).trim();
                    // 截取到"市"、"盟"、"地区"、"州"等
                    String cityLocation = extractCity(location);
                    dto.setLocation(cityLocation);
                }

                // 读取价格（第5列，索引4）
                Cell priceCell = row.getCell(4);
                if (priceCell != null) {
                    BigDecimal price = parsePrice(priceCell, dto.getLocation() != null ? dto.getLocation() : "未知");
                    dto.setPrice(price);
                }

                // 验证必填字段
                if (dto.getType() != null && !dto.getType().trim().isEmpty() &&
                    dto.getProvince() != null && !dto.getProvince().trim().isEmpty() &&
                    dto.getLocation() != null && !dto.getLocation().trim().isEmpty() &&
                    dto.getPrice() != null) {
                    dataList.add(dto);
                }
            }
        }
        
        return dataList;
    }

    /**
     * 获取单元格值（字符串）
     */
    private String getCellValueAsString(Cell cell) {
        if (cell == null) {
            return "";
        }
        
        switch (cell.getCellType()) {
            case STRING:
                return cell.getStringCellValue().trim();
            case NUMERIC:
                if (DateUtil.isCellDateFormatted(cell)) {
                    return cell.getDateCellValue().toString();
                } else {
                    // 避免科学计数法
                    double numericValue = cell.getNumericCellValue();
                    if (numericValue == (long) numericValue) {
                        return String.valueOf((long) numericValue);
                    } else {
                        return String.valueOf(numericValue);
                    }
                }
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            case FORMULA:
                return cell.getCellFormula();
            default:
                return "";
        }
    }

    /**
     * 解析日期时间
     */
    private LocalDateTime parseDateTime(Cell cell) {
        try {
            if (cell.getCellType() == CellType.NUMERIC && DateUtil.isCellDateFormatted(cell)) {
                java.util.Date date = cell.getDateCellValue();
                return new java.sql.Timestamp(date.getTime()).toLocalDateTime();
            } else if (cell.getCellType() == CellType.STRING) {
                String dateStr = cell.getStringCellValue().trim();
                // 尝试解析 "2025/11/23" 格式
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/M/d");
                return java.time.LocalDate.parse(dateStr, formatter).atStartOfDay();
            }
        } catch (Exception e) {
            // 解析失败，返回当前时间
        }
        return LocalDateTime.now();
    }

    /**
     * 解析价格（用于牛只数据导入，取平均值）
     * 支持格式：
     * - 数字：13.5
     * - 价格范围：13.41-14.61（取平均值）
     * - 字符串数字："13.5"
     * @param cell 价格单元格
     * @param location 位置信息（用于错误日志）
     */
    private BigDecimal parsePrice(Cell cell, String location) {
        try {
            if (cell == null) {
                System.out.println("解析价格失败: " + location + ", 错误: 单元格为空");
                return null;
            }
            
            if (cell.getCellType() == CellType.NUMERIC) {
                return BigDecimal.valueOf(cell.getNumericCellValue());
            } else if (cell.getCellType() == CellType.STRING) {
                String priceStr = cell.getStringCellValue().trim();
                if (priceStr == null || priceStr.isEmpty()) {
                    System.out.println("解析价格失败: " + location + ", 错误: 价格字符串为空");
                    return null;
                }
                
                // 处理价格范围格式，如 "13.41-14.61"
                if (priceStr.contains("-")) {
                    String[] parts = priceStr.split("-");
                    if (parts.length == 2) {
                        try {
                            BigDecimal min = new BigDecimal(parts[0].trim());
                            BigDecimal max = new BigDecimal(parts[1].trim());
                            // 计算平均值
                            BigDecimal average = min.add(max).divide(BigDecimal.valueOf(2), 2, java.math.RoundingMode.HALF_UP);
                            return average;
                        } catch (Exception e) {
                            // 如果解析范围失败，尝试解析第一个值
                            try {
                                return new BigDecimal(parts[0].trim());
                            } catch (Exception e2) {
                                System.out.println("解析价格失败: " + location + ", 价格字符串: " + priceStr + ", 错误: " + e2.getMessage());
                                return null;
                            }
                        }
                    }
                }
                
                // 处理普通数字字符串
                return new BigDecimal(priceStr);
            } else {
                System.out.println("解析价格失败: " + location + ", 错误: 单元格类型不支持, 类型: " + cell.getCellType());
            }
        } catch (Exception e) {
            // 解析失败，返回null
            String cellValue = cell != null ? getCellValueAsString(cell) : "null";
            System.out.println("解析价格失败: " + location + ", 单元格值: " + cellValue + ", 错误: " + (e.getMessage() != null ? e.getMessage() : e.getClass().getSimpleName()));
        }
        return null;
    }

    /**
     * 解析省份价格（用于省份数据导入，提取最低价格）
     * 支持格式：
     * - 数字：13.5
     * - 价格范围：13.4-14.9（提取最低价格 13.4）
     * - 字符串数字："13.5"
     * @param priceStr 价格字符串
     * @param province 省份名称（用于错误日志）
     * @return 最低价格
     */
    private BigDecimal parseProvincePrice(String priceStr, String province) {
        try {
            if (priceStr == null || priceStr.trim().isEmpty()) {
                System.out.println("解析省份价格失败: " + province + ", 错误: 价格字符串为空");
                return null;
            }
            
            priceStr = priceStr.trim();
            
            // 处理价格范围格式，如 "13.4-14.9"
            if (priceStr.contains("-")) {
                String[] parts = priceStr.split("-");
                if (parts.length == 2) {
                    try {
                        // 提取最低价格（第一部分）
                        BigDecimal minPrice = new BigDecimal(parts[0].trim());
                        return minPrice;
                    } catch (Exception e) {
                        System.out.println("解析省份价格失败: " + province + ", 价格字符串: " + priceStr + ", 错误: " + e.getMessage());
                        return null;
                    }
                }
            }
            
            // 处理普通数字字符串
            return new BigDecimal(priceStr);
        } catch (Exception e) {
            System.out.println("解析省份价格失败: " + province + ", 价格字符串: " + priceStr + ", 错误: " + (e.getMessage() != null ? e.getMessage() : e.getClass().getSimpleName()));
            return null;
        }
    }

    /**
     * 截取所在产地到"市"级别
     */
    private String extractCity(String location) {
        if (location == null || location.trim().isEmpty()) {
            return "";
        }
        
        // 查找"市"的位置
        int cityIndex = location.indexOf("市");
        if (cityIndex > 0) {
            // 包含"市"字符
            return location.substring(0, cityIndex + 1);
        }
        
        // 如果没有找到"市"，返回原字符串（可能是直辖市或其他格式）
        return location.trim();
    }

    /**
     * 从location中提取省份
     * 例如："安徽淮南市" -> "安徽"
     */
    private String extractProvince(String location) {
        if (location == null || location.trim().isEmpty()) {
            return "";
        }
        
        String trimmed = location.trim();
        
        // 中国省份列表（包括自治区、直辖市、特别行政区）
        String[] provinces = {
            "北京", "天津", "上海", "重庆",
            "河北", "山西", "辽宁", "吉林", "黑龙江",
            "江苏", "浙江", "安徽", "福建", "江西", "山东",
            "河南", "湖北", "湖南", "广东", "海南",
            "四川", "贵州", "云南", "陕西", "甘肃", "青海",
            "内蒙古", "广西", "西藏", "宁夏", "新疆",
            "香港", "澳门", "台湾"
        };
        
        // 匹配省份（包括自治区、直辖市等）
        for (String province : provinces) {
            if (trimmed.startsWith(province)) {
                // 处理特殊情况：内蒙古、黑龙江等
                if (province.equals("内蒙古") && trimmed.startsWith("内蒙古自治区")) {
                    return "内蒙古";
                }
                return province;
            }
        }
        
        // 如果没有匹配到，尝试提取前2-3个字符作为省份
        // 大多数省份名称是2-3个字符
        if (trimmed.length() >= 2) {
            // 尝试2个字符
            String twoChar = trimmed.substring(0, 2);
            for (String province : provinces) {
                if (province.equals(twoChar)) {
                    return province;
                }
            }
            
            // 尝试3个字符（如内蒙古）
            if (trimmed.length() >= 3) {
                String threeChar = trimmed.substring(0, 3);
                for (String province : provinces) {
                    if (province.equals(threeChar)) {
                        return province;
                    }
                }
            }
        }
        
        // 如果都匹配不到，返回空字符串
        return "";
    }

    /**
     * 解析省份数据Excel文件
     * Excel格式（列顺序）：
     * A列：省份
     * B列：2023存栏(万头) -> inventory_23th
     * C列：2023出栏(万头) -> slaughter_23th
     * D列：2024存栏(万头) -> inventory_24th
     * E列：2024出栏(万头) -> slaughter_24th
     * F列：2025存栏(万头) -> inventory_25th
     * G列：2025出栏(万头) -> slaughter_25th
     * H列：省份均价(元/斤) -> province_price
     */
    private List<com.example.cattletends.dto.ProvinceDataDTO> parseProvinceExcelFile(MultipartFile file) throws IOException {
        List<com.example.cattletends.dto.ProvinceDataDTO> dataList = new ArrayList<>();
        
        try (Workbook workbook = new XSSFWorkbook(file.getInputStream())) {
            Sheet sheet = workbook.getSheetAt(0);
            
            // 从第二行开始读取（第一行是表头）
            for (int i = 1; i <= sheet.getLastRowNum(); i++) {
                Row row = sheet.getRow(i);
                if (row == null) {
                    continue;
                }

                com.example.cattletends.dto.ProvinceDataDTO dto = new com.example.cattletends.dto.ProvinceDataDTO();
                
                // Excel模板列顺序（根据实际模板）：
                // A列（索引0）：省份
                // B列（索引1）：省份均价(元/斤) -> province_price
                // C列（索引2）：2023存栏(万头) -> inventory_23th
                // D列（索引3）：2023出栏(万头) -> slaughter_23th
                // E列（索引4）：2024存栏(万头) -> inventory_24th
                // F列（索引5）：2024出栏(万头) -> slaughter_24th
                // G列（索引6）：2025存栏(万头) -> inventory_25th
                // H列（索引7）：2025出栏(万头) -> slaughter_25th
                
                // 读取省份（A列，索引0）
                Cell provinceCell = row.getCell(0);
                if (provinceCell != null) {
                    String province = getCellValueAsString(provinceCell).trim();
                    // 完全按照表格内容导入，不做任何截取
                    dto.setProvince(province);
                }

                // 读取省份均价(元/斤)（B列，索引1）-> province_price_range（原始区间）和 province_price（最低价格）
                Cell priceCell = row.getCell(1);
                if (priceCell != null) {
                    String priceStr = getCellValueAsString(priceCell);
                    System.out.println("省份: " + dto.getProvince() + ", 原始价格字符串: [" + priceStr + "]");
                    
                    // 保存原始价格区间字符串
                    dto.setProvincePriceRange(priceStr);
                    
                    // 解析价格：如果是区间，提取最低价格；否则使用原值
                    BigDecimal price = parseProvincePrice(priceStr, dto.getProvince() != null ? dto.getProvince() : "未知省份");
                    dto.setProvincePrice(price);
                    System.out.println("省份: " + dto.getProvince() + ", 价格区间: " + priceStr + ", 最低价格: " + price);
                } else {
                    System.out.println("省份: " + dto.getProvince() + ", 价格单元格为空或不存在");
                }

                // 读取2023存栏(万头)（C列，索引2）-> inventory_23th
                Cell inv23Cell = row.getCell(2);
                if (inv23Cell != null) {
                    String cellValueStr = getCellValueAsString(inv23Cell);
                    Integer value = parseInteger(inv23Cell);
                    System.out.println("省份: " + dto.getProvince() + ", 2023存栏原始值: [" + cellValueStr + "], 解析后: " + value);
                    dto.setInventory23th(value);
                } else {
                    System.out.println("省份: " + dto.getProvince() + ", 2023存栏单元格为空");
                }

                // 读取2023出栏(万头)（D列，索引3）-> slaughter_23th
                Cell sla23Cell = row.getCell(3);
                if (sla23Cell != null) {
                    Integer value = parseInteger(sla23Cell);
                    dto.setSlaughter23th(value);
                }

                // 读取2024存栏(万头)（E列，索引4）-> inventory_24th
                Cell inv24Cell = row.getCell(4);
                if (inv24Cell != null) {
                    Integer value = parseInteger(inv24Cell);
                    dto.setInventory24th(value);
                }

                // 读取2024出栏(万头)（F列，索引5）-> slaughter_24th
                Cell sla24Cell = row.getCell(5);
                if (sla24Cell != null) {
                    Integer value = parseInteger(sla24Cell);
                    dto.setSlaughter24th(value);
                }

                // 读取2025存栏(万头)（G列，索引6）-> inventory_25th
                Cell inv25Cell = row.getCell(6);
                if (inv25Cell != null) {
                    Integer value = parseInteger(inv25Cell);
                    dto.setInventory25th(value);
                }

                // 读取2025出栏(万头)（H列，索引7）-> slaughter_25th
                Cell sla25Cell = row.getCell(7);
                if (sla25Cell != null) {
                    Integer value = parseInteger(sla25Cell);
                    dto.setSlaughter25th(value);
                }

                // 验证必填字段
                if (dto.getProvince() != null && !dto.getProvince().trim().isEmpty()) {
                    dataList.add(dto);
                }
            }
        }
        
        return dataList;
    }

    /**
     * 解析整数（处理可能包含±的情况，如"400±20"取400）
     */
    private Integer parseInteger(Cell cell) {
        try {
            if (cell.getCellType() == CellType.NUMERIC) {
                return (int) cell.getNumericCellValue();
            } else if (cell.getCellType() == CellType.STRING) {
                String value = cell.getStringCellValue().trim();
                // 处理"400±20"格式，取前面的数字
                if (value.contains("±")) {
                    value = value.substring(0, value.indexOf("±")).trim();
                }
                // 处理"万头"等后缀
                value = value.replace("万头", "").trim();
                return Integer.parseInt(value);
            }
        } catch (Exception e) {
            // 解析失败
        }
        return null;
    }
}

