package com.srs.quartz.task;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.srs.common.core.domain.AjaxResult;
import com.srs.comprehensive.domain.Dto.CphStuScoreMiddleDto;
import com.srs.comprehensive.service.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

@Component("CphTask")
public class CphTask {
    @Autowired
    ICphTestForService cphTestForService;
    @Autowired
    ICphStuScoreMiddlesService cphStuScoreMiddlesService;

    @Autowired
    CphSqlServerDataService sqlServerDataService;

    //学生
    @Autowired
    ISrsStudentService iSrsStudentService;

    //班级
    @Autowired
    ISrsClassService iSrsClassService;

    //专业
    @Autowired
    ISrsMajorsService iSrsMajorsService;

    //年级
    @Autowired
    ISrsGradeService iSrsGradeService;

    //辅导员
    @Autowired
    ICphTeacherService iCphTeacherService;


    /**
     * 更新成绩
     * @param stuYearId
     */
    public void totalScoreWrite(int stuYearId) {
        cphTestForService.testMethod(stuYearId);
    }

    /**
     * 同步学生成绩
     */
    public void stuScoreMiddleSync(){
        try {
            System.out.println("开始同步学生成绩数据...");
            long startTime = System.currentTimeMillis();

            // 清空现有数据
            cphStuScoreMiddlesService.emptyTableDate();
            System.out.println("已清空现有数据");

            // 配置参数
            int pageSize = 3000;
            int threadPoolSize = 8; // 定时任务使用较少线程，避免影响其他任务

            // 获取总数
            int studentInfoNumber = cphStuScoreMiddlesService.serectCphStuScoreMiddleCount(null);
            int totalPages = (int) Math.ceil((double) studentInfoNumber / pageSize);

            System.out.println("总记录数: " + studentInfoNumber + ", 总页数: " + totalPages);

            // 创建线程池
            ExecutorService executor = Executors.newFixedThreadPool(threadPoolSize);
            CountDownLatch latch = new CountDownLatch(totalPages);
            AtomicInteger successCount = new AtomicInteger(0);
            AtomicInteger errorCount = new AtomicInteger(0);

            // 提交任务
            for (int pageNum = 1; pageNum <= totalPages; pageNum++) {
                final int currentPage = pageNum;
                executor.submit(() -> {
                    try {
                        List<Map<String, Object>> cphStuScoreMiddles = cphStuScoreMiddlesService
                                .serectCphStuScoreMiddlesXh(currentPage, pageSize, null);

                        if (cphStuScoreMiddles != null && !cphStuScoreMiddles.isEmpty()) {
                            cphStuScoreMiddlesService.selectCphStuScoreMiddleEmptyAndAdd(cphStuScoreMiddles);
                            successCount.incrementAndGet();
                        }

                    } catch (Exception e) {
                        errorCount.incrementAndGet();
                        System.err.println("处理第" + currentPage + "页时发生错误: " + e.getMessage());
                    } finally {
                        latch.countDown();
                    }
                });
            }

            // 等待所有任务完成
            boolean completed = latch.await(30, TimeUnit.MINUTES);

            if (!completed) {
                System.err.println("同步任务未在指定时间内完成");
                return;
            }

            // 关闭线程池
            executor.shutdown();

            long endTime = System.currentTimeMillis();
            long duration = endTime - startTime;

            System.out.println("学生成绩同步完成 - 总耗时: " + duration + "ms, 成功页数: " +
                    successCount.get() + ", 失败页数: " + errorCount.get());

        } catch (Exception e) {
            System.err.println("同步学生成绩数据时发生严重错误: " + e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 同步年级
     */
    public void synchronousGradeInfoList(){
        System.out.println("启动 同步年级");
        List<Map> list=sqlServerDataService.getGradeInfoList();
        iSrsGradeService.sqlserverSynchronousMYSQL(list);//同步年级
    }
    /**
     * 同步学生
     */
    public void synchronousStudent(){
        int pageNum=1;
        int pageSize=3000;
        int studentInfoNumber = sqlServerDataService.getStudentInfoNumber();//总数
        int sum=studentInfoNumber/ pageSize;//需要循环的次数
        int sumS=studentInfoNumber%pageSize>0? sum + 1: sum;
        List<Map> stuNoList = new ArrayList<>();
        for (pageNum=1; pageNum <= sumS; pageNum++){
            List<Map> list=sqlServerDataService.getStudentInfoList(pageNum,pageSize,null);
            List<Map> maps = iSrsStudentService.sqlserverSynchronousMYSQL(list);//同步到mysql
            stuNoList.addAll(maps);
            list.clear();
        }
        iSrsStudentService.addStudentData(stuNoList);//添加到学生表
        iSrsStudentService.Usertb();//同步到用户表
    }

    /**
     *
     * 同步专业
     */
    public void synchronousSpecialtyInfoList(){
        List<Map> list=sqlServerDataService.getSpecialtyInfoList();
        iSrsMajorsService.sqlserverSynchronousMYSQL(list);//同步专业
    }

    /**
     * 同步辅导员
     */
    public void synchronousEmployEEInfoList(){
        //startPage();
        List<Map> list=sqlServerDataService.getEmployEEInfoList();
        iCphTeacherService.sqlserverSynchronousMYSQL(list);//同步辅导员
        iCphTeacherService.Usertb();
    }

    /**
     * 同步班级
     */
    public void synchronousClass(){
        List<Map> list=sqlServerDataService.getClassInfoList();
        iSrsClassService.sqlserverSynchronousMYSQL(list);//同步班级
    }
}
