package com.qianwen.smartman.common.utils;

import cn.hutool.core.util.StrUtil;
import java.time.DayOfWeek;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.chrono.ChronoLocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.SignStyle;
import java.time.temporal.ChronoUnit;
import java.time.temporal.IsoFields;
import java.time.temporal.TemporalUnit;
import java.time.temporal.WeekFields;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.stream.Stream;
import com.qianwen.smartman.common.constant.DateConstant;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.smartman.modules.mdc.vo.DateInfo;

public class LocalDateUtil {
    public static final String YEAR_MONTH_FORMAT = "yyyy-M";
    public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern(DateConstant.PATTERN_DATE);
    private static final DateTimeFormatter SHORT_DATE_FORMATTER = DateTimeFormatter.ofPattern("MM-dd");
    private static final DateTimeFormatter WEEK_FORMATTER = DateTimeFormatter.ofPattern("w");
    private static final DateTimeFormatter MONTH_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM");
    private static final DateTimeFormatter YEAR_WEEK_FORMATTER = new DateTimeFormatterBuilder().parseCaseInsensitive().appendValue(IsoFields.WEEK_BASED_YEAR, 4, 10, SignStyle.EXCEEDS_PAD).appendLiteral("-").appendValue(IsoFields.WEEK_OF_WEEK_BASED_YEAR, 2).toFormatter();
    Date date = new Date();
    Instant instant = this.date.toInstant();
    ZoneId zoneId = ZoneId.systemDefault();
    LocalDateTime localDateTime = this.instant.atZone(this.zoneId).toLocalDateTime();

    private LocalDateUtil() {
    }

    public static List<DateInfo> toDateShiftList(LocalDate start, LocalDate end, Collection<Map.Entry<String, String>> shiftKeyValue) {
    	List<DateInfo> result = new ArrayList<>();
        for (LocalDate s = start; s.compareTo(end) < 1; s = s.plusDays(1L)) {
          for (Map.Entry<String, String> kv : shiftKeyValue) {
            String code = StrUtil.format("{}_{}", new Object[] { s.format(DATE_FORMATTER), kv.getKey() });
            String title = StrUtil.format("{}{}", new Object[] { s.format(SHORT_DATE_FORMATTER), kv.getValue() });
            String date = s.format(DATE_FORMATTER);
            Integer week = Integer.valueOf(s.format(WEEK_FORMATTER));
            Integer month = Integer.valueOf(s.getMonthValue());
            Integer year = Integer.valueOf(s.getYear());
            result.add(new DateInfo(code, title, date, week, month, year, Integer.valueOf(kv.getKey())));
          } 
        } 
        return result;
    	/*
        List<DateInfo> result = new ArrayList<>();
        LocalDate localDate = start;
        while (true) {
            LocalDate s = localDate;
            if (s.compareTo((ChronoLocalDate) end) < 1) {
                for (Map.Entry<String, String> kv : shiftKeyValue) {
                    String code = StrUtil.format("{}_{}", new Object[]{s.format(DATE_FORMATTER), kv.getKey()});
                    String title = StrUtil.format("{}{}", new Object[]{s.format(SHORT_DATE_FORMATTER), kv.getValue()});
                    String date = s.format(DATE_FORMATTER);
                    Integer week = Integer.valueOf(s.format(WEEK_FORMATTER));
                    Integer month = Integer.valueOf(s.getMonthValue());
                    Integer year = Integer.valueOf(s.getYear());
                    result.add(new DateInfo(code, title, date, week, month, year, Integer.valueOf(kv.getKey())));
                }
                localDate = s.plusDays(1L);
            } else {
                return result;
            }
        }
        */
    }

    public static List<DateInfo> toMonthList(LocalDate start, LocalDate end) {
    	List<DateInfo> result = new ArrayList<>();
        for (LocalDate s = start; s.compareTo(end) < 1; s = s.plusMonths(1L)) {
          DateInfo info = buildDateInfo(s, MONTH_FORMATTER, MONTH_FORMATTER);
          result.add(info);
        } 
        return result;
        
    	/*
        List<DateInfo> result = new ArrayList<>();
        LocalDate localDate = start;
        while (true) {
            LocalDate s = localDate;
            if (s.compareTo((ChronoLocalDate) end) < 1) {
                DateInfo info = buildDateInfo(s, MONTH_FORMATTER, MONTH_FORMATTER);
                result.add(info);
                localDate = s.plusMonths(1L);
            } else {
                return result;
            }
        }
        */
    }

