package com.zhitan.airconditioner.service.impl;

import java.text.SimpleDateFormat;
import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;

import com.zhitan.airconditioner.domain.AirConditionerSchedule;
import com.zhitan.airconditioner.mapper.AirConditionerScheduleMapper;
import com.zhitan.airconditioner.service.IAirConditionerScheduleService;
import com.zhitan.airconditioner.service.IAirConditionerService;
import com.zhitan.common.utils.DateTimeUtil;
import com.zhitan.common.utils.DateUtils;
import com.zhitan.common.utils.SecurityUtils;
import com.zhitan.system.service.ISysHolidayService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * 空调定时任务Service业务层处理
 * 
 * @author zhitan
 */
/**
 * 空调定时任务Service业务层处理
 * 
 * @author zhitan
 */
@Service
public class AirConditionerScheduleServiceImpl implements IAirConditionerScheduleService 
{    
    private static final Logger log = LoggerFactory.getLogger(AirConditionerScheduleServiceImpl.class);
    
    @Autowired
    private AirConditionerScheduleMapper airConditionerScheduleMapper;
    
    @Autowired
    private IAirConditionerService airConditionerService;
    
    @Autowired
    private TaskScheduler taskScheduler;
    
    @Autowired
    private ISysHolidayService sysHolidayService;
    
    // 存储所有调度的任务，key为任务ID，value为调度的Future对象
    private final Map<String, ScheduledFuture<?>> scheduledTasks = new ConcurrentHashMap<>();
    
    /**
     * 初始化定时任务
     * 从数据库加载所有定时任务并进行调度
     */
    @PostConstruct
    public void init() {
        log.info("空调定时任务调度器初始化开始");
        
        // 查询所有有效的定时任务
        AirConditionerSchedule query = new AirConditionerSchedule();
        query.setStatus("0"); // 状态正常的任务
        List<AirConditionerSchedule> schedules = airConditionerScheduleMapper.selectAirConditionerScheduleList(query);
        
        if (schedules.isEmpty()) {
            log.info("没有找到需要调度的空调定时任务");
            return;
        }
        
        log.info("找到{}个需要调度的空调定时任务", schedules.size());
        
        // 为每个任务创建调度
        for (AirConditionerSchedule schedule : schedules) {
            scheduleTask(schedule);
        }
        
        log.info("空调定时任务调度器已启动，使用基于数据库的精确调度机制");
    }
    
    /**
     * 应用关闭时取消所有定时任务
     */
    @PreDestroy
    public void destroy() {
        for (Map.Entry<String, ScheduledFuture<?>> entry : scheduledTasks.entrySet()) {
            entry.getValue().cancel(false);
        }
        scheduledTasks.clear();
        log.info("空调定时任务调度器已关闭，所有任务已取消");
    }

    /**
     * 查询空调定时任务列表
     * 
     * @param airConditionerSchedule 空调定时任务信息
     * @return 空调定时任务集合
     */
    @Override
    public List<AirConditionerSchedule> selectAirConditionerScheduleList(AirConditionerSchedule airConditionerSchedule)
    {
        return airConditionerScheduleMapper.selectAirConditionerScheduleList(airConditionerSchedule);
    }

    /**
     * 查询空调定时任务信息
     * 
     * @param id 空调定时任务ID
     * @return 空调定时任务信息
     */
    @Override
    public AirConditionerSchedule selectAirConditionerScheduleById(Long id)
    {
        return airConditionerScheduleMapper.selectAirConditionerScheduleById(id);
    }
    
    /**
     * 根据空调ID查询定时任务列表
     * 
     * @param airConditionerId 空调ID
     * @return 定时任务列表
     */
    @Override
    public List<AirConditionerSchedule> selectAirConditionerScheduleByAirConditionerId(Long airConditionerId)
    {
        return airConditionerScheduleMapper.selectAirConditionerScheduleByAirConditionerId(airConditionerId);
    }

