package com.xjrsoft.module.courseTable.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteTable;
import com.alibaba.excel.write.metadata.style.WriteCellStyle;
import com.alibaba.excel.write.metadata.style.WriteFont;
import com.alibaba.excel.write.style.HorizontalCellStyleStrategy;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.xjrsoft.common.enums.CourseAdjustTypeEnum;
import com.xjrsoft.common.enums.DeleteMark;
import com.xjrsoft.common.enums.TimeNumberEnum;
import com.xjrsoft.common.enums.TimePeriodEnum;
import com.xjrsoft.common.enums.WeekEnum;
import com.xjrsoft.common.exception.MyException;
import com.xjrsoft.common.model.result.RT;
import com.xjrsoft.common.utils.VoToColumnUtil;
import com.xjrsoft.common.utils.excel.ExcelFillCellMergePrevColUtil;
import com.xjrsoft.common.utils.excel.ExcelMergeUtil;
import com.xjrsoft.config.TimetableConfig;
import com.xjrsoft.module.base.entity.BaseClass;
import com.xjrsoft.module.base.entity.BaseClassroom;
import com.xjrsoft.module.base.entity.BaseOfficeBuild;
import com.xjrsoft.module.base.entity.BaseSemester;
import com.xjrsoft.module.base.mapper.BaseClassroomMapper;
import com.xjrsoft.module.base.mapper.BaseOfficeBuildMapper;
import com.xjrsoft.module.base.mapper.BaseSemesterMapper;
import com.xjrsoft.module.base.service.IBaseClassService;
import com.xjrsoft.module.base.service.IBaseSemesterService;
import com.xjrsoft.module.courseTable.dto.ClassListDto;
import com.xjrsoft.module.courseTable.dto.ClassTeacherDto;
import com.xjrsoft.module.courseTable.dto.CourseTableParse;
import com.xjrsoft.module.courseTable.entity.ClassTime;
import com.xjrsoft.module.courseTable.entity.CourseTable;
import com.xjrsoft.module.courseTable.mapper.ClassTimeMapper;
import com.xjrsoft.module.courseTable.mapper.CourseTableMapper;
import com.xjrsoft.module.courseTable.service.ICourseTableService;
import com.xjrsoft.module.courseTable.vo.ClassListVo;
import com.xjrsoft.module.organization.entity.User;
import com.xjrsoft.module.organization.service.IUserService;
import com.xjrsoft.module.schedule.dto.ClassOptionDto;
import com.xjrsoft.module.schedule.dto.CourseTableAdjustDto;
import com.xjrsoft.module.schedule.dto.CourseTableDto;
import com.xjrsoft.module.schedule.dto.CourseTableExportQueryDto;
import com.xjrsoft.module.schedule.dto.ScheduleWeekExportQueryDto;
import com.xjrsoft.module.schedule.entity.CourseTableBak;
import com.xjrsoft.module.schedule.entity.WfCourseAdjust;
import com.xjrsoft.module.schedule.mapper.CourseTableBakMapper;
import com.xjrsoft.module.schedule.util.CourseTableExportQueryUtil;
import com.xjrsoft.module.schedule.util.ScheduleUtil;
import com.xjrsoft.module.schedule.vo.*;
import com.xjrsoft.module.student.entity.BaseStudentSchoolRoll;
import com.xjrsoft.module.student.service.IBaseStudentSchoolRollService;
import com.xjrsoft.module.teacher.entity.BaseTeacher;
import com.xjrsoft.module.teacher.entity.XjrUser;
import com.xjrsoft.module.teacher.service.ITeacherbaseManagerService;
import com.xjrsoft.module.veb.util.ImportExcelUtil;
import lombok.AllArgsConstructor;
import me.zhyd.oauth.log.Log;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xwpf.usermodel.*;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 课表 服务实现类
 * </p>
 *
 * @author baomidou
 * @since 2023-09-02 02:19:56
 */
@Service
@AllArgsConstructor
public class CourseTableServiceImpl extends ServiceImpl<CourseTableMapper, CourseTable> implements ICourseTableService {

    private final CourseTableMapper courseTableMapper;

    private final IBaseClassService baseClassService;

    private final ITeacherbaseManagerService teacherbaseManagerService;

    private final IBaseSemesterService baseSemesterService;

    private final TimetableConfig timetableConfig;

    private final ClassTimeMapper classTimeMapper;
    private final BaseSemesterMapper baseSemesterMapper;
    private final IBaseStudentSchoolRollService baseStudentSchoolRollService;
    private final CourseTableBakMapper courseTableBakMapper;
    private final IUserService userService;
    private final BaseClassroomMapper classroomMapper;
    private final BaseOfficeBuildMapper officeBuildMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean wordImport(InputStream inputStream) throws IOException {
        List<CourseTableParse> parses = courseTableWordParses(inputStream);


        String semester = null;
        if (parses.size() > 0) {
            semester = parses.get(0).getSemester();
        }

        BaseSemester baseSemester = baseSemesterService.getOne(Wrappers.<BaseSemester>query().lambda().eq(BaseSemester::getName, semester));
        if (baseSemester == null) {
            throw new MyException(String.format("学期【%s】不存在", semester));
        }

        // 获取班级信息
        List<BaseClass> baseClassList = baseClassService.list();
        Map<String, BaseClass> baseClassMap = baseClassList.stream().collect(Collectors.toMap(BaseClass::getName, a -> a, (k1, k2) -> k1));

        // 获取教师信息
        MPJLambdaWrapper<XjrUser> queryWrapper = new MPJLambdaWrapper<>();
        queryWrapper.disableSubLogicDel().innerJoin(BaseTeacher.class, BaseTeacher::getUserId, XjrUser::getId).selectAll(XjrUser.class);
        List<XjrUser> xjrUserList = teacherbaseManagerService.list(queryWrapper);
        Map<String, XjrUser> xjrUsersMap = xjrUserList.stream().collect(Collectors.toMap(XjrUser::getName, a -> a, (k1, k2) -> k1));

        // 清空所有数据
        courseTableMapper.delete(Wrappers.<CourseTable>query().lambda().eq(CourseTable::getBaseSemesterId, baseSemester.getId()));

        List<CourseTable> params = new ArrayList<>();
        for (CourseTableParse item : parses) {
            CourseTable courseTable = BeanUtil.toBean(item, CourseTable.class);
            courseTable.setBaseSemesterId(baseSemester.getId());
            BaseClass baseClass = baseClassMap.get(item.getClassName());
            if (baseClass != null) {
                courseTable.setClassId(baseClass.getId());
            }
            XjrUser xjrUser = xjrUsersMap.get(item.getTeacherName());
            if (xjrUser != null) {
                courseTable.setTeacherId(xjrUser.getId().toString());
            }
            if (item.getWeeksCn() != null) {
                courseTable.setWeeks(WeekEnum.getCode(item.getWeeksCn()));
            }
            params.add(courseTable);
        }
        return this.saveBatch(params);
    }

    @Override
    public List<ClassListVo> classList(ClassListDto dto) {
        LambdaQueryWrapper<CourseTable> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseTable::getClassId, dto.getClassId()).eq(ObjectUtil.isNotEmpty(dto.getWeeks()), CourseTable::getWeeks, dto.getWeeks());

        List<CourseTable> courseTables = courseTableMapper.selectList(queryWrapper);

        List<ClassListVo> classListVos = BeanUtil.copyToList(courseTables, ClassListVo.class);
        Boolean isCurrentSummer = isCurrentSummer();

        Map<String, ClassTime> classTimeMap = getClassTimeMap();

