package com.common.core.utils;

import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DateUtils {
    /**
     * 年-月-日 时:分:秒 时间格式
     */
    public static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss";
    /**
     * 年-月-日 时:分 时间格式
     */
    public static final String DATE_TIME_MINUTE_FORMAT = "yyyy-MM-dd HH:mm";
    /**
     * 年/月/日 时:分 时间格式
     */
    public static final String DATE_TIME_MINUTE_FORMAT1 = "yyyy/MM/dd HH:mm";
    /**
     * 日/月/年 时:分 时间格式
     */
    public static final String DATE_TIME_MINUTE_FORMAT2 = "dd/MM/yyyy HH:mm";
    /**
     * 2020-08-09T02:35:20.000+0000 格林威治时间
     */
    public static final String DATE_TIME_GL_ST_FORMAT = "yyyy-MM-dd'T'hh:mm:ss.SSSZ";

    public static final String DATE_TIME_GL_ST_FORMAT_ZT = "yyyy-MM-dd'T'HH:mm:ssXXX";
    public static final String DATE_TIME_GL_ST_FORMAT_ZT_1 = "yyyy-MM-dd'T'HH:mm:ss'Z'";
    /**
     * 年-月-日 时间格式
     */
    public static final String DATE_FORMAT = "yyyy-MM-dd";

    /**
     * 年-月-日 时间格式
     */
    public static final String YEAR_MONTH_FORMAT = "yyyy-MM-";

    /**
     * 小时格式
     */
    public static final String HOUR_FORMAT = "HH";
    /**
     * 年月日 时间格式
     */
    public static final String DATE_FORMAT_NO_SPACER = "yyyyMMdd";
    /**
     * 月日 时间格式
     */
    public static final String MONTH_DAY_FORMAT_NO_SPACER = "MMdd";
    /**
     * 年月 时间格式
     */
    public static final String YEAR_MONTH_FORMAT_NO_SPACER = "yyyyMM";

    public static final String YEAR_FORMAT = "yyyy";

    public static final String MONTH_FORMAT = "MM";

    public static final String DAY_OF_MONTH_FORMAT = "dd";

    public static final String BJ_TIME_ZONE = "+8";

    /**
     * 默认格式化类型集合
     */
    public static final Map<Pattern, String> SUPPORT_FORMAT_MAP;
    /**
     * 年-月-日T时:分:秒+时:分 时间格式正则匹配表达式
     */
    private static final Pattern DATE_TIME_PATTERN_ZT = Pattern.compile("^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\\b\\+[0-9]{2}:[0-9]{2}$");
    /**
     * 年-月-日 时:分:秒 时间格式正则匹配表达式
     */
    private static final Pattern DATE_TIME_PATTERN = Pattern.compile("^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}:[0-9]{2}$");
    /**
     * 年-月-日 时:分 时间格式正则匹配表达式
     */
    private static final Pattern DATE_TIME_MINUTE_PATTERN = Pattern.compile("^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}$");
    /**
     * 年/月/日 时:分 时间格式正则匹配表达式
     */
    private static final Pattern DATE_TIME_MINUTE_PATTERN1 = Pattern.compile("^[0-9]{4}/[0-9]{2}/[0-9]{2} [0-9]{2}:[0-9]{2}$");
    /**
     * 日/月年 时:分 时间格式正则匹配表达式
     */
    private static final Pattern DATE_TIME_MINUTE_PATTERN2 = Pattern.compile("[0-9]{2}/[0-9]{2}/^[0-9]{4} [0-9]{2}:[0-9]{2}$");

    /**
     * 年-月-日 时间格式正则匹配表达式
     */
    private static final Pattern DATE_PATTERN = Pattern.compile("^[0-9]{4}-[0-9]{2}-[0-9]{2}$");
    /**
     * 年月日 时间格式正则匹配表达式
     */
    private static final Pattern DATE_PATTERN_NO_SPACER = Pattern.compile("^[0-9]{4}[0-9]{2}[0-9]{2}$");
    /**
     * 月日 时间格式正则匹配表达式
     */
    private static final Pattern MONTH_DAY_PATTERN_NO_SPACER = Pattern.compile("^[0-9]{2}[0-9]{2}$");
    /**
     * 年日 时间格式正则匹配表达式
     */
    private static final Pattern YEAR_MONTH_PATTERN_NO_SPACER = Pattern.compile("^[0-9]{4}[0-9]{2}$");

    /**
     * 3
     */
    private static final Integer NUM_3 = 3;

    /**
     * 5
     */
    private static final Integer NUM_5 = 5;

    static {
        SUPPORT_FORMAT_MAP = new ConcurrentHashMap<Pattern, String>();
        SUPPORT_FORMAT_MAP.put(DATE_TIME_PATTERN, DATE_TIME_FORMAT);
        SUPPORT_FORMAT_MAP.put(DATE_TIME_MINUTE_PATTERN, DATE_TIME_MINUTE_FORMAT);
        SUPPORT_FORMAT_MAP.put(DATE_TIME_MINUTE_PATTERN1, DATE_TIME_MINUTE_FORMAT1);
        SUPPORT_FORMAT_MAP.put(DATE_TIME_MINUTE_PATTERN2, DATE_TIME_MINUTE_FORMAT2);
        SUPPORT_FORMAT_MAP.put(DATE_PATTERN, DATE_FORMAT);
        SUPPORT_FORMAT_MAP.put(DATE_PATTERN_NO_SPACER, DATE_FORMAT_NO_SPACER);
        SUPPORT_FORMAT_MAP.put(YEAR_MONTH_PATTERN_NO_SPACER, YEAR_MONTH_FORMAT_NO_SPACER);
        SUPPORT_FORMAT_MAP.put(MONTH_DAY_PATTERN_NO_SPACER, MONTH_DAY_FORMAT_NO_SPACER);
        SUPPORT_FORMAT_MAP.put(DATE_TIME_PATTERN_ZT, DATE_TIME_GL_ST_FORMAT_ZT);
    }

    /**
     * 字符串转日期类型
     *
     * @param dateString
     * @return
     */
    public static Date convert(String dateString) {
        Date date = null;
        if (StringUtils.isEmpty(dateString)) {
            return null;
        }
        for (Pattern pattern : SUPPORT_FORMAT_MAP.keySet()) {
            Matcher matcher = pattern.matcher(dateString);
            if (matcher.matches()) {
                try {
                    String format = SUPPORT_FORMAT_MAP.get(pattern);
                    SimpleDateFormat sdf = new SimpleDateFormat(format);
                    sdf.setLenient(false);
                    date = sdf.parse(dateString);
                } catch (ParseException ignored) {

                }
                break;
            }
        }
        return date;
    }

    /**
     * 带时区字符串转日期类型
     *
     * @param dateString
     * @return
     */
    public static Date timeZoneConvert(String dateString) {
        Date date = null;
        if (StringUtils.isNotBlank(dateString)) {
            Matcher matcher = DATE_TIME_PATTERN_ZT.matcher(dateString);
            if (matcher.matches()) {
                try {
                    String format = SUPPORT_FORMAT_MAP.get(DATE_TIME_PATTERN_ZT);
                    SimpleDateFormat sdf = new SimpleDateFormat(format);
                    sdf.setLenient(false);
                    date = sdf.parse(dateString);
                } catch (ParseException ignored) {
                }
            }
        }
        return date;
    }

    /**
     * 根据格式，转化字符串为日期
     *
     * @param dateString
     * @param format
     * @return
     */
    public static Date convert(String dateString, String format) {
        if (StringUtils.isBlank(dateString)) {
            return null;
        }
        boolean matches = false;
        for (String fmt : SUPPORT_FORMAT_MAP.values()) {
            if (fmt.equals(format)) {
                matches = true;
                break;
            }
        }
        if (!matches) {
            throw new IllegalArgumentException(format + " is not a valid date format");
        }
        Date date = null;
        try {
            date = new SimpleDateFormat(format).parse(dateString);
        } catch (ParseException ignored) {

        }
        return date;
    }

    /**
     * 根据格式，转化字符串为日期
     *
     * @param dateString
     * @param format
     * @return
     */
    public static Date convertSimple(String dateString, String format) {
        if (StringUtils.isBlank(dateString)) {
            return null;
        }
        Date date = null;
        try {
            date = new SimpleDateFormat(format).parse(dateString);
        } catch (ParseException ignored) {

        }
        return date;
    }

    /**
     * 根据时间字符串解析成Date对象，该方法会自适应时间字符串格式
     *
     * @param dateText 时间字符串
     */
    public static Date parse(String dateText) {
        return DateUtils.convert(dateText);
    }

    /**
     * 根据时间字符串，解析成指定格式的的Date对象
     *
     * @param dateText 时间字符串
     * @param format   指定解析格式
     */
    public static Date parse(String dateText, String format) {
        return DateUtils.convert(dateText, format);
    }

    /**
     * 格式化日期为yyyy-MM-dd HH:mm:ss格式字符串
     *
     * @param date 日期对象
     */
    public static String format(Date date) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        simpleDateFormat.applyPattern(DATE_TIME_FORMAT);
        return simpleDateFormat.format(date);
    }

    /**
     * 格式化日期为指定格式字符串
     *
     * @param date 日期对象
     */
    public static String format(Date date, String pattern) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        simpleDateFormat.applyPattern(pattern);
        return simpleDateFormat.format(date);
    }

    /**
     * 格式化日期为指定格式字符串
     *
     * @param date 日期对象
     */
    public static String formatToUtc(Date date, String pattern) {
        SimpleDateFormat df = new SimpleDateFormat(pattern);
        df.setTimeZone(new SimpleTimeZone(0, "UTC"));
        return df.format(date);
    }

    /**
     * 格式化日期为yyyy-MM-dd HH:mm:ss格式字符串
     *
     * @param timestamp 时间戳
     */
    public static String format(long timestamp) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        simpleDateFormat.applyPattern(DATE_TIME_FORMAT);
        return simpleDateFormat.format(DateUtils.newDate(timestamp));
    }

    /**
     * 格式化日期为指定格式字符串
     *
     * @param timestamp 时间戳
     */
    public static String format(long timestamp, String pattern) {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
        simpleDateFormat.applyPattern(pattern);
        return simpleDateFormat.format(DateUtils.newDate(timestamp));
    }

    /**
     * 格式化日期为时间戳
     */
    public static long format(String dateText) {
        if (StringUtils.isEmpty(dateText)) {
            return 0L;
        }
        Date date=DateUtils.convert(dateText);
        return date==null ? 0L : date.getTime();
    }

    /**
     * 获取当前时间的日期对象
     */
    public static Date now() {
        return DateUtils.newDate(DateUtils.nowTimestamp());
    }

    /**
     * 获取当前时间时间戳
     */
    public static long nowTimestamp() {
        return System.currentTimeMillis();
    }

    /**
     * 根据时间戳创建日期对象
     *
     * @param timestamp 时间戳
     */
    public static Date newDate(long timestamp) {
        return new Date(timestamp);
    }

    /**
     * 根据指定时间创建日期对象
     *
     * @param year        年
     * @param month       月
     * @param day         日
     * @param hour        时
     * @param minute      分
     * @param second      秒
     * @param millisecond 毫秒
     */
    public static Date newDate(int year, int month, int day, int hour, int minute, int second, int millisecond) {
        DateTime dateTime = new DateTime(year, month, day, hour, minute, second, millisecond);
        return dateTime.toDate();
    }

    /**
     * 根据指定时间创建日期对象
     *
     * @param year   年
     * @param month  月
     * @param day    日
     * @param hour   时
     * @param minute 分
     * @param second 秒
     */
    public static Date newDate(int year, int month, int day, int hour, int minute, int second) {
        return DateUtils.newDate(year, month, day, hour, minute, second, 0);
    }

    /**
     * 根据指定时间创建日期对象
     *
     * @param year   年
     * @param month  月
     * @param day    日
     * @param hour   时
     * @param minute 分
     */
    public static Date newDate(int year, int month, int day, int hour, int minute) {
        return DateUtils.newDate(year, month, day, hour, minute, 0, 0);
    }

    /**
     * 根据指定时间创建日期对象
     *
     * @param year  年
     * @param month 月
     * @param day   日
     * @param hour  时
     */
    public static Date newDate(int year, int month, int day, int hour) {
        return DateUtils.newDate(year, month, day, hour, 0, 0, 0);
    }

    /**
     * 根据指定时间创建日期对象
     *
     * @param year  年
     * @param month 月
     * @param day   日
     */
    public static Date newDate(int year, int month, int day) {
        return DateUtils.newDate(year, month, day, 0, 0, 0, 0);
    }

    /**
     * 日期加减 年月日时分秒毫秒数 正数加负数减
     *
     * @param date         日期
     * @param years        加减年数
     * @param months       加减月数
     * @param days         加减天数
     * @param hours        加减小时数
     * @param minutes      加减分钟数
     * @param seconds      加减秒数
     * @param milliseconds 加减毫秒数
     */
    public static Date add(Date date, int years, int months, int days, int hours, int minutes, int seconds, int milliseconds) {
        return DateUtils.add(date.getTime(), years, months, days, hours, minutes, seconds, milliseconds);
    }

    /**
     * 日期加减 年月日时分秒毫秒数 正数加负数减
     *
     * @param timestamp    时间戳
     * @param years        加减年数，如：1、-1
     * @param months       加减月数，如：1、-1
     * @param days         加减天数，如：1、-1
     * @param hours        加减小时数，如：1、-1
     * @param minutes      加减分钟数，如：1、-1
     * @param seconds      加减秒数，如：1、-1
     * @param milliseconds 加减毫秒数，如：1、-1
     */
    public static Date add(long timestamp, int years, int months, int days, int hours, int minutes, int seconds, int milliseconds) {
        int zero = 0;
        DateTime dateTime = new DateTime(timestamp);
        if (zero != years) {
            dateTime = dateTime.plusYears(years);
        }
        if (zero != months) {
            dateTime = dateTime.plusMonths(months);
        }
        if (zero != days) {
            dateTime = dateTime.plusDays(days);
        }
        if (zero != hours) {
            dateTime = dateTime.plusHours(hours);
        }
        if (zero != minutes) {
            dateTime = dateTime.plusMinutes(minutes);
        }
        if (zero != seconds) {
            dateTime = dateTime.plusSeconds(seconds);
        }
        if (zero != milliseconds) {
            dateTime = dateTime.plusMillis(milliseconds);
        }
        return dateTime.toDate();
    }

    /**
     * 获取本周的第一天
     *
     * @return Long
     **/
    public static Long getWeekStart(long timestamp) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(timestamp);
        Integer date = cal.get(Calendar.DATE);
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        if (cal.get(Calendar.DATE) > date) {
            cal.add(Calendar.DATE, -7);
        }
        Date time = cal.getTime();
        return format(new SimpleDateFormat("yyyy-MM-dd").format(time) + " 00:00:00");
    }

    /**
     * 获取本周的最后一天
     *
     * @return Long
     **/
    public static Long getWeekEnd(long timestamp) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(timestamp);
        Integer date = cal.get(Calendar.DATE);
        cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
        if (cal.get(Calendar.DATE) < date) {
            cal.add(Calendar.DATE, 7);
        }
        Date time = cal.getTime();
        return format(new SimpleDateFormat("yyyy-MM-dd").format(time) + " 23:59:59");
    }

    /**
     * 获取本天的最后一秒
     *
     * @return Long
     **/
    public static Date getDayEnd(Date date) {
        if (date == null) {
            return null;
        }
        return parse(new SimpleDateFormat("yyyy-MM-dd").format(date.getTime()) + " 23:59:59");
    }

    /**
     * 获取本天的第一秒
     *
     * @return Long
     **/
    public static Date getDayStart(Date date) {
        if (date == null) {
            return null;
        }
        return parse(new SimpleDateFormat("yyyy-MM-dd").format(date.getTime()) + " 00:00:00");
    }

    /**
     * 根据时间戳获取版本号，Calendar取周是从周日开始计算，需要进行修改为以周一为准
     *
     * @param timestamp 时间戳
     * @return 版本号
     */
    public static Integer getDateVersion(long timestamp) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(timestamp);
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.setMinimalDaysInFirstWeek(4);
        return calendar.get(Calendar.YEAR) * 1000 + calendar.get(Calendar.WEEK_OF_YEAR);
    }

    /**
     * 获取当前时间的版本号
     *
     * @return 版本号
     */
    public static Integer getNowVersion() {
        return getDateVersion(nowTimestamp());
    }


    /**
     * 获取年月周
     *
     * @return String
     **/
    public static Map<String, String> getYearMonthWeekStr(long timestamp) {
        // 当月第一天
        Calendar firstDay = Calendar.getInstance();
        firstDay.setTimeInMillis(timestamp);
        firstDay.set(Calendar.DAY_OF_MONTH, 1);

        // 当月最后一天
        Calendar lastDay = Calendar.getInstance();
        lastDay.setTimeInMillis(timestamp);
        lastDay.add(Calendar.MONTH, 1);
        lastDay.set(Calendar.DAY_OF_MONTH, 0);

        // 第一个周日
        Calendar firsSunday = Calendar.getInstance();
        firsSunday.setTimeInMillis(firstDay.getTimeInMillis());
        firsSunday.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
        if (firsSunday.getTimeInMillis() != firstDay.getTimeInMillis()) {
            firsSunday.add(Calendar.DATE, 7);
        }


        // 最后一个周一
        Calendar lastMonday = Calendar.getInstance();
        lastMonday.setTimeInMillis(lastDay.getTimeInMillis());
        lastMonday.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        if (lastMonday.getTimeInMillis() > lastDay.getTimeInMillis()) {
            lastMonday.add(Calendar.DATE, -7);
        }

        String year = "";
        String month = "";
        String week = "";
        DateFormat df = new SimpleDateFormat("MMM", Locale.ENGLISH);
        if (firsSunday.getTimeInMillis() >= timestamp) {
            // 三天以上算本月
            if (firsSunday.get(Calendar.DATE) > NUM_3) {
                Calendar cal = Calendar.getInstance();
                cal.setTimeInMillis(timestamp);
                year = cal.get(Calendar.YEAR) + "";
                month = df.format(cal.getTime());

                week = cal.get(Calendar.WEEK_OF_MONTH) + "th Week";
            } else {
                // 三天以内算上月
                // 上月第一天
                Calendar preFirstDay = Calendar.getInstance();
                preFirstDay.setTimeInMillis(timestamp);
                preFirstDay.set(Calendar.DAY_OF_MONTH, 1);
                preFirstDay.add(Calendar.MONTH, -1);

                // 上月第一个周日
                Calendar preFirsSunday = Calendar.getInstance();
                preFirsSunday.setTimeInMillis(preFirstDay.getTimeInMillis());
                preFirsSunday.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
                if (preFirsSunday.getTimeInMillis() != preFirstDay.getTimeInMillis()) {
                    preFirsSunday.add(Calendar.DATE, 7);
                }

                // 上月最后一天
                Calendar preLastDay = Calendar.getInstance();
                preLastDay.setTimeInMillis(firstDay.getTimeInMillis());
                preLastDay.add(Calendar.DATE, -1);

                year = preLastDay.get(Calendar.YEAR) + "";
                month = df.format(preLastDay.getTime());
                if (preFirsSunday.get(Calendar.DATE) > NUM_3) {
                    week = preLastDay.get(Calendar.WEEK_OF_MONTH) + "th Week";
                } else {
                    week = (preLastDay.get(Calendar.WEEK_OF_MONTH) - 1) + "th Week";
                }
            }
        } else if (lastMonday.getTimeInMillis() <= timestamp) {
            // 本月在最后一周占4天及以上
            if (lastDay.get(Calendar.DAY_OF_WEEK) >= NUM_5 || lastDay.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
                Calendar cal = Calendar.getInstance();
                cal.setTimeInMillis(timestamp);
                year = cal.get(Calendar.YEAR) + "";
                month = df.format(cal.getTime());
                if (firsSunday.get(Calendar.DATE) > NUM_3) {
                    week = cal.get(Calendar.WEEK_OF_MONTH) + "th Week";
                } else {
                    week = (cal.get(Calendar.WEEK_OF_MONTH) - 1) + "th Week";
                }
            } else {
                // 下月第一天
                Calendar nextFirstDay = Calendar.getInstance();
                nextFirstDay.setTimeInMillis(timestamp);
                nextFirstDay.add(Calendar.MONTH, 1);
                nextFirstDay.set(Calendar.DAY_OF_MONTH, 1);

                year = nextFirstDay.get(Calendar.YEAR) + "";
                month = df.format(nextFirstDay.getTime());
                week = nextFirstDay.get(Calendar.WEEK_OF_MONTH) + "th Week";
            }
        } else {
            Calendar cal = Calendar.getInstance();
            cal.setTimeInMillis(timestamp);

            year = cal.get(Calendar.YEAR) + "";
            month = df.format(cal.getTime());
            if (firsSunday.get(Calendar.DATE) > NUM_3) {
                week = cal.get(Calendar.WEEK_OF_MONTH) + "th Week";
            } else {
                week = (cal.get(Calendar.WEEK_OF_MONTH) - 1) + "th Week";
            }
        }

        Map<String, String> result = new HashMap<String, String>();
        result.put("year", year);
        result.put("month", month);
        result.put("week", week);
        return result;
    }

    /**
     * 添加年份
     *
     * @param date
     * @param years
     * @return
     */
    public static Date addYears(Date date, int years) {
        return DateUtils.addYears(date.getTime(), years);
    }

    /**
     * 添加年份
     *
     * @param timestamp
     * @param years
     * @return
     */
    public static Date addYears(long timestamp, int years) {
        return DateUtils.add(timestamp, years, 0, 0, 0, 0, 0, 0);
    }

    /**
     * 添加月份
     *
     * @param date
     * @param months
     * @return
     */
    public static Date addMonths(Date date, int months) {
        return DateUtils.addMonths(date.getTime(), months);
    }

    /**
     * 添加月份
     *
     * @param timestamp
     * @param months
     * @return
     */
    public static Date addMonths(long timestamp, int months) {
        return DateUtils.add(timestamp, 0, months, 0, 0, 0, 0, 0);
    }

    /**
     * 添加日期
     *
     * @param date
     * @param days
     * @return
     */
    public static Date addDays(Date date, int days) {
        return DateUtils.addDays(date.getTime(), days);
    }

    /**
     * 添加日期
     *
     * @param timestamp
     * @param days
     * @return
     */
    public static Date addDays(long timestamp, int days) {
        return DateUtils.add(timestamp, 0, 0, days, 0, 0, 0, 0);
    }

    /**
     * 添加小时
     *
     * @param date
     * @param hours
     * @return
     */
    public static Date addHours(Date date, int hours) {
        return DateUtils.addHours(date.getTime(), hours);
    }

    /**
     * 添加小时
     *
     * @param timestamp
     * @param hours
     * @return
     */
    public static Date addHours(long timestamp, int hours) {
        return DateUtils.add(timestamp, 0, 0, 0, hours, 0, 0, 0);
    }

    /**
     * 添加分钟
     *
     * @param date
     * @param minutes
     * @return
     */
    public static Date addMinutes(Date date, int minutes) {
        return DateUtils.addMinutes(date.getTime(), minutes);
    }

    /**
     * 添加分钟
     *
     * @param timestamp
     * @param minutes
     * @return
     */
    public static Date addMinutes(long timestamp, int minutes) {
        return DateUtils.add(timestamp, 0, 0, 0, 0, minutes, 0, 0);
    }

    /**
     * 获取当前月份
     *
     * @return
     */
    public static int getCurrentMonth() {
        DateTime dateTime = DateTime.now();
        return dateTime.getMonthOfYear();
    }

    /**
     * 通过时间秒毫秒数判断两个时间的间隔
     *
     * @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;
    }

    /**
     * 取两个日期的中间日期,默认取大
     *
     * @param start
     * @param end
     * @return
     */
    public static Date getMeddleDate(Date start, Date end) {
        int days = (int) ((end.getTime() - start.getTime()) / (1000 * 3600 * 24));
        return DateUtils.addDays(start, (int) Math.floor(Double.valueOf(days) / 2));
    }

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

    /**
     * 按日期递增规则生成分区列表
     *
     * @param start
     * @param end
     * @return
     */
    public static List<String> generateDayList(String start, String end, String pattern) {
        List<String> partitionList = new ArrayList<String>();
        partitionList.add(start);
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        Date startDate;
        Date endDate;
        try {
            startDate = sdf.parse(start);
            endDate = sdf.parse(end);
        } catch (Exception e) {

            return null;
        }
        Calendar startCal = Calendar.getInstance();
        Calendar endCal = Calendar.getInstance();
        startCal.setTime(startDate);
        endCal.setTime(endDate);
        while (startCal.before(endCal)) {
            startCal.add(Calendar.DAY_OF_MONTH, 1);
            partitionList.add(sdf.format(startCal.getTime()));
        }
        return partitionList;
    }

    /**
     * 格式化utc时间
     *
     * @param utcDate
     * @return
     */
    public static String formatUtcDate(String utcDate) {
        DateFormat df = new SimpleDateFormat(DateUtils.DATE_TIME_GL_ST_FORMAT);
        DateFormat df2 = new SimpleDateFormat(DateUtils.DATE_TIME_FORMAT);

        Date date = null;
        try {
            date = df.parse(utcDate);
        } catch (ParseException e) {
            return utcDate;
        }
        return df2.format(date);
    }

    /**
     * 变更日期字符串格式
     *
     * @return
     */
    public static String convertDateStrPattern(String dateStr, String sourcePattern, String targetPattern) {
        DateFormat df = new SimpleDateFormat(sourcePattern);
        DateFormat df2 = new SimpleDateFormat(targetPattern);

        Date date = null;
        try {
            date = df.parse(dateStr);
        } catch (ParseException e) {
            return null;
        }
        return df2.format(date);
    }

    /**
     * 格式化utc时间
     *
     * @param localDate
     * @return
     */
    public static Date localToUTC(Date localDate) {
        long localTimeInMillis = localDate.getTime();
        Calendar calendar = Calendar.getInstance();
        calendar.setTimeInMillis(localTimeInMillis);
        int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);
        int dstOffset = calendar.get(Calendar.DST_OFFSET);
        calendar.add(Calendar.MILLISECOND, -(zoneOffset + dstOffset));
        Date utcDate = new Date(calendar.getTimeInMillis());
        return utcDate;
    }

    /**
     * @param date1
     * @param date2
     * @return
     */
    public static int differentDays(Date date1, Date date2) {
        Calendar cal1 = Calendar.getInstance();
        cal1.setTime(date1);

        Calendar cal2 = Calendar.getInstance();
        cal2.setTime(date2);
        int day1 = cal1.get(Calendar.DAY_OF_YEAR);
        int day2 = cal2.get(Calendar.DAY_OF_YEAR);

        int year1 = cal1.get(Calendar.YEAR);
        int year2 = cal2.get(Calendar.YEAR);
        if (year1 != year2) {
            int timeDistance = 0;
            for (int i = year1; i < year2; i++) {
                if (i % 4 == 0 && i % 100 != 0 || i % 400 == 0) {//闰年
                    timeDistance += 366;
                } else {//不是闰年
                    timeDistance += 365;
                }
            }
            return timeDistance + (day2 - day1);
        } else { //不同年

            System.out.println("判断day2 - day1 : " + (day2 - day1));
            return day2 - day1;
        }
    }

    public static Long timestamp2dateLong(Long timestamp) {
        return DateUtils.format(DateUtils.format(timestamp).substring(0, 10));
    }

    public static boolean isValidDate(String str, String pattern) {
        boolean convertSuccess = true;
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        try {
            // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
            format.setLenient(false);
            format.parse(str);
        } catch (ParseException e) {
            convertSuccess = false;
        }
        return convertSuccess;
    }
}