    /**
     * 新增空调定时任务
     * 
     * @param airConditionerSchedule 空调定时任务信息
     * @return 结果
     */
    @Override
    public int insertAirConditionerSchedule(AirConditionerSchedule airConditionerSchedule)
    {
        airConditionerSchedule.setCreateTime(DateUtils.getNowDate());
        airConditionerSchedule.setCreateBy(SecurityUtils.getUsername());
        int rows = airConditionerScheduleMapper.insertAirConditionerSchedule(airConditionerSchedule);
        if (rows > 0) {
            // 重新调度任务，使新添加的定时任务生效
            rescheduleTask();
        }
        return rows;
    }

    /**
     * 修改空调定时任务
     * 
     * @param airConditionerSchedule 空调定时任务信息
     * @return 结果
     */
    @Override
    public int updateAirConditionerSchedule(AirConditionerSchedule airConditionerSchedule)
    {
        airConditionerSchedule.setUpdateTime(DateUtils.getNowDate());
        airConditionerSchedule.setUpdateBy(SecurityUtils.getUsername());
        int rows = airConditionerScheduleMapper.updateAirConditionerSchedule(airConditionerSchedule);
        if (rows > 0) {
            // 重新调度任务，使修改后的定时任务生效
            rescheduleTask();
        }
        return rows;
    }

    /**
     * 批量删除空调定时任务
     * 
     * @param ids 需要删除的空调定时任务ID
     * @return 结果
     */
    @Override
    public int deleteAirConditionerScheduleByIds(Long[] ids)
    {
        int rows = airConditionerScheduleMapper.deleteAirConditionerScheduleByIds(ids);
        if (rows > 0) {
            // 重新调度任务，使删除操作生效
            rescheduleTask();
        }
        return rows;
    }

    /**
     * 删除空调定时任务信息
     * 
     * @param id 空调定时任务ID
     * @return 结果
     */
    @Override
    public int deleteAirConditionerScheduleById(Long id)
    {
        int rows = airConditionerScheduleMapper.deleteAirConditionerScheduleById(id);
        if (rows > 0) {
            // 重新调度任务，使删除操作生效
            rescheduleTask();
        }
        return rows;
    }
    
    /**
     * 根据空调ID删除定时任务
     * 
     * @param airConditionerId 空调ID
     * @return 结果
     */
    @Override
    public int deleteAirConditionerScheduleByAirConditionerId(String airConditionerId)
    {
        int rows = airConditionerScheduleMapper.deleteAirConditionerScheduleByAirConditionerId(airConditionerId);
        if (rows > 0) {
            // 重新调度任务，使删除操作生效
            rescheduleTask();
        }
        return rows;
    }
    
    /**
     * 执行空调定时任务
     * 此方法保留用于兼容接口，在新的实现中不再使用
     * 新的实现为每个具体的时间点创建独立的调度任务，不再需要每分钟检查一次
     */
    @Override
    public void executeScheduleTasks()
    {
        log.info("executeScheduleTasks方法已被调用，但在新的实现中不再使用");
        log.info("当前使用基于数据库的精确定时任务调度机制，为每个时间点创建独立的调度任务");
        
        // 如果有必要，可以在这里重新调度所有任务
        // rescheduleTask();
    }
    
    /**
     * 重新调度任务
     * 当定时任务发生变化时（如添加、修改、删除定时任务）调用此方法
     * 取消所有当前的调度任务并重新创建
     */
    public void rescheduleTask() {
        // 取消所有现有的调度任务
        for (Map.Entry<String, ScheduledFuture<?>> entry : scheduledTasks.entrySet()) {
            entry.getValue().cancel(false);
        }
        scheduledTasks.clear();
        
        // 查询所有有效的定时任务并重新调度
        AirConditionerSchedule query = new AirConditionerSchedule();
        query.setStatus("0"); // 状态正常的任务
        List<AirConditionerSchedule> schedules = airConditionerScheduleMapper.selectAirConditionerScheduleList(query);
        
        if (schedules.isEmpty()) {
            log.info("没有找到需要调度的空调定时任务");
            return;
        }
        
        log.info("重新调度{}个空调定时任务", schedules.size());
        
        // 为每个任务创建调度
        for (AirConditionerSchedule schedule : schedules) {
            scheduleTask(schedule);
        }
        
        log.info("空调定时任务已重新调度完成");
    }
    
