DateTimeUtil-未验证，可能不准或者报错

package com.ioo.system.refactor_report.utils;

import cn.hutool.core.date.DateUtil;
import com.ioo.system.constant.CommonConstant;
import com.ioo.system.enums.ReplyCycle;
import com.ioo.system.refactor_report.controller.dto.ReportHMMDTO;
import com.ioo.system.refactor_report.controller.vo.ReportDateVO;
import com.ioo.system.refactor_report.controller.vo.ReportTemplateVO;
import org.apache.logging.log4j.util.Strings;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.*;
import java.util.*;

/**
 * @Project：astoa-admin
 * @Package：com.ioo.system.refactor_report.utils
 * @Author：xen
 * @name：DateTimeUtil
 * @Date：2024/8/1/0001 18:06
 */
public class DateTimeUtil {

    /**
     * 将 日期时间字符串补全
     *
     * @param dateTimeStr 日期时间字符串
     * @return 转换后的日期字符串
     */
    public static String complementStrDate(String dateTimeStr) {
        if (!dateTimeStr.matches("\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}"))
            dateTimeStr = dateTimeStr + ":00";
        return dateTimeStr;
    }

    /**
     * 将 日期时间字符串转换为特定格式的字符串。
     *
     * @param dateTimeStr 日期时间字符串
     * @param ft          格式，默认 yyyy-MM-dd HH:mm:ss
     * @return 转换后的日期字符串
     */
    public static String formatToFt(String dateTimeStr, String ft) {
        // 定义原始格式
        DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 定义目标格式
        DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern(ft);

        try {
            // 解析字符串为 LocalDateTime 对象
            LocalDateTime dateTime = LocalDateTime.parse(dateTimeStr, inputFormatter);
            // 格式化为 "MM月dd日" 格式的字符串
            return dateTime.format(outputFormatter);
        } catch (Exception e) {
            // 处理异常，例如格式不匹配
            System.err.println("Error parsing date: " + e.getMessage());
            return null;
        }
    }

    /**
     * 将时间戳转换为指定时区的 yyyy-MM-dd HH:mm:ss 格式的字符串。
     *
     * @param timestamp 时间戳，单位为毫秒
     * @param zoneId    时区ID，例如 "Asia/Shanghai"
     * @param ft        格式，默认 yyyy-MM-dd HH:mm:ss
     * @return 格式化的日期时间字符串
     */
    public static String formatTimestamp(long timestamp, String zoneId, String ft) {
        if (Strings.isBlank(ft))
            ft = "yyyy-MM-dd HH:mm:ss";
        // 将时间戳转换为Instant对象
        Instant instant = Instant.ofEpochMilli(timestamp);
        // 在指定时区创建ZonedDateTime对象
        ZonedDateTime zonedDateTime = instant.atZone(ZoneId.of(zoneId));
        // 定义日期时间格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(ft);
        // 格式化日期时间
        return zonedDateTime.format(formatter);
    }

    /**
     * 将给定的日期时间字符串从 "yyyy-MM-dd HH:mm:ss" 格式转换为 "X月X日" 格式。
     *
     * @param dateTimeStr 日期时间字符串
     * @return 转换后的日期字符串，格式为 "X月X日"
     */
    public static String formatToMonthDay(String dateTimeStr) {
        // 日期时间格式
        DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        // 月和日的格式
        DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern("MMMMdd日", Locale.CHINA);

        // 解析输入的日期时间字符串
        LocalDateTime dateTime = LocalDateTime.parse(dateTimeStr, inputFormatter);

        // 格式化为 "X月X日"
        return dateTime.format(outputFormatter);
    }

    /**
     * 根据给定的时间戳和时区ID，返回格式为YYYYMMDD的整数。
     *
     * @param timestamp 时间戳，以毫秒为单位
     * @param zoneId    时区ID，例如 "GMT+8" 或 "America/New_York"
     * @return 年月日的整数，例如 20240814
     */
    public static int getYyyyMmDdFromTimestamp(long timestamp, String zoneId) {
        // 将时间戳转换为ZonedDateTime
        ZonedDateTime zonedDateTime = Instant.ofEpochMilli(timestamp).atZone(ZoneId.of(zoneId));
        // 获取年、月、日并格式化为YYYYMMDD
        return zonedDateTime.getYear() * 10000 + zonedDateTime.getMonthValue() * 100 + zonedDateTime.getDayOfMonth();
    }

    /**
     * 根据给定的时间戳和时区ID，返回格式为YYYYWww的整数，表示年和周数。
     *
     * @param timestamp 时间戳，以毫秒为单位
     * @param zoneId    时区ID，例如 "Asia/Shanghai" 或 "GMT"
     * @return 年和周数的整数，例如 202418 表示2024年第18周
     */
    public static int getYearWeekFromTimestamp(long timestamp, String zoneId) {
        // 将时间戳转换为ZonedDateTime
        ZonedDateTime zonedDateTime = Instant.ofEpochMilli(timestamp).atZone(ZoneId.of(zoneId));
        // 获取年份和周数
        int year = zonedDateTime.getYear();
        int weekOfYear = zonedDateTime.get(IsoFields.WEEK_OF_WEEK_BASED_YEAR);
        // 格式化为YYYYWww
        return year * 100 + weekOfYear;
    }

    /**
     * 根据给定的时间戳和时区ID，返回格式为YYYYMM的整数。
     *
     * @param timestamp 时间戳，以毫秒为单位
     * @param zoneId    时区ID，例如 "Asia/Shanghai" 或 "GMT"
     * @return 年月的整数，例如 202408 表示2024年8月
     */
    public static int getYyyyMmFromTimestamp(long timestamp, String zoneId) {
        // 将时间戳转换为ZonedDateTime
        ZonedDateTime zonedDateTime = Instant.ofEpochMilli(timestamp).atZone(ZoneId.of(zoneId));
        // 使用DateTimeFormatter格式化日期为YYYYMM
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMM");
        String formattedDate = zonedDateTime.format(formatter);
        // 将格式化的字符串转换为整数
        return Integer.parseInt(formattedDate);
    }

    /**
     * @param temVO
     * @Description: 校验模板的开始时间是否小于结束时间, 不重复类型直接返回true跳过校验
     * @return: java.lang.Boolean
     * @Author: xl
     * @Date: 2024/8/15/0015 11:37
     */
    public static Boolean startEndTimeCheck(ReportTemplateVO temVO) {
        if (ReplyCycle.DAY.getType().equals(temVO.getReplyCycle())) {
            if (temVO.getDay().getIsNext())
                return true;
            return DateTimeUtil.compareTimeStrings(temVO.getDay().getBeginTime(), temVO.getDay().getEndTime()) < 0;
        } else if (ReplyCycle.WEEK.getType().equals(temVO.getReplyCycle())) {
            if (temVO.getWeek().getIsNext() || temVO.getWeek().getEndWeekDay() > temVO.getWeek().getBeginWeekDay())
                return true;
            if (temVO.getWeek().getBeginWeekDay() > temVO.getWeek().getEndWeekDay())
                return false;
            return DateTimeUtil.compareTimeStrings(temVO.getWeek().getBeginTime(), temVO.getWeek().getEndTime()) < 0;
        } else if (ReplyCycle.MONTH.getType().equals(temVO.getReplyCycle())) {
            if (!validateReportDays(temVO.getMonth().getBeginMonthDay(), temVO.getMonth().getEndMonthDay()))
                return false;
            return DateTimeUtil.compareTimeStrings(temVO.getMonth().getBeginTime(), temVO.getMonth().getEndTime()) < 0;
        } else return ReplyCycle.UNCYCLE.getType().equals(temVO.getReplyCycle());
    }

