package org.jeecg.common.util;

import org.jeecg.common.constant.SystemDateConstant;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.util.*;

/**
 * 类描述：时间操作定义类
 *
 * @Author: 张代浩
 * @Date:2012-12-8 12:15:03
 * @Version 1.0
 */
public class DateUtils extends PropertyEditorSupport {

    private static Logger logger = LoggerFactory.getLogger(DateUtils.class);

    public static ThreadLocal<SimpleDateFormat> date_sdf = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };
    public static ThreadLocal<SimpleDateFormat> yyyyMMdd = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyyMMdd");
        }
    };
    public static ThreadLocal<SimpleDateFormat> date_sdf_wz = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy年MM月dd日");
        }
    };
    public static ThreadLocal<SimpleDateFormat> time_sdf = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm");
        }
    };
    public static ThreadLocal<SimpleDateFormat> yyyymmddhhmmss = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyyMMddHHmmss");
        }
    };
    public static ThreadLocal<SimpleDateFormat> short_time_sdf = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("HH:mm");
        }
    };
    public static ThreadLocal<SimpleDateFormat> datetimeFormat = new ThreadLocal<SimpleDateFormat>() {
        @Override
        protected SimpleDateFormat initialValue() {
            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        }
    };

    // 以毫秒表示的时间
    private static final long DAY_IN_MILLIS = 24 * 3600 * 1000L;
    private static final long HOUR_IN_MILLIS = 3600 * 1000L;
    private static final long MINUTE_IN_MILLIS = 60 * 1000L;
    private static final long SECOND_IN_MILLIS = 1000L;
    /**
     * 格式常量
     */
    public final static String SHORT_FORMAT = "yyyyMMdd";
    public final static String LONG_FORMAT = "yyyyMMddHHmmss";
    public final static String YEARHOUR_FORMAT = "yyyyMMddHH";
    public final static String WEB_FORMAT = "yyyy-MM-dd";
    public final static String TIME_FORMAT = "HHmmss";
    public final static String COLON_TIME_FORMAT = "HH:mm:ss";
    public final static String CHINESEDT_FORMAT = "yyyy年MM月dd日";
    public final static String NEW_FORMAT = "yyyy-MM-dd HH:mm:ss";
    public final static String WEB_FORMAT_ALL = "yyyy MM dd HH mm ss";
    public final static String SECOND_FORMAT = "yyyy-MM-dd HH";
    public final static String GREGORIAN_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'";
    public final static String NOMS_GREGORIAN_FORMAT = "yyyy-MM-dd'T'HH:mm:ss'Z'";
    public static SimpleDateFormat format1 = new SimpleDateFormat(
            "yyyy-MM-dd HH:mm:ss");

    public static Date getStartDate(String date) {
        String temp = date + " 00:00:00";
        try {
            return format1.parse(temp);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }

    public static Date getEndDate(String date) {
        String temp = date + " 23:59:59";
        try {
            return format1.parse(temp);
        } catch (Exception e) {
            return null;
        }

    }

    public static String getNowHour(Date date) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH");
        return simpleDateFormat.format(date);
    }

    public static Date getNowDate() throws ParseException {
        SimpleDateFormat dsdf = new SimpleDateFormat("yyyy-MM-dd");
        String nowDate = getNowDate("yyyy-MM-dd");
        return dsdf.parse(nowDate);
    }


    public static boolean compare(String beginDate, String nowDate) throws ParseException {
        //如果想比较日期则写成"yyyy-MM-dd"就可以了
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //将字符串形式的时间转化为Date类型的时间
        Date a = sdf.parse(beginDate);
        Date b = sdf.parse(nowDate);
        return a.before(b);
    }


    public static String getDateByDateStr(String dateStr) throws ParseException {
        SimpleDateFormat dsdf = new SimpleDateFormat("yyyy-MM-dd");
        Date parse = dsdf.parse(dateStr);
        return dsdf.format(parse);
    }

    public static Integer getNowHour() throws ParseException {
        Calendar cal = Calendar.getInstance();
        Date date = new Date();
        cal.setTime(date);
        return cal.get(Calendar.HOUR_OF_DAY);
    }

    public static Integer getHour(String dateStr) throws ParseException {
        DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar cal = Calendar.getInstance();
        Date date = sdf.parse(dateStr);
        cal.setTime(date);
        return cal.get(Calendar.HOUR_OF_DAY);
    }

    public static String getEndTime(String time) throws ParseException {
        SimpleDateFormat smf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parse = smf.parse(time);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(parse);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.add(Calendar.DAY_OF_MONTH, 1);
        calendar.add(Calendar.SECOND, -1);
        Date end = calendar.getTime();
        String format = smf.format(end);
        return format;
    }


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

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

    /**
     * 日期转换为字符串
     *
     * @return 字符串
     */
    public static String date2Str() {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        return format.format(new Date());
    }

    public static List<Map<String, String>> getDateDayRange(String startDate, String endDate) throws ParseException {
        List<Map<String, String>> list = new ArrayList<>();
        String splitDate = DateUtils.addDay(endDate, -1);
        splitDate = DateUtils.addDay(splitDate, 1);
        if (DateUtils.compareDate(startDate, splitDate) >= 0) {
            Map<String, String> map = new HashMap<String, String>();
            map.put("startDate", startDate);
            map.put("endDate", endDate);
            list.add(map);
        } else {
            while (DateUtils.compareDate(startDate, splitDate) < 0 || DateUtils.compareDate(startDate, endDate) <= 0) {
                Map<String, String> map = new HashMap<>();
                map.put("startDate", splitDate);
                map.put("endDate", endDate);
                list.add(map);
                splitDate = DateUtils.addDay(splitDate, -1);
                endDate = DateUtils.addDay(endDate, -1);
                if (DateUtils.compareDate(startDate, splitDate) > 0) {
                    splitDate = startDate;
                }
            }
        }
        return list;
    }

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

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

    /**
     * 字符串转换成日期
     *
     * @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;
    }

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


    public static String getStartTime(Date date) {
        Calendar dateStart = Calendar.getInstance();
        dateStart.setTime(date);
        dateStart.set(Calendar.HOUR_OF_DAY, 0);
        dateStart.set(Calendar.MINUTE, 0);
        dateStart.set(Calendar.SECOND, 0);
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return simpleDateFormat.format(dateStart.getTime());
    }

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

    public static Date getDate() {
        return new Date();
    }

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

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

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


    public static String tempToDate(long millis) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = new Date(millis);
        String d2 = simpleDateFormat.format(d1);
        return d2;
    }

    public static String tempToDateLong(long millis) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMdd");
        Date d1 = new Date(millis);
        String d2 = simpleDateFormat.format(d1);
        return d2;
    }


    public static Long tempToLongDate(long millis) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = new Date(millis);
        String d2 = simpleDateFormat.format(d1);
        Long longDate = Long.valueOf(d2.replace("-", ""));
        return longDate;
    }


    public static String tempToLongDateStr(long millis) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = new Date(millis);
        String d2 = simpleDateFormat.format(d1);

        return d2;
    }


    public static Integer getHour(long millis) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HH");
        Date d1 = new Date(millis);
        String d2 = simpleDateFormat.format(d1);
        Integer hour = Integer.valueOf(d2);
        return hour;
    }




    public static String temp13ToDate(long millis) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = new Date(millis);
        String d2 = simpleDateFormat.format(d1);
        return d2;
    }



    /**
     * 以字符形式表示的时间戳
     *
     * @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.get().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.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);
        return Timestamp.valueOf(nowTime);
    }

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

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

    /**
     * 指定日历的毫秒数
     *
     * @param cal 指定日历
     * @return 指定日历的毫秒数
     */
    public static long getMillis(Calendar cal) {
        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.get().format(getCalendar().getTime());
    }

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

    public static String formatDateTime(Long time) {
        return datetimeFormat.get().format(time);
    }

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

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

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

    /**
     * 指定毫秒数表示日期的默认显示，具体格式：年-月-日
     *
     * @param millis 指定的毫秒数
     * @return 指定毫秒数表示日期按“年-月-日“格式显示
     */
    public static String formatDate(long millis) {
        return date_sdf.get().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.get().format(getCalendar().getTime());
    }

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

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

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

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

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

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

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

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

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

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

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

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

    public static String formatAddDate(String src, String pattern, int amount) {
        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
     * @throws
     */
    public static Timestamp parseTimestamp(String src, String pattern) {
        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(Calendar.YEAR) - calDes.get(Calendar.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 String getDateString(String createTime) throws ParseException {
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf1.parse(createTime);
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf2.format(date);
    }

    public static Map<String, Object> getStartEndTime(String createTime) throws ParseException {
        SimpleDateFormat smf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parse = smf.parse(createTime);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(parse);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        Date start = calendar.getTime();
        calendar.add(Calendar.DAY_OF_MONTH, 1);
        calendar.add(Calendar.SECOND, -1);
        Date end = calendar.getTime();
        Map<String, Object> map = new HashMap<>();
        map.put("start", smf.format(start));
        map.put("end", smf.format(end));
        return map;
    }

    public static String getQuarterStartDate(Date date) {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        Integer month = calendar.get(Calendar.MONTH);
        Integer compare = month % 3;
        calendar.add(Calendar.MONTH, -compare);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        Date getDate = calendar.getTime();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        return dateFormat.format(getDate);
    }

    public static String getQuarterEndDate(Date date) {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        Integer month = calendar.get(Calendar.MONTH);
        Integer compare = month % 3;
        calendar.add(Calendar.MONTH, (3 - compare));
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        Date getDate = calendar.getTime();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        return dateFormat.format(getDate);
    }

    public static Date stampToTime(Long ms) throws ParseException {
        long msl = ms * 1000;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date temp = null;
        if (ms != null) {
            try {
                String str = sdf.format(msl);
                temp = sdf.parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return temp;
    }

    private static Calendar zeroFromHour(long milliseconds) {
        Calendar calendar = Calendar.getInstance(); // 获得一个日历

        calendar.setTimeInMillis(completMilliseconds(milliseconds));
        zeroFromHour(calendar);
        return calendar;
    }

    private static long completMilliseconds(long milliseconds) {
        String milStr = Long.toString(milliseconds);
        if (milStr.length() == 10) {
            milliseconds = milliseconds * 1000;
        }
        return milliseconds;
    }

    private static void zeroFromHour(Calendar calendar) {
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
    }


    public static String getWhatDay(long timeStamp) {
        Calendar cal = zeroFromHour(timeStamp);
        String whatDay = "";
        if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY) {
            whatDay = "星期六";
        }
        if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
            whatDay = "星期日";
        }
        if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.MONDAY) {
            whatDay = "星期一";
        }
        if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.TUESDAY) {
            whatDay = "星期二";
        }
        if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.WEDNESDAY) {
            whatDay = "星期三";
        }
        if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.THURSDAY) {
            whatDay = "星期四";
        }
        if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.FRIDAY) {
            whatDay = "星期五";
        }
        return whatDay;
    }

    /* //日期转换为时间戳 */
    public static long timeToStamp(String timers) {
        Date d = new Date();
        long timeStemp = 0;
        try {
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            d = sf.parse(timers);// 日期转换为时间戳
        } catch (ParseException e) {

            e.printStackTrace();
        }
        timeStemp = d.getTime();
        return timeStemp / 1000;
    }


    public static int getdaysOfTwoDate(String minDate, String date) {
        Date bigDate = parseDate(date, "yyyy-MM-dd");
        Date smallDate = parseDate(minDate, "yyyy-MM-dd");
        int days = (int) ((bigDate.getTime() - smallDate.getTime()) / (1000 * 3600 * 24));
        return days + 1;
    }


    /**
     * 当前时间前推
     *
     * @param endDate
     * @param i
     * @return
     */
    public static Date addTime(Date endDate, int i) {
        Long time = Long.valueOf(i * 1000 * 60);
        Long time1 = endDate.getTime() - time;
        return new Date(time1);
    }


    /**
     * String类型 转换为Date, 如果参数长度为10 转换格式”yyyy-MM-dd“ 如果参数长度为19 转换格式”yyyy-MM-dd
     * HH:mm:ss“ * @param text String类型的时间值
     */
    @Override
    public void setAsText(String text) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat datetimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (StringUtils.hasText(text)) {
            try {
                if (text.indexOf(":") == -1 && text.length() == 10) {
                    setValue(format.parse(text));
                } else if (text.indexOf(":") > 0 && text.length() == 19) {
                    setValue(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(Date date) {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.YEAR);
    }


    public static Date timeStampToDate(Long time) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date;
        try {
            date = sdf.parse(sdf.format(time));
            return date;
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static List<Map<String, String>> getDateWeekRange(String startDate, String endDate) throws ParseException {
        List<Map<String, String>> list = new ArrayList<>();
        String splitDate = DateUtils.addWeek(endDate, -1);
        splitDate = DateUtils.addDay(splitDate, 1);
        if (DateUtils.compareDate(startDate, splitDate) >= 0) {
            Map<String, String> map = new HashMap<>();
            map.put("startDate", startDate);
            map.put("endDate", endDate);
            list.add(map);
        } else {
            while (DateUtils.compareDate(startDate, splitDate) < 0 || DateUtils.compareDate(startDate, endDate) <= 0) {
                Map<String, String> map = new HashMap<>();
                map.put("startDate", splitDate);
                map.put("endDate", endDate);
                list.add(map);
                splitDate = DateUtils.addWeek(splitDate, -1);
                endDate = DateUtils.addWeek(endDate, -1);
                if (DateUtils.compareDate(startDate, splitDate) > 0) {
                    splitDate = startDate;
                }
            }
        }
        return list;
    }

    public static List<Map<String, String>> getDateMonthRange(String startDate, String endDate) throws ParseException {
        List<Map<String, String>> list = new ArrayList<>();
        String splitDate = DateUtils.addMonth(endDate, -1);
        splitDate = DateUtils.addDay(splitDate, 1);
        if (DateUtils.compareDate(startDate, splitDate) >= 0) {
            Map<String, String> map = new HashMap<>();
            map.put("startDate", startDate);
            map.put("endDate", endDate);
            list.add(map);
        } else {
            while (DateUtils.compareDate(startDate, splitDate) < 0 || DateUtils.compareDate(startDate, endDate) <= 0) {
                Map<String, String> map = new HashMap<>();
                map.put("startDate", splitDate);
                map.put("endDate", endDate);
                list.add(map);
                splitDate = DateUtils.addMonth(splitDate, -1);
                endDate = DateUtils.addMonth(endDate, -1);
                if (DateUtils.compareDate(startDate, splitDate) > 0) {
                    splitDate = startDate;
                }
            }
        }
        return list;
    }

    public static String addMonth(String dateString, int month) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(dateString);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, month);
        return sdf.format(calendar.getTime());
    }

    public static String addWeek(String dateString, int week) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf.parse(dateString);
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.WEEK_OF_YEAR, week);
        return sdf.format(calendar.getTime());
    }

    public static String addDay(String dateString, int day) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = sdf.parse(dateString);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_YEAR, day);
        return sdf.format(calendar.getTime());
    }

    public static Date addDay(Date date, int day) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_YEAR, day);
        return calendar.getTime();
    }

    public static Date addSecond(Date date, int seconds) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.SECOND, seconds);
        return calendar.getTime();
    }

    public static int compareDate(String firstDateString, String secondDateString) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date firstDate = sdf.parse(firstDateString);
        Date secondDate = sdf.parse(secondDateString);
        long first = firstDate.getTime();
        long second = secondDate.getTime();
        return first == second ? 0 : (first > second ? 1 : -1);
    }

    public static String timeStamp2Date(Timestamp timeLong) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date;
        try {
            date = sdf.parse(sdf.format(timeLong));
            return sdf.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static String timeStamp2Date(long currentTimeMillis) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date;
        try {
            date = sdf.parse(sdf.format(currentTimeMillis));
            return sdf.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
            return null;
        }
    }


    public static Map<String, Object> getBeforeDate() {
        Date dNow = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(dNow);
        calendar.add(Calendar.DAY_OF_MONTH, -1);
        Date dBefore = calendar.getTime();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String defaultStartDate = sdf.format(dBefore);
        defaultStartDate = defaultStartDate + " 00:00:00";
        String defaultEndDate = defaultStartDate.substring(0, 10) + " 23:59:59";
        Map<String, Object> map = new HashMap<>();
        map.put("startDate", defaultStartDate);
        map.put("endDate", defaultEndDate);
        return map;
    }


    /**
     * @param format 返回日期格式
     * @param date   传入的初始日期
     * @param num    天数
     * @return
     */
    public static String getAnotherDay(String format, String date, Integer num) {

        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date getDate = null;
        try {
            getDate = sdf.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(getDate);
        calendar.add(Calendar.DAY_OF_MONTH, num);
        Date resultDate = calendar.getTime();
        return sdf.format(resultDate);
    }


    public static Map<String, String> getMonthStartAndEnd() {
        Map<String, String> map = new HashMap<>();
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); //格式化时间
        Calendar cal_1 = Calendar.getInstance();//获取当前日期
        cal_1.add(Calendar.MONTH, -1);
        cal_1.set(Calendar.DAY_OF_MONTH, 1);//设置为1号
        cal_1.set(Calendar.HOUR_OF_DAY, 0);
        cal_1.set(Calendar.MINUTE, 0);
        cal_1.set(Calendar.SECOND, 0);
        String firstDay = format.format(cal_1.getTime());
        map.put("firstDay", firstDay);

        Calendar cal_2 = Calendar.getInstance();
        cal_2.set(Calendar.DAY_OF_MONTH, 0);//设置为1号,当前日期既为本月第一天
        cal_2.set(Calendar.HOUR_OF_DAY, 23);
        cal_2.set(Calendar.MINUTE, 59);
        cal_2.set(Calendar.SECOND, 59);
        String lastDay = format.format(cal_2.getTime());
        map.put("lastDay", lastDay);
        return map;
    }

    public static void main(String[] args) {
        Integer hour = getHour(1714100399753L);
        System.err.println(hour);

    }

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


    public static String getMonthBefore(String format, String nowTime, int amount) {
        // 获取当前时间
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        Date date = null;
        try {
            date = dateFormat.parse(nowTime);
        } catch (ParseException e) {
            logger.error(e.getMessage(), e);
        }

        //得到日历
        Calendar calendar = Calendar.getInstance();
        //把当前时间赋给日历
        calendar.setTime(date);
        //设置为前2月，可根据需求进行修改
        calendar.add(Calendar.MONTH, amount);
        //获取2个月前的时间
        date = calendar.getTime();

        return dateFormat.format(date);
    }

    public static Map<String, Object> compareDate(String format, String date1, String date2) {
        DateFormat df = new SimpleDateFormat(format);
        Map<String, Object> map = new HashMap<>();
        try {
            Date dt1 = df.parse(date1);
            Date dt2 = df.parse(date2);
            if (dt1.getTime() > dt2.getTime()) {
                map.put("bigDate", date1);
                map.put("smallDate", date2);
                return map;
            } else if (dt1.getTime() < dt2.getTime()) {
                map.put("bigDate", date2);
                map.put("smallDate", date1);
                return map;
            }
        } catch (Exception exception) {
            exception.printStackTrace();
        }
        return null;
    }

    /**
     * 日期中获取年份
     *
     * @param format
     * @param date
     * @return
     * @throws ParseException
     */
    public static String getYear(String format, String date) throws ParseException {
        SimpleDateFormat df = new SimpleDateFormat(format);
        Date parse = df.parse(date);
        return String.format("%tY", parse);
    }

    /**
     * 日期中获取月份
     *
     * @param format
     * @param date
     * @return
     * @throws ParseException
     */
    public static String getMonth(String format, String date) throws ParseException {
        SimpleDateFormat df = new SimpleDateFormat(format);
        Date parse = df.parse(date);
        return String.format("%tm", parse);
    }

    /**
     * 日期中获取天
     *
     * @param format
     * @param date
     * @return
     * @throws ParseException
     */
    public static String getDay(String format, String date) throws ParseException {
        SimpleDateFormat df = new SimpleDateFormat(format);
        Date parse = df.parse(date);
        return String.format("%td", parse);
    }

    /**
     * 根据时间获取季度
     * 1即Q1（1，2，3月），以此类推
     *
     * @param date
     * @return
     */
    public static int getQuarter(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        //获取当前月份
        int month = cal.get(Calendar.MONTH) + 1;
        if (month <= 3) {
            return 1;
        } else if (month <= 6) {
            return 2;
        } else if (month <= 9) {
            return 3;
        } else if (month <= 12) {
            return 4;
        }

        return 0;
    }

    /**
     * 获取【所在周】周五的时间（周五为一周第一天，周四为一周最后一天）
     *
     * @param date
     */
    public static Date getFriday(Date date) {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        calendar.setFirstDayOfWeek(Calendar.FRIDAY);
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
        return calendar.getTime();
    }

    /**
     * 获取传入时间的年、月份和季度（周五为每周第一天，周四为每周最后一天）
     * 获取的是所属年、月、季度，因为很多月份的第一周或最后 一周会包括上一个月或者下一个月的部分日期
     */
    public static Map<String, Integer> getYearQuarter(Date date) {
        Map<String, Integer> dateMap = new HashMap<>();
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        int originYear = calendar.get(Calendar.YEAR);
        int originMonth = calendar.get(Calendar.MONTH);
        //本月所在季度（按照日期来的）
        int originQuarter = DateUtils.getQuarter(date);
        Calendar calendar1 = new GregorianCalendar();
        calendar1.setTime(date);
        calendar1.setFirstDayOfWeek(Calendar.FRIDAY);
        //1.判断当天所在周第一天是否跨月
        calendar1.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
        int fridayYear = calendar1.get(Calendar.YEAR);
        int fridayMonth = calendar1.get(Calendar.MONTH);
        int fridayQuarter = DateUtils.getQuarter(calendar1.getTime());

        //2.判断当天所在周的最后一天是否跨月
        Calendar calendar2 = new GregorianCalendar();
        calendar2.setTime(date);
        calendar2.setFirstDayOfWeek(Calendar.FRIDAY);
        calendar2.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
        int thursdayYear = calendar2.get(Calendar.YEAR);
        int thursdayMonth = calendar2.get(Calendar.MONTH);
        int thursdayQuarter = DateUtils.getQuarter(calendar2.getTime());

        //如果本周第一天（周五）和当前天不在一个月内，说明周跨月了
        if (fridayMonth == originMonth && thursdayMonth == originMonth) {
            dateMap.put("year", originYear);
            //最后一个月是11，应该+1
            dateMap.put("month", originMonth + 1);
            dateMap.put("quarter", originQuarter);
            return dateMap;
        } else if (fridayYear < originYear || (fridayYear == originYear && fridayMonth < originMonth)) {
            //判断本周有几天在本月,如果是（5，6，7）则就是本月本季度
            //int lastDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
            calendar1.set(Calendar.DATE, calendar1.getActualMaximum(Calendar.DATE));
            int lastDateWeek = calendar1.get(Calendar.DAY_OF_WEEK);
            //判断如果本周所在上个月的最后一天是周五、周六、周日的话，说明本周归属于本月（周五是第一天）；否则本周归属于上个季度
            if (lastDateWeek == 6 || lastDateWeek == 7 || lastDateWeek == 1) {
                dateMap.put("year", originYear);
                dateMap.put("month", originMonth + 1);
                dateMap.put("quarter", originQuarter);
            } else {
                //判断如果本周属于上个月，判断是否跨年
                if (originYear == fridayYear) {
                    dateMap.put("year", originYear);
                    dateMap.put("month", originMonth);
                    //判断是否跨季
                    if (originQuarter == fridayQuarter) {
                        dateMap.put("quarter", originQuarter);
                    } else {
                        dateMap.put("quarter", fridayQuarter);
                    }
                } else {
                    //跨年的话说明这周上年的12月（第四季度）
                    dateMap.put("year", originYear - 1);
                    dateMap.put("month", 12); //??查看是11，还是12
                    dateMap.put("quarter", 4);
                }
            }
            return dateMap;
        } else if (originYear < thursdayYear || (originYear == thursdayYear && originMonth < thursdayMonth)) {
            calendar2.set(Calendar.DATE, 1);
            int firstDateWeek = calendar2.get(Calendar.DAY_OF_WEEK);
            //如果跨月的第一天是周二周三周四的话说明这周不跨月，否在进入下个月（季度、年需要再判断）
            if (firstDateWeek == 3 || firstDateWeek == 4 || firstDateWeek == 5) {
                dateMap.put("year", originYear);
                dateMap.put("month", originMonth + 1);
                dateMap.put("quarter", originQuarter);
            } else {
                if (originYear == thursdayYear) {
                    dateMap.put("year", originYear);
                    dateMap.put("month", originMonth + 1 + 1);
                    //判断是否跨季
                    if (originQuarter == thursdayQuarter) {
                        dateMap.put("quarter", originQuarter);
                    } else {
                        dateMap.put("quarter", thursdayQuarter);
                    }
                } else {
                    //跨年的话说明这周属于明年的1月（第一季度）
                    dateMap.put("year", originYear + 1);
                    dateMap.put("month", 1);
                    dateMap.put("quarter", 1);
                }
            }
            return dateMap;
        }
        return dateMap;
    }

    /**
     * 获取当前月份第一天
     *
     * @return
     */
    public static String getMonthFirstDay() {
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.add(Calendar.MONTH, 0);
        String format = new SimpleDateFormat("yyyy-MM-dd").format(calendar.getTime());
        return format;
    }

    /**
     * 计算季度开始、结束时间
     * 原则：周五为本周的第一天，下一周的周四为本周的最后一天
     *
     * @param year
     * @param quarter
     */
    public static Map<String, String> quarterStartEndDate(int year, int quarter) {
        Map<String, String> quarterStartEndDateMap = new HashMap<>();

        Date startDate = null;
        Date endDate = null;

        int startMonth = 0;
        int endMonth = 0;

        if (quarter == 1) {
            startMonth = 1;
            endMonth = 3;
        } else if (quarter == 2) {
            startMonth = 4;
            endMonth = 6;
        } else if (quarter == 3) {
            startMonth = 7;
            endMonth = 9;
        } else {
            startMonth = 10;
            endMonth = 12;
        }

        //判断季度第一天的时间（以周为单位，有可能是上个月，也有可能是本月的非1号）
        Calendar calendar1 = new GregorianCalendar();
        calendar1.set(Calendar.YEAR, year);
        calendar1.set(Calendar.MONTH, startMonth - 1);
        calendar1.set(Calendar.DATE, 1);
        calendar1.setFirstDayOfWeek(Calendar.FRIDAY);

        //如果季度第一个月的第一天是周二周三周四，那么这周应该归属于上个季度，否则这周（包括上个月的时间）归属于这个季度
        int firstDateWeek = calendar1.get(Calendar.DAY_OF_WEEK);
        if (firstDateWeek == 5 || firstDateWeek == 3 || firstDateWeek == 4) {
            calendar1.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
            startDate = DateUtils.addDay(calendar1.getTime(), 1);
        } else {
            calendar1.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
            startDate = calendar1.getTime();
        }

        //判断季度最后一天的时间（以周为单位，有可能是下个月，也有可能是本月的非最后一天）
        Calendar calendar2 = new GregorianCalendar();
        calendar2.set(Calendar.YEAR, year);
        calendar2.set(Calendar.MONTH, endMonth - 1);
        calendar2.set(Calendar.DATE, 1);
        calendar2.setFirstDayOfWeek(Calendar.FRIDAY);

        //如果一个季度最后一个月最后一天是周五、周六、周日，则这个月最后一周属于下个季度
        calendar2.set(Calendar.DATE, calendar2.getActualMaximum(Calendar.DATE));
        int lastDateWeek = calendar2.get(Calendar.DAY_OF_WEEK);
        if (lastDateWeek == 1 || lastDateWeek == 7 || lastDateWeek == 6) {
            calendar2.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
            endDate = DateUtils.addDay(calendar2.getTime(), -1);
        } else {
            calendar2.set(Calendar.DAY_OF_WEEK, Calendar.THURSDAY);
            endDate = calendar2.getTime();
        }

        DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        quarterStartEndDateMap.put("startDate", sdf.format(startDate));
        quarterStartEndDateMap.put("endDate", sdf.format(endDate));
        return quarterStartEndDateMap;
    }

    /**
     * 获取上个季度的年度和季度数
     *
     * @param date
     * @return
     */
    public static Map<String, Integer> lastQuarter(Date date) {
        Map<String, Integer> resultMap = new HashMap<>();
        //获取当天所在
        Map<String, Integer> yearQuarter = getYearQuarter(date);
        Integer year = yearQuarter.get("year");
        Integer quarter = yearQuarter.get("quarter");

        Integer lastyear = 0;
        Integer lastQuarter = 0;

        if (quarter == 4 || quarter == 3 || quarter == 2) {
            lastyear = year;
            lastQuarter = quarter - 1;
        } else {
            lastyear = year - 1;
            lastQuarter = 4;
        }

        resultMap.put("year", lastyear);
        resultMap.put("quarter", lastQuarter);

        return resultMap;
    }

    /***
     * 两日期之间相差天数
     * @param dateStart
     * @param dateEnd
     * @return
     */
    public static long getDiscrepantDays(String dateStart, String dateEnd) {
        //设置转换的日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //结束时间
        Date startDate = null;
        Date endDate = null;
        try {
            //开始时间
            startDate = sdf.parse(dateStart);
            endDate = sdf.parse(dateEnd);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        //得到相差的天数 betweenDate
        return (endDate.getTime() - startDate.getTime()) / (60 * 60 * 24 * 1000);
    }

    /***
     * 两个日期之间间隔的月数（不考虑日期的情况）
     */
    public static int calDiffMonth(Date start, Date end) {
        GregorianCalendar startCalendar = new GregorianCalendar();
        startCalendar.setTime(start);
        GregorianCalendar endCalendar = new GregorianCalendar();
        endCalendar.setTime(end);
        int startYear = startCalendar.get(Calendar.YEAR);
        int startMonth = startCalendar.get(Calendar.MONTH) + 1;
        int endYear = endCalendar.get(Calendar.YEAR);
        int endMonth = endCalendar.get(Calendar.MONTH) + 1;
        return (endYear - startYear) * 12 + (endMonth - startMonth);
    }

    public static int getDaysOfMonth(int year, int month) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(year, month - 1, 1);
        return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
    }

    public static int getFirstDateOfMonth(int year, int month) {
        Calendar calendar = Calendar.getInstance();
        calendar.set(year, month - 1, 1);
        return calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
    }

    /**
     * 获取指定日期下个月的第一天
     *
     * @param dateStr
     * @param format
     * @return
     */
    public static Map<String, String> getMaxMinDaysOfAddMonth(String dateStr, String format, int addMonth) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Map<String, String> dateMap = new HashMap<>();
        try {
            Date date = sdf.parse(dateStr);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.MONTH, addMonth);
            calendar.set(Calendar.DAY_OF_MONTH, 1);
            dateMap.put("startDate", sdf.format(calendar.getTime()));

            calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DATE));
            dateMap.put("endDate", sdf.format(calendar.getTime()));
            return dateMap;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }


    public static int dateDiff(String start, String end) {
        //设置转换的日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //开始时间
        Date startDate = null;
        Date endDate = null;
        try {
            startDate = sdf.parse(start);
            endDate = sdf.parse(end);
        } catch (ParseException e) {
            e.printStackTrace();
        }

        //得到相差的天数 betweenDate
        long betweenDate = (endDate.getTime() - startDate.getTime()) / (60 * 60 * 24 * 1000);
        return (int) betweenDate;
    }

    /**
     * 判断两个日期间隔是否大于半年
     *
     * @return
     */
    public static boolean isMoreSixMonth(String startDate, String endDate) throws ParseException {
        Calendar c = Calendar.getInstance();
        c.setTime(Objects.requireNonNull(parseDate(startDate, SystemDateConstant.yyyy_MM_dd)));
        long time1 = c.getTimeInMillis();
        c.setTime(Objects.requireNonNull(parseDate(endDate, SystemDateConstant.yyyy_MM_dd)));
        long time2 = c.getTimeInMillis();
        long betweenDays = (time2 - time1) / (1000 * 3600 * 24);
        int day = Integer.parseInt(String.valueOf(betweenDays));
        return day > 180;
    }

    public static List<Date> findDates(Date dBegin, Date dEnd) {
        List<Date> lDate = new ArrayList<>();
        lDate.add(dBegin);
        Calendar calBegin = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calBegin.setTime(dBegin);
        Calendar calEnd = Calendar.getInstance();
        // 使用给定的 Date 设置此 Calendar 的时间
        calEnd.setTime(dEnd);
        // 测试此日期是否在指定日期之后
        while (dEnd.after(calBegin.getTime())) {
            // 根据日历的规则，为给定的日历字段添加或减去指定的时间量
            calBegin.add(Calendar.DAY_OF_MONTH, 1);
            lDate.add(calBegin.getTime());
        }
        return lDate;
    }

    /**
     * 以time为节点，获取前几天的日期 yyyy-MM-dd
     *
     * @param
     * @return java.lang.String
     * @throws
     * @author ZHAOXA
     */
    public static String getLastDay(String time, int days) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        Date date = null;
        try {
            date = sdf.parse(time);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        calendar.setTime(date);
        int day = calendar.get(Calendar.DATE);
        //                      此处修改为+1则是获取后一天
        calendar.set(Calendar.DATE, day - days);

        String lastDay = sdf.format(calendar.getTime());
        return lastDay;
    }

    /**
     * 获取当月1号零时零分的时间
     *
     * @param
     * @return java.lang.String
     * @throws
     * @author ZHAOXA
     */
    public static String initDateByMonth() {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(new Date());
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(calendar.getTime());
    }

    /**
     * 根据数字查询本周对应的日期
     * 1-7对应周一~周天
     *
     * @param
     * @return java.lang.String
     * @throws
     * @author ZHAOXA
     */
    public static String getdateFromWeek(int number) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();

        while (calendar.get(Calendar.DAY_OF_WEEK) != Calendar.MONDAY) {
            calendar.add(Calendar.DAY_OF_WEEK, -1);
        }
        for (int i = 1; i <= 7; i++) {
            if (number == i) {
                return sdf.format(calendar.getTime());
            }
            calendar.add(Calendar.DAY_OF_MONTH, 1);
        }
        return null;
    }

    /**
     * 获取两个日期之间的所有日期集合
     *
     * @param
     * @return java.util.List<java.lang.String>
     * @throws
     * @author ZHAOXA
     */
    public static List<String> getDays(String startTime, String endTime) {
        // 返回的日期集合
        List<String> days = new ArrayList<String>();
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date start = dateFormat.parse(startTime);
            Date end = dateFormat.parse(endTime);

            Calendar tempStart = Calendar.getInstance();
            tempStart.setTime(start);

            Calendar tempEnd = Calendar.getInstance();
            tempEnd.setTime(end);
            tempEnd.add(Calendar.DATE, +1);// 日期加1(包含结束)
            while (tempStart.before(tempEnd)) {
                days.add(dateFormat.format(tempStart.getTime()));
                tempStart.add(Calendar.DAY_OF_YEAR, 1);
            }

        } catch (ParseException e) {
            e.printStackTrace();
        }

        return days;
    }

    /**
     * 判断time是否在from，to之内
     *
     * @param time 指定日期
     * @param from 开始日期
     * @param to   结束日期
     * @throws
     */
    public static boolean checkTimeLimit(Date time, Date from, Date to) {
        Calendar date = Calendar.getInstance();
        date.setTime(time);

        Calendar after = Calendar.getInstance();
        after.setTime(from);

        Calendar before = Calendar.getInstance();
        before.setTime(to);

        if (date.after(after) && date.before(before)) {
            return true;
        } else {
            return false;
        }
    }
}


