package com.ynxbd.common.helper.common;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.time.DateUtils;

import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;

@Slf4j
public class DateHelper {

    public enum DateEnum {
        yyyy_MM_dd_HH_mm_ss("yyyy-MM-dd HH:mm:ss"),
        yyyy_MM_dd("yyyy-MM-dd"),
        HH_mm_ss("HH:mm:ss"),
        HH_mm_ss_SSS("HH:mm:ss:SSS"),
        HH_mm("HH:mm"),
        //============================
        yyyyMMddHHmmss("yyyyMMddHHmmss"),
        yyyyMMdd("yyyyMMdd"),
        HHmmss("HHmmss"),
        yyyy("yyyy"),
        MM("MM"),
        dd("dd"),
        HH("HH"),
        mm("mm"),
        ss("ss");

        public final String TYPE;

        DateEnum(String TYPE) {
            this.TYPE = TYPE;
        }
    }

    public static LocalDateTime strToLocalDateTime(String date) {
        try {
            return LocalDateTime.parse(date, DateTimeFormatter.ofPattern(DateEnum.yyyy_MM_dd_HH_mm_ss.TYPE));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 计算毫秒是几分钟
     *
     * @param millisecond 毫秒
     * @return 时间
     */
    public static String getMillisecondToMinute(long millisecond) {
        try {
            long minutes = (millisecond / 1000) / 60;
            long seconds = (millisecond / 1000) % 60;
            return String.format("%s分钟 %s秒", minutes, seconds);
        } catch (Exception e) {
            return "";
        }
    }

    /**
     * 格式验证
     *
     * @param dateStr 日期字符串
     * @return 是否满足
     */
    public static boolean isValidDate(String dateStr) {
        return isValidDate(dateStr, DateEnum.yyyy_MM_dd);
    }

    /**
     * 格式验证
     *
     * @param dateStr  日期字符串
     * @param dateEnum 日期枚举值
     * @return 是否满足
     */
    public static boolean isValidDate(String dateStr, DateEnum dateEnum) {
        try {
            if (ObjectUtils.isEmpty(dateStr) || dateEnum == null) {
                return false;
            }
            SimpleDateFormat format = new SimpleDateFormat(dateEnum.TYPE);
            // 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
            format.setLenient(false);
            format.parse(dateStr);
            return true;
        } catch (Exception e) {
            return false;
        }
    }


    /**
     * [日期字符串]转日期/时间
     *
     * @param dateStr  日期字符串
     * @param dateEnum 日期格式枚举
     * @return 日期/时间
     */
    public static Date strToDate(String dateStr, DateEnum dateEnum) {
        return strToDate(dateStr, dateEnum.TYPE);
    }


    /**
     * [日期字符串]转日期/时间
     *
     * @param dateStr 日期字符串
     * @return 日期/时间
     */
    public static String strDateTimeToTime(String dateStr) {
        try {
            return new SimpleDateFormat(DateEnum.HH_mm_ss.TYPE)
                    .format(new SimpleDateFormat(DateEnum.yyyy_MM_dd_HH_mm_ss.TYPE).parse(dateStr));
        } catch (Exception e) {
            ErrorHelper.println(e);
            return null;
        }
    }


    /**
     * [日期字符串]转日期
     *
     * @param dateStr 日期字符串
     * @param format  日期格式
     * @return 日期/时间
     */
    public static Date strToDate(String dateStr, String format) {
        try {
            return new SimpleDateFormat(format).parse(dateStr);
        } catch (Exception e) {
            ErrorHelper.println(e);
            return null;
        }
    }


    /**
     * [日期]转字符串
     *
     * @param date     日期
     * @param dateEnum 日期格式枚举
     * @return 日期字符串
     */
    public static String dateToStr(Date date, DateEnum dateEnum) {
        return dateToStr(date, dateEnum.TYPE);
    }


    /**
     * [日期]转字符串
     *
     * @param date   日期
     * @param format 日期格式
     * @return 日期字符串
     */
    public static String dateToStr(Date date, String format) {
        try {
            return new SimpleDateFormat(format).format(date);
        } catch (Exception e) {
            ErrorHelper.println(e);
            return null;
        }
    }

    /**
     * 计算两个日期间隔天数
     *
     * @param begDateStr 开始日期
     * @param endDateStr 结束日期
     * @param isInclude  是否包含起止日期
     * @return 间隔天数
     */
    public static int intervalDays(String begDateStr, String endDateStr, boolean isInclude) {
        if (begDateStr == null || endDateStr == null) {
            return -1;
        }
        try {
            SimpleDateFormat format = new SimpleDateFormat(DateEnum.yyyy_MM_dd.TYPE);
            Calendar calendar = Calendar.getInstance();

            calendar.setTime(format.parse(begDateStr));
            long begTime = calendar.getTimeInMillis();

            calendar.setTime(format.parse(endDateStr));
            long endTime = calendar.getTimeInMillis();

            long between_days;
            if (begTime == endTime) {
                return 0;
            }

            if (begTime < endTime) {
                between_days = (endTime - begTime) / (1000 * 3600 * 24);
            } else {
                between_days = (begTime - endTime) / (1000 * 3600 * 24);
            }
            return Integer.parseInt(String.valueOf(between_days)) + (isInclude ? 1 : -1);
        } catch (Exception e) {
            e.printStackTrace();
            return -1;
        }
    }


    /**
     * 计算两个日期间隔天数
     *
     * @param date 时间点
     * @return 间隔天数
     */
    public static long differCurTimeSecond(Date date) {
        if (date == null) {
            return 0L;
        }
        return new Date().getTime() - date.getTime();
    }

    /**
     * 判断当前时间是否超过了指定时间
     *
     * @return 间隔天数
     */
    public static boolean isExceedDateTime(Date date) {
        return (new Date().getTime() - date.getTime()) > 0;
    }


    /**
     * 当前时间是否已经超过时间点
     *
     * @param time 指定时间点
     */
    public static Boolean isCurTimeOver(String time) {
        return isDateTimeOver(getCurDateTime(), time);
    }

    /**
     * 判断[指定日期 dateTime]是否已超过[指定时间点 time]
     *
     * @param dateTime 指定日期
     * @param time     指定时间点
     */
    public static Boolean isDateTimeOver(String dateTime, String time) {
        try {
            if (time == null || "".equals(time) || dateTime == null || "".equals(dateTime)) {
                return null;
            }

            SimpleDateFormat format = new SimpleDateFormat(DateEnum.yyyy_MM_dd_HH_mm_ss.TYPE);
            time = getCurDate() + " " + time.trim();
            long spotTime = format.parse(time).getTime(); // 比对时间点
            long curTime = format.parse(dateTime).getTime(); // 当前时间点
            return curTime > spotTime;
        } catch (Exception e) {
            ErrorHelper.println(e);
        }
        return null;
    }


    /**
     * 判断[指定日期 date ]是否已超过[根据今日移动计算的日期]
     *
     * @param date     指定日期
     * @param moveDays 根据今日移动计算的日期（可以为负数）
     * @return 是否超过
     */
    public static Boolean isDateOverMoveDate(String date, int moveDays) {
        try {
            if (date == null || "".equals(date)) {
                return null;
            }
            SimpleDateFormat format = new SimpleDateFormat(DateEnum.yyyy_MM_dd.TYPE);
            long dateTime = format.parse(date).getTime();

            // 以今天为起点，获取半年前的日期
            String moveDate = getMoveDate(getCurDate(), moveDays);
            long moveTime = format.parse(moveDate).getTime();

            return dateTime > moveTime;
        } catch (Exception e) {
            ErrorHelper.println(e);
        }
        return null;
    }


    /**
     * 获取当前时间
     *
     * @return 当前时间
     */
    public static String getCurDateTime() {
        SimpleDateFormat formatter = new SimpleDateFormat(DateEnum.yyyy_MM_dd_HH_mm_ss.TYPE);
        return formatter.format(new Date());
    }

    /**
     * 获取当前时间
     *
     * @return 时间
     */
    public static String getCurTime() {
        SimpleDateFormat formatter = new SimpleDateFormat(DateEnum.HH_mm_ss.TYPE);
        return formatter.format(new Date());
    }


    /**
     * 获取当前日期
     *
     * @return 日期
     */
    public static String getCurDate() {
        SimpleDateFormat formatter = new SimpleDateFormat(DateEnum.yyyy_MM_dd.TYPE);
        return formatter.format(new Date());
    }

    /**
     * 判断对照日期是否是今天
     *
     * @param date 对照日期
     * @return boolean
     */
    public static boolean isToday(String date) {
        return inDateRange(date, date, null, DateEnum.yyyy_MM_dd);
    }


    /**
     * 时间校验和转换
     *
     * @param timeStr        时间字符串
     * @param defaultTimeStr 默认时间字符串（处理值为空时返回该值）
     * @return 转换后的时间
     */
    public static String timeToHms(String timeStr, String defaultTimeStr) {
        if (timeStr == null || "".equals(timeStr)) {
            timeStr = defaultTimeStr;

        } else {
            if (DateHelper.isValidDate(timeStr, DateEnum.HH_mm)) {
                timeStr = DateHelper.hmToHms(timeStr);
                timeStr = timeStr == null ? defaultTimeStr : timeStr;
            } else {
                timeStr = DateHelper.isValidDate(timeStr, DateEnum.HH_mm_ss) ? timeStr : defaultTimeStr;
            }
        }
        return timeStr;
    }


    /**
     * 时间转换
     *
     * @param dateStr 时间字符串
     * @return 转换后的时间
     */
    public static String hmToHms(String dateStr) {
        try {
            SimpleDateFormat hmFormat = new SimpleDateFormat(DateEnum.HH_mm.TYPE);
            Date hmDate = hmFormat.parse(dateStr);

            SimpleDateFormat hmsFormat = new SimpleDateFormat(DateEnum.HH_mm_ss.TYPE);
            return hmsFormat.format(hmDate);
        } catch (Exception e) {
            e.printStackTrace();
            ErrorHelper.println(e);
        }
        return null;
    }

    /**
     * 判断当前时间是否在[startTime, endTime]区间
     *
     * @param beginTime 开始时间
     * @param endTime   结束时间
     * @return boolean
     */
    public static boolean inTimeRangeH_m_s(String beginTime, String endTime) {
        if (ObjectUtils.isEmpty(beginTime) || ObjectUtils.isEmpty(endTime)) {
            return false;
        }
        return inDateRange(beginTime + ":000", endTime + ":999", null, DateEnum.HH_mm_ss_SSS);
    }


    /**
     * 判断对照时间是否在[startTime, endTime]区间
     *
     * @param beginTime 开始时间
     * @param endTime   结束时间
     * @param dateEnum  时间格式枚举
     * @return boolean
     */
    public static boolean inDateRange(String beginTime, String endTime, DateEnum dateEnum) {
        return inDateRange(beginTime, endTime, null, dateEnum);
    }

    /**
     * 判断对照时间是否在[startTime, endTime]区间
     *
     * @param beginTime   开始时间
     * @param endTime     结束时间
     * @param compareTime 对照时间
     * @param dateEnum    时间格式枚举
     * @return boolean
     */
    public static boolean inDateRange(String beginTime, String endTime, String compareTime, DateEnum dateEnum) {
        if (beginTime == null || endTime == null || dateEnum == null
                || beginTime.length() != dateEnum.TYPE.length() || endTime.length() != dateEnum.TYPE.length()) {
            return false;
        }

        try {
            SimpleDateFormat sdf = new SimpleDateFormat(dateEnum.TYPE);
            if (compareTime == null) {
                compareTime = sdf.format(new Date());
            }
            Date begin = sdf.parse(beginTime);
            Date end = sdf.parse(endTime);
            Date now = sdf.parse(compareTime);

            if (now.getTime() == begin.getTime() || now.getTime() == end.getTime()) {
                return true;
            }

            Calendar nowCalendar = Calendar.getInstance();
            nowCalendar.setTime(now);

            Calendar beginCalendar = Calendar.getInstance();
            beginCalendar.setTime(begin);

            Calendar endCalendar = Calendar.getInstance();
            endCalendar.setTime(end);
            return nowCalendar.after(beginCalendar) && nowCalendar.before(endCalendar);

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


    /**
     * 得到一个时间延后或前移几天的时间
     *
     * @param dateStr     指定日期
     * @param moveSeconds 移动秒数
     * @return String 日期
     */
    public static String getMoveSeconds(String dateStr, Long moveSeconds) {
        try {
            try {
                if (dateStr == null) {
                    return null;
                }
                SimpleDateFormat format = new SimpleDateFormat(DateEnum.yyyy_MM_dd_HH_mm_ss.TYPE);
                ParsePosition pos = new ParsePosition(0);
                Date day = format.parse(dateStr, pos);
                long time = (day.getTime() / 1000) + moveSeconds;
                day.setTime(time * 1000);
                return format.format(day);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 得到一个时间延后或前移几天的时间
     *
     * @param date     指定日期
     * @param moveDays 移动天数
     * @return String 日期
     */
    public static String getMoveDate(Date date, int moveDays) {
        try {
            SimpleDateFormat format = new SimpleDateFormat(DateEnum.yyyy_MM_dd.TYPE);
            return getMoveDate(format.format(date), moveDays);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 获得按[指定时间]平移[moveMinute]分钟得时间
     *
     * @param dateStr    传入日期进行拼接（为空不拼接）
     * @param moveMinute 移动分钟（可为负数）
     * @return 日期
     */
    public static String getMoveMinute(String dateStr, long moveMinute) {
        try {
            if (dateStr == null) {
                return null;
            }
            SimpleDateFormat format = new SimpleDateFormat(DateEnum.yyyy_MM_dd_HH_mm_ss.TYPE);
            ParsePosition pos = new ParsePosition(0);
            Date day = format.parse(dateStr, pos);
            long time = (day.getTime() / 1000) + (moveMinute * 60);
            day.setTime(time * 1000);
            return format.format(day);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 得到一个时间延后或前移几天的时间
     *
     * @param date     指定日期
     * @param moveDays 移动天数
     * @return String 日期
     */
    public static String getMoveDate(String date, int moveDays) {
        try {
            if (date == null) {
                return null;
            }
            SimpleDateFormat format = new SimpleDateFormat(DateEnum.yyyy_MM_dd.TYPE);
            ParsePosition pos = new ParsePosition(0);
            Date day = format.parse(date, pos);
            long time = (day.getTime() / 1000) + (moveDays * 24 * 60 * 60L);
            day.setTime(time * 1000);
            return format.format(day);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 时间转换
     * yyyy-MM-dd HH:mm:ss转换为yyyy-MM-dd
     */
    public static String dateFormatShort(String inTime) {
        String outTime = null;
        try {
            SimpleDateFormat timeSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            SimpleDateFormat dateSdf = new SimpleDateFormat("yyyy-MM-dd");
            Date tempDate = timeSdf.parse(inTime);
            outTime = dateSdf.format(dateSdf.parse(timeSdf.format(tempDate)));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return outTime;
    }

    private static final String[] parsePatterns = {"yyyy-MM-dd", "yyyy年MM月dd日",
            "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy/MM/dd",
            "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyyMMdd"};

    public static Date parseDate(String date) {
        if (date == null) {
            return null;
        }
        try {
            return DateUtils.parseDate(date, parsePatterns);
        } catch (ParseException e) {
            return null;
        }
    }

}