package com.storlead.framework.common.util;

import cn.hutool.core.util.RandomUtil;
import lombok.extern.log4j.Log4j2;
import org.springframework.util.StringUtils;

import java.beans.PropertyEditorSupport;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.Instant;
import java.time.LocalDate;
import java.time.Month;
import java.time.ZoneId;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 *
 * 类描述：时间操作定义类
 *
 * @Author: 张代浩
 * @Date:2012-12-8 12:15:03
 * @Version 1.0
 */
@Log4j2
public class DateUtils extends PropertyEditorSupport {
	// 各种时间格式
	public static final SimpleDateFormat date_sdf = new SimpleDateFormat("yyyy-MM-dd");

	public static final SimpleDateFormat date_yyyy_mm = new SimpleDateFormat("yyyy-MM");
	// 各种时间格式
	public static final SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
	// 各种时间格式
	public static final SimpleDateFormat date_sdf_wz = new SimpleDateFormat("yyyy年MM月dd日");
	public static final SimpleDateFormat time_sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
	public static final SimpleDateFormat yyyymmddhhmmss = new SimpleDateFormat("yyyyMMddHHmmss");
	public static final SimpleDateFormat short_time_sdf = new SimpleDateFormat("HH:mm");
	public static final SimpleDateFormat long_time_sdf = new SimpleDateFormat("HHmmss");
	public static final SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	// 以毫秒表示的时间
	private static final long DAY_IN_MILLIS = 24 * 3600 * 1000;
	private static final long HOUR_IN_MILLIS = 3600 * 1000;
	private static final long MINUTE_IN_MILLIS = 60 * 1000;
	private static final long SECOND_IN_MILLIS = 1000;

	// 指定模式的时间格式
	private static SimpleDateFormat getSDFormat(String pattern) {
		return new SimpleDateFormat(pattern);
	}

	/**
	 * 当前日历，这里用中国时间表示
	 *
	 * @return 以当地时区表示的系统当前日历
	 */
	public static Calendar getCalendar() {
		return Calendar.getInstance();
	}

	/**
	 * 指定毫秒数表示的日历
	 *
	 * @param millis 毫秒数
	 * @return 指定毫秒数表示的日历
	 */
	public static Calendar getCalendar(long millis) {
		Calendar cal = Calendar.getInstance();
		// --------------------cal.setTimeInMillis(millis);
		cal.setTime(new Date(millis));
		return cal;
	}

	// ////////////////////////////////////////////////////////////////////////////
	// getDate
	// 各种方式获取的Date
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 当前日期
	 *
	 * @return 系统当前时间
	 */
	public static Date getDate() {
		return new Date();
	}

	/**
	 * 指定毫秒数表示的日期
	 *
	 * @param millis 毫秒数
	 * @return 指定毫秒数表示的日期
	 */
	public static Date getDate(long millis) {
		return new Date(millis);
	}

	/**
	 * 时间戳转换为字符串
	 *
	 * @param time
	 * @return
	 */
	public static String timestamptoStr(Timestamp time) {
		Date date = null;
		if (null != time) {
			date = new Date(time.getTime());
		}
		return date2Str(date_sdf);
	}

	/**
	 * 字符串转换时间戳
	 *
	 * @param str
	 * @return
	 */
	public static Timestamp str2Timestamp(String str) {
		Date date = str2Date(str, date_sdf);
		return new Timestamp(date.getTime());
	}

