package com.qgutech.qgyun.apaas.sync.utils;

import com.qgutech.qgyun.apaas.sync.base.BoErrorCode;
import com.qgutech.qgyun.apaas.sync.base.BoException;
import com.qgutech.qgyun.apaas.sync.cps.enums.QuarterEnum;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class DateDealUtils {

    private static final String DATE_TIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

    /**
     * 解析年份开始时间
     */
    public static Date parseYearStartTime(String year) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(DATE_TIME_PATTERN);
            return sdf.parse(year + "-01-01 00:00:00");
        } catch (ParseException e) {
            throw new BoException(BoErrorCode.PARAM_ERROR, "年份格式错误");
        }
    }

    /**
     * 解析年份结束时间
     */
    public static Date parseYearEndTime(String year) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(DATE_TIME_PATTERN);
            return sdf.parse(year + "-12-31 23:59:59");
        } catch (ParseException e) {
            throw new BoException(BoErrorCode.PARAM_ERROR, "年份格式错误");
        }
    }

    /**
     * 解析季度开始时间
     */
    public static Date parseQuarterStartTime(String year, QuarterEnum quarter) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(DATE_TIME_PATTERN);
            return sdf.parse(year + "-" + quarter.getStartDate() + " 00:00:00");
        } catch (ParseException e) {
            throw new BoException(BoErrorCode.PARAM_ERROR, "季度日期格式错误");
        }
    }

    /**
     * 解析季度结束时间
     */
    public static Date parseQuarterEndTime(String year, QuarterEnum quarter) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat(DATE_TIME_PATTERN);
            return sdf.parse(year + "-" + quarter.getEndDate() + " 23:59:59");
        } catch (ParseException e) {
            throw new BoException(BoErrorCode.PARAM_ERROR, "季度日期格式错误");
        }
    }

    /**
     * 解析日期字符串，支持以下格式：
     * <ul>
     *   <li>yyyy-MM-dd HH:mm:ss</li>
     *   <li>yyyy-MM-dd</li>
     *   <li>yyyy/MM/dd HH:mm:ss</li>
     *   <li>yyyy/MM/dd</li>
     * </ul>
     *
     * @param dateStr 日期字符串
     * @return 解析后的日期，为空时返回 null
     */
    public static Date parseDate(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return null;
        }
        String trimmed = dateStr.trim();
        String[] patterns = new String[]{
                "yyyy-MM-dd HH:mm:ss",
                "yyyy-MM-dd",
                "yyyy/MM/dd HH:mm:ss",
                "yyyy/MM/dd"
        };
        for (String pattern : patterns) {
            try {
                SimpleDateFormat sdf = new SimpleDateFormat(pattern);
                sdf.setLenient(false);
                return sdf.parse(trimmed);
            } catch (ParseException ignored) {
                // 尝试下一个格式
            }
        }
        throw new BoException(BoErrorCode.PARAM_ERROR, "日期格式错误，支持 yyyy-MM-dd [HH:mm:ss]");
    }

    /**
     * 将开始时间字符串解析为当天的 00:00:00（若未包含时间部分）
     */
    public static Date parseStartTime(String dateStr) {
        Date date = parseDate(dateStr);
        if (date == null) {
            return null;
        }
        // 如果传入的字符串不包含时间部分，则默认为当天开始
        if (dateStr != null && dateStr.trim().length() <= 10) {
            return date;
        }
        return date;
    }

    /**
     * 将结束时间字符串解析为当天的 23:59:59（若未包含时间部分）
     */
    public static Date parseEndTime(String dateStr) {
        Date date = parseDate(dateStr);
        if (date == null) {
            return null;
        }
        // 如果传入的字符串不包含时间部分，则默认为当天结束
        if (dateStr != null && dateStr.trim().length() <= 10) {
            java.util.Calendar cal = java.util.Calendar.getInstance();
            cal.setTime(date);
            cal.set(java.util.Calendar.HOUR_OF_DAY, 23);
            cal.set(java.util.Calendar.MINUTE, 59);
            cal.set(java.util.Calendar.SECOND, 59);
            cal.set(java.util.Calendar.MILLISECOND, 999);
            return cal.getTime();
        }
        return date;
    }

    /**
     * 获取当前月的开始时间（当月 1 号 00:00:00.000）
     */
    public static Date getCurrentMonthStartTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMinimum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }

    /**
     * 获取当前月的结束时间（当月最后一天 23:59:59.999）
     */
    public static Date getCurrentMonthEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    /**
     * 解析开始时间字符串，为空时默认返回当前月开始时间
     */
    public static Date parseStartTimeOrCurrentMonthStart(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getCurrentMonthStartTime();
        }
        return parseStartTime(dateStr);
    }

    /**
     * 解析结束时间字符串，为空时默认返回当前月结束时间
     */
    public static Date parseEndTimeOrCurrentMonthEnd(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getCurrentMonthEndTime();
        }
        return parseEndTime(dateStr);
    }

    /**
     * 获取当前日期前一天的结束时间（昨天 23:59:59.999）
     */
    public static Date getYesterdayEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DAY_OF_MONTH, -1);
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    /**
     * 解析结束时间字符串，为空时默认返回当前日期前一天的结束时间
     */
    public static Date parseEndTimeOrYesterdayEnd(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getYesterdayEndTime();
        }
        return parseEndTime(dateStr);
    }

    /**
     * 获取当前天的开始时间（今天 00:00:00.000）
     */
    public static Date getCurrentDayStartTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }

    /**
     * 获取当前天的结束时间（今天 23:59:59.999）
     */
    public static Date getCurrentDayEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    /**
     * 解析开始时间字符串，为空时默认返回当前天开始时间
     */
    public static Date parseStartTimeOrCurrentDayStart(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getCurrentDayStartTime();
        }
        return parseStartTime(dateStr);
    }

    /**
     * 解析结束时间字符串，为空时默认返回当前天结束时间
     */
    public static Date parseEndTimeOrCurrentDayEnd(String dateStr) {
        if (dateStr == null || dateStr.trim().isEmpty()) {
            return getCurrentDayEndTime();
        }
        return parseEndTime(dateStr);
    }
}