    /**
     * @param temVO
     * @Description: 校验模板的结束时间是否大于下个实例的开始时间, 不重复类型直接返回true跳过校验
     * @return: java.lang.Boolean
     * @Author: xl
     * @Date: 2024/8/16/0016 14:51
     */
    public static Boolean endStartTimeCheck(ReportTemplateVO temVO) {
        if (ReplyCycle.DAY.getType().equals(temVO.getReplyCycle())) {
            if (!temVO.getDay().getIsNext())
                return true;
            return DateTimeUtil.compareTimeStrings(temVO.getDay().getEndTime(), temVO.getDay().getBeginTime()) < 0;
        } else if (ReplyCycle.WEEK.getType().equals(temVO.getReplyCycle())) {
            if (!temVO.getWeek().getIsNext() || temVO.getWeek().getEndWeekDay() < temVO.getWeek().getBeginWeekDay())
                return true;
            if (temVO.getWeek().getEndWeekDay() > temVO.getWeek().getBeginWeekDay())
                return false;
            return DateTimeUtil.compareTimeStrings(temVO.getWeek().getEndTime(), temVO.getWeek().getBeginTime()) < 0;
        }
        return true;
    }


    /**
     * 校验月报的开始节点和结束节点是否有效。
     *
     * @param startDay               月报的开始节点，表示每月的第几天。
     * @param endDayBeforeEndOfMonth 月报的结束节点，表示每月截止前的倒数第几天。
     * @return 如果结束节点大于开始节点，返回true；否则返回false。
     */
    public static boolean validateReportDays(int startDay, int endDayBeforeEndOfMonth) {
        // 假设每个月都是28天.按最少的来算
        int daysInMonth = 28;

        // 计算结束节点的具体日期
        int endDay = daysInMonth - endDayBeforeEndOfMonth;

        // 校验开始节点和结束节点
        return endDay > startDay;
    }

    /**
     * 比较两个时间字符串的大小。
     *
     * @param time1 第一个时间字符串，格式为"HH时mm分"
     * @param time2 第二个时间字符串，格式为"HH时mm分"
     * @return 如果time1在time2之前返回负数，如果time1和time2相同返回0，如果time1在time2之后返回正数
     */
    public static int compareTimeStrings(String time1, String time2) {
        // 定义时间格式
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm");

        // 解析时间字符串
        LocalTime timeParsed1 = LocalTime.parse(time1, formatter);
        LocalTime timeParsed2 = LocalTime.parse(time2, formatter);

        // 比较时间
        return timeParsed1.compareTo(timeParsed2);
    }