    /**
     * 为单个定时任务创建调度
     * 分别为开机时间和关机时间创建独立的调度任务
     * 开机指令只在法定工作日添加定时任务，关机指令每天都添加定时任务
     * 
     * @param schedule 定时任务信息
     */
    private void scheduleTask(AirConditionerSchedule schedule) {
        if (schedule == null || schedule.getId() == null) {
            log.error("无法调度空或无ID的定时任务");
            return;
        }
        
        try {
            // 为开机时间创建调度
            if (schedule.getStartTime() != null) {
                // 开机指令只在法定工作日添加定时任务
                scheduleSpecificTask(schedule, schedule.getStartTime(), true);
            }
            
            // 为关机时间创建调度
            if (schedule.getOffTime() != null) {
                // 关机指令每天都添加定时任务
                scheduleSpecificTask(schedule, schedule.getOffTime(), false);
            }
        } catch (Exception e) {
            log.error("为定时任务创建调度失败，任务ID：{}，错误信息：{}", schedule.getId(), e.getMessage());
        }
    }
    
    /**
     * 为特定时间点创建调度任务
     * 
     * @param schedule 定时任务信息
     * @param targetTime 目标时间点
     * @param isStartTime 是否为开机时间（true为开机，false为关机）
     */
    private void scheduleSpecificTask(AirConditionerSchedule schedule, Date targetTime, boolean isStartTime) {
        // 计算下一次执行时间
        Date nextExecutionTime = calculateNextExecutionTime(targetTime);
        
        if (nextExecutionTime == null) {
            log.error("计算下一次执行时间失败，任务ID：{}", schedule.getId());
            return;
        }
        
        // 如果是开机任务，检查执行日期是否为工作日
        if (isStartTime) {
            // 如果不是工作日，则计算下一个工作日
            while (!isWorkDay(nextExecutionTime)) {
                // 不是工作日，跳到下一天再检查
                nextExecutionTime = DateUtils.addDays(nextExecutionTime, 1);
                
                // 更新时间部分（保持原来的时分秒不变）
                Calendar cal = Calendar.getInstance();
                cal.setTime(nextExecutionTime);
                
                Calendar targetCal = Calendar.getInstance();
                targetCal.setTime(targetTime);
                
                cal.set(Calendar.HOUR_OF_DAY, targetCal.get(Calendar.HOUR_OF_DAY));
                cal.set(Calendar.MINUTE, targetCal.get(Calendar.MINUTE));
                cal.set(Calendar.SECOND, targetCal.get(Calendar.SECOND));
                
                nextExecutionTime = cal.getTime();
            }
            
            log.info("开机任务已调整为下一个工作日执行，执行时间：{}", 
                    new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(nextExecutionTime));
        }
        
        // 创建任务ID，格式为：任务ID + "_start"或"_off"
        String taskKey = schedule.getId() + (isStartTime ? "_start" : "_off");
        
        // 取消已存在的相同任务（如果有）
        ScheduledFuture<?> existingTask = scheduledTasks.get(taskKey);
        if (existingTask != null) {
            existingTask.cancel(false);
            scheduledTasks.remove(taskKey);
        }
        
        // 创建新的调度任务
        ScheduledFuture<?> future = taskScheduler.schedule(
            () -> executeSpecificTask(schedule, isStartTime),
            nextExecutionTime
        );
        
        // 保存调度任务
        scheduledTasks.put(taskKey, future);
        
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        log.info("已为空调ID：{}创建{}定时任务，执行时间：{}", 
                schedule.getAirConditionerId(), 
                isStartTime ? "开机" : "关机", 
                sdf.format(nextExecutionTime));
    }
    
