package com.ruoyi.quartz.task;

import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.*;
import com.ruoyi.system.mapper.*;
import com.ruoyi.system.service.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 车辆异常运行监控定时任务
 * 
 * @author ruoyi
 */
@Component("vehicleAbnormalAlertTask")
public class VehicleAbnormalAlertTask {
    
    private static final Logger log = LoggerFactory.getLogger(VehicleAbnormalAlertTask.class);

    @Autowired
    private ISysConfigService configService;

    @Autowired
    private VehicleGpsSegmentMileageMapper segmentMileageMapper;

    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;

    @Autowired
    private SysTaskMapper sysTaskMapper;

    @Autowired
    private VehicleAbnormalAlertMapper alertMapper;

    @Autowired
    private IQyWechatService qyWechatService;

    @Autowired
    private ISysDeptService deptService;

    @Autowired
    private IVehicleAbnormalAlertService alertService;

    @Autowired
    private IVehicleAlertConfigService alertConfigService;

    @Autowired
    private ISysUserService userService;

    /**
     * 监控车辆异常运行情况
     */
    public void monitorVehicleAbnormalRunning() {
        try {
            // 检查功能开关
            if (!isAlertEnabled()) {
                log.debug("车辆异常告警功能未启用，跳过监控");
                return;
            }

            log.info("开始执行车辆异常运行监控任务");
            
            // 加载配置参数
            AlertConfig config = loadAlertConfig();
            
            // 获取监控时间窗口
            Date endTime = new Date();
            Calendar cal = Calendar.getInstance();
            cal.setTime(endTime);
            cal.add(Calendar.MINUTE, -config.timeWindow);
            Date startTime = cal.getTime();
            
            // 查询所有活跃车辆
            List<VehicleInfo> vehicles = vehicleInfoMapper.selectVehicleInfoList(new VehicleInfo());
            if (vehicles == null || vehicles.isEmpty()) {
                log.info("没有找到需要监控的车辆");
                return;
            }
            
            log.info("开始监控 {} 辆车辆，时间窗口: {} 到 {}", vehicles.size(), 
                    DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, startTime),
                    DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, endTime));
            
            int alertCount = 0;
            for (VehicleInfo vehicle : vehicles) {
                try {
                    if (checkVehicleAbnormalRunning(vehicle, startTime, endTime, config)) {
                        alertCount++;
                    }
                } catch (Exception e) {
                    log.error("检查车辆 {} 异常运行失败", vehicle.getVehicleNo(), e);
                }
            }
            