    /**
     * 解析时间字符串并返回小时、分钟和秒。
     *
     * @param timeString 时间字符串，格式应为 "HH:mm"
     * @return 一个包含小时、分钟和秒的对象
     * @throws IllegalArgumentException 如果时间字符串格式不正确或无效
     */
    public static ReportHMMDTO parseTimeString(String timeString) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm");
        try {
            LocalTime localTime = LocalTime.parse(timeString, formatter);
            return ReportHMMDTO.builder()
                    .hour(localTime.getHour())
                    .minute(localTime.getMinute())
                    .second(localTime.getSecond())
                    .build();
        } catch (DateTimeParseException e) {
            throw new IllegalArgumentException("Invalid time format", e);
        }
    }

    /**
     * 根据指定的时区获取当前日期和时间的字符串表示。
     *
     * @param timeZone 时区ID，例如 "Asia/Shanghai"
     * @return 格式化的日期和时间字符串，格式为 "yyyy-MM-dd HH:mm:ss"
     */
    public static String getCurrentDateTimeByTimeZone(String timeZone, String ft) {
        // 创建DateTimeFormatter对象，用于格式化日期和时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(ft);

        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of(timeZone));

        // 使用DateTimeFormatter格式化日期和时间
        return formatter.format(zonedDateTime);
    }


    /**
     * 根据特定时区和相对天数获取日期，返回yyyy-MM-dd格式的字符串日期。
     *
     * @param timeZone    时区ID，例如 "Asia/Shanghai"
     * @param daysFromNow 相对今天的天数，0表示今天，1表示明天，以此类推
     * @return 格式化的日期字符串
     */
    public static String getDateByDaysFromNow(String timeZone, int daysFromNow) {
        // 创建DateTimeFormatter对象，用于格式化日期
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        // 获取特定时区的ZonedDateTime对象
        ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of(timeZone));

        // 根据相对天数计算目标日期
        ZonedDateTime targetDate = zonedDateTime.plus(daysFromNow, ChronoUnit.DAYS);

        // 使用DateTimeFormatter格式化日期
        return targetDate.format(formatter);
    }

    /**
     * 根据指定的时区获取当前日期，返回java.util.Date对象。
     *
     * @param timeZone 时区ID，例如 "Asia/Shanghai"
     * @return 返回一个java.util.Date对象，表示指定时区的当前日期和时间
     * String timeZone = "Asia/Shanghai";
     * Date currentDate = getCurrentDateByTimeZone(timeZone);
     * SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     * System.out.println("Current date and time in " + timeZone + " is: " + sdf.format(currentDate));
     */
    public static Date getCurrentDateByTimeZone(String timeZone, String ft) {
        // 创建一个SimpleDateFormat对象，用于格式化日期
        SimpleDateFormat sdf = new SimpleDateFormat(ft);

        // 设置时区
        sdf.setTimeZone(TimeZone.getTimeZone(timeZone));

        // 获取当前时间的Date对象
        Date currentDate = new Date();

        // 格式化当前日期为指定时区的字符串
        String formattedDate = sdf.format(currentDate);

        // 使用相同的SimpleDateFormat和时区来解析格式化的字符串，得到一个新的Date对象
        Date dateByTimeZone = null;
        try {
            dateByTimeZone = sdf.parse(formattedDate);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return dateByTimeZone;
    }

    public static Date getCurrentDateByTimeZone(String timeZone) {
        return getCurrentDateByTimeZone(timeZone, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 获取指定时区的当前日期所在的周数
     *
     * @param zoneId 时区ID
     * @return 当前日期所在的周数
     * int tokyoWeekInYear = DateTimeUtils.getCurrentWeekOfYear("Asia/Tokyo");
     * int nyWeekInYear = DateTimeUtils.getCurrentWeekOfYear("America/New_York");
     */
    public static int getCurrentWeekOfYear(String zoneId) {
        // 获取指定时区的当前日期
        LocalDate localDate = LocalDate.now(ZoneId.of(zoneId));

        // 获取当前日期所在的周数
        return localDate.get(WeekFields.of(Locale.getDefault()).weekOfYear());
    }

    /**
     * 根据给定的时间戳和时区，获取该时间戳在对应时区下的一年中的第几周。
     *
     * @param timestamp 时间戳（毫秒）
     * @param timeZone  时区ID，例如 "Asia/Shanghai"
     * @return 一年中的周数
     */
    public static int getWeekOfYear(long timestamp, String timeZone) {
        // 将时间戳转换为ZonedDateTime对象，并指定时区
        ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(
                java.time.Instant.ofEpochMilli(timestamp),
                ZoneId.of(timeZone)
        );

        // 获取该日期是一年中的第几天
        long dayOfYear = zonedDateTime.get(ChronoField.DAY_OF_YEAR);

        // 计算该日期是第几周
        // 一周的开始被认为是周一，因此，如果dayOfYear小于周的中间（例如，如果一周从周日开始，则是4），则为前一周
        int weekOfYear = (int) ((dayOfYear + 3) / 7);

        return weekOfYear;
    }

    /**
     * 根据给定的时间戳和时区，获取该时间戳在对应时区下的月份。
     *
     * @param timestamp 时间戳（毫秒）
     * @param timeZone  时区ID，例如 "Asia/Shanghai"
     * @return 月份（1-12）
     */
    public static int getMonth(long timestamp, String timeZone) {
        // 将时间戳转换为ZonedDateTime对象，并指定时区
        ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(
                java.time.Instant.ofEpochMilli(timestamp),
                ZoneId.of(timeZone)
        );

        // 获取月份
        return zonedDateTime.get(ChronoField.MONTH_OF_YEAR);
    }


    /**
     * 根据指定的时区获取当前年份。
     *
     * @param timeZone 时区ID，例如 "Asia/Shanghai" 或 "UTC"
     * @return 当前年份的整数值
     * String timeZone = "Asia/Shanghai";
     * int currentYear = getCurrentYear(timeZone);
     */
    public static int getCurrentYear(String timeZone) {
        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime now = ZonedDateTime.now(ZoneId.of(timeZone));

        // 获取当前年份
        return now.getYear();
    }

    /**
     * 根据指定的时区获取当前月份。
     *
     * @param timeZone 时区ID，例如 "Asia/Shanghai" 或 "UTC"
     * @return 当前月份
     * String timeZone = "Asia/Shanghai";
     * String currentMonth = getCurrentMonth(timeZone);
     */
    public static int getCurrentMonth(String timeZone) {
        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime now = ZonedDateTime.now(ZoneId.of(timeZone));

        // 获取当前月份，返回Month枚举
        Month currentMonth = now.getMonth();

        // 返回月份的名称
        return currentMonth.getValue();
    }

    /**
     * 根据指定的时区获取今天是几号。
     *
     * @param timeZone 时区ID，例如 "Asia/Shanghai" 或 "UTC"
     * @return 今天是几号
     * String timeZone = "Asia/Shanghai";
     * int dayOfMonth = getDayOfMonth(timeZone);
     */
    public static int getDayOfMonth(String timeZone) {
        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime now = ZonedDateTime.now(ZoneId.of(timeZone));

        // 获取今天的日期
        return now.get(ChronoField.DAY_OF_MONTH);
    }

    /**
     * 根据指定的时区获取今天是周几，返回值为1（周一）到7（周日）。
     *
     * @param timeZone 时区ID，例如 "Asia/Shanghai" 或 "UTC"
     * @return 今天是周几的整数表示
     * String timeZone = "Asia/Shanghai";
     * int dayOfWeekInt = getTodayDayOfWeekAsInt(timeZone);
     */
    public static int getTodayDayOfWeekAsInt(String timeZone) {
        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime now = ZonedDateTime.now(ZoneId.of(timeZone));

        // 获取今天是星期几，返回DayOfWeek枚举
        DayOfWeek dayOfWeek = now.getDayOfWeek();

        // 返回星期几的整数表示，根据DayOfWeek的getValue方法
        return dayOfWeek.getValue();
    }


    /**
     * 根据特定时区和yyyy-MM-dd格式的字符串日期，获取该时区下该日期是周几。
     *
     * @param dateString 日期字符串，格式为 "yyyy-MM-dd"
     * @param timeZone   时区ID，例如 "Asia/Shanghai"
     * @return 星期几的整数值，1代表周一，2代表周二，...，7代表周日
     */
    public static int getDayOfWeek(String dateString, String timeZone) {
        // 创建日期时间格式器
//        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        // 使用ZonedDateTime解析日期字符串，并指定时区
//        ZonedDateTime zonedDateTime = ZonedDateTime.parse(dateString, formatter)
//                .withZoneSameInstant(ZoneId.of(timeZone));
//
//        // 获取星期几的整数值
//        int dayOfWeekValue = zonedDateTime.get(ChronoField.DAY_OF_WEEK);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        ZonedDateTime zonedDateTime = ZonedDateTime.of(
                LocalDate.parse(dateString, formatter),
                LocalTime.of(0, 0),
                ZoneId.of(timeZone)
        );
        return zonedDateTime.get(ChronoField.DAY_OF_WEEK);
    }

    /**
     * 根据特定时区和未来N天后的特定时间（X时X分X秒），计算时间戳。
     *
     * @param days     未来天数
     * @param hour     小时（0-23）
     * @param minute   分钟（0-59）
     * @param second   秒（0-59）
     * @param timeZone 时区ID，例如 "Asia/Shanghai"
     * @return 时间戳（毫秒）
     */
    public static long getFutureTimestamp(int days, int hour, int minute, int second, String timeZone) {
//        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
//        ZonedDateTime now = ZonedDateTime.now(ZoneId.of(timeZone));
//
//        // 添加N天
//        ZonedDateTime futureDate = now.plusDays(days);
//
//        // 设置时间为X时X分X秒
//        LocalDateTime specificTime = futureDate.toLocalDateTime()
//                .withHour(hour)
//                .withMinute(minute)
//                .withSecond(second);
//
//        // 转换回ZonedDateTime，并获取时间戳
//        return specificTime.atZone(ZoneId.of(timeZone)).toInstant().toEpochMilli();

        ZoneId zone = ZoneId.of(timeZone);
        LocalDate today = LocalDate.now(zone);
        LocalDateTime future = LocalDateTime.of(today.plusDays(days), LocalTime.of(hour, minute, second));
        ZonedDateTime zonedFuture = ZonedDateTime.of(future, zone);
        return zonedFuture.toInstant().toEpochMilli();
    }

    /**
     * 根据指定的时区获取明天 X时X分X秒的时间戳。
     *
     * @param hour     小时
     * @param minute   分钟
     * @param second   秒
     * @param timeZone 时区ID
     * @return 时间戳（毫秒）
     * int hour = 13;
     * int minute = 45;
     * int second = 30;
     * String timeZone = "Asia/Shanghai";
     * long timestamp = getTomorrowTimestamp(hour, minute, second, timeZone);
     */
    public static long getTomorrowTimestamp(int hour, int minute, int second, String timeZone) {
        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime now = ZonedDateTime.now(ZoneId.of(timeZone));

        // 找到明天的日期
        ZonedDateTime tomorrow = now.plusDays(1);

        // 设置时间为明天的X时X分X秒
        ZonedDateTime specificDateTime = tomorrow.withHour(hour)
                .withMinute(minute)
                .withSecond(second);

        // 返回时间戳
        return specificDateTime.toInstant().toEpochMilli();
    }

    /**
     * 根据指定的时区、年、月、日、时、分、秒获取时间戳。
     *
     * @param year     年份
     * @param month    月份（1-12）
     * @param day      日（1-31，根据月份不同）
     * @param hour     小时（0-23）
     * @param minute   分钟（0-59）
     * @param second   秒（0-59）
     * @param timeZone 时区ID，例如 "Asia/Shanghai"
     * @return 时间戳（毫秒）
     * int year = 2024;
     * int month = 7; // 注意月份从1开始计数
     * int day = 24;
     * int hour = 12;
     * int minute = 30;
     * int second = 25;
     * String timeZone = "Asia/Shanghai";
     * long timestamp = getTimestamp(year, month, day, hour, minute, second, timeZone);
     */
    public static long getTimestampByYMDHMS(int year, int month, int day, int hour, int minute, int second, String timeZone) {
        // 创建DateTimeFormatter对象
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 构建日期时间字符串
        String dateTimeString = String.format("%d-%02d-%02d %02d:%02d:%02d",
                year, month, day, hour, minute, second);

        // 解析日期时间字符串为ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime zonedDateTime = ZonedDateTime.parse(dateTimeString, formatter)
                .withZoneSameInstant(ZoneId.of(timeZone));

        // 转换为时间戳
        return zonedDateTime.toInstant().toEpochMilli();
    }

    /**
     * 根据指定的时区获取本月第X天 X时X分X秒的时间戳。
     *
     * @param dayOfMonth 本月的第几天（例如，1表示本月第一天）
     * @param hour       小时（0-23）
     * @param minute     分钟（0-59）
     * @param second     秒（0-59）
     * @param timeZone   时区ID，例如 "Asia/Shanghai"
     * @return 时间戳（毫秒）
     */
    public static long getTimestampOfSpecificDayOfMonth(int dayOfMonth, int hour, int minute, int second, String timeZone) {
        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of(timeZone));

        // 找到本月的第一天
        ZonedDateTime firstDayOfMonth = zonedDateTime.with(TemporalAdjusters.firstDayOfMonth());

        // 计算目标日期
        ZonedDateTime specificDayOfMonth = firstDayOfMonth.plusDays(dayOfMonth - 1);

        // 设置时间为X时X分X秒
        ZonedDateTime specificDateTime = specificDayOfMonth.withHour(hour)
                .withMinute(minute)
                .withSecond(second);

        // 返回时间戳
        return specificDateTime.toInstant().toEpochMilli();
    }

    /**
     * 根据指定的时区获取N月后第X天 X时X分X秒的时间戳。
     *
     * @param monthLater N个月后，0代表本月，1代表下个月，以此类推
     * @param dayOfMonth 月份中的第几天
     * @param hour       小时
     * @param minute     分钟
     * @param second     秒
     * @param timeZone   时区ID，例如 "Asia/Shanghai"
     * @return 时间戳（毫秒）
     */
    public static long getTimestampOfSpecificDayInMonth(int monthLater, int dayOfMonth, int hour, int minute, int second, String timeZone) {
        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of(timeZone));

        // 计算N个月后的第一天
        ZonedDateTime firstDayOfTargetMonth = zonedDateTime
                .with(TemporalAdjusters.firstDayOfNextMonth())
                .plusMonths(monthLater - 1); // 减1是因为firstDayOfNextMonth已经增加了一个月

        // 计算目标日期：N月后的第X天
        ZonedDateTime specificDay = firstDayOfTargetMonth.withDayOfMonth(dayOfMonth);

        // 设置时间为X时X分X秒
        ZonedDateTime specificDateTime = specificDay.withHour(hour)
                .withMinute(minute)
                .withSecond(second);

        // 返回时间戳
        return specificDateTime.toInstant().toEpochMilli();
    }

    /**
     * 根据指定的时区获取本月倒数第X天 X时X分X秒的时间戳。
     *
     * @param dayIndexFromEnd 本月的倒数第几天（例如，0表示月底最后一天）
     * @param hour            小时
     * @param minute          分钟
     * @param second          秒
     * @param timeZone        时区ID
     * @return 时间戳（毫秒）
     * int dayIndexFromEnd = 2; // 本月倒数第2天
     * int hour = 15;
     * int minute = 30;
     * int second = 25;
     * String timeZone = "Asia/Shanghai";
     * long timestamp = getLastOfMonthTimestamp(dayIndexFromEnd, hour, minute, second, timeZone);
     */
    public static long getLastOfMonthTimestamp(int dayIndexFromEnd, int hour, int minute, int second, String timeZone) {
        // 获取本月的最后一天
        LocalDate lastDayOfMonth = LocalDate.now(ZoneId.of(timeZone))
                .with(TemporalAdjusters.lastDayOfMonth());

        // 计算目标日期（本月倒数第X天）
        LocalDate targetDay = lastDayOfMonth.minusDays(dayIndexFromEnd);

        // 创建目标日期和时间的LocalDateTime对象
        LocalDateTime specificDateTime = LocalDateTime.of(targetDay.getYear(), targetDay.getMonth(), targetDay.getDayOfMonth(), hour, minute, second);

        // 转换为特定时区的ZonedDateTime对象
        ZonedDateTime zonedDateTime = specificDateTime.atZone(ZoneId.of(timeZone));

        // 返回时间戳
        return zonedDateTime.toInstant().toEpochMilli();
    }

    /**
     * 根据指定的时区获取下周周X X时X分X秒的时间戳。
     *
     * @param dayOfWeek 下周的星期几（例如，MONDAY为1，SUNDAY为7）
     * @param hour      小时（0-23）
     * @param minute    分钟（0-59）
     * @param second    秒（0-59）
     * @param timeZone  时区ID，例如 "Asia/Shanghai"
     * @return 时间戳（毫秒）
     * int dayOfWeek = 2; // 星期二（DayOfWeek.MONDAY 为 1，以此类推）
     * int hour = 15;
     * int minute = 30;
     * int second = 25;
     * String timeZone = "Asia/Shanghai";
     * long timestamp = getTimestampNextWeekDay(dayOfWeek, hour, minute, second, timeZone);
     */
    public static long getTimestampNextWeekDay(int dayOfWeek, int hour, int minute, int second, String timeZone) {
        // 获取当前时间的ZonedDateTime对象，并转换为指定的时区
        ZonedDateTime now = ZonedDateTime.now(ZoneId.of(timeZone));

        // 找到下周对应的星期几的日期
        ZonedDateTime nextWeekDay = now.with(TemporalAdjusters.nextOrSame(DayOfWeek.of(dayOfWeek)));

        // 设置时间为X时X分X秒
        ZonedDateTime specificDateTime = nextWeekDay.withHour(hour)
                .withMinute(minute)
                .withSecond(second);

        // 返回时间戳
        return specificDateTime.toInstant().toEpochMilli();
    }

    /**
     * 根据指定的时区获取本周周X X时X分X秒的时间戳。
     *
     * @param dayOfWeekIndex 星期几的索引（1=周一，2=周二，...，7=周日）
     * @param hour           小时
     * @param minute         分钟
     * @param second         秒
     * @param timeZone       时区ID
     * @return 时间戳（毫秒）
     * int dayOfWeekIndex = 3; // 周三（ISO标准，1=周一，...，7=周日）
     * int hour = 12;
     * int minute = 30;
     * int second = 0;
     * String timeZone = "Asia/Shanghai";
     * long timestamp = getThisWeekTimestamp(dayOfWeekIndex, hour, minute, second, timeZone);
     */
    public static long getThisWeekTimestamp(int dayOfWeekIndex, int hour, int minute, int second, String timeZone) {
        // 获取当前时间的本地日期时间对象，并设置为本周一的00:00:00
        LocalDateTime startOfWeek = LocalDateTime.now(ZoneId.of(timeZone))
                .with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY))
                .withHour(0)
                .withMinute(0)
                .withSecond(0)
                .withNano(0);

        // 计算目标星期几的日期时间对象
        DayOfWeek targetDayOfWeek = DayOfWeek.of(dayOfWeekIndex);
        LocalDateTime targetDateTime = startOfWeek.with(TemporalAdjusters.nextOrSame(targetDayOfWeek))
                .withHour(hour)
                .withMinute(minute)
                .withSecond(second);

        // 转换为特定时区的ZonedDateTime对象
        ZonedDateTime zonedDateTime = targetDateTime.atZone(ZoneId.of(timeZone));

        // 返回时间戳
        return zonedDateTime.toInstant().toEpochMilli();
    }


    /**
     * 获取指定时区N周后的周X X时X分X秒的时间戳。
     *
     * @param timeZoneStr    时区字符串，如 "Asia/Shanghai"
     * @param weeks          周数
     * @param dayOfWeek      星期几，1表示周一，7表示周日
     * @param hourOfDay      小时，24小时制
     * @param minuteOfHour   分钟
     * @param secondOfMinute 秒
     * @return 时间戳
     */
    public static long getTimeStampInTimeZone(int weeks, int dayOfWeek, int hourOfDay, int minuteOfHour, int secondOfMinute, String timeZoneStr) {
        // 使用系统默认时区的当前时间
        LocalDateTime now = LocalDateTime.now();
        // 转换为指定时区的ZonedDateTime
        ZonedDateTime zonedDateTime = now.atZone(ZoneId.of(timeZoneStr));

        //已过的日期和未过的日期，如果不处理一下结果会相差1个星期
//        if (weeks < 1 && getDayOfWeekAsInt(timeZoneStr) < dayOfWeek)
//        if (weeks < 1 && getDayOfWeekAsInt(timeZoneStr) >= dayOfWeek)
//            weeks++;

        if (getDayOfWeekAsInt(timeZoneStr) < dayOfWeek)
            weeks--;

//        weeks--;
        // 根据weeks的值来决定是使用当前时间还是增加相应的周数
//        if (weeks > 0) {
        // 如果weeks大于0，计算N周后的日期
        zonedDateTime = zonedDateTime.plusWeeks(weeks);
//        }

        // 调整到周X的指定时间
        zonedDateTime = zonedDateTime.with(TemporalAdjusters.ofDateAdjuster(date -> {
                    // 找到当前周或未来周的指定星期几
                    DayOfWeek targetDayOfWeek = DayOfWeek.of(dayOfWeek);
                    DayOfWeek currentDayOfWeek = date.getDayOfWeek();
                    if (currentDayOfWeek.getValue() >= targetDayOfWeek.getValue()) {
                        // 如果当前是目标星期或之后，直接调整到目标星期
                        return date.with(targetDayOfWeek);
                    } else {
                        // 如果当前是目标星期之前，需要调整到下一周的目标星期
                        return date.plusWeeks(1).with(targetDayOfWeek);
                    }
                }))
                .withHour(hourOfDay)
                .withMinute(minuteOfHour)
                .withSecond(secondOfMinute)
                .with(ChronoField.NANO_OF_SECOND, 0); // 确保纳秒为0

        // 返回时间戳
        return zonedDateTime.toInstant().toEpochMilli();
    }

    /**
     * 获取指定时区今天是周几的工具函数。
     *
     * @param timeZoneId 时区ID，例如 "Asia/Shanghai"
     * @return 返回今天是周几的整数，1代表周一，7代表周日
     */
    public static int getDayOfWeekAsInt(String timeZoneId) {
        // 获取当前时间，并指定时区
        ZonedDateTime zonedDateTime = ZonedDateTime.now(java.time.ZoneId.of(timeZoneId));
        // 获取今天是周几
        DayOfWeek dayOfWeek = zonedDateTime.getDayOfWeek();
        // 将DayOfWeek转换为整数
        return dayOfWeek.getValue();
    }


    /**
     * 根据指定的年份、周数、星期几、小时、分钟和秒以及时区获取时间戳。
     *
     * @param year       年份
     * @param weekOfYear 一年中的周数（例如第1周）
     * @param dayOfWeek  星期几（1=星期一，...，7=星期日）
     * @param hour       小时
     * @param minute     分钟
     * @param second     秒
     * @param timeZone   时区ID，例如 "Asia/Shanghai"
     * @return 时间戳（毫秒）
     */
    public static long getTimestamp(int year, int weekOfYear, int dayOfWeek, int hour, int minute, int second, String timeZone) {
        // 定义周的第一天为星期一
        WeekFields weekFields = WeekFields.of(Locale.getDefault());
        DayOfWeek firstDayOfWeek = weekFields.getFirstDayOfWeek();

        // 计算年初的日期
        LocalDateTime startOfYear = LocalDateTime.of(year, 1, 1, 0, 0);
        int currentWeek = startOfYear.get(weekFields.weekOfYear());

        // 找到年初的第一个星期的第一天
        LocalDateTime firstWeekStartDate = startOfYear.with(TemporalAdjusters.previousOrSame(firstDayOfWeek));

        // 计算目标日期
        long daysToAdd = (weekOfYear - 1) * 7 + (dayOfWeek - firstDayOfWeek.getValue());
        LocalDateTime targetDateTime = firstWeekStartDate.plusDays(daysToAdd)
                .withHour(hour)
                .withMinute(minute)
                .withSecond(second);

        // 转换为特定时区的时间戳
        ZonedDateTime zonedDateTime = targetDateTime.atZone(ZoneId.of(timeZone));
        return zonedDateTime.toInstant().toEpochMilli();
    }


    /**
     * 根据给定的时间戳和时区，转换为java.util.Date格式的日期。
     *
     * @param timestamp 时间戳（毫秒）
     * @param timeZone  时区ID
     * @return java.util.Date对象
     * long timestamp = System.currentTimeMillis(); // 假设当前时间戳
     * String timeZone = "Asia/Shanghai";
     * Date date = convertToDateTime(timestamp, timeZone);
     */
    public static Date convertToDateTime(long timestamp, String timeZone) {
//        // 创建一个Date对象，该对象将时间戳设置为给定的时间戳
//        Date date = new Date(timestamp);
//
//        // 设置时区
//        TimeZone tz = TimeZone.getTimeZone(timeZone);
//
//        // 将Date对象转换为特定时区的日期
//
//        return new Date(date.getTime() - tz.getRawOffset());


//        // 将时间戳转换为Instant对象
//        Instant instant = Instant.ofEpochMilli(timestamp);
//
//        // 根据时区创建ZonedDateTime对象
//        ZonedDateTime zonedDateTime = instant.atZone(ZoneId.of(timeZone));
//
//        // 将ZonedDateTime对象转换为java.util.Date
//        return Date.from(zonedDateTime.toInstant());


//        // 将时间戳转换为Instant对象
//        Instant instant = Instant.ofEpochMilli(timestamp);
//
//        // 根据时区创建ZonedDateTime对象,并考虑夏令时的影响
//        TimeZone tz = TimeZone.getTimeZone(timeZone);
//        ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(instant, tz.toZoneId());
//
//        return Date.from(zonedDateTime.toInstant());
        // 设置时区
        TimeZone.setDefault(TimeZone.getTimeZone(timeZone));

        // 使用 Hutool 将时间戳转换为 java.util.Date
        return DateUtil.date(timestamp);
    }

    /**
     * 获取当前时间戳。
     *
     * @return java.util.Date对象
     */
    public static Long getCurrentTimestamp() {
        // 获取当前时间戳
        return System.currentTimeMillis();
    }

    /**
     * 获取当前北京时间，并以Date对象格式返回。
     *
     * @return 当前北京时间的Date对象
     */
    public static Date getCurrentBeijingTime() {
        // 设置时区为亚洲/上海，代表北京时间
        TimeZone timeZone = TimeZone.getTimeZone("Asia/Shanghai");

        // 获取当前时间的毫秒数（自1970年1月1日00:00:00 GMT以来）
        long currentTimeMillis = System.currentTimeMillis();

        return new Date(currentTimeMillis);
    }


    /**
     * 根据给定的Date对象和时区，转换为时间戳。
     *
     * @param date     java.util.Date对象
     * @param timeZone 时区
     * @return 时间戳（毫秒）
     * Date date = new Date(); // 假设当前时间
     * TimeZone timeZone = TimeZone.getTimeZone("Asia/Shanghai");
     * long timestamp = convertToDateTimestamp(date, timeZone);
     */
    public static long convertToDateTimestamp(Date date, TimeZone timeZone) {
        // 将Date对象转换为特定时区的时间戳
        long timestamp = date.getTime();

        // 如果需要转换到不同的时区，可以调整时间戳
        // 以下代码将时间戳从默认时区转换到指定的时区
        long offset = timeZone.getRawOffset() - date.getTimezoneOffset() * 1000;

        return timestamp + offset;
    }

    /**
     * 根据给定的日期和时区字符串转换为时间戳。
     *
     * @param date       需要转换的日期
     * @param timeZoneId 时区的字符串表示，例如 "Asia/Shanghai"
     * @return 转换后的时间戳
     */
    public static long convertDateToTimestamp(Date date, String timeZoneId) {
        // 设置时区
        TimeZone timeZone = TimeZone.getTimeZone(timeZoneId);
        // 将日期转换为毫秒值（时间戳）
        long timestamp = date.getTime();
        // 根据时区调整时间戳
        long adjustedTimestamp = timestamp + (timeZone.getRawOffset() - TimeZone.getDefault().getRawOffset());
        return adjustedTimestamp;
    }


    /**
     * 根据给定的日期字符串和时区，转换为时间戳。
     *
     * @param dateString 日期字符串
     * @param timeZone   时区，例如 "Asia/Shanghai" 或 "GMT"
     * @param dateFormat 日期格式，例如 "yyyy-MM-dd HH:mm:ss"
     * @return 时间戳（毫秒）
     * String dateString = "2024-07-24 00:00:00";
     * String timeZone = "CST"; // 例如，中国标准时间
     * String dateFormat = "yyyy-MM-dd HH:mm:ss";
     * long timestamp = convertToDateTimestamp(dateString, timeZone, dateFormat);*
     */
    public static long convertToDateTimestamp(String dateString, String timeZone, String dateFormat) {
        SimpleDateFormat formatter = new SimpleDateFormat(dateFormat);
        formatter.setTimeZone(TimeZone.getTimeZone(timeZone));

        try {
            Date date = formatter.parse(dateString);
            return date.getTime();
        } catch (ParseException e) {

            if (dateFormat.equals("yyyy-MM-dd HH:mm:ss"))
                return convertToDateTimestamp(dateString, timeZone, "yyyy-MM-dd HH:mm");

            e.printStackTrace();
            return -1;
        }
    }


    /**
     * @param dt 格式
     * @Description: 封装汇报时间ReportDateVO
     * @return: com.ioo.system.web.report_statistic.controller.vo.ReportDateVO
     * @Author: xl
     * @Date: 2024/8/8/0008 18:12
     */
    public static ReportDateVO getDays(String dt) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate date2 = LocalDate.parse(dt, formatter);
        int year = date2.getYear();
        int month = date2.getMonthValue();
        int dayOfMonth = date2.getDayOfMonth();
        String firstDay = getFirstDay(year, month, "yyyy-MM-dd");
        String lastDay = getLastDay(year, month, "yyyy-MM-dd");
        ReportDateVO build = ReportDateVO.builder().title(dt).year(year).day(dayOfMonth).startDate(stringToDateToYMD(firstDay, "yyyy-MM-dd")).endDate(stringToDateToYMD(lastDay, "yyyy-MM-dd"))
                .start(firstDay)
                .end(lastDay)
                .month(month).build();

        return build;
    }

    /**
     * @param dt 格式
     * @Description: 封装汇报时间ReportDateVO
     * @return: com.ioo.system.web.report_statistic.controller.vo.ReportDateVO
     * @Author: xl
     * @Date: 2024/8/8/0008 18:14
     */
    public static ReportDateVO getWeeks(String dt) {

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate date2 = LocalDate.parse(dt, formatter);

        int year = date2.getYear();
        int month = date2.getMonthValue();
        int day = date2.getDayOfMonth();

        // 指定日期
        LocalDate date = LocalDate.of(year, month, day);

        // 获取当前年份的第几周
        int weekOfYear = date.get(IsoFields.WEEK_OF_WEEK_BASED_YEAR);

        List<String> strings = weekToDayFormate(year, weekOfYear);

        ReportDateVO build = ReportDateVO.builder().title(year + "年第" +
                        weekOfYear + "周").year(year).startDate(stringToDateToYMD(strings.get(0))).endDate(stringToDateToYMD(strings.get(1)))
                .start(strings.get(0))
                .end(strings.get(1))
                .weekNum((weekOfYear)).build();

        return build;
    }

    /**
     * @param startDate
     * @param endDate
     * @Description: 计算两个时间内 所有的周数
     * @return: java.util.List<com.ioo.system.refactor_report.controller.vo.ReportDateVO>
     * @Author: xl
     * @Date: 2024/8/22/0022 15:49
     */
    public static List<ReportDateVO> getWeeks(String startDate, String endDate) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date parse = sdf.parse(startDate);
        Date parse2 = sdf.parse(endDate);
        List<ReportDateVO> dateList = new ArrayList<>();
        Calendar startC = Calendar.getInstance();
        startC.setFirstDayOfWeek(Calendar.MONDAY);
        startC.setTime(parse);
        Long startCurrentWeek = dateScaleplate(startC);
        //转为周一
        int weekYear = startC.get(Calendar.YEAR);
        int weekOfYear = startC.get(Calendar.WEEK_OF_YEAR);
        startC.setWeekDate(weekYear, weekOfYear, Calendar.MONDAY);
        Calendar endC = Calendar.getInstance();
        endC.setFirstDayOfWeek(Calendar.MONDAY);
        endC.setTime(parse2);
        Long endWeek = dateScaleplate(endC);
        int weekYear2 = endC.get(Calendar.YEAR);
        int weekOfYear2 = endC.get(Calendar.WEEK_OF_YEAR);
        endC.setWeekDate(weekYear2, weekOfYear2, Calendar.SUNDAY);
        while (true) {
            int weekNum = startC.get(Calendar.WEEK_OF_YEAR);
            ReportDateVO build = ReportDateVO.builder().title(startC.getWeekYear() + "年第" +
                            (weekNum > 9 ? weekNum : "0" + weekNum) + "周").year(startC.getWeekYear())
                    .weekNum((weekNum > 9 ? weekNum : Integer.valueOf("0" + weekNum))).build();
            dateList.add(build);
//            if (c1.getTimeInMillis() >= c2.getTimeInMillis()) {
//                System.out.println("22-c1:"+cdt1+"-c2:"+cdt2);
//                break;
//            }
            if (startCurrentWeek >= endWeek) {
                break;
            }
            //增加7天
            startC.setTimeInMillis(startC.getTimeInMillis() + 1000 * 60 * 60 * 24 * 7);
            startCurrentWeek = dateScaleplate(startC);
        }
        return dateList;
    }

    private static Long dateScaleplate(Calendar calendar) {
        int year = calendar.get(Calendar.YEAR);
        // 获取月份（月份是从0开始的，因此需要+1）
//        int month = calendar.get(Calendar.MONTH) + 1;
//        int day = calendar.get(Calendar.DAY_OF_MONTH);
        int weekNum = calendar.get(Calendar.WEEK_OF_YEAR);
        String dt = year + "" + weekNum;
        return Long.parseLong(dt);
    }

    /**
     * @param dt 格式
     * @Description: 封装汇报时间ReportDateVO
     * @return: com.ioo.system.web.report_statistic.controller.vo.ReportDateVO
     * @Author: xl
     * @Date: 2024/8/8/0008 18:14
     */
    public static ReportDateVO getMonths(String dt) {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate date2 = LocalDate.parse(dt, formatter);
        int year = date2.getYear();
        int month = date2.getMonthValue();
        String firstDay = getFirstDay(year, month, "yyyy-MM-dd");
        String lastDay = getLastDay(year, month, "yyyy-MM-dd");
        ReportDateVO build = ReportDateVO.builder().title(year + "年第" +
                        month + "月").year(year).startDate(stringToDateToYMD(firstDay, "yyyy-MM-dd")).endDate(stringToDateToYMD(lastDay, "yyyy-MM-dd"))
                .start(firstDay)
                .end(lastDay)
                .month(month).build();

        return build;
    }

    /**
     * @param time 日期时间
     * @param h    目标小时
     * @param min  目标分钟
     * @Description: 修改日期的时间部分
     * @return: java.util.Date
     * @Author: xl
     * @Date: 2024/8/8/0008 18:15
     */
    public static Date setDt(Date time, int h, int min) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(time);
        cal.set(Calendar.HOUR_OF_DAY, h); //时
        cal.set(Calendar.MINUTE, min); //分
        cal.set(Calendar.SECOND, 0); //秒
        cal.set(Calendar.MILLISECOND, 0); //毫秒
        return cal.getTime();
    }

    /**
     * @param year 哪一年
     * @Description: 获取指定年的开始日期和结束日期
     * @return: java.util.List<java.util.Date>
     * @Author: xl
     * @Date: 2024/8/8/0008 18:15
     */
    public static List<Date> getFirstDayAndLastDayOfTheSpecifiedYear(int year) {
        Calendar calendar = Calendar.getInstance();
        // 设置某年的开始时间
        calendar.set(year, Calendar.JANUARY, 1, 0, 0, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        Date startTime = calendar.getTime();

        // 设置某年的结束时间
        calendar.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        Date endTime = calendar.getTime();
        // 设置返回信息,返回样式根据需求自行格式化
        List<Date> years = new ArrayList<>();
        years.add(setDt(startTime, 0, 0));
        years.add(setDt(endTime, 23, 59));
        return years;
    }

    /**
     * @param year  哪一年
     * @param month 哪个月
     * @Description: 获取指定年指定月的开始日期和结束日期
     * @return: java.util.List<java.util.Date>
     * @Author: xl
     * @Date: 2024/8/8/0008 18:16
     */
    public static List<Date> getFirstDayAndLastDayOfTheSpecifiedMonth(int year, int month) {
        // 获取当前分区的日历信息(这里可以使用参数指定时区)
        Calendar calendar = Calendar.getInstance();
        // 设置年
        calendar.set(Calendar.YEAR, year);
        // 设置月，月份从0开始
        calendar.set(Calendar.MONTH, month - 1);
        // 设置为指定月的第一天
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        // 获取指定月第一天的时间
        Date start = calendar.getTime();
        // 设置日历天数为当前月实际天数的最大值，即指定月份的最后一天
        calendar.set(Calendar.DATE, calendar.getActualMaximum(Calendar.DATE));
        // 获取最后一天的时间
        Date end = calendar.getTime();
        // 设置返回信息,返回样式根据需求自行格式化
        List<Date> months = new ArrayList<>();
        months.add(setDt(start, 0, 0));
        months.add(setDt(end, 23, 59));
        return months;
    }


    /**
     * @param
     * @Description: 获取当前月份的开始和结束时间
     * @return: java.util.List<java.util.Date>
     * @Author: xl
     * @Date: 2024/8/8/0008 18:16
     */
    public static List<Date> getCurMonth() {
        List<Date> month = new ArrayList<>();
        // 获取当前日期
        Date currentDate = new Date();
        // 创建Calendar实例
        Calendar calendar = Calendar.getInstance();
        // 设置日期为当前日期
        calendar.setTime(currentDate);
        // 将日期设置为该月的第一天
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        // 获取本月的开始时间
        Date startTime = calendar.getTime();
        // 将日期设置为该月的最后一天
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        // 获取本月的结束时间
        Date endTime = calendar.getTime();
        month.add(setDt(startTime, 0, 0));
        month.add(setDt(endTime, 23, 59));

        return month;
    }

    /**
     * @param
     * @Description: 获取当前时间的年月日
     * @return: java.lang.String
     * @Author: xl
     * @Date: 2024/8/8/0008 18:16
     */
    public static String getCurrentDate() {
        Date currentDate = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String formattedDate = dateFormat.format(currentDate);
        return formattedDate;
    }

    /**
     * @param
     * @Description: 获取当前时间的年月日时分秒
     * @return: java.lang.String
     * @Author: xl
     * @Date: 2024/8/8/0008 18:16
     */
    public static String getCurrentDateHMS() {
        Date currentDate = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String formattedDate = dateFormat.format(currentDate);
        return formattedDate;
    }

    /**
     * @param
     * @Description: 获取N天前的年月日
     * @return: java.lang.String
     * @Author: xl
     * @Date: 2024/8/8/0008 18:17
     */
    public static String getDateSpan() {
        LocalDate today = LocalDate.now(); // 获取当前日期
        LocalDate oneHundredEightyDaysAgo = today.minusDays(CommonConstant.WEEK_DATE_SPAN); // 当前日期减去365天
        // 格式化日期为年月日
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        String formattedDate = oneHundredEightyDaysAgo.format(formatter);
        return formattedDate;
    }

    /**
     * @param startDate
     * @param endDate
     * @Description: 计算两个日期中所有的月份
     * @return: java.util.List<java.lang.String>
     * @Author: xl
     * @Date: 2024/8/8/0008 18:17
     */
    public static List<String> getMonths(String startDate, String endDate) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date parse = sdf.parse(startDate);
        Date parse2 = sdf.parse(endDate);
        List<String> dateList = new ArrayList<>();
        Calendar startC = Calendar.getInstance();
        startC.setTime(parse);
        //转为周一
        int year = startC.get(Calendar.YEAR);
        int month = startC.get(Calendar.MONTH);
        startC.set(year, month, 1, 0, 0, 0);
        Calendar endC = Calendar.getInstance();
        endC.setTime(parse2);
        int weekYear2 = endC.get(Calendar.YEAR);
        int weekOfYear2 = endC.get(Calendar.WEEK_OF_YEAR);
        endC.setWeekDate(weekYear2, weekOfYear2, Calendar.SUNDAY);
        while (true) {
            int tempMonth = startC.get(Calendar.MONTH);
            String date = startC.getWeekYear() + "-" + ((tempMonth + 1) <= 9 ? "0" + (tempMonth + 1) : tempMonth + 1);
            dateList.add(date);
            //下一个月<结束日期
            startC.set(Calendar.MONTH, tempMonth + 1);
            if (startC.getTimeInMillis() >= endC.getTimeInMillis()) {
                break;
            }
        }
        return dateList;
    }

    /**
     * @param year   年份
     * @param month  月份
     * @param format 格式
     * @Description: 根据年月获取月末最后一天日期
     * @return: java.lang.String
     * @Author: xl
     * @Date: 2024/8/8/0008 18:17
     */
    public static String getLastDay(int year, int month, String format) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        calendar.set(Calendar.MONTH, month);

        calendar.set(Calendar.DAY_OF_MONTH, 1);

        calendar.add(Calendar.DAY_OF_MONTH, -1);

        calendar.set(Calendar.HOUR_OF_DAY, 23); //时
        calendar.set(Calendar.MINUTE, 59); //分
        calendar.set(Calendar.SECOND, 59); //秒
        calendar.set(Calendar.MILLISECOND, 0); //毫秒