    public static List<DateInfo> toDateList(LocalDate start, LocalDate end) {
    	List<DateInfo> result = new ArrayList<>();
        for (LocalDate s = start; s.compareTo(end) < 1; s = s.plusDays(1L)) {
          DateInfo info = buildDateInfo(s, DATE_FORMATTER, SHORT_DATE_FORMATTER);
          result.add(info);
        } 
        return result;
    	/*
        List<DateInfo> result = new ArrayList<>();
        LocalDate localDate = start;
        while (true) {
            LocalDate s = localDate;
            if (s.compareTo((ChronoLocalDate) end) < 1) {
                DateInfo info = buildDateInfo(s, DATE_FORMATTER, SHORT_DATE_FORMATTER);
                result.add(info);
                localDate = s.plusDays(1L);
            } else {
                return result;
            }
        }
        */
    }

    public static List<DateInfo> toWeekList(LocalDate startDate, LocalDate endDate) {
    	List<DateInfo> result = new ArrayList<>();
        for (LocalDate s = startDate; s.compareTo(endDate) < 1; s = s.plusWeeks(1L)) {
          DateInfo info = buildDateInfo(s, YEAR_WEEK_FORMATTER, YEAR_WEEK_FORMATTER);
          result.add(info);
        } 
        return result;
    	/*
        List<DateInfo> result = new ArrayList<>();
        LocalDate localDate = startDate;
        while (true) {
            LocalDate s = localDate;
            if (s.compareTo((ChronoLocalDate) endDate) < 1) {
                DateInfo info = buildDateInfo(s, YEAR_WEEK_FORMATTER, YEAR_WEEK_FORMATTER);
                result.add(info);
                localDate = s.plusWeeks(1L);
            } else {
                return result;
            }
        }
        */
    }

    private static DateInfo buildDateInfo(LocalDate date, DateTimeFormatter codeFormatter, DateTimeFormatter titleFormatter) {
        String code = date.format(codeFormatter);
        String title = date.format(titleFormatter);
        String dateStr = date.format(DATE_FORMATTER);
        Integer week = Integer.valueOf(date.get(WeekFields.of(DayOfWeek.MONDAY, 1).weekOfYear()));
        Integer month = Integer.valueOf(date.getMonthValue());
        Integer year = Integer.valueOf(date.getYear());
        return new DateInfo(code, title, dateStr, week, month, year);
    }

    public static LocalDateTime daysPlus(LocalDate localDate, int difference, TemporalUnit field) {
        return localDate.atStartOfDay().plus(difference, field);
    }

    public static Long getMinuteDuration(LocalDateTime startTime, LocalDateTime endTime) {
        Duration duration = Duration.between(startTime, endTime);
        long minutes = duration.toMinutes();
        return Long.valueOf(minutes);
    }

    public static Long getHourDuration(LocalDateTime startTime, LocalDateTime endTime) {
        Duration duration = Duration.between(startTime, endTime);
        long hours = duration.toHours();
        return Long.valueOf(hours);
    }

    public static LocalDateTime daysMinus(LocalDate localDate, int difference, TemporalUnit field) {
        return localDate.atStartOfDay().minus(difference, field);
    }

    public static LocalDate LocalDateTimeToLocalDate(LocalDateTime localDateTime) {
        return localDateTime.toLocalDate();
    }

    public static LocalDate dateToLocalDate(Date date) {
        if (null == date) {
            return null;
        }
        return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
    }

    public static LocalDateTime dateToLocalDateTime(Date date) {
        Instant instant = date.toInstant();
        ZoneId zoneId = ZoneId.systemDefault();
        LocalDateTime localDateTime = instant.atZone(zoneId).toLocalDateTime();
        return localDateTime;
    }

    public static LocalDate LocalDateTimeToLocalDate(String date) {
        return LocalDate.parse(date, DateTimeFormatter.ISO_LOCAL_DATE);
    }

    public static LocalDate getDayOfWeek(Integer year, Integer week) {
        WeekFields weekFields = WeekFields.of(Locale.getDefault());
        LocalDate ldt = LocalDate.now().withYear(year.intValue()).with(weekFields.weekOfYear(), week.intValue()).with(weekFields.dayOfWeek(), 2L);
        return ldt;
    }