        // 获取节次时间
        for (int i = 0; i < classListVos.size(); i++) {
            ClassListVo c = classListVos.get(i);
            String key = String.format("%d_%d", c.getTimePeriod(), c.getTimeNumber());
            ClassTime ct = classTimeMap.get(key);
            if (ct != null) {
                if (isCurrentSummer) {
                    c.setStartTime(ct.getSummerStartTime());
                    c.setEndTime(ct.getSummerEndTime());
                } else {
                    c.setStartTime(ct.getWinterStartTime());
                    c.setEndTime(ct.getWinterEndTime());
                }
            }
        }
        return classListVos;
    }

    @Override
    public CourseTableVo getList(CourseTableDto dto) {

        List<ClassTime> classTimes = classTimeMapper.selectList(new QueryWrapper<ClassTime>().lambda().ne(ClassTime::getTimePeriod, 0).orderByAsc(ClassTime::getSummerStartTime)

        );

        CourseTableVo tableVo = new CourseTableVo();
        tableVo.setClassTimeList(classTimes);

        if (dto.getSemesterId() != null) {
            BaseSemester baseSemester = baseSemesterMapper.selectById(dto.getSemesterId());
            tableVo.setSemesterName(baseSemester.getName());
            LocalDateTime now = LocalDateTime.now();
            // 计算本周是第几周
            LocalDate semesterStart = LocalDate.ofInstant(baseSemester.getTeachingStart().toInstant(), ZoneId.systemDefault());
            LocalDate semesterEnd = LocalDate.ofInstant(baseSemester.getTeachingEnd().toInstant(), ZoneId.systemDefault());

            // 调整到完整的周范围（周一到周日）
            LocalDate weekStart = semesterStart.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));
            LocalDate weekEnd = semesterEnd.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));

            // 计算总周数
            long totalWeeks = ChronoUnit.WEEKS.between(weekStart, weekEnd.plusDays(1)); // 加1天以确保包含最后一周

            if (dto.getWeek() == null) {
                // 查找当前日期所在的周
                long weeksBetween = ChronoUnit.WEEKS.between(weekStart, now);
                LocalDate calculatedWeekStart = weekStart.plusWeeks(weeksBetween);
                LocalDate calculatedWeekEnd = calculatedWeekStart.plusDays(6);

                // 验证是否在学期范围内
                LocalDate nowDate = now.toLocalDate();

                if (!nowDate.isBefore(weekStart) && !nowDate.isAfter(weekEnd)) {
                    int currentWeek = (int) (weeksBetween + 1);
                    tableVo.setWeek("第" + currentWeek + "周");
                    tableVo.setStartDate(calculatedWeekStart);
                    tableVo.setEndDate(calculatedWeekEnd);
                } else {
                    tableVo.setWeek("不在学期范围内");
                    tableVo.setStartDate(weekStart);
                    tableVo.setEndDate(weekEnd);
                }
            } else {
                // 根据指定周数计算日期范围
                int weekNumber = dto.getWeek();
                if (weekNumber < 1 || weekNumber > totalWeeks) {
                    throw new MyException("周数必须在1到" + totalWeeks + "之间");
                }

                LocalDateTime semesterStartDateTime = baseSemester.getTeachingStart().toInstant()
                        .atZone(ZoneId.systemDefault())
                        .toLocalDateTime();

                LocalDateTime weekStartDateTime = semesterStartDateTime
                        .plusWeeks(weekNumber - 1)
                        .toLocalDate()
                        .with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY))
                        .atStartOfDay();

                LocalDateTime weekEndDateTime = weekStartDateTime.plusDays(6)
                        .with(LocalTime.MAX);

                dto.setStartDate(weekStartDateTime);
                dto.setEndDate(weekEndDateTime);
                tableVo.setWeek("第" + weekNumber + "周");
                tableVo.setWeek("第" + weekNumber + "周");
                tableVo.setStartDate(weekStartDateTime.toLocalDate());
                tableVo.setEndDate(weekEndDateTime.toLocalDate());
            }
        }
        if (!StrUtil.isEmpty(dto.getTeacherName())) {
            List<XjrUser> userList = teacherbaseManagerService.list(new QueryWrapper<XjrUser>().lambda().like(!StrUtil.isEmpty(dto.getTeacherName()), XjrUser::getName, dto.getTeacherName()));
            List<XjrUser> userList2 = teacherbaseManagerService.list(new QueryWrapper<XjrUser>().lambda().like(!StrUtil.isEmpty(dto.getTeacherName()), XjrUser::getCode, dto.getTeacherName()));
            userList.addAll(userList2);
            if (!userList.isEmpty()) {
                XjrUser xjrUser = userList.get(0);
                dto.setTeacherId(xjrUser.getId());
                tableVo.setTeacherName(xjrUser.getName());
            }
        }
        if (dto.getStartDate() != null && dto.getEndDate() != null && dto.getIsCustom() == null) {
            if (dto.getStudentId() == null && dto.getTeacherId() == null && dto.getClassId() == null) {
                dto.setTeacherId(StpUtil.getLoginIdAsLong());
            } else {
                List<BaseStudentSchoolRoll> schoolRolls = baseStudentSchoolRollService.list(new QueryWrapper<BaseStudentSchoolRoll>().lambda().eq(BaseStudentSchoolRoll::getUserId, dto.getStudentId()));
                if (schoolRolls != null && !schoolRolls.isEmpty()) {
                    dto.setCourseType("class");
                    dto.setClassId(schoolRolls.get(0).getClassId());
                }
            }
        }
        List<CourseDetailVo> list = courseTableMapper.getList(dto);
        tableVo.setCourseList(list);
        tableVo.setClassHour(list.size());
        if (dto.getClassId() != null) {
            BaseClass baseClass = baseClassService.getById(dto.getClassId());
            tableVo.setClassName(baseClass.getName());
        }

        return tableVo;
    }

    /**
     * 调课顶课查询
     */
    @Override
    public List<CourseListVo> getAdjustList(String teacherId, String adjustDate, String classId, String adjustType) {
        CourseTableAdjustDto dto = new CourseTableAdjustDto();
        if (adjustDate != null && !"".equals(adjustDate)) {
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
            LocalDate localDateTime = LocalDate.parse(adjustDate, formatter);
            DayOfWeek dayOfWeek = localDateTime.getDayOfWeek();
            dto.setAdjustDate(adjustDate);
            dto.setWeek(dayOfWeek.getValue());
        }
        dto.setClassId(classId);
        if (teacherId != null && !"".equals(teacherId)) {
            dto.setTeacherId(Long.parseLong(teacherId));
        }
        dto.setAdjustType(adjustType);
        //查询正在进行中或者已经完成
        List<Long> courseIds = courseTableMapper.getExceptCourseIds(dto.getTeacherId());
        dto.setExceptCourseList(courseIds);
        List<CourseListVo> list = courseTableMapper.getAdjustList(dto);
        for (CourseListVo courseListVo : list) {
            if (courseListVo.getTimePeriod() == 1) {
                courseListVo.setTimePeriodCn("上午");
            } else if (courseListVo.getTimePeriod() == 2) {
                courseListVo.setTimePeriodCn("下午");
            } else if (courseListVo.getTimePeriod() == 3) {
                courseListVo.setTimePeriodCn("晚上");
            }
        }
        return list;
    }

    @Override
    public String getPreCheck(String preCheckType, String courseId, String swapCourseId, String swapDate, String subTeacherId) {
        if (preCheckType != null && !"".equals(preCheckType)) {
            if (CourseAdjustTypeEnum.courseExchange.getCode().equals(preCheckType)) {
                CourseTable courseTable = courseTableMapper.selectById(courseId);
                CourseTable swapCourseTable = courseTableMapper.selectById(swapCourseId);
                try {
                    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
                    LocalDate localDateTime = LocalDate.parse(swapDate, formatter);
                    JsonObject preCheck = getExtendPreCheck(localDateTime, courseTable, swapCourseTable);
                    if (preCheck.get("code").getAsInt() == -1 && !preCheck.get("msg").isJsonNull()) {
                        return preCheck.get("msg").getAsString();
                    }
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }

            } else if (CourseAdjustTypeEnum.courseSubstitute.getCode().equals(preCheckType)) {
                CourseTable courseTable = courseTableMapper.selectById(courseId);
                try {
                    JsonObject jsonObject = substitutePreTestin(subTeacherId, courseTable);
                    if (jsonObject.get("code").getAsInt() == -1 && !jsonObject.get("msg").isJsonNull()) {
                        return jsonObject.get("msg").getAsString();
                    }
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return null;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean adjustCourse(WfCourseAdjust courseAdjust) {
        //先查询课表数据，看是否能够查询到，如果能查到
        List<CourseTable> list = this.list(new MPJLambdaWrapper<CourseTable>().select(CourseTable::getId).select(CourseTable.class, x -> VoToColumnUtil.fieldsToColumns(CourseTable.class).contains(x.getProperty())).innerJoin(CourseTableBak.class, CourseTableBak::getId, CourseTable::getId).eq(CourseTableBak::getWfCourseAdjustId, courseAdjust.getId()));
        String[] courseIds = courseAdjust.getCourseId().split(",");

        ArrayList<String> courseIdList = new ArrayList<>(Arrays.asList(courseIds));

        String[] exchangeCourseIds = null;
        int courseCount = courseIds.length;
        if (CourseAdjustTypeEnum.courseExchange.getCode().equals(courseAdjust.getAdjustType())) {
            exchangeCourseIds = courseAdjust.getExchangeCourseId().split(",");
            courseCount += exchangeCourseIds.length;
            courseIdList.addAll(Arrays.asList(exchangeCourseIds));
        }
        LocalDateTime now = LocalDateTime.now();

        if (list.isEmpty() || list.size() != courseCount) {
            list = this.list(new MPJLambdaWrapper<CourseTable>().select(CourseTable::getId).select(CourseTable.class, x -> VoToColumnUtil.fieldsToColumns(CourseTable.class).contains(x.getProperty())).innerJoin(CourseTableBak.class, CourseTableBak::getKeyInfo, CourseTable::getKeyInfo).eq(CourseTableBak::getWfCourseAdjustId, courseAdjust.getId()));
            Map<String, CourseTable> courseMap = list.stream().collect(Collectors.toMap(CourseTable::getKeyInfo, x -> x));
            List<CourseTableBak> bakList = courseTableBakMapper.selectList(new QueryWrapper<CourseTableBak>().lambda().eq(CourseTableBak::getWfCourseAdjustId, courseAdjust.getId()));
            Map<Long, String> bakKeyInfoMap = bakList.stream().collect(Collectors.toMap(CourseTableBak::getId, CourseTableBak::getKeyInfo));
            Map<Long, CourseTableBak> bakCourseMap = bakList.stream().collect(Collectors.toMap(CourseTableBak::getId, x -> x));

            if (CourseAdjustTypeEnum.courseExchange.getCode().equals(courseAdjust.getAdjustType())) {
                for (int i = 0; i < courseIds.length; i++) {
                    String courseId = courseIds[i];
                    String exchangeCourseId = exchangeCourseIds[i];
                    if (StrUtil.isEmpty(exchangeCourseId)) {
                        continue;
                    }

                    //调课，将双方课程的日期（schedule_date）、时段（time_period）、节次（time_number）、周（week）、星期几(1-7)（weeks）、星期中文（weeks_cn）对调
                    CourseTable courseTable = courseMap.get(bakKeyInfoMap.get(Long.parseLong(courseId)));
                    if (courseTable == null) {
                        continue;
                    }

                    CourseTable swapCourseTable = courseMap.get(bakKeyInfoMap.get(Long.parseLong(exchangeCourseId)));
                    if (swapCourseTable == null) {
                        continue;
                    }
                    CourseTableBak courseTableBak = bakCourseMap.get(Long.parseLong(courseId));
                    CourseTableBak swapCourseTableBak = bakCourseMap.get(Long.parseLong(exchangeCourseId));

                    courseTable.setAdjustType(courseAdjust.getAdjustType());
                    courseTable.setCourseName(swapCourseTableBak.getCourseName());
                    courseTable.setCourseId(swapCourseTableBak.getCourseId());
                    courseTable.setTeacherId(swapCourseTableBak.getTeacherId());
                    courseTable.setSiteId(swapCourseTableBak.getSiteId());
                    courseTable.setTeacherName(swapCourseTableBak.getTeacherName());
//                    courseTable.setKeyInfo(courseTable.getTeacherId() + "_"
//                            + courseTable.getClassId() + "_"
//                            + courseTable.getScheduleDate() + "_"
//                            + courseTable.getCourseId() + "_"
//                            + courseTable.getSiteId() + "_"
//                            + courseTable.getTimeNumber()
//                    );
                    courseTableMapper.updateById(courseTable);

                    swapCourseTable.setAdjustType(courseAdjust.getAdjustType());
//                    swapCourseTable.setKeyInfo(swapCourseTable.getTeacherId() + "_"
//                            + swapCourseTable.getClassId() + "_"
//                            + swapCourseTable.getScheduleDate() + "_"
//                            + swapCourseTable.getCourseId() + "_"
//                            + swapCourseTable.getSiteId() + "_"
//                            + swapCourseTable.getTimeNumber()
//                    );
                    swapCourseTable.setCourseId(courseTableBak.getCourseId());
                    swapCourseTable.setCourseName(courseTableBak.getCourseName());
                    swapCourseTable.setTeacherId(courseTableBak.getTeacherId());
                    swapCourseTable.setSiteId(courseTableBak.getSiteId());
                    swapCourseTable.setTeacherName(courseTableBak.getTeacherName());
                    courseTableMapper.updateById(swapCourseTable);
                }
                //提交调课接口
                //sendExchange(courseTableBak, swapCourseTableBak, courseAdjust);
            } else if (CourseAdjustTypeEnum.courseSubstitute.getCode().equals(courseAdjust.getAdjustType())) {
                for (String courseId : courseIds) {
                    CourseTable courseTable = courseMap.get(bakKeyInfoMap.get(Long.parseLong(courseId)));
                    if (courseTable == null) {
                        continue;
                    }

                    User applyUser = userService.getById(courseAdjust.getUserId());//申请人
                    User exchangeUser = userService.getById(courseAdjust.getExchangeTeacherId());//顶课人

                    String teacherId = courseTable.getTeacherId().replace(courseAdjust.getUserId().toString(), courseAdjust.getExchangeTeacherId());
                    String teacherName = courseTable.getTeacherName().replace(applyUser.getName(), exchangeUser.getName());
                    courseTable.setAdjustType(courseAdjust.getAdjustType());
                    courseTable.setTeacherId(teacherId);
                    courseTable.setTeacherName(teacherName);

//                    courseTable.setKeyInfo(teacherId + "_" + courseTable.getClassId() + "_" + courseTable.getScheduleDate() + "_" + courseTable.getCourseId() + "_" + courseTable.getSiteId() + "_" + courseTable.getTimeNumber());
                    courseTableMapper.updateById(courseTable);
                }

                //提交顶课接口
                //sendSubstitute(courseTable, courseAdjust);
            }
        } else {
            if (CourseAdjustTypeEnum.courseExchange.getCode().equals(courseAdjust.getAdjustType())) {
                for (int i = 0; i < courseIds.length; i++) {
                    String courseId = courseIds[i];
                    String exchangeCourseId = exchangeCourseIds[i];

                    //调课，将双方课程的日期（schedule_date）、时段（time_period）、节次（time_number）、周（week）、星期几(1-7)（weeks）、星期中文（weeks_cn）对调
                    CourseTable courseTable = courseTableMapper.selectById(courseId);
                    CourseTable swapCourseTable = courseTableMapper.selectById(exchangeCourseId);
                    if (courseTable == null || swapCourseTable == null) {
                        continue;
                    }

                    CourseTable courseTableBak = BeanUtil.toBean(courseTable, CourseTable.class);
                    CourseTable swapCourseTableBak = BeanUtil.toBean(swapCourseTable, CourseTable.class);

                    courseTable.setAdjustType(courseAdjust.getAdjustType());
                    courseTable.setCourseName(swapCourseTableBak.getCourseName());
                    courseTable.setCourseId(swapCourseTableBak.getCourseId());
                    courseTable.setTeacherId(swapCourseTableBak.getTeacherId());
                    courseTable.setSiteId(swapCourseTableBak.getSiteId());
                    courseTable.setTeacherName(swapCourseTableBak.getTeacherName());
//                    courseTable.setKeyInfo(courseTable.getTeacherId() + "_"
//                            + courseTable.getClassId() + "_"
//                            + courseTable.getScheduleDate() + "_"
//                            + courseTable.getCourseId() + "_"
//                            + courseTable.getSiteId() + "_"
//                            + courseTable.getTimeNumber()
//                    );
                    courseTable.setModifyDate(now);
                    courseTableMapper.updateById(courseTable);

                    swapCourseTable.setAdjustType(courseAdjust.getAdjustType());
//                    swapCourseTable.setKeyInfo(swapCourseTable.getTeacherId() + "_"
//                            + swapCourseTable.getClassId() + "_"
//                            + swapCourseTable.getScheduleDate() + "_"
//                            + swapCourseTable.getCourseId() + "_"
//                            + swapCourseTable.getSiteId() + "_"
//                            + swapCourseTable.getTimeNumber()
//                    );
                    swapCourseTable.setCourseId(courseTableBak.getCourseId());
                    swapCourseTable.setCourseName(courseTableBak.getCourseName());
                    swapCourseTable.setTeacherId(courseTableBak.getTeacherId());
                    swapCourseTable.setSiteId(courseTableBak.getSiteId());
                    swapCourseTable.setTeacherName(courseTableBak.getTeacherName());
                    swapCourseTable.setModifyDate(now);
                    courseTableMapper.updateById(swapCourseTable);
                }
                //提交调课接口
                //sendExchange(courseTableBak, swapCourseTableBak, courseAdjust);
            } else if (CourseAdjustTypeEnum.courseSubstitute.getCode().equals(courseAdjust.getAdjustType())) {
                for (String courseId : courseIds) {
                    CourseTable courseTable = courseTableMapper.selectById(courseId);
                    if (courseTable == null) {
                        continue;
                    }

                    User applyUser = userService.getById(courseAdjust.getUserId());//申请人
                    User exchangeUser = userService.getById(courseAdjust.getExchangeTeacherId());//顶课人

                    String teacherId = courseTable.getTeacherId().replace(courseAdjust.getUserId().toString(), courseAdjust.getExchangeTeacherId());
                    String teacherName = courseTable.getTeacherName().replace(applyUser.getName(), exchangeUser.getName());
                    courseTable.setAdjustType(courseAdjust.getAdjustType());
                    courseTable.setTeacherId(teacherId);
                    courseTable.setTeacherName(teacherName);
                    courseTable.setModifyDate(now);
//                    courseTable.setKeyInfo(teacherId + "_" + courseTable.getClassId() + "_" + courseTable.getScheduleDate() + "_" + courseTable.getCourseId() + "_" + courseTable.getSiteId() + "_" + courseTable.getTimeNumber());
                    courseTableMapper.updateById(courseTable);
                }

                //提交顶课接口
                //sendSubstitute(courseTable, courseAdjust);
            }
        }

        return Boolean.TRUE;
    }

    @Override
    public ByteArrayOutputStream listScheduleWeekExportQuery(ScheduleWeekExportQueryDto dto) {
        // 创建一个字节输出流
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

        // 获取课程表数据
        CourseTableVo courseTableVo = getCourseTableVo(dto);

        // 构建课程安排导出列表
        List<ScheduleWeekExportQueryVo> scheduleWeekExportQueryVoList = buildScheduleWeekExportQueryList(courseTableVo);

        // 将数据写入Excel文件
        writeScheduleWeekExportToExcel(courseTableVo, outputStream, scheduleWeekExportQueryVoList);

        return outputStream;
    }

    @Override
    public List<ClassOptionVo> getClassListByTeacherId(ClassOptionDto dto) {
        return this.baseMapper.getClassListByTeacherId(dto);
    }

    private CourseTableVo getCourseTableVo(ScheduleWeekExportQueryDto dto) {
        CourseTableDto courseTableDto = new CourseTableDto();
        BeanUtils.copyProperties(dto, courseTableDto);
        return this.getList(courseTableDto);
    }

    private List<ScheduleWeekExportQueryVo> buildScheduleWeekExportQueryList(CourseTableVo courseTableVo) {
        List<ClassTime> classTimeList = courseTableVo.getClassTimeList();
        List<CourseDetailVo> courseList = courseTableVo.getCourseList();
        List<ScheduleWeekExportQueryVo> scheduleWeekExportQueryVoList = new ArrayList<>();

        if (!courseList.isEmpty()) {
            Map<Integer, Map<Integer, List<CourseDetailVo>>> courseDetailVoMap = buildCourseDetailMap(courseList);
            scheduleWeekExportQueryVoList.addAll(buildScheduleWeekExportQueryVoList(courseDetailVoMap, classTimeList));
        }

        return scheduleWeekExportQueryVoList;
    }

    private Map<Integer, Map<Integer, List<CourseDetailVo>>> buildCourseDetailMap(List<CourseDetailVo> courseList) {
        // 实现构建课程详情Map的逻辑
        Map<Integer, Map<Integer, List<CourseDetailVo>>> courseDetailVoMap = new HashMap<>();

        for (CourseDetailVo courseDetailVo : courseList) {
            int timePeriod = Integer.parseInt(courseDetailVo.getTimePeriod().trim());
            int timeNumber = Integer.parseInt(courseDetailVo.getTimeNumber().trim());

            // 如果时间段不存在，则创建一个新的时间段Map
            courseDetailVoMap.putIfAbsent(timePeriod, new HashMap<>());

            // 获取当前时间段的Map
            Map<Integer, List<CourseDetailVo>> timePeriodMap = courseDetailVoMap.get(timePeriod);

            // 如果时间序号不存在，则创建一个新的课程列表
            timePeriodMap.putIfAbsent(timeNumber, new ArrayList<>());

            // 将课程详情添加到对应的时间段和时间序号中
            timePeriodMap.get(timeNumber).add(courseDetailVo);
        }

        // 返回构建好的课程详情Map
        return courseDetailVoMap;
    }

    private List<ScheduleWeekExportQueryVo> buildScheduleWeekExportQueryVoList(Map<Integer, Map<Integer, List<CourseDetailVo>>> courseDetailVoMap, List<ClassTime> classTimeList) {
        List<ScheduleWeekExportQueryVo> scheduleWeekExportQueryVoList = new ArrayList<>();
        // 实现构建ScheduleWeekExportQueryVo对象列表的逻辑
        for (ClassTime classTime : classTimeList) {
            ScheduleWeekExportQueryVo scheduleWeekExportQueryVo = new ScheduleWeekExportQueryVo();
            scheduleWeekExportQueryVo.setTimePeriod(TimePeriodEnum.getValue(classTime.getTimePeriod()));
            scheduleWeekExportQueryVo.setTimeNumber(TimeNumberEnum.getValue(classTime.getNumber()));

            Map<Integer, List<CourseDetailVo>> timePeriodListMap = courseDetailVoMap.get(classTime.getTimePeriod());
            if (timePeriodListMap != null) {
                List<CourseDetailVo> courseDetailVoList = timePeriodListMap.get(classTime.getNumber());
                if (courseDetailVoList != null) {
                    for (CourseDetailVo courseDetailVo : courseDetailVoList) {
                        for (int i = 1; i <= 7; i++) {
                            if (courseDetailVo.getWeeks() != i) {
                                continue;
                            }
                            if (courseDetailVo != null) {
                                String courseInfo = courseDetailVo.getCourseName() + "\n" + courseDetailVo.getTeacherName() + "\n" + courseDetailVo.getClassName() + "\n" + courseDetailVo.getClassroomName() + "\n";
                                switch (i) {
                                    case 1:
                                        scheduleWeekExportQueryVo.setMonday(courseInfo);
                                        break;
                                    case 2:
                                        scheduleWeekExportQueryVo.setTuesday(courseInfo);
                                        break;
                                    case 3:
                                        scheduleWeekExportQueryVo.setWednesday(courseInfo);
                                        break;
                                    case 4:
                                        scheduleWeekExportQueryVo.setThursday(courseInfo);
                                        break;
                                    case 5:
                                        scheduleWeekExportQueryVo.setFriday(courseInfo);
                                        break;
                                    case 6:
                                        scheduleWeekExportQueryVo.setSaturday(courseInfo);
                                        break;
                                    case 7:
                                        scheduleWeekExportQueryVo.setSunday(courseInfo);
                                        break;
                                }
                            }
                        }
                    }
                }
            }

            scheduleWeekExportQueryVoList.add(scheduleWeekExportQueryVo);
        }
        // 返回构建好的ScheduleWeekExportQueryVo对象列表
        return scheduleWeekExportQueryVoList;
    }

    private void writeScheduleWeekExportToExcel(CourseTableVo courseTableVo, ByteArrayOutputStream outputStream, List<ScheduleWeekExportQueryVo> scheduleWeekExportQueryVoList) {
        // 创建内容样式
        WriteCellStyle contentWriteCellStyle = createContentCellStyle();
        // 创建头部样式
        WriteCellStyle headWriteCellStyle = createHeadCellStyle();
        // 将数据写入Excel文件
        try (ExcelWriter excelWriter = EasyExcel.write(outputStream, ScheduleWeekExportQueryVo.class).registerWriteHandler(new HorizontalCellStyleStrategy(headWriteCellStyle, contentWriteCellStyle)).build()) {

            writeSheetHead(courseTableVo, excelWriter);

            writeSheetContent(excelWriter, scheduleWeekExportQueryVoList);

        }
    }

    private void writeSheetContent(ExcelWriter excelWriter, List<ScheduleWeekExportQueryVo> scheduleWeekExportQueryVoList) {
        int mergeRowIndex = 2;
        int[] mergeColumeIndex = {0};
        ExcelMergeUtil excelFillCellMergeStrategy = new ExcelMergeUtil(mergeRowIndex, mergeColumeIndex);

        WriteTable writeSheetContentTable = EasyExcel.writerTable(1).needHead(Boolean.TRUE).automaticMergeHead(Boolean.TRUE).registerWriteHandler(excelFillCellMergeStrategy).build();
        excelWriter.write(scheduleWeekExportQueryVoList, EasyExcel.writerSheet("模板").build(), writeSheetContentTable);
    }

    private void writeSheetHead(CourseTableVo courseTableVo, ExcelWriter excelWriter) {
        List<List<String>> sheetHeadList = new ArrayList<>();
        sheetHeadList.add(Collections.singletonList(courseTableVo.getSemesterName() + " " + ((courseTableVo.getTeacherName() != null) ? courseTableVo.getTeacherName() : courseTableVo.getClassName()) + " " + courseTableVo.getWeek() + " " + "课程表"));

        ExcelFillCellMergePrevColUtil sheetHeadColumn = new ExcelFillCellMergePrevColUtil();
        sheetHeadColumn.add(0, 0, 8);

        WriteTable writeSheetHeadTable = EasyExcel.writerTable(0).needHead(Boolean.TRUE).head(sheetHeadList).registerWriteHandler(sheetHeadColumn).build();
        excelWriter.write(new ArrayList<>(), EasyExcel.writerSheet("模板").needHead(Boolean.FALSE).build(), writeSheetHeadTable);
    }

    private WriteCellStyle createContentCellStyle() {
        WriteCellStyle contentWriteCellStyle = new WriteCellStyle();
        contentWriteCellStyle.setHorizontalAlignment(HorizontalAlignment.CENTER);
        contentWriteCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
        contentWriteCellStyle.setWrapped(true);

        WriteFont contentWriteFont = new WriteFont();
        contentWriteFont.setFontHeightInPoints((short) 12);
        contentWriteFont.setFontName("宋体");
        contentWriteCellStyle.setWriteFont(contentWriteFont);

        contentWriteCellStyle.setBorderBottom(BorderStyle.THIN);
        contentWriteCellStyle.setBottomBorderColor(IndexedColors.BLACK.getIndex());
        contentWriteCellStyle.setBorderLeft(BorderStyle.THIN);
        contentWriteCellStyle.setLeftBorderColor(IndexedColors.BLACK.getIndex());
        contentWriteCellStyle.setBorderRight(BorderStyle.THIN);
        contentWriteCellStyle.setRightBorderColor(IndexedColors.BLACK.getIndex());
        contentWriteCellStyle.setBorderTop(BorderStyle.THIN);
        contentWriteCellStyle.setTopBorderColor(IndexedColors.BLACK.getIndex());

        return contentWriteCellStyle;
    }

    private WriteCellStyle createHeadCellStyle() {
        WriteCellStyle headWriteCellStyle = new WriteCellStyle();
        WriteFont headWriteFont = new WriteFont();
        headWriteFont.setFontName("宋体");
        headWriteFont.setFontHeightInPoints((short) 14);
        headWriteFont.setBold(true);
        headWriteCellStyle.setWriteFont(headWriteFont);

        headWriteCellStyle.setBorderBottom(BorderStyle.THIN);
        headWriteCellStyle.setBottomBorderColor(IndexedColors.BLACK.getIndex());
        headWriteCellStyle.setBorderLeft(BorderStyle.THIN);
        headWriteCellStyle.setLeftBorderColor(IndexedColors.BLACK.getIndex());
        headWriteCellStyle.setBorderRight(BorderStyle.THIN);
        headWriteCellStyle.setRightBorderColor(IndexedColors.BLACK.getIndex());
        headWriteCellStyle.setBorderTop(BorderStyle.THIN);
        headWriteCellStyle.setTopBorderColor(IndexedColors.BLACK.getIndex());
        headWriteCellStyle.setWrapped(true);
        headWriteCellStyle.setHorizontalAlignment(HorizontalAlignment.CENTER);
        headWriteCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
        headWriteCellStyle.setShrinkToFit(true);

        return headWriteCellStyle;
    }

    /**
     * 提交顶课接口
     *
     * @param courseTable
     * @param courseAdjust
     * @throws Exception
     */
    void sendSubstitute(CourseTable courseTable, WfCourseAdjust courseAdjust) throws Exception {
        String url = ScheduleUtil.apiUrl + "RescheduleApply/Extend/Substitute/Submit";
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("timetableId", courseTable.getJianyueId());
        jsonObject.addProperty("isCycles", Boolean.FALSE);
        jsonObject.addProperty("reason", courseAdjust.getReason());
        jsonObject.addProperty("teacherId", courseAdjust.getUserId());
        JsonArray extendIds = new JsonArray();
        extendIds.add(courseTable.getTeacherId());
        jsonObject.add("extendIds", extendIds);

        //获取时间戳
        long timestamp = System.currentTimeMillis();
        //生成签名
        String sign = ScheduleUtil.createSign(timestamp);
        String result = ScheduleUtil.doPost(url, jsonObject.toString(), sign, timestamp);
    }

    /**
     * 提交调课
     *
     * @param courseTable
     * @param swapCourseTable
     * @throws Exception
     */
    void sendExchange(CourseTable courseTable, CourseTable swapCourseTable, WfCourseAdjust courseAdjust) throws Exception {
        String url = ScheduleUtil.apiUrl + "RescheduleApply/Extend/Submit";
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("timetableId", courseTable.getJianyueId());
        jsonObject.addProperty("isCycles", Boolean.FALSE);
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        jsonObject.addProperty("date", swapCourseTable.getScheduleDate().format(formatter));
        jsonObject.addProperty("numberOfDay", swapCourseTable.getTimeNumber());
        jsonObject.addProperty("rescheduleId", swapCourseTable.getJianyueId());
        jsonObject.addProperty("reason", courseAdjust.getReason());
        jsonObject.addProperty("teacherId", courseAdjust.getUserId());

        //获取时间戳
        long timestamp = System.currentTimeMillis();
        //生成签名
        String sign = ScheduleUtil.createSign(timestamp);
        String result = ScheduleUtil.doPost(url, jsonObject.toString(), sign, timestamp);
    }


    /**
     * 顶课预检查
     *
     * @param courseTable
     * @return 检查结果
     */
    JsonObject substitutePreTestin(String subTeacherId, CourseTable courseTable) throws Exception {
        JsonParser jsonParser = new JsonParser();
        String url = ScheduleUtil.apiUrl + "RescheduleApply/Extend/Substitute/PreTesting";
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("timetableId", courseTable.getJianyueId());
        jsonObject.addProperty("isCycles", Boolean.FALSE);
        JsonArray extendIds = new JsonArray();
        extendIds.add(subTeacherId);
        jsonObject.add("extendIds", extendIds);
        //获取时间戳
        long timestamp = System.currentTimeMillis();
        //生成签名
        String sign = ScheduleUtil.createSign(timestamp);
        String result = ScheduleUtil.doPost(url, jsonObject.toString(), sign, timestamp);
        if (StrUtil.isEmpty(result)) {
            return null;
        }

        return jsonParser.parse(result).getAsJsonObject();
    }

    /**
     * 调课预检查
     *
     * @param courseTable     需要调整的课程
     * @param swapCourseTable 对调的课程
     * @return 检查结果
     */
    JsonObject getExtendPreCheck(LocalDate swapDate, CourseTable courseTable, CourseTable swapCourseTable) throws Exception {
        JsonParser jsonParser = new JsonParser();
        String url = ScheduleUtil.apiUrl + "RescheduleApply/Extend/PreTesting";
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("timetableId", courseTable.getJianyueId());
        jsonObject.addProperty("isCycles", Boolean.FALSE);
//        jsonObject.addProperty("startDate", "2024-01-01");
//        jsonObject.addProperty("endDate", "2024-01-31");
//        jsonObject.addProperty("dayOfweek", 5);
        jsonObject.addProperty("numberOfday", swapCourseTable.getTimeNumber());
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        jsonObject.addProperty("date", swapDate.format(formatter));
        jsonObject.addProperty("reschduleId", courseTable.getJianyueId());

        //获取时间戳
        long timestamp = System.currentTimeMillis();
        //生成签名
        String sign = ScheduleUtil.createSign(timestamp);
        String result = ScheduleUtil.doPost(url, jsonObject.toString(), sign, timestamp);
        if (StrUtil.isEmpty(result)) {
            return null;
        }

        return jsonParser.parse(result).getAsJsonObject();
    }

    /**
     * 获取节次
     *
     * @return
     */
    private Map<String, ClassTime> getClassTimeMap() {
        List<ClassTime> classTimes = classTimeMapper.selectList(null);

        Map<String, ClassTime> result = new HashMap<>();

        for (ClassTime item : classTimes) {
            String key = String.format("%d_%d", item.getTimePeriod(), item.getNumber());
            result.put(key, item);
        }

        return result;
    }

    /**
     * 当前时间是否在夏季
     *
     * @return
     */
    private Boolean isCurrentSummer() {
        DateTime now = DateUtil.date();
        DateTime summerStart = DateUtil.parse(String.format("%d-%s", now.year(), timetableConfig.getSummerStart()));
        DateTime summerEnd = DateUtil.parse(String.format("%d-%s", now.year(), timetableConfig.getSummerEnd()));
        DateTime winterStart = DateUtil.parse(String.format("%d-%s", now.year(), timetableConfig.getWinterStart()));
        DateTime winterEnd = DateUtil.parse(String.format("%d-%s", now.year(), timetableConfig.getWinterEnd()));

        // 如果开始时间大于结束时间，开始时间增加1年
        if (DateUtil.compare(summerStart, summerEnd) > 0) {
            summerEnd = DateUtil.offset(summerEnd, DateField.DAY_OF_YEAR, 1);
        }
        if (DateUtil.compare(winterStart, winterEnd) > 0) {
            winterEnd = DateUtil.offset(winterEnd, DateField.DAY_OF_YEAR, 1);
        }

        return DateUtil.compare(summerStart, now) > 0 && DateUtil.compare(summerEnd, now) < 0;
    }

    /**
     * 解析word课表
     *
     * @param inputStream
     * @return
     * @throws IOException
     */
    private List<CourseTableParse> courseTableWordParses(InputStream inputStream) throws IOException {
        XWPFDocument doc = new XWPFDocument(inputStream);

        List<XWPFParagraph> paras = doc.getParagraphs();
        String semester = null;
        List<String> cNames = new ArrayList<>();
        //获取标题
        for (int i = 0; i < paras.size(); i++) {
            String txt = paras.get(i).getText();
            if (i == 0) {
                semester = txt;
                continue;
            }
            txt = txt.replaceAll("总课程表", "").replace("\n", "").trim();
            if (!txt.equals("") && !txt.equals(semester)) {
                cNames.add(txt);
            }
        }
        List<CourseTableParse> result = new ArrayList<>();
        //获取文档中所有的表格
        List<XWPFTable> tables = doc.getTables();
        int tNum = 0;
        for (XWPFTable table : tables) {
            int rNum = 0;
            String timePeriod = null;
            List<String> weeks = new ArrayList<>();
            List<XWPFTableRow> rows = table.getRows();
            for (XWPFTableRow row : rows) {
                //获取行对应的单元格
                List<XWPFTableCell> cells = row.getTableCells();
                String timeNumber = null;
                for (int i = 0; i < cells.size(); i++) {
                    String cellText = cells.get(i).getText();
                    if (cellText.equals("") || rNum < 1) continue;

                    if (rNum == 1) {
                        weeks.add(cellText);
                        continue;
                    }
                    if (i == 0) {
                        timePeriod = cellText;
                        continue;
                    }
                    if (i == 1) {
                        timeNumber = cellText;
                        continue;
                    }
                    List<XWPFParagraph> cParagraph = cells.get(i).getParagraphs();
                    CourseTableParse item = new CourseTableParse();
                    item.setSemester(semester);
                    item.setTimePeriod(TimePeriodEnum.getCode(timePeriod));
                    item.setTimeNumber(TimeNumberEnum.getCode(timeNumber));
                    String week = weeks.get(Math.max(i - 2, 0));
                    item.setWeeksCn(week);
                    item.setClassName(cNames.get(tNum));
                    for (int j = 0; j < cParagraph.size(); j++) {
                        cellText = cParagraph.get(j).getText().trim();
                        switch (j) {
                            case 0:
                                item.setCourseName(cellText);
                                break;
                            case 1:
                                item.setTeacherName(cellText);
                                break;
                            case 2:
                                item.setSiteName(cellText);
                                break;
                        }
                    }
                    result.add(item);
                }
                rNum++;
            }
            tNum++;
        }
        inputStream.close();
        return result;
    }


    @Override
    public void deleteBakData(Long wfCourseAdjustId) {
        courseTableBakMapper.delete(new QueryWrapper<CourseTableBak>().lambda().eq(CourseTableBak::getWfCourseAdjustId, wfCourseAdjustId));
    }


    @Override
    public ByteArrayOutputStream scheduleWeekExportQuery(CourseTableDto dto) {
        try {
            CourseTableVo data = this.getList(dto);

            Workbook workbook = new XSSFWorkbook();
            // 创建一个工作表(sheet)
            String sheetName = "课表";
            Sheet sheet = workbook.createSheet(sheetName);

            createFirstTitle(workbook, sheet, data, dto);

            createSecondTitle(workbook, sheet, 1);

            Map<Integer, ClassTime> timeNumberMap = data.getClassTimeList().stream().collect(Collectors.toMap(ClassTime::getNumber, x -> x));
            Map<String, List<CourseDetailVo>> timeNumberDataMap = data.getCourseList().stream().collect(Collectors.groupingBy(CourseDetailVo::getTimeNumber));

            List<Integer> weekList = new ArrayList<>();
            weekList.add(1);
            weekList.add(2);
            weekList.add(3);
            weekList.add(4);
            weekList.add(5);
            weekList.add(6);
            weekList.add(7);
            Collections.sort(weekList);

            List<Integer> timeNumberList = data.getClassTimeList().stream().map(ClassTime::getNumber).collect(Collectors.toList());
            Collections.sort(timeNumberList);

            Map<Integer, Integer> timePeriodMap = data.getClassTimeList().stream().collect(Collectors.toMap(ClassTime::getNumber, ClassTime::getTimePeriod));

            ArrayList<ArrayList<String>> dataList = new ArrayList<>();

            for (Integer timeNumber : timeNumberList) {
                ArrayList<String> rowData = new ArrayList<>();
                Integer timePeriod = timePeriodMap.get(timeNumber);
                String timePeriodStr = "";
                if (timePeriod == 1) {
                    timePeriodStr = "上午";
                } else if (timePeriod == 2) {
                    timePeriodStr = "下午";
                } else if (timePeriod == 3) {
                    timePeriodStr = "晚上";
                }
                rowData.add(timePeriodStr);
                ClassTime classTime = timeNumberMap.get(timeNumber);
                String timeNumberStr = classTime.getShortName() + "\r\n" + classTime.getSummerStartTime() + "-" + classTime.getSummerEndTime();
                rowData.add(timeNumberStr);
                List<CourseDetailVo> list1 = timeNumberDataMap.get(timeNumber.toString());
                if (list1 == null) {
                    for (Integer week : weekList) {
                        rowData.add("");
                    }
                    dataList.add(rowData);
                    continue;
                }
                Map<Integer, List<CourseDetailVo>> weeksMap = list1.stream().collect(Collectors.groupingBy(CourseDetailVo::getWeeks));
                for (Integer week : weekList) {
                    String content = "";
                    List<CourseDetailVo> list = weeksMap.get(week);
                    if (list != null && !list.isEmpty()) {
                        if (list.size() == 1) {
                            CourseDetailVo courseDetailVo = list.get(0);
                            content += courseDetailVo.getCourseName() + "\r\n";
                            content += courseDetailVo.getClassroomName() + "\r\n";
                            if ("teacher".equals(dto.getCourseType())) {
                                content += courseDetailVo.getClassName();
                            } else if ("class".equals(dto.getCourseType())) {
                                content += courseDetailVo.getTeacherName();
                            }
                        } else {
                            CourseDetailVo courseDetailVo = list.get(0);
                            content += courseDetailVo.getCourseName() + "\r\n";
                            content += courseDetailVo.getClassroomName() + "\r\n";
                            if ("teacher".equals(dto.getCourseType())) {
                                content += courseDetailVo.getClassName();
                            } else if ("class".equals(dto.getCourseType())) {
                                Set<String> classNames = list.stream().map(CourseDetailVo::getTeacherName).collect(Collectors.toSet());
                                content += classNames.toString().replace("]", "").replace("[", "").replace(" ", "");
                            }
                        }
                    }
                    rowData.add(content);
                }
                dataList.add(rowData);
            }

            Font font = workbook.createFont();
            font.setFontName("宋体");
            font.setFontHeightInPoints((short) 9);

            // 创建一个单元格样式对象
            CellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setFont(font); // 将字体应用到样式
            cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
            cellStyle.setAlignment(HorizontalAlignment.CENTER);
            cellStyle.setWrapText(true);
            cellStyle.setBorderTop(BorderStyle.THIN);
            cellStyle.setBorderBottom(BorderStyle.THIN);
            cellStyle.setBorderLeft(BorderStyle.THIN);
            cellStyle.setBorderRight(BorderStyle.THIN);

            int rowNumber = 2;
            for (ArrayList<String> strings : dataList) {
                Row row = sheet.createRow(rowNumber);
                int cellNumber = 0;
                for (String string : strings) {
                    Cell row1cell1 = row.createCell(cellNumber);
                    row1cell1.setCellValue(string);
                    row1cell1.setCellStyle(cellStyle);
                    cellNumber++;
                }
                rowNumber++;
                row.setHeightInPoints(48);
            }
            //合并
            Map<Integer, List<Integer>> collect = data.getClassTimeList().stream().collect(Collectors.groupingBy(ClassTime::getTimePeriod, Collectors.mapping(ClassTime::getNumber, Collectors.toList())));
            int firstRow = 2;
            for (Integer i : collect.keySet()) {
                int lastRow = firstRow + collect.get(i).size() - 1;
                if (lastRow == firstRow) {
                    continue;
                }
                sheet.addMergedRegion(new CellRangeAddress(firstRow, lastRow, 0, 0));

                firstRow = firstRow + collect.get(i).size();
            }

            ByteArrayOutputStream bot = new ByteArrayOutputStream();
            workbook.write(bot);
            return bot;
        } catch (Exception e) {
            Log.error(e.getMessage(), e);
            throw new MyException("导出报错，请联系管理员");
        }
    }

    void createSecondTitle(Workbook workbook, Sheet sheet, int rowNumber) {
        // 创建一个字体对象
        Font font = workbook.createFont();
        font.setBold(true);// 设置为粗体
        font.setFontName("宋体");
        //font.setColor(IndexedColors.RED.getIndex()); // 设置字体颜色为红色
        font.setFontHeightInPoints((short) 12);

        // 创建一个单元格样式对象
        CellStyle cellStyle = workbook.createCellStyle();
        cellStyle.setFont(font); // 将字体应用到样式
        cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
        cellStyle.setAlignment(HorizontalAlignment.CENTER);
        cellStyle.setBorderTop(BorderStyle.THIN);
        cellStyle.setBorderBottom(BorderStyle.THIN);
        cellStyle.setBorderLeft(BorderStyle.THIN);
        cellStyle.setBorderRight(BorderStyle.THIN);

        Row row = sheet.createRow(rowNumber);

        int cellNumber = 0;
        Cell row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue("时间");
        row1cell1.setCellStyle(cellStyle);
        sheet.setColumnWidth(0, 4 * 256);
        cellNumber++;

        row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue("");
        row1cell1.setCellStyle(cellStyle);

        //合并
        sheet.addMergedRegion(new CellRangeAddress(rowNumber, rowNumber, 0, 1));
        cellNumber++;
        sheet.setColumnWidth(1, 12 * 256);

        row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue("周一");
        row1cell1.setCellStyle(cellStyle);
        sheet.setColumnWidth(2, 16 * 256);
        cellNumber++;


        row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue("周二");
        row1cell1.setCellStyle(cellStyle);
        sheet.setColumnWidth(cellNumber, 16 * 256);
        cellNumber++;

        row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue("周三");
        row1cell1.setCellStyle(cellStyle);
        sheet.setColumnWidth(cellNumber, 16 * 256);
        cellNumber++;

        row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue("周四");
        row1cell1.setCellStyle(cellStyle);
        sheet.setColumnWidth(cellNumber, 16 * 256);
        cellNumber++;

        row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue("周五");
        row1cell1.setCellStyle(cellStyle);
        sheet.setColumnWidth(cellNumber, 16 * 256);
        cellNumber++;

        row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue("周六");
        row1cell1.setCellStyle(cellStyle);
        sheet.setColumnWidth(cellNumber, 16 * 256);
        cellNumber++;

        row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue("周日");
        row1cell1.setCellStyle(cellStyle);
        sheet.setColumnWidth(cellNumber, 16 * 256);
    }

    void createFirstTitle(Workbook workbook, Sheet sheet, CourseTableVo data, CourseTableDto dto) {
        // 创建一个字体对象
        Font font = workbook.createFont();
        font.setBold(true);// 设置为粗体
        font.setFontName("宋体");
        //font.setColor(IndexedColors.RED.getIndex()); // 设置字体颜色为红色
        font.setFontHeightInPoints((short) 18);

        // 创建一个单元格样式对象
        CellStyle cellStyle = workbook.createCellStyle();
        cellStyle.setFont(font); // 将字体应用到样式
        cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
        cellStyle.setAlignment(HorizontalAlignment.CENTER);
        cellStyle.setBorderTop(BorderStyle.THIN);
        cellStyle.setBorderBottom(BorderStyle.THIN);
        cellStyle.setBorderLeft(BorderStyle.THIN);
        cellStyle.setBorderRight(BorderStyle.THIN);

        Row row = sheet.createRow(0);
        String title = data.getSemesterName();
        if ("class".equals(dto.getCourseType())) {
            title += " " + data.getClassName() + " ";
        } else if ("teacher".equals(dto.getCourseType())) {
            title += " " + data.getTeacherName() + " ";
        }
        title += data.getWeek() + " 课程表";

        int cellNumber = 0;
        Cell row1cell1 = row.createCell(cellNumber);
        row1cell1.setCellValue(title);
        row1cell1.setCellStyle(cellStyle);

        for (int i = 1; i < 9; i++) {
            row1cell1 = row.createCell(i);
            row1cell1.setCellValue("");
            row1cell1.setCellStyle(cellStyle);
        }

        //合并
        sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 8));
//        sheet.setColumnWidth(0, 335 * 256);
    }

    public Integer getSubstituteTeacherCourseCountByParams(ClassTeacherDto dto) {
        return this.baseMapper.getSubstituteTeacherCourseCountByParams(dto);
    }

    /**
     * 课表导出
     *
     * @param dto
     * @return
     */
    @Override
    public ByteArrayOutputStream exportQuery(CourseTableExportQueryDto dto) throws IOException {
        BaseSemester baseSemester = baseSemesterMapper.selectById(dto.getSemesterId());
        CourseTableExportQueryUtil exportQueryUtil = new CourseTableExportQueryUtil();
        String schoolName = "重庆市铜梁职业教育中心";
        ByteArrayOutputStream bot = new ByteArrayOutputStream();

        //查询数据
        CourseTableDto dataDto = new CourseTableDto();
        dataDto.setSemesterId(dto.getSemesterId());
        dataDto.setWeek(dto.getWeek());
        dataDto.setIsCustom(1);
        CourseTableVo tableVo = this.getList(dataDto);

        if ("class".equals(dto.getCourseType())) {//班级课表
            //根据年级、专业部，查询需要导出的班级
            List<BaseClass> classList = baseClassService.list(new QueryWrapper<BaseClass>().lambda().eq(BaseClass::getDeleteMark, DeleteMark.NODELETE.getCode()).eq(BaseClass::getIsGraduate, 1).in(BaseClass::getGradeId, dto.getGradeIds()).in(BaseClass::getOrgId, dto.getDeptIds()));
            if (classList.isEmpty()) {
                throw new MyException("未查询到班级，无法导出");
            }

            Map<String, List<CourseDetailVo>> classDataMap = tableVo.getCourseList().stream().filter(x -> x.getClassName() != null).collect(Collectors.groupingBy(CourseDetailVo::getClassName));

            List<Long> teacherIds = classList.stream().map(BaseClass::getTeacherId).collect(Collectors.toList());
            List<User> userList = userService.listByIds(teacherIds);
            Map<Long, String> teacherMap = userList.stream().collect(Collectors.toMap(User::getId, User::getName));

            Workbook workbook = new XSSFWorkbook();
            String sheetName = "班级课表";
            Sheet sheet = workbook.createSheet(sheetName);
            String bigHead = "课程表";

            int classTableRowCount = 16;//每个班的课表占用的总行数
            int i = 0;
            for (BaseClass baseClass : classList) {
                CourseTableVo classData = new CourseTableVo();
                classData.setClassTimeList(tableVo.getClassTimeList());
                if (!classDataMap.containsKey(baseClass.getName())) {
                    continue;
                }
                classData.setCourseList(classDataMap.get(baseClass.getName()));

                String rightName = "班主任：" + teacherMap.get(baseClass.getTeacherId()) + " 行政班：" + baseClass.getName();
                int bigHeadRow = (classTableRowCount + 3) * i;
                //生成第一行title
                ImportExcelUtil.createBigHead(workbook, sheet, bigHead, bigHeadRow, 8);
                //生成副标题，展示所属学期
                ImportExcelUtil.createSubtitle(workbook, sheet, baseSemester.getName(), bigHeadRow + 1, 8);
                //生成第三行，显示学校名字、班主任和班级名字
                exportQueryUtil.createThirdTitle(workbook, sheet, bigHeadRow + 2, schoolName, rightName);
                //生成表头
                createSecondTitle(workbook, sheet, bigHeadRow + 3);
                //生成内容
                exportQueryUtil.createContent(workbook, sheet, bigHeadRow + 4, classData, dto.getCourseType());
                i++;
            }
            workbook.write(bot);
        } else if ("teacher".equals(dto.getCourseType())) {//教师课表
            //根据学期和周次，查询当前所有有课表的教师id
            LocalDateTime startDateTime = LocalDateTime.ofInstant(baseSemester.getTeachingStart().toInstant(), ZoneId.systemDefault());

            LocalDate startDate = startDateTime.plusDays((dto.getWeek() - 1) * 7L).toLocalDate();
            LocalDate endDate = startDate.plusDays(6);

            List<CourseTable> list = this.list(new QueryWrapper<CourseTable>().lambda().eq(CourseTable::getBaseSemesterId, dto.getSemesterId()).ge(CourseTable::getScheduleDate, startDate).le(CourseTable::getScheduleDate, endDate));
            Set<String> teacherIds = list.stream().map(CourseTable::getTeacherId).collect(Collectors.toSet());
            Set<Long> teacherIdList = new HashSet<>();
            for (String teacherId : teacherIds) {
                String[] split = teacherId.split(", ");
                for (String s : split) {
                    teacherIdList.add(Long.parseLong(s));
                }
            }
            List<User> userList = userService.listByIds(teacherIdList);

            Workbook workbook = new XSSFWorkbook();
            String sheetName = "教师课表";
            Sheet sheet = workbook.createSheet(sheetName);
            String bigHead = "课程表";
            int classTableRowCount = 16;//每个班的课表占用的总行数

            for (int i = 0; i < userList.size(); i++) {
                User user = userList.get(i);
                List<CourseDetailVo> courseList = tableVo.getCourseList().stream().filter(x -> x.getTeacherName().contains(user.getName())).collect(Collectors.toList());

                CourseTableVo classData = new CourseTableVo();
                classData.setClassTimeList(tableVo.getClassTimeList());
                classData.setCourseList(courseList);

                String rightName = "教师：" + user.getName();
                int bigHeadRow = (classTableRowCount + 3) * i;
                //生成第一行title
                ImportExcelUtil.createBigHead(workbook, sheet, bigHead, bigHeadRow, 8);
                //生成副标题，展示所属学期
                ImportExcelUtil.createSubtitle(workbook, sheet, baseSemester.getName(), bigHeadRow + 1, 8);
                //生成第三行，显示学校名字、班主任和班级名字
                exportQueryUtil.createThirdTitle(workbook, sheet, bigHeadRow + 2, schoolName, rightName);
                //生成表头
                createSecondTitle(workbook, sheet, bigHeadRow + 3);
                //生成内容
                exportQueryUtil.createContent(workbook, sheet, bigHeadRow + 4, classData, dto.getCourseType());
            }
            workbook.write(bot);
        } else if ("classroom".equals(dto.getCourseType())) {//教室课表
            Map<String, List<CourseDetailVo>> classroomDataMap = tableVo.getCourseList().stream().filter(x -> x.getClassroomName() != null).collect(Collectors.groupingBy(CourseDetailVo::getClassroomName));
            List<BaseClassroom> classroomList = classroomMapper.selectList(new QueryWrapper<BaseClassroom>().lambda().eq(BaseClassroom::getDeleteMark, DeleteMark.NODELETE.getCode()));
            List<BaseOfficeBuild> buildList = officeBuildMapper.selectList(new QueryWrapper<BaseOfficeBuild>().lambda().eq(BaseOfficeBuild::getDeleteMark, DeleteMark.NODELETE.getCode()));
            Map<Long, String> buildMap = buildList.stream().collect(Collectors.toMap(BaseOfficeBuild::getId, BaseOfficeBuild::getName));

            Workbook workbook = new XSSFWorkbook();
            String sheetName = "教室课表";
            Sheet sheet = workbook.createSheet(sheetName);
            String bigHead = "课程表";
            int classTableRowCount = 16;//每个班的课表占用的总行数
            int i = 0;
            for (BaseClassroom baseClassroom : classroomList) {
                String classroomName = buildMap.get(baseClassroom.getOfficeBuildId()) + baseClassroom.getName();
                if (!classroomDataMap.containsKey(classroomName)) {
                    continue;
                }

                List<CourseDetailVo> courseList = classroomDataMap.get(classroomName);

                CourseTableVo classData = new CourseTableVo();
                classData.setClassTimeList(tableVo.getClassTimeList());
                classData.setCourseList(courseList);

                int bigHeadRow = (classTableRowCount + 3) * i;
                //生成第一行title
                ImportExcelUtil.createBigHead(workbook, sheet, bigHead, bigHeadRow, 8);
                //生成副标题，展示所属学期
                ImportExcelUtil.createSubtitle(workbook, sheet, baseSemester.getName(), bigHeadRow + 1, 8);
                //生成第三行，显示学校名字、班主任和班级名字
                exportQueryUtil.createThirdTitle(workbook, sheet, bigHeadRow + 2, schoolName, classroomName);
                //生成表头
                createSecondTitle(workbook, sheet, bigHeadRow + 3);
                //生成内容
                exportQueryUtil.createContent(workbook, sheet, bigHeadRow + 4, classData, dto.getCourseType());

                i++;
            }
            workbook.write(bot);
        } else if ("all".equals(dto.getCourseType())) {//总课表
            //根据年级、专业部，查询需要导出的班级
            List<BaseClass> classList = baseClassService.list(new QueryWrapper<BaseClass>().lambda().eq(BaseClass::getDeleteMark, DeleteMark.NODELETE.getCode()).eq(BaseClass::getIsGraduate, 1).in(BaseClass::getGradeId, dto.getGradeIds()).in(BaseClass::getOrgId, dto.getDeptIds()).orderByAsc(BaseClass::getName));
            if (classList.isEmpty()) {
                throw new MyException("未查询到班级，无法导出");
            }
            Map<String, List<CourseDetailVo>> classDataMap = tableVo.getCourseList().stream().filter(x -> x.getClassName() != null).collect(Collectors.groupingBy(CourseDetailVo::getClassName));
            ArrayList<ArrayList<String>> dataList = new ArrayList<>();
            for (BaseClass baseClass : classList) {
                List<CourseDetailVo> detailVoList = classDataMap.get(baseClass.getName());
                if (detailVoList == null) {
                    continue;
                }
                Map<Integer, List<CourseDetailVo>> weeksMap = detailVoList.stream().collect(Collectors.groupingBy(CourseDetailVo::getWeeks));

                List<Integer> weekList = new ArrayList<>();
                weekList.add(1);
                weekList.add(2);
                weekList.add(3);
                weekList.add(4);
                weekList.add(5);
                weekList.add(6);
                weekList.add(7);

                ArrayList<String> classData = new ArrayList<>();
                classData.add(baseClass.getName());
                for (Integer weeks : weekList) {
                    if (!weeksMap.containsKey(weeks)) {
                        for (ClassTime classTime : tableVo.getClassTimeList()) {
                            classData.add("");
                        }
                        continue;
                    }
                    Map<String, CourseDetailVo> timeNumberMap = weeksMap.get(weeks).stream().filter(x -> x.getTimeNumber() != null).collect(Collectors.toMap(CourseDetailVo::getTimeNumber, x -> x));
                    for (ClassTime classTime : tableVo.getClassTimeList()) {
                        CourseDetailVo courseDetailVo = timeNumberMap.get(classTime.getNumber().toString());
                        if (courseDetailVo == null) {
                            classData.add("");
                            continue;
                        }
                        String content = courseDetailVo.getCourseName() + "\r\n" + courseDetailVo.getTeacherName();
                        if (courseDetailVo.getClassroomName() != null) {
                            content += "\r\n" + courseDetailVo.getClassroomName();
                        }
                        classData.add(content);
                    }
                }
                dataList.add(classData);
            }

            Workbook workbook = new XSSFWorkbook();
            String sheetName = "总课表";
            Sheet sheet = workbook.createSheet(sheetName);

            exportQueryUtil.createAllCourseTableTitle(workbook, sheet, tableVo.getClassTimeList());

            Font font = workbook.createFont();
            font.setFontName("宋体");
            font.setFontHeightInPoints((short) 12);

            CellStyle cellStyle = workbook.createCellStyle();
            cellStyle.setFont(font); // 将字体应用到样式
            cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
            cellStyle.setAlignment(HorizontalAlignment.CENTER);
            cellStyle.setBorderTop(BorderStyle.THIN);
            cellStyle.setBorderBottom(BorderStyle.THIN);
            cellStyle.setBorderLeft(BorderStyle.THIN);
            cellStyle.setBorderRight(BorderStyle.THIN);
            cellStyle.setWrapText(true);
            int rowNumber = 2;
            for (ArrayList<String> rowData : dataList) {
                Row row = sheet.createRow(rowNumber);
                for (int i = 0; i < rowData.size(); i++) {
                    Cell cell = row.createCell(i);
                    cell.setCellValue(rowData.get(i));
                    cell.setCellStyle(cellStyle);
                }
                rowNumber++;
                row.setHeightInPoints(48);
            }

            workbook.write(bot);
        }
        return bot;
    }

    @Override
    public CurrentWeekVo getCurrentWeekOld(CourseTableDto dto) {
        BaseSemester baseSemester = baseSemesterService.getCurrentSemester();
        if (baseSemester == null) {
            return null;
        }
        LocalDateTime now = LocalDateTime.now();
        if (dto.getScheduleDate() != null) {
            now = dto.getScheduleDate();
        }
        //计算本周是第几周
        LocalDateTime startDateTime = LocalDateTime.ofInstant(baseSemester.getTeachingStart().toInstant(), ZoneId.systemDefault());
        LocalDateTime endDateTime = LocalDateTime.ofInstant(baseSemester.getTeachingEnd().toInstant(), ZoneId.systemDefault());
        Duration between = Duration.between(startDateTime, endDateTime);
        long days = between.toDays();
        int weeks = (int) Math.ceil((double) days / 7);

        for (int i = 0; i < weeks; i++) {
            LocalDateTime startDate = startDateTime.plusDays(i * 7L).withHour(0).withMinute(0).withSecond(0).withNano(0);
            LocalDateTime endDate = startDate.plusDays(6).withHour(23).withMinute(59).withSecond(59).withNano(9999);
            if (now.isAfter(startDate) && now.isBefore(endDate)) {
                CurrentWeekVo currentWeekVo = new CurrentWeekVo();
                currentWeekVo.setWeek(i + 1);
                currentWeekVo.setStartDate(startDate.toLocalDate());
                currentWeekVo.setEndDate(endDate.toLocalDate());
                return currentWeekVo;
            }
        }
        return null;
    }

    @Override
    public CurrentWeekVo getCurrentWeek(CourseTableDto dto) {
        BaseSemester baseSemester = baseSemesterService.getCurrentSemester();
        if (baseSemester == null) {
            return null;
        }
        LocalDateTime now = LocalDateTime.now();
        if (dto.getScheduleDate() != null) {
            now = dto.getScheduleDate();
        }

        LocalDate semesterStart = LocalDate.ofInstant(baseSemester.getTeachingStart().toInstant(), ZoneId.systemDefault());
        LocalDate semesterEnd = LocalDate.ofInstant(baseSemester.getTeachingEnd().toInstant(), ZoneId.systemDefault());

        // 调整开始日期到本周星期一
        LocalDate adjustedStart = semesterStart.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));
        // 调整结束日期到本周星期日
        LocalDate adjustedEnd = semesterEnd.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));

        // 计算总周数
        long totalDays = java.time.temporal.ChronoUnit.DAYS.between(adjustedStart, adjustedEnd) + 1;
        int totalWeeks = (int) (totalDays / 7);

        // 生成每一周的信息
        for (int i = 0; i < totalWeeks; i++) {
            LocalDateTime startDate = adjustedStart.plusWeeks(i).atStartOfDay();//.atTime(0, 0, 0);
            LocalDateTime endDate = startDate.plusDays(6).withHour(23).withMinute(59).withSecond(59).withNano(9999);

            if (now.isAfter(startDate) && now.isBefore(endDate)) {
                CurrentWeekVo currentWeekVo = new CurrentWeekVo();
                currentWeekVo.setWeek(i + 1);
                currentWeekVo.setStartDate(startDate.toLocalDate());
                currentWeekVo.setEndDate(endDate.toLocalDate());
                return currentWeekVo;
            }
        }
        return null;
    }

}