	/**
	 * 字符串转换成日期
	 *
	 * @param str
	 * @param sdf
	 * @return
	 */
	public static Date str2Date(String str, SimpleDateFormat sdf) {
		if (null == str || "".equals(str)) {
			return null;
		}
		Date date = null;
		try {
			date = sdf.parse(str);
			return date;
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 日期转换为字符串
	 *
	 * @return 字符串
	 */
	public static String date2Str(SimpleDateFormat date_sdf) {
		Date date = getDate();
		if (null == date) {
			return null;
		}
		return date_sdf.format(date);
	}

	/**
	 * 格式化时间
	 *
	 * @param date
	 * @param format
	 * @return
	 */
	public static String dateformat(String date, String format) {
		SimpleDateFormat sformat = new SimpleDateFormat(format);
		Date _date = null;
		try {
			_date = sformat.parse(date);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return sformat.format(_date);
	}

	/**
	 * 日期转换为字符串
	 *
	 * @param date   日期
	 * @return 字符串
	 */
	public static String date2Str(Date date, SimpleDateFormat date_sdf) {
		if (null == date) {
			return null;
		}
		return date_sdf.format(date);
	}

	/**
	 * 日期转换为字符串
	 *
	 * @param format 日期格式
	 * @return 字符串
	 */
	public static String getDate(String format) {
		Date date = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(date);
	}

	public static String getYestoday() {
		DateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd");
		Calendar calendar=Calendar.getInstance();
		calendar.set(Calendar.HOUR_OF_DAY,-24);
		return dateFormat.format(calendar.getTime());
	}

	/**
	 * 指定毫秒数的时间戳
	 *
	 * @param millis 毫秒数
	 * @return 指定毫秒数的时间戳
	 */
	public static Timestamp getTimestamp(long millis) {
		return new Timestamp(millis);
	}

	/**
	 * 以字符形式表示的时间戳
	 *
	 * @param time 毫秒数
	 * @return 以字符形式表示的时间戳
	 */
	public static Timestamp getTimestamp(String time) {
		return new Timestamp(Long.parseLong(time));
	}

	/**
	 * 系统当前的时间戳
	 *
	 * @return 系统当前的时间戳
	 */
	public static Timestamp getTimestamp() {
		return new Timestamp(System.currentTimeMillis());
	}

	/**
	 * 当前时间，格式 yyyy-MM-dd HH:mm:ss
	 *
	 * @return 当前时间的标准形式字符串
	 */
	public static String now() {
		return datetimeFormat.format(getCalendar().getTime());
	}

	/**
	 * 指定日期的时间戳
	 *
	 * @param date 指定日期
	 * @return 指定日期的时间戳
	 */
	public static Timestamp getTimestamp(Date date) {
		return new Timestamp(date.getTime());
	}

	/**
	 * 指定日历的时间戳
	 *
	 * @param cal 指定日历
	 * @return 指定日历的时间戳
	 */
	public static Timestamp getCalendarTimestamp(Calendar cal) {
		// ---------------------return new Timestamp(cal.getTimeInMillis());
		return new Timestamp(cal.getTime().getTime());
	}

	public static Timestamp gettimestamp() {
		Date dt = new Date();
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String nowTime = df.format(dt);
		Timestamp buydate = Timestamp.valueOf(nowTime);
		return buydate;
	}

	// ////////////////////////////////////////////////////////////////////////////
	// getMillis
	// 各种方式获取的Millis
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 系统时间的毫秒数
	 *
	 * @return 系统时间的毫秒数
	 */
	public static long getMillis() {
		return System.currentTimeMillis();
	}

	/**
	 * 指定日历的毫秒数
	 *
	 * @param cal 指定日历
	 * @return 指定日历的毫秒数
	 */
	public static long getMillis(Calendar cal) {
		// --------------------return cal.getTimeInMillis();
		return cal.getTime().getTime();
	}

	/**
	 * 指定日期的毫秒数
	 *
	 * @param date 指定日期
	 * @return 指定日期的毫秒数
	 */
	public static long getMillis(Date date) {
		return date.getTime();
	}

	/**
	 * 指定时间戳的毫秒数
	 *
	 * @param ts 指定时间戳
	 * @return 指定时间戳的毫秒数
	 */
	public static long getMillis(Timestamp ts) {
		return ts.getTime();
	}

	// ////////////////////////////////////////////////////////////////////////////
	// formatDate
	// 将日期按照一定的格式转化为字符串
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 默认方式表示的系统当前日期，具体格式：年-月-日
	 *
	 * @return 默认日期按“年-月-日“格式显示
	 */
	public static String formatDate() {
		return date_sdf.format(getCalendar().getTime());
	}

	/**
	 * 默认方式表示的系统当前日期，具体格式：yyyy-MM-dd HH:mm:ss
	 *
	 * @return 默认日期按“yyyy-MM-dd HH:mm:ss“格式显示
	 */
	public static String formatDateTime() {
		return datetimeFormat.format(getCalendar().getTime());
	}

	/**
	 * 获取时间字符串
	 */
	public static String getDataString(SimpleDateFormat formatstr) {
		return formatstr.format(getCalendar().getTime());
	}

	/**
	 * 指定日期的默认显示，具体格式：年-月-日
	 *
	 * @param cal 指定的日期
	 * @return 指定日期按“年-月-日“格式显示
	 */
	public static String formatDate(Calendar cal) {
		return date_sdf.format(cal.getTime());
	}

	/**
	 * 指定日期的默认显示，具体格式：年-月-日
	 *
	 * @param date 指定的日期
	 * @return 指定日期按“年-月-日“格式显示
	 */
	public static String formatDate(Date date) {
		return date_sdf.format(date);
	}

	/**
	 * 指定毫秒数表示日期的默认显示，具体格式：年-月-日
	 *
	 * @param millis 指定的毫秒数
	 * @return 指定毫秒数表示日期按“年-月-日“格式显示
	 */
	public static String formatDate(long millis) {
		return date_sdf.format(new Date(millis));
	}

	/**
	 * 默认日期按指定格式显示
	 *
	 * @param pattern 指定的格式
	 * @return 默认日期按指定格式显示
	 */
	public static String formatDate(String pattern) {
		return getSDFormat(pattern).format(getCalendar().getTime());
	}

	/**
	 * 指定日期按指定格式显示
	 *
	 * @param cal     指定的日期
	 * @param pattern 指定的格式
	 * @return 指定日期按指定格式显示
	 */
	public static String formatDate(Calendar cal, String pattern) {
		return getSDFormat(pattern).format(cal.getTime());
	}

	/**
	 * 指定日期按指定格式显示
	 *
	 * @param date    指定的日期
	 * @param pattern 指定的格式
	 * @return 指定日期按指定格式显示
	 */
	public static String formatDate(Date date, String pattern) {
		return getSDFormat(pattern).format(date);
	}

	// ////////////////////////////////////////////////////////////////////////////
	// formatTime
	// 将日期按照一定的格式转化为字符串
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 默认方式表示的系统当前日期，具体格式：年-月-日 时：分
	 *
	 * @return 默认日期按“年-月-日 时：分“格式显示
	 */
	public static String formatTime() {
		return time_sdf.format(getCalendar().getTime());
	}

	/**
	 * 指定毫秒数表示日期的默认显示，具体格式：年-月-日 时：分
	 *
	 * @param millis 指定的毫秒数
	 * @return 指定毫秒数表示日期按“年-月-日 时：分“格式显示
	 */
	public static String formatTime(long millis) {
		return time_sdf.format(new Date(millis));
	}

	/**
	 * 指定日期的默认显示，具体格式：年-月-日 时：分
	 *
	 * @param cal 指定的日期
	 * @return 指定日期按“年-月-日 时：分“格式显示
	 */
	public static String formatTime(Calendar cal) {
		return time_sdf.format(cal.getTime());
	}

	/**
	 * 指定日期的默认显示，具体格式：年-月-日 时：分
	 *
	 * @param date 指定的日期
	 * @return 指定日期按“年-月-日 时：分“格式显示
	 */
	public static String formatTime(Date date) {
		return time_sdf.format(date);
	}

	// ////////////////////////////////////////////////////////////////////////////
	// formatShortTime
	// 将日期按照一定的格式转化为字符串
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 默认方式表示的系统当前日期，具体格式：时：分
	 *
	 * @return 默认日期按“时：分“格式显示
	 */
	public static String formatShortTime() {
		return short_time_sdf.format(getCalendar().getTime());
	}

	/**
	 * 指定毫秒数表示日期的默认显示，具体格式：时：分
	 *
	 * @param millis 指定的毫秒数
	 * @return 指定毫秒数表示日期按“时：分“格式显示
	 */
	public static String formatShortTime(long millis) {
		return short_time_sdf.format(new Date(millis));
	}

	/**
	 * 指定日期的默认显示，具体格式：时：分
	 *
	 * @param cal 指定的日期
	 * @return 指定日期按“时：分“格式显示
	 */
	public static String formatShortTime(Calendar cal) {
		return short_time_sdf.format(cal.getTime());
	}

	/**
	 * 指定日期的默认显示，具体格式：时：分
	 *
	 * @param date 指定的日期
	 * @return 指定日期按“时：分“格式显示
	 */
	public static String formatShortTime(Date date) {
		return short_time_sdf.format(date);
	}

	// ////////////////////////////////////////////////////////////////////////////
	// parseDate
	// parseCalendar
	// parseTimestamp
	// 将字符串按照一定的格式转化为日期或时间
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
	 *
	 * @param src     将要转换的原始字符窜
	 * @param pattern 转换的匹配格式
	 * @return 如果转换成功则返回转换后的日期
	 * @throws ParseException
	 */
	public static Date parseDate(String src, String pattern) throws ParseException {
		return getSDFormat(pattern).parse(src);

	}

	/**
	 * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
	 *
	 * @param src     将要转换的原始字符窜
	 * @param pattern 转换的匹配格式
	 * @return 如果转换成功则返回转换后的日期
	 * @throws ParseException
	 */
	public static Calendar parseCalendar(String src, String pattern) throws ParseException {

		Date date = parseDate(src, pattern);
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		return cal;
	}

	public static String formatAddDate(String src, String pattern, int amount) throws ParseException {
		Calendar cal;
		cal = parseCalendar(src, pattern);
		cal.add(Calendar.DATE, amount);
		return formatDate(cal);
	}

	/**
	 * 根据指定的格式将字符串转换成Date 如输入：2003-11-19 11:20:20将按照这个转成时间
	 *
	 * @param src     将要转换的原始字符窜
	 * @param pattern 转换的匹配格式
	 * @return 如果转换成功则返回转换后的时间戳
	 * @throws ParseException
	 */
	public static Timestamp parseTimestamp(String src, String pattern) throws ParseException {
		Date date = parseDate(src, pattern);
		return new Timestamp(date.getTime());
	}

	// ////////////////////////////////////////////////////////////////////////////
	// dateDiff
	// 计算两个日期之间的差值
	// ////////////////////////////////////////////////////////////////////////////

	/**
	 * 计算两个时间之间的差值，根据标志的不同而不同
	 *
	 * @param flag   计算标志，表示按照年/月/日/时/分/秒等计算
	 * @param calSrc 减数
	 * @param calDes 被减数
	 * @return 两个日期之间的差值
	 */
	public static int dateDiff(char flag, Calendar calSrc, Calendar calDes) {

		long millisDiff = getMillis(calSrc) - getMillis(calDes);

		if (flag == 'y') {
			return (calSrc.get(calSrc.YEAR) - calDes.get(calDes.YEAR));
		}

		if (flag == 'd') {
			return (int) (millisDiff / DAY_IN_MILLIS);
		}

		if (flag == 'h') {
			return (int) (millisDiff / HOUR_IN_MILLIS);
		}

		if (flag == 'm') {
			return (int) (millisDiff / MINUTE_IN_MILLIS);
		}

		if (flag == 's') {
			return (int) (millisDiff / SECOND_IN_MILLIS);
		}

		return 0;
	}
	// 计算两个日期之间的差值
	public static int daysBetween(Date one, Date two) {
		long difference =  (one.getTime()-two.getTime())/86400000;
		return (int)Math.abs(difference);
	}


	/**
	 * String类型 转换为Date, 如果参数长度为10 转换格式”yyyy-MM-dd“ 如果参数长度为19 转换格式”yyyy-MM-dd
	 * HH:mm:ss“ * @param text String类型的时间值
	 */
	@Override
	public void setAsText(String text) throws IllegalArgumentException {
		if (StringUtils.hasText(text)) {
			try {
				if (text.indexOf(":") == -1 && text.length() == 10) {
					setValue(this.date_sdf.parse(text));
				} else if (text.indexOf(":") > 0 && text.length() == 19) {
					setValue(this.datetimeFormat.parse(text));
				} else {
					throw new IllegalArgumentException("Could not parse date, date format is error ");
				}
			} catch (ParseException ex) {
				IllegalArgumentException iae = new IllegalArgumentException("Could not parse date: " + ex.getMessage());
				iae.initCause(ex);
				throw iae;
			}
		} else {
			setValue(null);
		}
	}

	public static int getYear() {
		GregorianCalendar calendar = new GregorianCalendar();
		calendar.setTime(getDate());
		return calendar.get(Calendar.YEAR);
	}
	 /***
	  * @Description: 获取日本月的第一天（本月）
	  * @Param:
	  * @return:
	  * @Author: YPZ
	  * @Date: 2023/5/19 14:48
	  */
	public static Date getMonthFirstDate() {
		// 获取当前日期
		Date currentDate = new Date();
		// 创建Calendar实例
		Calendar calendar = Calendar.getInstance();
		// 设置日期为当前日期
		calendar.setTime(currentDate);
		// 将日期设置为该月的第一天
		calendar.set(Calendar.DAY_OF_MONTH, 1);
		String strNew = new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime());
		try {
			Date date =new SimpleDateFormat("yyyy-MM-dd").parse(strNew);
			return date;
		}catch (Exception e){
			log.error("日期转换错误");
		}
		// 获取本月的开始时间

		return calendar.getTime();
	}

	/***
	  * @Description: 获取本月的最后一天（本月）
	  * @Param:
	  * @return:
	  * @Author: YPZ
	  * @Date: 2023/5/19 14:48
	  */
	public static Date getMonthLastDate() {
		// 获取当前日期
		Date currentDate = new Date();
		// 创建Calendar实例
		Calendar calendar = Calendar.getInstance();
		// 设置日期为当前日期
		calendar.setTime(currentDate);
		// 将日期设置为该月的第一天
		calendar.set(Calendar.DAY_OF_MONTH, 1);

		// 将日期设置为该月的最后一天
		calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
		// 获取本月的结束时间
//		return calendar.getTime();
		String strNew = new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime());
		try {
			Date date =new SimpleDateFormat("yyyy-MM-dd").parse(strNew);
			return date;
		}catch (Exception e){
			log.error("日期转换错误");
		}
		// 获取本月的开始时间

		return calendar.getTime();
	}

	/**
   * 获取当前日期所在季度的开始日期和结束日期
   * 季度一年四季， 第一季度：1月-3月， 第二季度：4月-6月， 第三季度：7月-9月， 第四季度：10月-12月
   * @param isFirst  true表示查询本季度开始日期  false表示查询本季度结束日期
   * @return
   */
      public static Date getStartOrEndDayOfQuarter(Boolean isFirst){
		         LocalDate today=LocalDate.now();
		         LocalDate resDate = LocalDate.now();
		         if (today == null) {
			             today = resDate;
			         }
		         Month month = today.getMonth();
		         Month firstMonthOfQuarter = month.firstMonthOfQuarter();
		         Month endMonthOfQuarter = Month.of(firstMonthOfQuarter.getValue() + 2);
		         if (isFirst) {
			             resDate = LocalDate.of(today.getYear(), firstMonthOfQuarter, 1);
			         } else {
			             resDate = LocalDate.of(today.getYear(), endMonthOfQuarter, endMonthOfQuarter.length(today.isLeapYear()));
			         }
		         return Date.from(resDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
		     }

	/**
	 * 通过时间秒毫秒数判断两个时间的间隔
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static int differentDaysByMillisecond(Date date1,Date date2)
	{
		int days = (int) ((date2.getTime() - date1.getTime()) / (1000*3600*24));
		return days;
	}

	public static String getUploadFileName() {
		return date2Str(long_time_sdf)+RandomUtil.randomNumbers(4);
	}

	public static String getUploadDir() {
		return date2Str(yyyyMMdd);
	}
	/**
	* @Description:  取日期的后一天
	* @Param:
	* @return:
	* @Author: YPZ
	* @Date: 2022/7/25
	*/

	public static Date nextDate(Date date) {
		Calendar calendar = Calendar.getInstance(); //得到日历
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, 1);  //设置为后一天
		Date tomorrow = calendar.getTime();   //得到后一天的时间
		return tomorrow;

	}

	/**
	* @Description:  取日期的前一天
	* @Param:
	* @return:
	* @Author: YPZ
	* @Date: 2022/7/25
	*/

	public static Date preDate(Date date) {
		Calendar calendar = Calendar.getInstance(); //得到日历
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, -1);  //设置为前一天
		Date tomorrow = calendar.getTime();   //得到前一天的时间
		return tomorrow;

	}

