package com.ruoyi.safe.service.impl;

import com.ruoyi.safe.pojo.SafeLineInspectionTask;
import lombok.RequiredArgsConstructor;
import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.stereotype.Service;

import java.time.LocalTime;
import java.time.ZoneId;
import java.time.format.DateTimeParseException;
import java.util.Arrays;
import java.util.Date;
import java.util.stream.Collectors;

@Service
@RequiredArgsConstructor
public class SafeLineInspectionTaskScheduler {

    private static final String JOB_GROUP = "safeLineInspectionTask";
    private static final String TRIGGER_GROUP = "safeLineInspectionTaskTrigger";

    private final Scheduler scheduler;

    public void scheduleTask(SafeLineInspectionTask task) throws SchedulerException {
        JobDetail jobDetail = buildJobDetail(task);
        if (scheduler.checkExists(jobDetail.getKey())) {
            scheduler.deleteJob(jobDetail.getKey());
        }
        scheduler.scheduleJob(jobDetail, buildJobTrigger(task, jobDetail));
    }

    public void rescheduleTask(SafeLineInspectionTask task) throws SchedulerException {
        TriggerKey triggerKey = getTriggerKey(task.getId());
        Trigger oldTrigger = scheduler.getTrigger(triggerKey);
        if (oldTrigger == null) {
            scheduleTask(task);
            return;
        }
        JobDetail jobDetail = scheduler.getJobDetail(oldTrigger.getJobKey());
        if (jobDetail == null) {
            scheduleTask(task);
            return;
        }
        scheduler.rescheduleJob(triggerKey, buildJobTrigger(task, jobDetail));
    }

    public void unscheduleTask(Long taskId) {
        try {
            scheduler.deleteJob(getJobKey(taskId));
        } catch (SchedulerException e) {
            throw new RuntimeException(e);
        }
    }

    private JobDetail buildJobDetail(SafeLineInspectionTask task) {
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("taskId", task.getId());
        jobDataMap.put("taskName", task.getInspectionName());
        jobDataMap.put("frequencyType", task.getFrequencyType());

        return JobBuilder.newJob(SafeLineInspectionTaskJob.class)
                .withIdentity(getJobKey(task.getId()))
                .withDescription(task.getInspectionName())
                .usingJobData(jobDataMap)
                .storeDurably(true)
                .requestRecovery(true)
                .build();
    }

    private Trigger buildJobTrigger(SafeLineInspectionTask task, JobDetail jobDetail) {
        return TriggerBuilder.newTrigger()
                .withIdentity(getTriggerKey(task.getId()))
                .withDescription(task.getInspectionName() + "_TRIGGER")
                .forJob(jobDetail)
                .withSchedule(CronScheduleBuilder
                        .cronSchedule(convertToCronExpression(task))
                        .withMisfireHandlingInstructionDoNothing())
                .startAt(task.getNextExecutionTime() != null
                        ? Date.from(task.getNextExecutionTime().atZone(ZoneId.systemDefault()).toInstant())
                        : new Date())
                .build();
    }

    private JobKey getJobKey(Long taskId) {
        return new JobKey("safeLineInspectionTask_" + taskId, JOB_GROUP);
    }

    private TriggerKey getTriggerKey(Long taskId) {
        return new TriggerKey("safeLineInspectionTaskTrigger_" + taskId, TRIGGER_GROUP);
    }

    private String convertToCronExpression(SafeLineInspectionTask task) {
        if (task == null || task.getFrequencyType() == null || task.getFrequencyDetail() == null) {
            throw new IllegalArgumentException("任务频率不能为空");
        }
        return switch (task.getFrequencyType().toUpperCase()) {
            case "DAILY" -> convertDailyToCron(task.getFrequencyDetail());
            case "WEEKLY" -> convertWeeklyToCron(task.getFrequencyDetail());
            case "MONTHLY" -> convertMonthlyToCron(task.getFrequencyDetail());
            default -> throw new IllegalArgumentException("不支持的频率类型: " + task.getFrequencyType());
        };
    }

    private String convertDailyToCron(String frequencyDetail) {
        LocalTime time = parseTime(frequencyDetail);
        return String.format("0 %d %d * * ?", time.getMinute(), time.getHour());
    }

    private String convertWeeklyToCron(String frequencyDetail) {
        String[] parts = validateAndSplit(frequencyDetail, 2);
        String daysOfWeek = Arrays.stream(parts[0].split("\\|"))
                .map(this::convertSingleDayName)
                .collect(Collectors.joining(","));
        LocalTime time = parseTime(parts[1]);
        return String.format("0 %d %d ? * %s", time.getMinute(), time.getHour(), daysOfWeek);
    }

    private String convertMonthlyToCron(String frequencyDetail) {
        String[] parts = validateAndSplit(frequencyDetail, 2);
        int day = validateDayOfMonth(parts[0]);
        LocalTime time = parseTime(parts[1]);
        return String.format("0 %d %d %d * ?", time.getMinute(), time.getHour(), day);
    }

    private String[] validateAndSplit(String input, int expectedParts) {
        String[] parts = input.split(",");
        if (parts.length != expectedParts) {
            throw new IllegalArgumentException("任务频率详情格式错误");
        }
        return Arrays.stream(parts).map(String::trim).toArray(String[]::new);
    }

    private LocalTime parseTime(String timeStr) {
        try {
            return LocalTime.parse(timeStr);
        } catch (DateTimeParseException e) {
            throw new IllegalArgumentException("时间格式必须为HH:mm", e);
        }
    }

    private int validateDayOfMonth(String dayStr) {
        int day = Integer.parseInt(dayStr);
        if (day < 1 || day > 31) {
            throw new IllegalArgumentException("日期必须在1-31之间");
        }
        return day;
    }

    private String convertSingleDayName(String dayName) {
        return switch (dayName.toUpperCase()) {
            case "MON" -> "MON";
            case "TUE" -> "TUE";
            case "WED" -> "WED";
            case "THU" -> "THU";
            case "FRI" -> "FRI";
            case "SAT" -> "SAT";
            case "SUN" -> "SUN";
            default -> throw new IllegalArgumentException("无效的星期几: " + dayName);
        };
    }
}