    public static LocalDateTime DateToLocalDateTime(Date date) {
        Instant instant = date.toInstant();
        ZoneId zone = ZoneId.systemDefault();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, zone);
        return localDateTime;
    }

    public static List<String> getCurrentMonthDate() {
        LocalDate now = LocalDate.now();
        LocalDate startDate = LocalDate.of(now.getYear(), now.getMonth(), 1);
        LocalDate endDate = LocalDate.of(now.getYear(), now.getMonth(), now.lengthOfMonth());
        List<String> list = new ArrayList<>();
        long distance = ChronoUnit.DAYS.between(startDate, endDate);
        if (distance < 1) {
            return list;
        }
        Stream.iterate(startDate, d -> {
            return d.plusDays(1L);
        }).limit(distance + 1).forEach(f -> {
            list.add(f.toString());
        });
        return list;
    }

    public static List<LocalDateTime> getCurrentMonthLocalDate(LocalDate now) {
        LocalDateTime startNow = LocalDateTime.of(now.minusDays(2L), LocalTime.of(0, 0, 0));
        LocalDateTime endDate = LocalDateTime.of(now.getYear(), now.getMonthValue(), 1, 0, 0, 0);
        List<LocalDateTime> list = new ArrayList<>();
        long distance = ChronoUnit.DAYS.between(endDate, startNow);
        if (distance < 0) {
            return list;
        }
        Stream.<LocalDateTime>iterate(endDate, d -> d.plusDays(1L)).limit(distance + 1L).forEach(list::add);
        /*
        Stream limit = Stream.iterate(endDate, d -> {
            return d.plusDays(1L);
        }).limit(distance + 1);
        list.getClass();
        limit.forEach((v1) -> {
            r1.add(v1);
        });
        */
        
        return list;
    }

    public static List<LocalDateTime> getThirtyLocalDateTimeBeforeCurrent(LocalDate localDate) {
        LocalDateTime now = LocalDateTime.of(localDate.minusDays(2L), LocalTime.of(0, 0, 0));
        LocalDateTime endDate = LocalDateTime.of(localDate.minusDays(29L), LocalTime.of(0, 0, 0));
        List<LocalDateTime> list = new ArrayList<>();
        long distance = ChronoUnit.DAYS.between(endDate, now);
        if (distance < 1) {
            return list;
        }
        Stream.<LocalDateTime>iterate(endDate, d -> d.plusDays(1L)).limit(distance + 1L).forEach(list::add);
        /*
        Stream limit = Stream.iterate(endDate, d -> {
            return d.plusDays(1L);
        }).limit(distance + 1);
        list.getClass();
        limit.forEach((v1) -> {
            r1.add(v1);
        });*/
        return list;
    }

    public static List<LocalDate> getCurrentDaysTimeAxis(Integer currentDays) {
        LocalDate now = LocalDate.now();
        LocalDate endDate = now.minusDays(currentDays.intValue() - 1);
        List<LocalDate> list = new ArrayList<>();
        long distance = ChronoUnit.DAYS.between(endDate, now);
        if (distance < 1) {
            return list;
        }
        
        Stream.<LocalDate>iterate(endDate, d -> d.plusDays(1L)).limit(distance + 1L).forEach(list::add);
        /*
        Stream limit = Stream.iterate(endDate, d -> {
            return d.plusDays(1L);
        }).limit(distance + 1);
        list.getClass();
        limit.forEach((v1) -> {
            r1.add(v1);
        });
        */
        return list;
    }

    public static List<String> getNearlyTwelveMonth() {
        LocalDate now = LocalDate.now();
        LocalDate endDate = now.minusMonths(11L);
        List<String> list = new ArrayList<>();
        long distance = ChronoUnit.MONTHS.between(endDate, now);
        if (distance < 1) {
            return list;
        }
        
        Stream.<LocalDate>iterate(endDate, d -> d.plusMonths(1L)).limit(distance + 1L).forEach(o -> list.add(DateUtil.format(DateUtil.toDate(o), YEAR_MONTH_FORMAT)));
        /*
        Stream.iterate(endDate, d -> {
            return d.plusMonths(1L);
        }).limit(distance + 1).forEach(o -> {
            list.add(DateUtil.format(DateUtil.toDate(o), YEAR_MONTH_FORMAT));
        });*/
        return list;
    }

    public static List<String> getPreviousMonthDate() {
        LocalDate now = LocalDate.now();
        LocalDate startDate = now.minusDays(29L);
        List<String> list = new ArrayList<>();
        long distance = ChronoUnit.DAYS.between(startDate, now);
        if (distance < 1) {
            return list;
        }
        
        Stream.<LocalDate>iterate(startDate, d -> d.plusDays(1L)).limit(distance + 1L).forEach(f -> list.add(f.toString()));
        /*
        Stream.iterate(startDate, d -> {
            return d.plusDays(1L);
        }).limit(distance + 1).forEach(f -> {
            list.add(f.toString());
        });*/
        return list;
    }

    public static LocalDate stringToLocalDate(String date, String pattern) {
        Date parse = DateUtil.parse(date, pattern);
        return parse.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
    }

    public static Date localToDate(LocalDate localDate) {
        if (null == localDate) {
            return null;
        }
        ZonedDateTime zonedDateTime = localDate.atStartOfDay(ZoneId.systemDefault());
        return Date.from(zonedDateTime.toInstant());
    }

    public static String formatLocaldate(LocalDate localDate) {
        DateTimeFormatter fmt = DateTimeFormatter.ofPattern(DateConstant.PATTERN_DATE);
        String dateStr = localDate.format(fmt);
        return dateStr;
    }

    public static Date localDateTimeToDate(LocalDateTime localDateTime) {
        Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
        return date;
    }
}