package com.estate.expert.admin.utils;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;

/**
 * Excel 导入数据解析工具类
 * 
 * 用于统一处理 Excel 导入时的数据解析，包括空值、异常处理等
 */
public class ExcelParseUtils {

    /**
     * 解析字符串，空值返回 null
     * 
     * @param value 原始值
     * @return 处理后的字符串，空值返回 null
     */
    public static String parseString(String value) {
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        return value.trim();
    }

    /**
     * 解析字符串，空值返回默认值
     * 
     * @param value 原始值
     * @param defaultValue 默认值
     * @return 处理后的字符串
     */
    public static String parseString(String value, String defaultValue) {
        String result = parseString(value);
        return result != null ? result : defaultValue;
    }

    /**
     * 解析整数，空值或解析失败返回 null
     * 
     * @param value 原始值
     * @return 解析后的整数，失败返回 null
     */
    public static Integer parseInt(String value) {
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        try {
            return Integer.parseInt(value.trim());
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /**
     * 解析整数，空值或解析失败返回默认值
     * 
     * @param value 原始值
     * @param defaultValue 默认值
     * @return 解析后的整数
     */
    public static Integer parseInt(String value, Integer defaultValue) {
        Integer result = parseInt(value);
        return result != null ? result : defaultValue;
    }

    /**
     * 解析长整数，空值或解析失败返回 null
     * 
     * @param value 原始值
     * @return 解析后的长整数，失败返回 null
     */
    public static Long parseLong(String value) {
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        try {
            return Long.parseLong(value.trim());
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /**
     * 解析长整数，空值或解析失败返回默认值
     * 
     * @param value 原始值
     * @param defaultValue 默认值
     * @return 解析后的长整数
     */
    public static Long parseLong(String value, Long defaultValue) {
        Long result = parseLong(value);
        return result != null ? result : defaultValue;
    }

    /**
     * 解析双精度浮点数，空值或解析失败返回 null
     * 
     * @param value 原始值
     * @return 解析后的双精度浮点数，失败返回 null
     */
    public static Double parseDouble(String value) {
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        try {
            return Double.parseDouble(value.trim());
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /**
     * 解析双精度浮点数，空值或解析失败返回默认值
     * 
     * @param value 原始值
     * @param defaultValue 默认值
     * @return 解析后的双精度浮点数
     */
    public static Double parseDouble(String value, Double defaultValue) {
        Double result = parseDouble(value);
        return result != null ? result : defaultValue;
    }

    /**
     * 解析 BigDecimal，空值或解析失败返回 null
     * 
     * @param value 原始值
     * @return 解析后的 BigDecimal，失败返回 null
     */
    public static BigDecimal parseBigDecimal(String value) {
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        try {
            return new BigDecimal(value.trim());
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /**
     * 解析 BigDecimal，空值或解析失败返回默认值
     * 
     * @param value 原始值
     * @param defaultValue 默认值
     * @return 解析后的 BigDecimal
     */
    public static BigDecimal parseBigDecimal(String value, BigDecimal defaultValue) {
        BigDecimal result = parseBigDecimal(value);
        return result != null ? result : defaultValue;
    }

    /**
     * 解析布尔值，空值或解析失败返回 null
     * 支持：true/false, 是/否, 1/0, yes/no
     * 
     * @param value 原始值
     * @return 解析后的布尔值，失败返回 null
     */
    public static Boolean parseBoolean(String value) {
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        String trimmed = value.trim().toLowerCase();
        if ("true".equals(trimmed) || "是".equals(trimmed) || "1".equals(trimmed) || "yes".equals(trimmed)) {
            return true;
        }
        if ("false".equals(trimmed) || "否".equals(trimmed) || "0".equals(trimmed) || "no".equals(trimmed)) {
            return false;
        }
        return null;
    }

    /**
     * 解析布尔值，空值或解析失败返回默认值
     * 
     * @param value 原始值
     * @param defaultValue 默认值
     * @return 解析后的布尔值
     */
    public static Boolean parseBoolean(String value, Boolean defaultValue) {
        Boolean result = parseBoolean(value);
        return result != null ? result : defaultValue;
    }

    /**
     * 解析日期，空值或解析失败返回 null
     * 默认格式：yyyy-MM-dd
     * 
     * @param value 原始值
     * @return 解析后的日期，失败返回 null
     */
    public static LocalDate parseDate(String value) {
        return parseDate(value, "yyyy-MM-dd");
    }

    /**
     * 解析日期，支持自定义格式
     * 
     * @param value 原始值
     * @param pattern 日期格式
     * @return 解析后的日期，失败返回 null
     */
    public static LocalDate parseDate(String value, String pattern) {
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
            return LocalDate.parse(value.trim(), formatter);
        } catch (DateTimeParseException e) {
            return null;
        }
    }

    /**
     * 解析日期时间，空值或解析失败返回 null
     * 默认格式：yyyy-MM-dd HH:mm:ss
     * 
     * @param value 原始值
     * @return 解析后的日期时间，失败返回 null
     */
    public static LocalDateTime parseDateTime(String value) {
        return parseDateTime(value, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 解析日期时间，支持自定义格式
     * 
     * @param value 原始值
     * @param pattern 日期时间格式
     * @return 解析后的日期时间，失败返回 null
     */
    public static LocalDateTime parseDateTime(String value, String pattern) {
        if (value == null || value.trim().isEmpty()) {
            return null;
        }
        try {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
            return LocalDateTime.parse(value.trim(), formatter);
        } catch (DateTimeParseException e) {
            return null;
        }
    }

    /**
     * 检查字符串是否为空（null 或空白）
     * 
     * @param value 要检查的字符串
     * @return 是否为空
     */
    public static boolean isEmpty(String value) {
        return value == null || value.trim().isEmpty();
    }

    /**
     * 检查字符串是否非空
     * 
     * @param value 要检查的字符串
     * @return 是否非空
     */
    public static boolean isNotEmpty(String value) {
        return !isEmpty(value);
    }
}