            log.info("车辆异常运行监控任务完成，共产生 {} 个告警", alertCount);
            
        } catch (Exception e) {
            log.error("车辆异常运行监控任务执行失败", e);
        }
    }

    /**
     * 检查单个车辆是否异常运行
     */
    private boolean checkVehicleAbnormalRunning(VehicleInfo vehicle, Date startTime, Date endTime, AlertConfig globalConfig) {
        Long vehicleId = vehicle.getVehicleId();
        String vehicleNo = vehicle.getVehicleNo();
        Long deptId = vehicle.getDeptId();
        
        // 获取该车辆的配置（优先级：车辆 > 部门 > 全局）
        AlertConfig config = getVehicleAlertConfig(vehicleId, deptId, globalConfig);
        if (config == null) {
//            log.info("车辆 {} 未找到有效配置，跳过监控", vehicleNo);
            return false;
        }
        
        // 1. 查询车辆在时间窗口内的总运行里程
        BigDecimal totalMileage = calculateVehicleMileage(vehicleId, startTime, endTime);
        if (totalMileage == null || totalMileage.compareTo(BigDecimal.ZERO) == 0) {
//            log.info("车辆 {} 在监控窗口内无运行里程", vehicleNo);
            return false;
        }
        
        // 2. 查询车辆在时间窗口内有任务时的里程
        BigDecimal taskMileage = calculateTaskMileage(vehicleId, startTime, endTime);
        if (taskMileage == null) {
            taskMileage = BigDecimal.ZERO;
        }
        
        // 3. 计算非任务状态下的运行里程
        BigDecimal nonTaskMileage = totalMileage.subtract(taskMileage);
        if (nonTaskMileage.compareTo(BigDecimal.ZERO) <= 0) {
//            log.info("车辆 {} 在监控窗口内无非任务里程", vehicleNo);
            return false;
        }
        
//        log.info("车辆 {} 总里程: {}km, 任务里程: {}km, 非任务里程: {}km",
//                vehicleNo, totalMileage, taskMileage, nonTaskMileage);
        
        // 4. 检查非任务里程是否超过公里数阈值
        if (nonTaskMileage.compareTo(config.mileageThreshold) <= 0) {
//            log.info("车辆 {} 非任务运行里程 {}km 未超过阈值 {}km",
//                    vehicleNo, nonTaskMileage, config.mileageThreshold);
            return false;
        }
        
        // 5. 检查告警频率限制
        if (!checkAlertFrequency(vehicleId, config)) {
//            log.info("车辆 {} 已达到告警频率限制", vehicleNo);
            return false;
        }
        
        // 6. 创建告警记录
        return createAlertAndNotify(vehicle, nonTaskMileage, startTime, endTime, config);
    }

    /**
     * 计算车辆运行里程
     */
    private BigDecimal calculateVehicleMileage(Long vehicleId, Date startTime, Date endTime) {
        try {
            // 查询车辆在时间窗口内的分段里程记录
            VehicleGpsSegmentMileage query = new VehicleGpsSegmentMileage();
            query.setVehicleId(vehicleId);
            
            Map<String, Object> params = new HashMap<>();
            params.put("vehicleId", vehicleId);
            params.put("startTime", startTime);
            params.put("endTime", endTime);
            
            List<VehicleGpsSegmentMileage> segments = segmentMileageMapper.selectSegmentsByTimeRange(params);
            
            if (segments == null || segments.isEmpty()) {
                return BigDecimal.ZERO;
            }
            
            // 累加所有分段里程
            BigDecimal totalMileage = segments.stream()
                    .map(VehicleGpsSegmentMileage::getSegmentDistance)
                    .filter(Objects::nonNull)
                    .reduce(BigDecimal.ZERO, BigDecimal::add);
            
            return totalMileage;
            
        } catch (Exception e) {
            log.error("计算车辆里程失败，vehicleId={}", vehicleId, e);
            return BigDecimal.ZERO;
        }
    }

    /**
     * 计算车辆在有任务时的运行里程
     */
    private BigDecimal calculateTaskMileage(Long vehicleId, Date startTime, Date endTime) {
        try {
            // 1. 查询车辆在时间窗口内的任务
            Map<String, Object> taskParams = new HashMap<>();
            taskParams.put("vehicleId", vehicleId);
            taskParams.put("startTime", startTime);
            taskParams.put("endTime", endTime);
            
            List<SysTask> tasks = sysTaskMapper.selectVehicleTasksInTimeRange(taskParams);
            
            if (tasks == null || tasks.isEmpty()) {
                return BigDecimal.ZERO;
            }
            
            // 排除已取消的任务
            List<SysTask> activeTasks = tasks.stream()
                    .filter(t -> !"CANCELLED".equals(t.getTaskStatus()))
                    .collect(Collectors.toList());
            
            if (activeTasks.isEmpty()) {
                return BigDecimal.ZERO;
            }
            
            // 2. 查询车辆的所有GPS分段里程
            Map<String, Object> segmentParams = new HashMap<>();
            segmentParams.put("vehicleId", vehicleId);
            segmentParams.put("startTime", startTime);
            segmentParams.put("endTime", endTime);
            
            List<VehicleGpsSegmentMileage> segments = segmentMileageMapper.selectSegmentsByTimeRange(segmentParams);
            
            if (segments == null || segments.isEmpty()) {
                return BigDecimal.ZERO;
            }
            
            // 3. 筛选出在任务时间范围内的分段里程
            BigDecimal taskMileage = BigDecimal.ZERO;
            
            for (VehicleGpsSegmentMileage segment : segments) {
                Date segmentStart = segment.getSegmentStartTime();
                Date segmentEnd = segment.getSegmentEndTime();
                
                if (segmentStart == null || segmentEnd == null) {
                    continue;
                }
                
                // 检查该分段是否在任意任务的时间范围内
                for (SysTask task : activeTasks) {
                    Date taskStart = task.getPlannedStartTime();
                    Date taskEnd = task.getActualEndTime();
                    
                    // 如果任务还没完成，使用当前时间作为结束时间
                    if (taskEnd == null) {
                        taskEnd = endTime;
                    }
                    
                    if (taskStart == null) {
                        continue;
                    }
                    
                    // 判断分段时间是否与任务时间有重叠
                    if (isTimeOverlap(segmentStart, segmentEnd, taskStart, taskEnd)) {
                        if (segment.getSegmentDistance() != null) {
                            taskMileage = taskMileage.add(segment.getSegmentDistance());
                        }
                        break; // 该分段已计入任务里程，不重复计算
                    }
                }
            }
            
            return taskMileage;
            
        } catch (Exception e) {
            log.error("计算任务里程失败，vehicleId={}", vehicleId, e);
            return BigDecimal.ZERO;
        }
    }
    
    /**
     * 判断两个时间段是否有重叠
     */
    private boolean isTimeOverlap(Date start1, Date end1, Date start2, Date end2) {
        // 时间段1: [start1, end1]
        // 时间段2: [start2, end2]
        // 有重叠的条件：start1 < end2 && start2 < end1
        return start1.before(end2) && start2.before(end1);
    }

    /**
     * 检查告警频率限制
     */
    private boolean checkAlertFrequency(Long vehicleId, AlertConfig config) {
        try {
            // 1. 检查当日告警次数
            Date today = DateUtils.parseDate(DateUtils.getDate());
            int dailyCount = alertMapper.selectDailyAlertCount(vehicleId, today);
            if (dailyCount >= config.dailyLimit) {
                log.debug("车辆 {} 今日告警次数 {} 已达上限 {}", vehicleId, dailyCount, config.dailyLimit);
                return false;
            }
            
            // 2. 检查告警间隔
            Date lastAlertTime = alertMapper.selectLastAlertTime(vehicleId);
            if (lastAlertTime != null) {
                long minutesDiff = (new Date().getTime() - lastAlertTime.getTime()) / (1000 * 60);
                if (minutesDiff < config.alertInterval) {
                    log.debug("车辆 {} 距离上次告警仅 {} 分钟，未达到间隔 {} 分钟", 
                            vehicleId, minutesDiff, config.alertInterval);
                    return false;
                }
            }
            
            return true;
            
        } catch (Exception e) {
            log.error("检查告警频率失败，vehicleId={}", vehicleId, e);
            // 出错时谨慎处理，允许告警
            return true;
        }
    }

    /**
     * 创建告警并发送通知
     */
    private boolean createAlertAndNotify(VehicleInfo vehicle, BigDecimal mileage, 
                                         Date startTime, Date endTime, AlertConfig config) {
        try {
            Long vehicleId = vehicle.getVehicleId();
            String vehicleNo = vehicle.getVehicleNo();
            
            // 获取车辆归属部门信息
            Long deptId = vehicle.getDeptId();
            String deptName = vehicle.getDeptName();
            
            // 创建告警记录
            boolean created = alertService.checkAndCreateAlert(
                    vehicleId, vehicleNo, mileage, startTime, endTime, deptId, deptName);
            
            if (!created) {
//                log.info("车辆 {} 今日已存在相同类型的告警，不再创建", vehicleNo);
                return false;
            }
            
//            log.info("车辆 {} 产生异常告警：无任务运行 {}km，时间 {} 至 {}",
//                    vehicleNo, mileage,
//                    DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, startTime),
//                    DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, endTime));
            
            // 发送通知
            sendAlertNotification(vehicle, mileage, deptId, config);
            
            return true;
            
        } catch (Exception e) {
            log.error("创建告警失败，vehicleNo={}", vehicle.getVehicleNo(), e);
            return false;
        }
    }

    /**
     * 发送告警通知
     */
    private void sendAlertNotification(VehicleInfo vehicle, BigDecimal mileage, 
                                       Long deptId, AlertConfig config) {
        try {
            // 获取通知用户列表
            List<Long> notifyUserIds = getNotifyUsers(deptId, config);
            if (notifyUserIds.isEmpty()) {
                log.warn("车辆 {} 告警无通知用户，跳过发送", vehicle.getVehicleNo());
                return;
            }
            
            // 构造通知内容
            String title = "车辆异常运行告警";
            String content = String.format("车辆 %s 在无任务状态下运行了 %.2f 公里，请及时录入任务单，点击去录单。",
                    vehicle.getVehicleNo(), mileage);
            
            // 通过企业微信发送通知
            if (qyWechatService != null && qyWechatService.isEnabled()) {
                for (Long userId : notifyUserIds) {
                    try {
                        // 这里可以根据实际需求指定跳转链接
                        String notifyUrl = "/pagesTask/create-emergency"; // 实际链接需根据业务调整
                        qyWechatService.sendNotifyMessageWithDefaultAppId(userId, title, content, notifyUrl);
                        log.info("已向用户 {} 发送车辆 {} 异常告警通知", userId, vehicle.getVehicleNo());
                    } catch (Exception e) {
                        log.error("向用户 {} 发送告警通知失败", userId, e);
                    }
                }
            } else {
                log.warn("企业微信服务未启用，无法发送告警通知");
            }
            
        } catch (Exception e) {
            log.error("发送告警通知失败，vehicleNo={}", vehicle.getVehicleNo(), e);
        }
    }

    /**
     * 获取通知用户列表
     */
    private List<Long> getNotifyUsers(Long deptId, AlertConfig config) {
        List<Long> userIds = new ArrayList<>();
        
        try {
            // 1. 优先使用配置的用户列表
            if (StringUtils.isNotEmpty(config.notifyUsers)) {
                String[] userIdStrs = config.notifyUsers.split(",");
                for (String userIdStr : userIdStrs) {
                    try {
                        userIds.add(Long.parseLong(userIdStr.trim()));
                    } catch (NumberFormatException e) {
                        log.warn("无效的用户ID: {}", userIdStr);
                    }
                }
            }
            
            // 2. 如果没有配置用户，查询车辆所属部门的负责人
            if ( deptId != null) {
                SysDept dept = deptService.selectDeptById(deptId);
                if (dept != null && StringUtils.isNotEmpty(dept.getLeader())) {
                    // leader是用户名，通过用户名查询用户ID
                    com.ruoyi.common.core.domain.entity.SysUser leaderUser = 
                            userService.selectUserByUserName(dept.getLeader());
                    if (leaderUser != null) {
                        userIds.add(leaderUser.getUserId());
//                        log.info("使用部门 {} 负责人: {} (ID: {})",
//                                dept.getDeptName(), dept.getLeader(), leaderUser.getUserId());
                    } else {
                        log.warn("部门 {} 负责人 {} 未找到对应用户", 
                                dept.getDeptName(), dept.getLeader());
                    }
                }
            }
            
            // 3. 如果还是没有用户，使用系统默认配置的用户列表（总公司负责人）
            if (userIds.isEmpty()) {
                String defaultUsers = configService.selectConfigByKey("vehicle.alert.default.users");
                if (StringUtils.isNotEmpty(defaultUsers)) {
                    String[] defaultUserIds = defaultUsers.split(",");
                    for (String userId : defaultUserIds) {
                        try {
                            userIds.add(Long.parseLong(userId.trim()));
                            log.info("使用系统默认通知用户: {}", userId);
                        } catch (NumberFormatException e) {
                            log.warn("无效的默认用户ID: {}", userId);
                        }
                    }
                }
            }
            
        } catch (Exception e) {
            log.error("获取通知用户列表失败", e);
        }
        
        return userIds;
    }

    /**
     * 检查告警功能是否启用
     */
    private boolean isAlertEnabled() {
        try {
            String enabled = configService.selectConfigByKey("vehicle.alert.enabled");
            return "true".equalsIgnoreCase(enabled);
        } catch (Exception e) {
            log.warn("获取告警开关配置失败，使用默认值(false)", e);
            return false;
        }
    }

    /**
     * 获取车辆的告警配置（优先级：车辆 > 部门 > 全局）
     */
    private AlertConfig getVehicleAlertConfig(Long vehicleId, Long deptId, AlertConfig globalConfig) {
        try {
            // 从数据库查询配置
            VehicleAlertConfig dbConfig = alertConfigService.getConfigByVehicle(vehicleId, deptId);
            
            if (dbConfig != null) {
                // 将数据库配置转换为AlertConfig
                AlertConfig config = new AlertConfig();
                config.mileageThreshold = dbConfig.getMileageThreshold();
                config.dailyLimit = dbConfig.getDailyAlertLimit();
                config.alertInterval = dbConfig.getAlertInterval();
                config.timeWindow = globalConfig.timeWindow; // 时间窗口使用全局配置
                config.notifyUsers = dbConfig.getNotifyUserIds();
                return config;
            }
            
            // 如果没有数据库配置，使用全局配置
            return globalConfig;
            
        } catch (Exception e) {
            log.error("获取车辆配置失败，vehicleId={}", vehicleId, e);
            return globalConfig;
        }
    }

    /**
     * 加载告警配置参数
     */
    private AlertConfig loadAlertConfig() {
        AlertConfig config = new AlertConfig();
        
        try {
            // 公里数阈值
            String thresholdStr = configService.selectConfigByKey("vehicle.alert.mileage.threshold");
            config.mileageThreshold = StringUtils.isNotEmpty(thresholdStr) 
                    ? new BigDecimal(thresholdStr) : new BigDecimal("10");
            
            // 每日告警次数限制
            String limitStr = configService.selectConfigByKey("vehicle.alert.daily.limit");
            config.dailyLimit = StringUtils.isNotEmpty(limitStr) ? Integer.parseInt(limitStr) : 5;
            
            // 告警间隔时间
            String intervalStr = configService.selectConfigByKey("vehicle.alert.interval.minutes");
            config.alertInterval = StringUtils.isNotEmpty(intervalStr) ? Integer.parseInt(intervalStr) : 5;
            
            // 监控时间窗口
            String windowStr = configService.selectConfigByKey("vehicle.alert.time.window");
            config.timeWindow = StringUtils.isNotEmpty(windowStr) ? Integer.parseInt(windowStr) : 10;
            
            // 通知用户列表
            config.notifyUsers = configService.selectConfigByKey("vehicle.alert.notify.users");
            
//            log.debug("告警配置: 阈值={}km, 每日限制={}次, 间隔={}分钟, 时间窗口={}分钟",
//                    config.mileageThreshold, config.dailyLimit, config.alertInterval, config.timeWindow);
            
        } catch (Exception e) {
            log.error("加载告警配置失败，使用默认值", e);
        }
        
        return config;
    }

    /**
     * 告警配置内部类
     */
    private static class AlertConfig {
        BigDecimal mileageThreshold = new BigDecimal("10");  // 公里数阈值
        int dailyLimit = 5;                                   // 每日告警次数限制
        int alertInterval = 5;                                // 告警间隔（分钟）
        int timeWindow = 10;                                  // 监控时间窗口（分钟）
        String notifyUsers;                                   // 通知用户列表
    }
}