//        TimeZone timeZone = TimeZone.getTimeZone("UTC");
//        calendar.setTimeZone(timeZone);


        Date endDate = calendar.getTime();

        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String formattedEndDate = sdf.format(endDate);

        return formattedEndDate;
    }

    /**
     * @param year   年份
     * @param month  月份
     * @param format 格式
     * @Description: 根据年月获取月末最后一天日期
     * @return: java.lang.String
     * @Author: xl
     * @Date: 2024/8/8/0008 18:18
     */
    public static String getFirstDay(int year, int month, String format) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        calendar.set(Calendar.MONTH, month - 1);
        calendar.set(Calendar.DAY_OF_MONTH, 1);

        calendar.set(Calendar.HOUR_OF_DAY, 0); //时
        calendar.set(Calendar.MINUTE, 0); //分
        calendar.set(Calendar.SECOND, 0); //秒
        calendar.set(Calendar.MILLISECOND, 0); //毫秒

//        TimeZone timeZone = TimeZone.getTimeZone("UTC");
//        calendar.setTimeZone(timeZone);

        Date startDate = calendar.getTime();

        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String formattedStartDate = sdf.format(startDate);

        return formattedStartDate;
    }

    public static String dateToString(Date date, String ft) {
        SimpleDateFormat sdf = new SimpleDateFormat(ft);
        return sdf.format(date);
    }

    /**
     * 根据给定的日期字符串，返回 "XX年第XX周" 格式化的字符串。
     *
     * @param dateString 日期字符串
     * @param ft         日期字符串的格式
     * @return 格式化的周字符串，例如 "2024年第35周"
     */
    public static String formatToYearWeek(String dateString, String ft) {
        if (Strings.isBlank(ft))
            ft = "yyyy-MM-dd HH:mm:ss";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(ft);

        try {
            // 解析日期字符串
            LocalDate date = LocalDate.parse(dateString, formatter);
            // 获取年份和周数
            int year = date.getYear();
            int week = date.get(IsoFields.WEEK_OF_WEEK_BASED_YEAR);

            // 格式化为 "XX年第XX周" 格式的字符串
            return String.format("%d年第%d周", year, week);
        } catch (Exception e) {
            // 处理异常，例如格式不匹配
            System.err.println("Error parsing date: " + e.getMessage());
            return null;
        }
    }

    /**
     * 根据给定的Date对象，返回格式化的字符串，格式为 "XX年第XX周"。
     *
     * @param date java.util.Date对象
     * @return 格式化的字符串，例如 "2023年第47周"
     */
    public static String formatDateToYearAndWeek(Date date) {
        if (date == null) {
            throw new IllegalArgumentException("日期对象不能为空");
        }

        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);

        // 获取年份
        int year = calendar.get(Calendar.YEAR);

        // 获取一年中的第几周
        int weekOfYear = calendar.get(Calendar.WEEK_OF_YEAR);

        // 格式化为 "XX年第XX周"
        return String.format("%d年第%d周", year, weekOfYear);
    }

    /**
     * 根据给定的日期字符串，返回 "XX年XX月" 格式化的字符串。
     *
     * @param dateString 日期字符串
     * @param ft         日期字符串的格式
     * @return 格式化的年月字符串，例如 "2024年08月"
     */
    public static String formatToYearMonth(String dateString, String ft) {
        if (Strings.isBlank(ft))
            ft = "yyyy-MM-dd HH:mm:ss";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(ft);
        try {
            // 解析日期字符串
            LocalDate date = LocalDate.parse(dateString, formatter);
            // 定义输出格式
            DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern("yyyy年MM月");
            // 格式化日期
            return date.format(outputFormatter);
        } catch (Exception e) {
            // 处理异常，例如格式不匹配
            System.err.println("Error parsing date: " + e.getMessage());
            return null;
        }
    }

    /**
     * 根据给定的Date对象，返回格式化的字符串，格式为 "XX年XX月"。
     *
     * @param date java.util.Date对象
     * @return 格式化的字符串，例如 "2023年11月"
     */
    public static String formatDateToYearAndMonth(Date date) {
        if (date == null) {
            throw new IllegalArgumentException("日期对象不能为空");
        }
        // 创建SimpleDateFormat对象，设置日期格式
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月");
        // 格式化日期
        return dateFormat.format(date);
    }


    /**
     * @param date 字符串日期
     * @Description: 字符串转日期格式- yyyy-MM-dd HH:mm:ss
     * @return: java.util.Date
     * @Author: xl
     * @Date: 2024/8/8/0008 18:18
     */
    public static Date stringToDateToYMD(String date) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parse = new Date();
        try {
            parse = format.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return parse;
    }

    /**
     * @param date 字符串日期
     * @param ft   日期格式
     * @Description: 字符串转日期格式
     * @return: java.util.Date
     * @Author: xl
     * @Date: 2024/8/8/0008 18:19
     */
    public static Date stringToDateToYMD(String date, String ft) {
        SimpleDateFormat format = new SimpleDateFormat(ft);
        Date parse = new Date();
        try {
            parse = format.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return parse;
    }

    /**
     * @param year 年份
     * @param week 周数
     * @Description: 根据某年的某周，查询本周的起止时间
     * @return: java.util.List<java.lang.String>
     * @Author: xl
     * @Date: 2024/8/8/0008 18:19
     */
    public static List<String> weekToDayFormate(int year, int week) {
        Calendar calendar = Calendar.getInstance();
        // ①.设置该年份的开始日期：第一个月的第一天
        calendar.set(year, 0, 1);
        List<String> dateList = new ArrayList<>();
        // ②.计算出第一周还剩几天：+1是因为1号是1天
        int dayOfWeek = 7 - calendar.get(Calendar.DAY_OF_WEEK) + 1;
        // ③.周数减去第一周再减去要得到的周
        week = week - 2;
        // ④.计算起止日期
        calendar.add(Calendar.DAY_OF_YEAR, week * 7 + dayOfWeek);
        calendar.add(Calendar.DAY_OF_YEAR, 1);

        TimeZone timeZone = TimeZone.getTimeZone("GMT+8");
        calendar.setTimeZone(timeZone);

        dateList.add(new SimpleDateFormat("yyyy-MM-dd 00:00:00").format(calendar.getTime()));
        calendar.add(Calendar.DAY_OF_YEAR, 6);

//        calendar.set(Calendar.HOUR_OF_DAY, 23); //时
//        calendar.set(Calendar.MINUTE, 59); //分
//        calendar.set(Calendar.SECOND, 59); //秒
//        calendar.set(Calendar.MILLISECOND, 0); //毫秒

        dateList.add(new SimpleDateFormat("yyyy-MM-dd 23:59:59").format(calendar.getTime()));
        return dateList;
    }

    /**
     * @param endDate   截止日期
     * @param startTime 开始日期
     * @Description: 计算2个日期差
     * @return: java.lang.String
     * @Author: xl
     * @Date: 2024/8/8/0008 18:20
     */
    public static String timeDistance(Date endDate, Date startTime) {
        long nd = 1000 * 24 * 60 * 60;
        long nh = 1000 * 60 * 60;
        long nm = 1000 * 60;
        // long ns = 1000;
        // 获得两个时间的毫秒时间差异
        long diff = endDate.getTime() - startTime.getTime();
        // 计算差多少天
        long day = diff / nd;
        // 计算差多少小时
        long hour = diff % nd / nh;
        // 计算差多少分钟
        long min = diff % nd % nh / nm;
        // 计算差多少秒//输出结果
        // long sec = diff % nd % nh % nm / ns;
        return (day > 0L ? day + "天" : "") + (hour > 0L ? hour + "小时" : "") + min + "分钟";
    }

    /**
     * @param dateString 字符串日期
     * @Description: 字符串日期转yyyy年MM月dd日格式的字符串日期
     * @return: java.lang.String
     * @Author: xl
     * @Date: 2024/8/8/0008 18:21
     */
    public static String stringDateToString(String dateString) {
        SimpleDateFormat originalFormat = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat targetFormat = new SimpleDateFormat("yyyy年MM月dd日");
        String formattedDate = dateString;
        try {
            Date date = originalFormat.parse(dateString);
            formattedDate = targetFormat.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return formattedDate;
    }

    /**
     * @param dateString 字符串日期
     * @Description: 字符串日期转时间戳
     * @return: java.lang.Long
     * @Author: xl
     * @Date: 2024/8/8/0008 18:22
     */
    public static Long stringDateToTimestamp(String dateString) {
        long timestamp = -999l;
        try {
            SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = formatter.parse(dateString);
            timestamp = date.getTime();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return timestamp;
    }
}