import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.hl.analyze.utils.enums.DateFmtEnum;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.*;

/**
 * @author Starry
 * @date 9:46 2018/4/13 Modified By:
 */

@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class DateUtils {
    private static final Logger log = LoggerFactory.getLogger(DateUtils.class);

    /**
     * 日期格式化
     */
    private static final String GS = "yyyy-MM-dd HH:mm:ss";
    private static final DateTimeFormatter DF = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd");

    /**
     * 日期轉換字串
     */
    public static String parseDate(Date date, String gs) {
        SimpleDateFormat sdf = new SimpleDateFormat(gs);
        return sdf.format(date);

    }

    /**
     * 準換字串
     *
     * @param strDate 要轉換的日期
     * @param pat2    轉換後的日期格式
     */
    public static String str2Str(String strDate, String pat2) {
        // 例項化模板物件
        SimpleDateFormat sdf1 = new SimpleDateFormat(GS);
        // 例項化模板物件
        SimpleDateFormat sdf2 = new SimpleDateFormat(pat2);
        Date d = null;
        try {
            // 將給定的字串中的日期提取出來
            d = sdf1.parse(strDate);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        // 將日期變為新的格式
        return (sdf2.format(d));
    }

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

    /**
     * 字串轉為日期
     */
    public static Date stringToDate(String time, String gs) {
        SimpleDateFormat sDateFormat = new SimpleDateFormat(gs);
        Date d = null;
        try {
            d = sDateFormat.parse(time);
        } catch (ParseException e) {
            log.error(e.getMessage(), e);
        }
        return d;

    }

    public static String getSpecifiedDayBefore(String specifiedDay) {

        Calendar c = Calendar.getInstance();
        Date date = null;
        try {
            date = new SimpleDateFormat("yyyy-MM-dd").parse(specifiedDay);
        } catch (ParseException e) {
            log.error(e.getMessage(), e);
        }

        c.setTime(date);
        int day = c.get(Calendar.DATE);

        c.set(Calendar.DATE, day - 1);

        String dayBefore = new SimpleDateFormat("yyyy-MM-dd").format(c.getTime());

        return dayBefore;

    }

    /**
     * 獲取當前時間
     *
     * @return
     */
    public static String getDate() {
        Date date = new Date();
        String d = parseDate(date, "yyyy-MM-dd HH:mm:ss");
        return d;
    }

    /**
     * 獲取當前時間
     *
     * @return
     */
    public static String getDateDay() {
        Date date = new Date();
        String d = parseDate(date, "yyyy-MM-dd");
        return d;
    }

    public static Integer getDifference(Date beginTime, Date endTime) {
        return (int) ((endTime.getTime() - beginTime.getTime()) / (1000 * 3600 * 24));
    }

    /**
     * @Description yyyy-MM-dd HH:mm:ss
     */
    public static Integer getDifference(String beginTime, String endTime) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat(GS);
        Date beginDate = format.parse(beginTime);
        Date endDate = format.parse(endTime);

        return (int) ((endDate.getTime() - beginDate.getTime()) / (1000 * 3600 * 24));
    }

    /**
     * @Description yyyy-MM-dd HH:mm:ss
     */
    public static List<String> getDifferenceList(String beginTime, String endTime) throws ParseException {
        LinkedList<String> result = Lists.newLinkedList();
        LocalDateTime begin = LocalDateTime.parse(beginTime, DF);
        LocalDateTime end = LocalDateTime.parse(endTime, DF);
        int i = end.compareTo(begin);
        if (i == 1 && !end.toLocalDate().toString().equals(begin.toLocalDate().toString())) {
            result.add(begin.toLocalDate().toString());
            result.add(end.toLocalDate().toString());
            return result;
        }
        if (i == 1 && end.toLocalDate().toString().equals(begin.toLocalDate().toString())) {
            result.add(begin.toLocalDate().toString());
            return result;
        } else if (i > 1) {
            for (int j = 0; j <= i; j++) {
                result.add(begin.toLocalDate().plusDays(j).toString());
            }

        }
        return result;
    }

    /**
     * 獲取輸入時間與當前時間的差
     *
     * @param time  比較時間
     * @param level 深入層，x年x月x天x時x秒之前，level用來確定精確層數，比如level=2 則x年x月 若年為0 則x月x天
     * @return x年x月x天x時x秒之前，層數受level約束
     */
    public static String getDateDiffForNow(LocalDateTime time, int level) {
        return getDateDiffStr(time, LocalDateTime.now(), level);
    }

    /**
     * 獲取輸入時間之間時間差
     *
     * @param before 之前時間
     * @param after  之後時間
     * @param level  深入層，x年x月x天x時x秒之前，level用來確定精確層數，比如level=2 則x年x月 若年為0 則x月x天
     * @return x年x月x天x時x秒，層數受level約束
     */
    public static String getDateDiffStr(LocalDateTime before, LocalDateTime after, int level) {
        int currLevel = 0;
        long lastData = 0;
        List<ChronoUnit> chL = Arrays.asList(ChronoUnit.YEARS, ChronoUnit.MONTHS, ChronoUnit.DAYS, ChronoUnit.HOURS,
                ChronoUnit.MINUTES, ChronoUnit.SECONDS);
        // 記錄中文的時間描述
        String[] desCn = {"年", "月", "天", "小時", "分", "秒"};
        // 記錄相鄰的兩個時間刻度之間的轉換值，為方便計算，第一位為空缺0
        int[] diff = {0, 12, 30, 24, 60, 60};

        StringBuilder timeSb = new StringBuilder();

        for (int i = 0; i < chL.size(); i++) {
            long cal = chL.get(i).between(before, after);
            if (cal != 0) {
                timeSb.append(cal - lastData * diff[i]).append(desCn[i]);
                currLevel++;
                lastData = cal;

                if (currLevel == level) {
                    break;
                }
            }
        }

        return timeSb.toString();
    }

    /**
     * 返回當前時間字串，格式：yyyy-MM-dd HH:mm:ss
     *
     * @return
     */
    public static String getNowStr() {
        return getNowStr(com.hl.analyze.utils.enums.DateFmtEnum.FMT_SECODE_HYPHEN);
    }

    /**
     * 根據格式化格式返回當前時間
     *
     * @param fmt 格式化
     * @return
     */
    public static String getNowStr(com.hl.analyze.utils.enums.DateFmtEnum fmt) {
        return getNowStr(fmt.getValue());
    }

    /**
     * 根據格式化格式返回當前時間
     *
     * @param fmt 格式化
     * @return
     */
    public static String getNowStr(String fmt) {
        return localDateTimeFmt(LocalDateTime.now(), fmt);
    }

    /**
     * 將時間格式化為字串，預設格式化為yyyy-MM-dd HH:mm:ss
     *
     * @param time 時間
     * @return
     */
    public static String localDatetimeFmt(LocalDateTime time) {
        return localDateTimeFmt(time, com.hl.analyze.utils.enums.DateFmtEnum.FMT_SECODE_HYPHEN);
    }

    /**
     * 將時間格式化為字串
     *
     * @param time 時間
     * @param fmt  格式化
     * @return
     */
    public static String localDateTimeFmt(LocalDateTime time, DateFmtEnum fmt) {
        return localDateTimeFmt(time, fmt.getValue());
    }

    /**
     * 將時間格式化為字串
     *
     * @param time 時間
     * @param fmt  格式化
     * @return
     */
    public static String localDateTimeFmt(LocalDateTime time, String fmt) {
        return time.format(DateTimeFormatter.ofPattern(fmt));
    }

    /**
     * 計算日期時間差（小時）
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static long getDateHour(Date startDate, Date endDate) {
        long nd = 1000 * 60 * 60L;
        // 獲得兩個時間的毫秒時間差異
        long diff = endDate.getTime() - startDate.getTime();
        // 計算差多少天
//        long day = diff / nd /24;
        // 計算差多少小時
        long hour = diff / nd;
        return hour;
    }

    /**
     * 計算日期時間差（分鐘）
     *
     * @param startDate 開始時間
     * @param endDate   結束時間
     * @return
     */
    public static long getDateMinute(Date startDate, Date endDate) {
        long nd = 1000 * 60L;
        // 獲得兩個時間的毫秒時間差異
        long diff = endDate.getTime() - startDate.getTime();
        // 計算差多少分鐘
        long minute = diff / nd;
        return minute;
    }

    /**
     * 計算當前時間到次日0點秒數
     *
     * @return
     */
    public static long getTomorrowZeroSeconds() {
        // 當前時間毫秒數
        long current = System.currentTimeMillis();
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        long tomorrowzero = calendar.getTimeInMillis();
        long tomorrowzeroSeconds = (tomorrowzero - current) / 1000;
        return tomorrowzeroSeconds;
    }

    /**
     * 獲取之前日期
     *
     * @param amount 相差的天數
     */
    public static String getThePreviousDay(Integer amount) {
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(new Date());
        calendar.add(Calendar.DATE, amount);
        SimpleDateFormat sdf = new SimpleDateFormat(GS);
        return sdf.format(calendar.getTime());
    }

    public static List<String> getThePreviousSixDaysDate() {
        ArrayList<String> dateList = Lists.newArrayList();
        dateList.add(DateUtils.getThePreviousDay(-1));
        dateList.add(DateUtils.getThePreviousDay(-2));
        dateList.add(DateUtils.getThePreviousDay(-3));
        dateList.add(DateUtils.getThePreviousDay(-4));
        dateList.add(DateUtils.getThePreviousDay(-5));
        dateList.add(DateUtils.getThePreviousDay(-6));
        return dateList;
    }

    /**
     * @param currentDateTime 當前時間
     * @return boolean
     * @Description 大於當前時間為true
     */
    public static boolean isItGreaterThanTheCurrentDate(String currentDateTime) {
        SimpleDateFormat sdf = new SimpleDateFormat(GS);

        Date today = new Date();

        try {
            //將字串轉換為 date 型別  Debug：Sun Nov 11 00:00:00 CST 2018
            Date dateD = sdf.parse(currentDateTime);
            return dateD.getTime() >= today.getTime();
        } catch (ParseException e1) {
            e1.printStackTrace();
            return false;
        }
    }

    public static List<DateSplit> splitByMinute(Date startTime, Date endTime, int intervalMinutes) {
        if (endTime.getTime() <= startTime.getTime()) {
            return null;
        }
        List<DateSplit> dateSplits = new ArrayList<>(256);

        DateSplit param = new DateSplit();
        param.setStartDateTime(startTime);
        param.setEndDateTime(endTime);
        param.setEndDateTime(addMinute(startTime, intervalMinutes));
        while (true) {
            param.setStartDateTime(startTime);
            Date tempEndTime = addMinute(startTime, intervalMinutes);
            if (tempEndTime.getTime() >= endTime.getTime()) {
                tempEndTime = endTime;
            }
            param.setEndDateTime(tempEndTime);

            dateSplits.add(new DateSplit(param.getStartDateTime(), param.getEndDateTime()));

            startTime = addMinute(startTime, intervalMinutes);
            if (startTime.getTime() >= endTime.getTime()) {
                break;
            }
            if (param.getEndDateTime().getTime() >= endTime.getTime()) {
                break;
            }
        }
        return dateSplits;
    }

    private static String formatDateTime(Date date) {
        if (date == null) {
            return "";
        }
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return simpleDateFormat.format(date);
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class DateSplit {
        private Date startDateTime;
        private Date endDateTime;

        public String getStartDateTimeStr() {
            return formatDateTime(startDateTime);
        }

        public String getEndDateTimeStr() {
            return formatDateTime(endDateTime);
        }
    }

    private static Date addDays(Date date, int days) {
        return add(date, Calendar.DAY_OF_MONTH, days);
    }

    private static Date addHours(Date date, int hours) {
        return add(date, Calendar.HOUR_OF_DAY, hours);
    }

    private static Date addMinute(Date date, int minute) {
        return add(date, Calendar.MINUTE, minute);
    }

    private static Date addSeconds(Date date, int second) {
        return add(date, Calendar.SECOND, second);
    }

    private static Date add(final Date date, final int calendarField, final int amount) {
        final Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(calendarField, amount);
        return c.getTime();
    }

    /**
     * @param year eg.2021
     * @return java.util.TreeMap<java.lang.String, com.alibaba.fastjson.JSONObject>
     * @Description 獲取當年每個月的第一天和最後一天的日期
     */
    public static TreeMap<String, JSONObject> getMonthStartDateAndEndDate(Integer year) {
        final List<Integer> monthList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
        log.info("查詢年份" + year);
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        TreeMap<String, JSONObject> jsonObject = new TreeMap<>();
        for (Integer month : monthList) {
            calendar.set(Calendar.MONTH, Integer.parseInt(String.valueOf(month - 1)));
            calendar.set(Calendar.DAY_OF_MONTH, 1);
            calendar.set(Calendar.DATE, calendar.getActualMinimum(Calendar.DATE));
            final String startDate = DATE_FORMAT.format(calendar.getTime());
            calendar.set(Calendar.DATE, calendar.getActualMaximum(Calendar.DATE));
            final String endDate = DATE_FORMAT.format(calendar.getTime());
            JSONObject date = new JSONObject();
            date.put("start", startDate);
            date.put("end", endDate);
            jsonObject.put(LocalDate.parse(DATE_FORMAT.format(calendar.getTime())).format(DateTimeFormatter.ofPattern("yyyy-MM")), date);
        }
        return jsonObject;
    }

    /**
     * @param yearAndMonth eg.2021
     * @return java.util.TreeMap<java.lang.String, com.alibaba.fastjson.JSONObject>
     * @Description 獲取當年當前月的最後一天的日期
     */
    public static String getMonthEndDate(String yearAndMonth) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(DateUtils.getDate(yearAndMonth, "yyyy-MM"));
        calendar.add(Calendar.MONTH, 1);
        calendar.set(Calendar.DAY_OF_MONTH, 0);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        return DateUtils.parseDate(calendar.getTime());
    }

    /**
     * @param yearAndMonth eg.2021
     * @return java.util.TreeMap<java.lang.String, com.alibaba.fastjson.JSONObject>
     * @Description 獲取當年當前月的第一天的日期
     */
    public static String getMonthFirstDate(String yearAndMonth) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(DateUtils.getDate(yearAndMonth, "yyyy-MM"));
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 00);
        calendar.set(Calendar.MINUTE, 00);
        calendar.set(Calendar.SECOND, 00);
        return DateUtils.parseDate(calendar.getTime());
    }

    public static Date getDate(String source, String gs) {
        SimpleDateFormat sdf = new SimpleDateFormat(gs);
        try {
            return sdf.parse(source);
        } catch (ParseException var4) {
            return null;
        }
    }

    /**
     * 獲取兩個日期之間的所有日期 (年月日)
     *
     * @param startTime
     * @param endTime
     * @return
     */
    public static List<String> getBetweenDate(String startTime, String endTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 宣告儲存日期集合
        List<String> list = new ArrayList<String>();
        try {
            // 轉化成日期型別
            Date startDate = sdf.parse(startTime);
            Date endDate = sdf.parse(endTime);

            //用Calendar 進行日期比較判斷
            Calendar calendar = Calendar.getInstance();
            while (startDate.getTime() <= endDate.getTime()) {
                // 把日期新增到集合
                list.add(sdf.format(startDate));
                // 設定日期
                calendar.setTime(startDate);
                //把日期增加一天
                calendar.add(Calendar.DATE, 1);
                // 獲取增加後的日期
                startDate = calendar.getTime();
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 獲取兩個日期之間的所有月份 (年月)
     *
     * @param startTime
     * @param endTime
     * @return：YYYY-MM
     */
    public static List<String> getMonthBetweenDate(String startTime, String endTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
        // 宣告儲存日期集合
        List<String> list = new ArrayList<String>();
        try {
            // 轉化成日期型別
            Date startDate = sdf.parse(startTime);
            Date endDate = sdf.parse(endTime);

            //用Calendar 進行日期比較判斷
            Calendar calendar = Calendar.getInstance();
            while (startDate.getTime() <= endDate.getTime()) {
                // 把日期新增到集合
                list.add(sdf.format(startDate));
                // 設定日期
                calendar.setTime(startDate);
                //把日期增加一天
                calendar.add(Calendar.MONTH, 1);
                // 獲取增加後的日期
                startDate = calendar.getTime();
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return list;
    }

    public static Date str2DateTime(String time) {
        SimpleDateFormat sDateFormat = new SimpleDateFormat(GS);
        Date d = null;
        try {
            d = sDateFormat.parse(time);
        } catch (ParseException e) {
            log.error(e.getMessage(), e);
        }
        return d;

    }

    /**
     * 獲取昨天的日期
     */
    public static String getYesterday() {
        SimpleDateFormat smdate = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(new Date());
        calendar.add(Calendar.DATE, -1);
        String date = smdate.format(calendar.getTime());
        return date;
    }

}



//日期格式 工具

/**
 * 日期轉換格式
 * 
 * @author dell
 *
 */
public enum DateFmtEnum {

   /**
    * yyyy-MM-dd HH:mm:ss
    */
   FMT_SECODE_HYPHEN("yyyy-MM-dd HH:mm:ss"),
   /**
    * yyyy/MM/dd HH:mm:ss
    */
   FMT_SECODE_SLASH("yyyy/MM/dd HH:mm:ss"),
   /**
    * yyyyMMdd HH:mm:ss
    */
   FMT_SECODE_NONE("yyyyMMdd HH:mm:ss");


   private String value;

   public String getValue() {
      return value;
   }

   private DateFmtEnum(String value) {
      this.value = value;
   }
}