	/**
	* @Description:  取日期的最后一秒
	* @Param:
	* @return:
	* @Author: YPZ
	* @Date: 2022/7/25
	*/

	public static Date dateEndTime(Date date) {

		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String time=sdf.format(date);//将前端的日期转成String字符串
			time+=" 23:59:59";//字符串拼接
			SimpleDateFormat end = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//将字符串格式化一下
			return end.parse(time);
		}catch (ParseException e){
			return date;
		}
	}

	/**
	* @Description:  取日期的最后一秒
	* @Param:
	* @return:
	* @Author: YPZ
	* @Date: 2022/7/25
	*/

	public static Date dateEndTime(LocalDate localdate) {

		ZoneId zone = ZoneId.systemDefault();
		Instant instant = localdate.atStartOfDay().atZone(zone).toInstant();
		Date date = Date.from(instant);
		try {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			String time=sdf.format(date);//将前端的日期转成String字符串
			time+=" 23:59:59";//字符串拼接
			SimpleDateFormat end = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//将字符串格式化一下
			return end.parse(time);
		}catch (ParseException e){
			return null;
		}
	}



	/**
	 * 判断一年的第几周
	 * @param datetime
	 * @return
	 * @throws ParseException
	 */
	public static Integer whatWeek(String datetime) {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		Date date = null;
		try {
			date = format.parse(datetime);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		Calendar calendar = Calendar.getInstance();
		calendar.setFirstDayOfWeek(Calendar.MONDAY);
		calendar.setTime(date);
		Integer weekNumbe = calendar.get(Calendar.WEEK_OF_YEAR);
		return weekNumbe;
	}
	public static Integer weekTest(String datetime){
		Calendar calendar = Calendar.getInstance();
		//设置星期一为一周开始的第一天
		calendar.setFirstDayOfWeek(Calendar.MONDAY);
		//获得当前的时间戳
		calendar.setTimeInMillis(System.currentTimeMillis());
		//获得当前日期属于今年的第几周
		Integer weekOfYear = calendar.get(Calendar.WEEK_OF_YEAR);
		return weekOfYear;
	}
	 /***
	  * @Description: 获取日期几年前后的时间
	  * @Param: years参照时间，年（之前为负数，之后为正数）
	  * @return:
	  * @Author: YPZ
	  * @Date: 2022/11/22 14:38
	  */
	public static Date calYear(Date date,int years){
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.YEAR,years);
		return calendar.getTime();
	}

	public static void main(String[] args) {

		System.out.println("本月第一天为："+getMonthFirstDate());
		System.out.println("本月最后一天为："+getMonthLastDate());
		System.out.println("本季度第一天为："+getStartOrEndDayOfQuarter(true));
		System.out.println("本季度最后一天为："+getStartOrEndDayOfQuarter(false));
//		System.out.println(getUploadDir());
//		System.out.println(weekTest("2022-02-18"));
//		LocalDateTime end = LocalDateTime.parse("2022-07-21 23:59:59", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
//
//		long until = java.time.LocalDate.now().until(end, ChronoUnit.DAYS);
//		System.out.println(until);
//		try {
//		LocalDate localDate1 = LocalDate.of(2022,8,15);
//
//		String beginTime = "2022-08-16 14:42:32";
//		String endTime = "2022-08-17 14:42:32";
//		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//		Date date1 = format.parse(beginTime);
//		Date date2 = format.parse(endTime);
//
//		LocalDate localDate2 = date1.toInstant()
//				.atZone(ZoneId.systemDefault())
//				.toLocalDate();
//		Boolean isBefore = localDate1.isBefore(localDate2);
//
//			System.out.println(isBefore);
//		}catch (Exception e){
//
//		}

	}

}