    /**
     * 计算下一次执行时间
     * 如果今天的执行时间已过，则安排在明天的同一时间执行
     * 
     * @param targetTime 目标时间
     * @return 下一次执行时间
     */
    private Date calculateNextExecutionTime(Date targetTime) {
        if (targetTime == null) {
            return null;
        }
        
        // 将Date转换为LocalTime（只保留时分秒）
        LocalTime targetLocalTime = targetTime.toInstant()
                .atZone(ZoneId.systemDefault())
                .toLocalTime();
        
        // 获取当前日期和时间
        LocalDateTime now = LocalDateTime.now();
        LocalDate today = now.toLocalDate();
        
        // 创建今天的目标执行时间
        LocalDateTime targetDateTime = LocalDateTime.of(today, targetLocalTime);
        
        // 如果目标时间已过，安排在明天的同一时间执行
        if (targetDateTime.isBefore(now)) {
            targetDateTime = targetDateTime.plusDays(1);
        }
        
        // 转换回Date类型
        return Date.from(targetDateTime.atZone(ZoneId.systemDefault()).toInstant());
    }
    
    /**
     * 执行特定的定时任务
     * 
     * @param schedule 定时任务信息
     * @param isStartTime 是否为开机时间（true为开机，false为关机）
     */
    private void executeSpecificTask(AirConditionerSchedule schedule, boolean isStartTime) {
        try {
            if (isStartTime) {
                // 开机操作 - 根据季节自动判断制热或制冷模式
                String controlMode = determineControlModeByMonth();
                
                log.info("执行空调开机任务，空调ID：{}，控制模式：{}", schedule.getAirConditionerId(), controlMode);
                
                // 执行空调开机控制
                airConditionerService.controlAirConditioner(
                    schedule.getAirConditionerId(), 
                    controlMode, // 0制冷或1制热
                    "1" // 自动操作
                );
            } else {
                // 关机操作
                log.info("执行空调关机任务，空调ID：{}", schedule.getAirConditionerId());
                
                // 执行空调关机控制
                airConditionerService.controlAirConditioner(
                    schedule.getAirConditionerId(), 
                    "2", // 关机
                    "1" // 自动操作
                );
            }
            
            // 任务执行完成后，重新调度下一天的同一时间点
            // 获取原始的时间点
            Date originalTime = isStartTime ? schedule.getStartTime() : schedule.getOffTime();
            // 重新调度
            scheduleSpecificTask(schedule, originalTime, isStartTime);
            
        } catch (Exception e) {
            log.error("执行空调{}任务失败，空调ID：{}，错误信息：{}", 
                    isStartTime ? "开机" : "关机", 
                    schedule.getAirConditionerId(), 
                    e.getMessage());
        }
    }
    
    /**
     * 判断日期是否为工作日
     * 工作日判断逻辑：
     * 1. 如果是周一至周五，且不是法定节假日，则为工作日
     * 2. 如果是周六日，但是为调休工作日，则为工作日
     * 
     * @param date 需要判断的日期
     * @return 如果是工作日返回true，否则返回false
     */
    private boolean isWorkDay(Date date) {
        // 调用节假日服务进行精确的工作日判断
        return sysHolidayService.isWorkDay(date);
    }
    
    /**
     * 根据月份自动判断制热或制冷模式
     * 5-9月为夏季，使用制冷模式
     * 11-3月为冬季，使用制热模式
     * 4月和10月为过渡季节，根据当前温度判断
     * 
     * @return 控制模式（0制冷 1制热）
     */
    private String determineControlModeByMonth()
    {
        // 获取当前月份
        int currentMonth = DateTimeUtil.getMonthOfYear(new Date());
        
        // 根据月份判断季节
        if (currentMonth >= 5 && currentMonth <= 9)
        {
            // 夏季使用制冷模式
            return "0";
        }
        else if ((currentMonth >= 11 && currentMonth <= 12) || (currentMonth >= 1 && currentMonth <= 3))
        {
            // 冬季使用制热模式
            return "1";
        }
        else
        {
            // 过渡季节，默认使用制冷模式
            // 实际应用中可以根据当前温度判断
            return "0";
        }
    }
    
    /**
     * 注意：对于只存储时分秒的时间字段（如开始时间和结束时间），
     * 数据库应该使用TIME类型而非DATETIME或TIMESTAMP类型。
     * 
     * MySQL中的TIME类型格式为'HH:MM:SS'，只存储时间部分，不包含日期信息。
     * 这样可以减少存储空间，并且更符合业务需求。
     * 
     * 在Java实体类中，虽然使用Date类型表示，但在与数据库交互时，
     * 只有时分秒部分会被保存和读取。
     */
}