package com.ruoyi.app.utils;

import com.ruoyi.app.mendian.dto.AppointmentTimeDto;
import com.ruoyi.system.domain.OperatingHours;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

public class OperatingUtil {
    /**
     * 判断当前时间是否在营业时间段内
     *
     * @param operatingHoursList
     * @return
     */
    public static boolean storeIsOperatingOfDay(List<OperatingHours> operatingHoursList) {
        boolean result = false;
        int day = LocalDate.now()
                .getDayOfWeek().getValue();
       List<OperatingHours> filters= operatingHoursList.stream().filter(operatingHours -> operatingHours.getDayOfWeek().equals(day) && operatingHours.getIsOpen()).collect(Collectors.toList()) ;
        DateUtil dateUtil = new DateUtil();
        for (OperatingHours operatingHours : filters) {
            //是否在上班时间内
            boolean sb = dateUtil.isLegalTime(operatingHours.getStartTime(), operatingHours.getEndTime());
            if (sb) {
                result = true;
                break;
            }
        }
       return result;
    }

    /**
     * 获取预约时间段列表
     * 按小时划分时间段，过滤掉当前时间之前的时间段
     *
     * @param dto 包含营业开始时间和结束时间的DTO
     * @return 可预约的时间段列表
     */
    public static List<AppointmentTimeDto> getAppointmentTime(AppointmentTimeDto dto) {
        List<AppointmentTimeDto> timeList = new ArrayList<>();

        // 定义时间格式，支持 "H:mm" 格式（如 "9:00"）
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("H:mm");

        // 解析营业时间
        LocalTime startTime = LocalTime.parse(dto.getStartTime(), formatter);
        LocalTime endTime = LocalTime.parse(dto.getEndTime(), formatter);
        LocalTime currentTime = LocalTime.now();

        // 按小时划分时间段
        LocalTime currentHour = startTime;
        while (currentHour.isBefore(endTime)) {
            LocalTime nextHour = currentHour.plusHours(1);

            // 如果下一个小时超过结束时间，则使用结束时间
            if (nextHour.isAfter(endTime)) {
                nextHour = endTime;
            }

            // 只添加当前时间之后的时间段（包括当前时间所在的时间段）
            // 如果时间段的结束时间大于当前时间，则包含该时间段
            if (nextHour.isAfter(currentTime)) {
                AppointmentTimeDto timeDto = new AppointmentTimeDto();
                timeDto.setStartTime(currentHour.toString());
                timeDto.setEndTime(nextHour.toString());
                timeList.add(timeDto);
            }

            currentHour = nextHour;
        }

        return timeList;
    }

    /**
     * 返回预约时间段，
     * 按小时划分时间段，过滤掉当前时间之前的时间段
     * @param hours 营业时间列表
     * @return 可预约的时间段列表，按小时划分（如 12:00-13:00）
     */
    public static List<AppointmentTimeDto> getAppointmentTime(List<OperatingHours> hours){
        List<AppointmentTimeDto> timeList = new ArrayList<>();

        if (hours == null || hours.isEmpty()) {
            return timeList;
        }

        // 获取当前是星期几（1=周一, ..., 7=周日）
        int currentDay = LocalDate.now().getDayOfWeek().getValue();
        LocalTime currentTime = LocalTime.now();

        // 定义时间格式，支持 "H:mm" 和 "HH:mm" 格式（如 "9:00" 或 "09:00"）
        DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("H:mm");
        DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("HH:mm");

        // 过滤出当天且营业的时间段
        List<OperatingHours> todayHours = hours.stream()
                .filter(h -> h.getDayOfWeek() != null && h.getDayOfWeek().equals(currentDay))
                .filter(h -> h.getIsOpen() != null && h.getIsOpen())
                .filter(h -> h.getStartTime() != null && h.getEndTime() != null)
                .collect(Collectors.toList());

        // 对每个营业时间段按小时划分
        for (OperatingHours operatingHour : todayHours) {
            try {
                LocalTime startTime;
                LocalTime endTime;

                // 尝试解析时间，支持两种格式
                try {
                    startTime = LocalTime.parse(operatingHour.getStartTime(), formatter1);
                } catch (Exception e) {
                    startTime = LocalTime.parse(operatingHour.getStartTime(), formatter2);
                }

                try {
                    endTime = LocalTime.parse(operatingHour.getEndTime(), formatter1);
                } catch (Exception e) {
                    endTime = LocalTime.parse(operatingHour.getEndTime(), formatter2);
                }

                // 将开始时间对齐到下一个整点（如果开始时间不是整点）
                LocalTime alignedStart = startTime;
                if (startTime.getMinute() > 0 || startTime.getSecond() > 0 || startTime.getNano() > 0) {
                    alignedStart = LocalTime.of(startTime.getHour() + 1, 0);
                    if (!alignedStart.isBefore(endTime)) {
                        continue;
                    }
                }

                // 按小时划分时间段
                LocalTime currentHour = alignedStart;
                while (currentHour.isBefore(endTime)) {
                    LocalTime nextHour = currentHour.plusHours(1);

                    if (!nextHour.isBefore(endTime)) {
                        nextHour = endTime;
                    }

                    if (nextHour.isAfter(currentTime)) {
                        AppointmentTimeDto timeDto = new AppointmentTimeDto();
                        timeDto.setStartTime(currentHour.format(DateTimeFormatter.ofPattern("HH:mm")));
                        timeDto.setEndTime(nextHour.format(DateTimeFormatter.ofPattern("HH:mm")));
                        timeList.add(timeDto);
                    }

                    if (nextHour.equals(endTime)) {
                        break;
                    }

                    currentHour = nextHour;
                }
            } catch (Exception e) {
                continue;
            }
        }

        return timeList;
    }


}
