import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalQuery;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

class Main {
  public static void main(String[] args) {
    DateTimeUtils.main(args);
  }
  public enum DateTimeUtils {

    /**
     * 日期格式 <code>[yyyy-MM-dd]</code>
     **/
    YEAR("yyyy", 4), 
    MONTH("MM", 2), 
    DATE("yyyy-MM-dd", 10), 
    DATE_FOR_EXCEL("yyyy.MM.dd", 10),
    DATE_SLASH("yyyy/MM/dd", 10), 
    DATE_MONTH_FOR_EXCEL("yyyy-MM", 7), 
    DATE_MONTH_SLASH_FOR_EXCEL("yyyy/MM", 7),
    TIME("HH:mm:ss", 8), 
    DATE_TIME("yyyy-MM-dd HH:mm:ss", 19), 
    DATE_TIME_FOR_EXCEL("yyyy.MM.dd HH:mm:ss", 19),

    YEAR_CHINESE("yyyy年", 5), 
    MONTH_CHINESE("MM月", 3), 
    DATE_MONTH_CHINESE("yyyy年MM月", 8),
    DATE_CHINESE("yyyy年MM月dd日", 11), 
    DATE_TIME_CHINESE("yyyy年MM月dd日 HH时mm分ss秒", 21);

    
    private final DateTimeFormatter formatter;

    String pattern;
    int len;

    DateTimeUtils(String pattern, int len) {
        this.pattern = pattern;
        this.len = len;
        this.formatter = DateTimeFormatter.ofPattern(pattern).withZone(ZoneId.systemDefault());
    }

    
    /**
     * 获取现在时
     *
     * @return
     */
    public String now() {
        return formatter.format(Instant.now());
    }

    /**
     * 转换成时间字符串
     */
    public String formatDate(Date date) {
        return date != null ? formatter.format(date.toInstant()) : "";
    }

    public String formatIimestamp(long epochMilli) {
        return formatter.format(Instant.ofEpochMilli(epochMilli));
    }

    private <R> R parse(String date, TemporalQuery<R> query) {
        return formatter.parse(date, query);
    }

    private <R> Date parseDate(String dateStr, TemporalQuery<R> query) {
        return Date.from(parseInstant(dateStr, query));
    }

    private <R> Instant parseInstant(String dateStr, TemporalQuery<R> query) {
        R temporal = parse(dateStr, query);
        if (temporal instanceof Instant) {
            return (Instant) temporal;
        }
        if (temporal instanceof LocalDateTime) {
            return ((LocalDateTime) temporal).atZone(ZoneId.systemDefault()).toInstant();
        }
        if (temporal instanceof LocalDate) {
            return ((LocalDate) temporal).atStartOfDay(ZoneId.systemDefault()).toInstant();
        }
        if (temporal instanceof LocalDateTime) {
            LocalDate epoch = LocalDate.of(1970, 1, 1);
            LocalDateTime dateTime = LocalDateTime.of(epoch, (LocalTime) temporal);
            return dateTime.atZone(ZoneId.systemDefault()).toInstant();
        }
        throw new DateTimeException(" Type parameter must be LocalDateTime of LocalDate of LocalTime of Instant ");
    }

    /**
     * 字符串转换成时间
     */
    public Date parseDate(String dateStr) throws ParseException {
        return new SimpleDateFormat(pattern).parse(dateStr);
    }

    /**
     * 加对应数量的年单位
     */
    public static Date setYearDate(int year) {
        return setDate(year, 0, 0, null);
    }

    /**
     * 加对应数量的年单位
     */
    public static Date setYearDate(int year, Date date) {
        return setDate(year, 0, 0, date);
    }

    /**
     * 加对应数量的月单位
     */
    public static Date setMonthDate(int month) {
        return setDate(0, month, 0, null);
    }

    /**
     * 加对应数量的月单位
     */
    public static Date setMonthDate(int month, Date date) {
        return setDate(0, month, 0, date);
    }

    /**
     * 加对应数量的天单位
     */
    public static Date setDayDate(int day) {
        return setDate(0, 0, day, null);

    }

    /**
     * 加对应数量的天单位
     */
    public static Date setDayDate(int day, Date date) {
        return setDate(0, 0, day, date);
    }

    /**
     * 加对应数量的年月日单位
     */
    public static Date setDate(int year, int month, int day, Date date) {
        final Calendar instance = Calendar.getInstance();
        if (date != null) {
            instance.setTime(date);
        }
        instance.add(Calendar.YEAR, year);
        instance.add(Calendar.MONTH, month);
        instance.add(Calendar.DATE, day);
        return instance.getTime();
    }

    /**
     * 加对应数量的时分秒单位
     */
    public static Date setTime(int hour, int minute, int second, Date date) {
        final Calendar instance = Calendar.getInstance();
        if (date != null) {
            instance.setTime(date);
        }
        instance.add(Calendar.HOUR_OF_DAY, hour);
        instance.add(Calendar.MINUTE, minute);
        instance.add(Calendar.SECOND, second);
        return instance.getTime();
    }

    public String getPattern() {
        return pattern;
    }

    public int getLen() {
        return len;
    }

    /**
     * 获取当周第一天
     * 
     * @param dateStr
     * @return
     */
    public static Date getFirstDayOfWeek(String dateStr) {
        if (dateStr == null || "".equals(dateStr)) {
            return null;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return null;
        }
        try {
            final Date date = dateTimeUtil.parseDate(dateStr);
            return getFirstDayOfWeek(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取当周第一天
     * 
     * @param date
     * @return
     */
    public static Date getFirstDayOfWeek(Date date) {
        if (date == null) {
            return null;
        }
        final Calendar cal = Calendar.getInstance();
        try {
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_WEEK, 1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cal.getTime();
    }

    /**
     * 获取当周最后一天
     * 
     * @param dateStr
     * @return
     */
    public static Date getLastDayOfWeek(String dateStr) {
        if (dateStr == null || "".equals(dateStr)) {
            return null;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return null;
        }
        try {
            final Date date = dateTimeUtil.parseDate(dateStr);
            return getLastDayOfWeek(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取当周最后一天
     * 
     * @param date
     * @return
     */
    public static Date getLastDayOfWeek(Date date) {
        final Calendar cal = Calendar.getInstance();
        try {
            cal.setTime(date);
            cal.set(Calendar.DAY_OF_WEEK, 1);
            cal.set(Calendar.DATE, cal.get(Calendar.DATE) + 6);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cal.getTime();
    }

    /**
     * 获取时间枚举工具类
     *
     * @param dateStr
     * @return
     */
    public static DateTimeUtils getDateTimeUtil(String dateStr) {
        if (null == dateStr) {
            return null;
        }
        DateTimeUtils[] values = DateTimeUtils.values();
        for (int i = 0; i < values.length; i++) {
            DateTimeUtils dateTimeUtil = values[i];
            if (dateTimeUtil.len == dateStr.length() && dateTimeUtil.pattern.charAt(4) == dateStr.charAt(4)) {
                    return dateTimeUtil;
            }
        }
        return null;
    }

    /**
     * 获取月的最后一天
     * 
     * @return
     */
    public static Date getLastDayOfMonth() {
        return getLastDayOfMonth(new Date(System.currentTimeMillis()));
    }

    /**
     * 获取月的最后一天
     * 
     * @param date 日期
     * @return
     */
    public static Date getLastDayOfMonth(Date date) {
        final Calendar instance = Calendar.getInstance();
        instance.setTime(date);
        instance.set(Calendar.DAY_OF_MONTH, 1);
        instance.roll(Calendar.DAY_OF_MONTH, -1);
        return setTime(23, 59, 59, instance.getTime());
    }

    /**
     * 获取月的第一天
     * 
     * @param date 日期
     * @return
     */
    public static Date getFirstDayOfMonth(Date date) {
        final Calendar instance = Calendar.getInstance();
        instance.setTime(date);
        instance.set(Calendar.DAY_OF_MONTH, 1);
        return instance.getTime();
    }
    public static Date getWeekendFirstDayOfMonday(String dateStr) {
        if (dateStr == null || "".equals(dateStr)) {
            return null;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return null;
        }
        try {
            final Date date = dateTimeUtil.parseDate(dateStr);
            return getWeekendFirstDayOfMonday(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 以周日为第一天的获取
     * @param date
     * @return
     */
    public static Date getWeekendFirstDayOfMonday(Date date) {
        if (date == null) {
            return null;
        }
        final Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        return calendar.getTime();
    }

    public static Date getWeekendFirstDayOfSunday(String dateStr) {
        if (dateStr == null || "".equals(dateStr)) {
            return null;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return null;
        }
        try {
            final Date date = dateTimeUtil.parseDate(dateStr);
            return getWeekendFirstDayOfSunday(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;

    }

    public static Date getWeekendFirstDayOfSunday(Date date) {
        if (date == null) {
            return null;
        }
        final Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.setFirstDayOfWeek(Calendar.MONDAY);
        calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
        return calendar.getTime();
    }

    /**
     * 转化成对应的中文内容
     * 
     * @param dateStr
     * @param chineseDateTimeUtil
     * @return
     * @throws ParseException
     */
    public static String getDataChineseValue(String dateStr, DateTimeUtils chineseDateTimeUtil) throws ParseException {
        String chineseData = "";
        if (dateStr == null || "".equals(dateStr)) {
            return chineseData;
        }
        final DateTimeUtils dateTimeUtil = getDateTimeUtil(dateStr);
        if (dateTimeUtil == null) {
            return chineseData;
        }
        chineseData = chineseDateTimeUtil.formatDate(dateTimeUtil.parseDate(dateStr));

        return chineseData;
    }

     private static String[] appsName = {"字符串通过指定枚举转换成Date"};

    public static void main(String[] args)  {
        Scanner scan=new Scanner(System.in);
        //展示功能名称

        String select = viewAppName(scan);
        System.out.println(select);
        switch (select) {
        case "1":
            try {
                dateFormat(scan,new Date());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            break;

        default:
            break;
        }
    }
    private static String viewAppName(Scanner scan) {
        System.out.println("请输入序号选择功能:");//提示输入
        for (int i = 0; i < appsName.length; i++) {
            System.out.println(String.format("[%d]:%s;", i+1 , appsName[i]));
        }
        try {
            return scan.nextLine();
        } catch (Exception e) {
            System.out.println("请输入正确的功能参数！！！！");
            //展示功能名称
            viewAppName(scan);
        }
        return "0";
    }
    
    /**
     * 对应参数转时间类�?
     * @return
     * @throws InterruptedException 
     */
    private static void dateFormat(Scanner scan,Date date) throws InterruptedException {
        DateTimeUtils[] values = DateTimeUtils.values();
        for (int i = 0; i < values.length; i++) {
            DateTimeUtils dateTimeUtils = values[i];
            //转换方法的例子
            String formatDate = dateTimeUtils.formatDate(date);
            System.out.println(String.format("[%d] 解析字符串转换成：%s 格式 例：%s",i, dateTimeUtils.pattern,formatDate));
        }
        System.out.println("请选择解析类型");
        Thread.sleep(500);
        String nextLine = scan.next();
        DateTimeUtils dateTimeUtils = null;
        try {
            dateTimeUtils = values[Integer.parseInt(nextLine)];
        } catch (NumberFormatException | ArrayIndexOutOfBoundsException  e) {
            System.out.println("请输入正确的参数");
            dateFormat(scan,date);
            return ;
        }
        
        try {
            System.out.println("请输入要解析的字符串");
            nextLine = scan.next();
            while(dateTimeUtils.len != nextLine.length()) {
                System.out.println("输入字符串有误，请重新输入");
                nextLine = scan.next();
            }
            System.out.println(String.format("输入字符串 %s", nextLine));
            Date parseDate = dateTimeUtils.parseDate(nextLine);
            System.out.println(String.format("解析成功 解析后的时间 %s", DateTimeUtils.DATE_TIME.formatDate(parseDate)));
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        return;
        
    }

}
}