package com.ruoyi.system.service.impl;

import java.util.Date;
import java.util.List;
import java.util.ArrayList;
import java.io.File;
import java.io.IOException;

import com.ruoyi.system.utils.TaskCodeGenerator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.GpsDistanceUtils;
import com.ruoyi.common.utils.file.FileUploadUtils;
import com.ruoyi.common.utils.file.FileUtils;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskVehicle;
import com.ruoyi.system.domain.SysTaskAttachment;
import com.ruoyi.system.domain.SysTaskLog;
import com.ruoyi.system.domain.vo.TaskQueryVO;
import com.ruoyi.system.domain.vo.TaskCreateVO;
import com.ruoyi.system.domain.vo.TaskUpdateVO;
import com.ruoyi.system.domain.vo.TaskStatisticsVO;
import com.ruoyi.system.domain.enums.TaskStatus;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.mapper.SysTaskVehicleMapper;
import com.ruoyi.system.mapper.SysTaskAttachmentMapper;
import com.ruoyi.system.mapper.SysTaskLogMapper;
import com.ruoyi.system.mapper.VehicleInfoMapper;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.service.ISysTaskService;

/**
 * 任务管理Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-01-15
 */
@Service
public class SysTaskServiceImpl implements ISysTaskService {
    
    @Autowired
    private SysTaskMapper sysTaskMapper;
    
    @Autowired
    private SysTaskVehicleMapper sysTaskVehicleMapper;
    
    @Autowired
    private SysTaskAttachmentMapper sysTaskAttachmentMapper;
    
    @Autowired
    private SysTaskLogMapper sysTaskLogMapper;
    
    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;

    /**
     * 查询任务管理
     * 
     * @param taskId 任务管理主键
     * @return 任务管理
     */
    @Override
    public SysTask selectSysTaskByTaskId(Long taskId) {
        return sysTaskMapper.selectSysTaskByTaskId(taskId);
    }

    /**
     * 查询任务管理列表
     * 
     * @param queryVO 任务查询对象
     * @return 任务管理
     */
    @Override
    public List<SysTask> selectSysTaskList(TaskQueryVO queryVO) {
        return sysTaskMapper.selectSysTaskList(queryVO);
    }

    /**
     * 新增任务管理
     * 
     * @param createVO 任务创建对象
     * @return 结果
     */
    @Override
    @Transactional
    public int insertSysTask(TaskCreateVO createVO) {
        SysTask task = new SysTask();
        task.setTaskCode(generateTaskCode());
        task.setTaskType(createVO.getTaskType());
        task.setTaskStatus(TaskStatus.PENDING.getCode());
        task.setTaskDescription(createVO.getTaskDescription());
        task.setDepartureAddress(createVO.getDepartureAddress());
        task.setDestinationAddress(createVO.getDestinationAddress());
        task.setDepartureLongitude(createVO.getDepartureLongitude());
        task.setDepartureLatitude(createVO.getDepartureLatitude());
        task.setDestinationLongitude(createVO.getDestinationLongitude());
        task.setDestinationLatitude(createVO.getDestinationLatitude());
        task.setPlannedStartTime(createVO.getPlannedStartTime());
        task.setPlannedEndTime(createVO.getPlannedEndTime());
        task.setAssigneeId(createVO.getAssigneeId());
        task.setCreatorId(SecurityUtils.getUserId());
        task.setDeptId(SecurityUtils.getDeptId());
        task.setCreateBy(SecurityUtils.getUsername());
        task.setCreateTime(DateUtils.getNowDate());
        task.setUpdateBy(SecurityUtils.getUsername());
        task.setUpdateTime(DateUtils.getNowDate());
        task.setRemark(createVO.getRemark());
        task.setDelFlag("0");
        
        // 计算预计公里数
        calculateEstimatedDistance(task);
        
        int result = sysTaskMapper.insertSysTask(task);
        
        // 保存车辆关联信息
        if (result > 0 && createVO.getVehicleIds() != null && !createVO.getVehicleIds().isEmpty()) {
            for (Long vehicleId : createVO.getVehicleIds()) {
                SysTaskVehicle taskVehicle = new SysTaskVehicle();
                taskVehicle.setTaskId(task.getTaskId());
                taskVehicle.setVehicleId(vehicleId);
                taskVehicle.setAssignTime(DateUtils.getNowDate());
                taskVehicle.setAssignBy(SecurityUtils.getUsername());
                taskVehicle.setStatus("ASSIGNED");
                taskVehicle.setCreateBy(SecurityUtils.getUsername());
                taskVehicle.setCreateTime(DateUtils.getNowDate());
                taskVehicle.setUpdateBy(SecurityUtils.getUsername());
                taskVehicle.setUpdateTime(DateUtils.getNowDate());
                
                sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
            }
        }
        
        // 记录操作日志
        if (result > 0) {
            recordTaskLog(task.getTaskId(), "CREATE", "创建任务", null, 
                         "任务类型：" + createVO.getTaskType(), SecurityUtils.getUserId(), SecurityUtils.getUsername());
        }
        
        return result;
    }

    /**
     * 修改任务管理
     * 
     * @param updateVO 任务更新对象
     * @return 结果
     */
    @Override
    @Transactional
    public int updateSysTask(TaskUpdateVO updateVO) {
        SysTask oldTask = sysTaskMapper.selectSysTaskByTaskId(updateVO.getTaskId());
        if (oldTask == null) {
            throw new RuntimeException("任务不存在");
        }
        
        SysTask task = new SysTask();
        task.setTaskId(updateVO.getTaskId());
        task.setTaskDescription(updateVO.getTaskDescription());
        task.setDepartureAddress(updateVO.getDepartureAddress());
        task.setDestinationAddress(updateVO.getDestinationAddress());
        task.setDepartureLongitude(updateVO.getDepartureLongitude());
        task.setDepartureLatitude(updateVO.getDepartureLatitude());
        task.setDestinationLongitude(updateVO.getDestinationLongitude());
        task.setDestinationLatitude(updateVO.getDestinationLatitude());
        task.setPlannedStartTime(updateVO.getPlannedStartTime());
        task.setPlannedEndTime(updateVO.getPlannedEndTime());
        task.setAssigneeId(updateVO.getAssigneeId());
        task.setUpdateBy(SecurityUtils.getUsername());
        task.setUpdateTime(DateUtils.getNowDate());
        task.setRemark(updateVO.getRemark());
        
        // 重新计算预计公里数
        calculateEstimatedDistance(task);
        
        int result = sysTaskMapper.updateSysTask(task);
        
        // 记录操作日志
        if (result > 0) {
            recordTaskLog(updateVO.getTaskId(), "UPDATE", "更新任务", 
                         buildTaskDescription(oldTask), buildTaskDescription(task), 
                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
        }
        
        return result;
    }

    /**
     * 批量删除任务管理
     * 
     * @param taskIds 需要删除的任务管理主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSysTaskByTaskIds(Long[] taskIds) {
        int result = 0;
        for (Long taskId : taskIds) {
            // 记录删除日志
            recordTaskLog(taskId, "DELETE", "删除任务", null, null, 
                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
            result += sysTaskMapper.deleteSysTaskByTaskId(taskId);
        }
        return result;
    }

    /**
     * 分配任务
     * 
     * @param taskId 任务ID
     * @param assigneeId 执行人ID
     * @param remark 备注
     * @return 结果
     */
    @Override
    @Transactional
    public int assignTask(Long taskId, Long assigneeId, String remark) {
        SysTask task = new SysTask();
        task.setTaskId(taskId);
        task.setAssigneeId(assigneeId);
        task.setUpdateBy(SecurityUtils.getUsername());
        task.setUpdateTime(DateUtils.getNowDate());
        
        int result = sysTaskMapper.assignTask(task);
        
        // 记录操作日志
        if (result > 0) {
            recordTaskLog(taskId, "ASSIGN", "分配任务", null, 
                         "分配给用户ID：" + assigneeId + "，备注：" + remark, 
                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
        }
        
        return result;
    }

    /**
     * 变更任务状态
     * 
     * @param taskId 任务ID
     * @param newStatus 新状态
     * @param remark 备注
     * @return 结果
     */
    @Override
    @Transactional
    public int changeTaskStatus(Long taskId, TaskStatus newStatus, String remark) {
        SysTask oldTask = sysTaskMapper.selectSysTaskByTaskId(taskId);
        if (oldTask == null) {
            throw new RuntimeException("任务不存在");
        }
        
        // 验证状态流转是否合法
        TaskStatus oldTaskStatus = TaskStatus.getByCode(oldTask.getTaskStatus());
        if (!oldTask.canChangeStatus(newStatus)) {
            throw new RuntimeException("状态流转不合法：从 " + oldTaskStatus.getInfo() + " 到 " + newStatus.getInfo());
        }
        
        SysTask task = new SysTask();
        task.setTaskId(taskId);
        task.setTaskStatus(newStatus.getCode());
        task.setUpdateBy(SecurityUtils.getUsername());
        task.setUpdateTime(DateUtils.getNowDate());
        
        // 根据状态设置相应的时间
        if (newStatus == TaskStatus.IN_PROGRESS && oldTask.getActualStartTime() == null) {
            task.setActualStartTime(DateUtils.getNowDate());
        } else if (newStatus == TaskStatus.COMPLETED) {
            task.setActualEndTime(DateUtils.getNowDate());
        }
        
        int result = sysTaskMapper.updateTaskStatus(task);
        
        // 记录操作日志
        if (result > 0) {
            recordTaskLog(taskId, "STATUS_CHANGE", "状态变更", 
                         "状态：" + oldTaskStatus.getInfo(), 
                         "状态：" + newStatus.getInfo() + "，备注：" + remark, 
                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
        }
        
        return result;
    }

    /**
     * 上传任务附件
     * 
     * @param taskId 任务ID
     * @param file 文件
     * @return 结果
     */
    @Override
    @Transactional
    public int uploadAttachment(Long taskId, MultipartFile file) {
        try {
            // 上传文件
            String fileName = FileUploadUtils.upload("/task", file);
            String filePath = FileUploadUtils.getDefaultBaseDir() + fileName;
            
            SysTaskAttachment attachment = new SysTaskAttachment();
            attachment.setTaskId(taskId);
            attachment.setFileName(file.getOriginalFilename());
            attachment.setFilePath(filePath);
            attachment.setFileSize(file.getSize());
            attachment.setFileType(getFileType(file.getOriginalFilename()));
            attachment.setUploadTime(DateUtils.getNowDate());
            attachment.setUploadBy(SecurityUtils.getUsername());
            
            int result = sysTaskAttachmentMapper.insertSysTaskAttachment(attachment);
            
            // 记录操作日志
            if (result > 0) {
                recordTaskLog(taskId, "UPDATE", "上传附件", null, 
                             "上传文件：" + file.getOriginalFilename(), 
                             SecurityUtils.getUserId(), SecurityUtils.getUsername());
            }
            
            return result;
        } catch (IOException e) {
            throw new RuntimeException("文件上传失败：" + e.getMessage());
        }
    }

    /**
     * 删除任务附件
     * 
     * @param attachmentId 附件ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteAttachment(Long attachmentId) {
        SysTaskAttachment attachment = sysTaskAttachmentMapper.selectSysTaskAttachmentByAttachmentId(attachmentId);
        if (attachment == null) {
            throw new RuntimeException("附件不存在");
        }
        
        // 删除物理文件
        try {
            FileUtils.deleteFile(attachment.getFilePath());
        } catch (Exception e) {
            // 忽略文件删除失败
        }
        
        int result = sysTaskAttachmentMapper.deleteSysTaskAttachmentByAttachmentId(attachmentId);
        
        // 记录操作日志
        if (result > 0) {
            recordTaskLog(attachment.getTaskId(), "UPDATE", "删除附件", 
                         "删除文件：" + attachment.getFileName(), null, 
                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
        }
        
        return result;
    }

    /**
     * 分配车辆给任务
     * 
     * @param taskId 任务ID
     * @param vehicleId 车辆ID
     * @param remark 备注
     * @return 结果
     */
    @Override
    @Transactional
    public int assignVehicleToTask(Long taskId, Long vehicleId, String remark) {
        // 检查是否已经分配
        int exists = sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId);
        if (exists > 0) {
            throw new RuntimeException("车辆已经分配给该任务");
        }
        
        SysTaskVehicle taskVehicle = new SysTaskVehicle();
        taskVehicle.setTaskId(taskId);
        taskVehicle.setVehicleId(vehicleId);
        taskVehicle.setAssignTime(DateUtils.getNowDate());
        taskVehicle.setAssignBy(SecurityUtils.getUsername());
        taskVehicle.setStatus("ASSIGNED");
        taskVehicle.setRemark(remark);
        
        int result = sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
        
        // 记录操作日志
        if (result > 0) {
            recordTaskLog(taskId, "ASSIGN", "分配车辆", null, 
                         "分配车辆ID：" + vehicleId + "，备注：" + remark, 
                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
        }
        
        return result;
    }

    /**
     * 取消任务车辆分配
     * 
     * @param taskId 任务ID
     * @param vehicleId 车辆ID
     * @return 结果
     */
    @Override
    @Transactional
    public int unassignVehicleFromTask(Long taskId, Long vehicleId) {
        int result = sysTaskVehicleMapper.deleteSysTaskVehicleByTaskIdAndVehicleId(taskId, vehicleId);
        
        // 记录操作日志
        if (result > 0) {
            recordTaskLog(taskId, "ASSIGN", "取消车辆分配", 
                         "取消车辆ID：" + vehicleId, null, 
                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
        }
        
        return result;
    }

    /**
     * 批量分配车辆给任务
     * 
     * @param taskId 任务ID
     * @param vehicleIds 车辆ID列表
     * @param remark 备注
     * @return 结果
     */
    @Override
    @Transactional
    public int assignMultipleVehiclesToTask(Long taskId, List<Long> vehicleIds, String remark) {
        List<SysTaskVehicle> taskVehicles = new ArrayList<>();
        Date now = DateUtils.getNowDate();
        String assignBy = SecurityUtils.getUsername();
        
        for (Long vehicleId : vehicleIds) {
            // 检查是否已经分配
            int exists = sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId);
            if (exists == 0) {
                SysTaskVehicle taskVehicle = new SysTaskVehicle();
                taskVehicle.setTaskId(taskId);
                taskVehicle.setVehicleId(vehicleId);
                taskVehicle.setAssignTime(now);
                taskVehicle.setAssignBy(assignBy);
                taskVehicle.setStatus("ASSIGNED");
                taskVehicle.setRemark(remark);
                taskVehicles.add(taskVehicle);
            }
        }
        
        int result = 0;
        if (!taskVehicles.isEmpty()) {
            result = sysTaskVehicleMapper.batchInsertSysTaskVehicle(taskVehicles);
        }
        
        // 记录操作日志
        if (result > 0) {
            recordTaskLog(taskId, "ASSIGN", "批量分配车辆", null, 
                         "分配车辆数量：" + result + "，备注：" + remark, 
                         SecurityUtils.getUserId(), SecurityUtils.getUsername());
        }
        
        return result;
    }

    /**
     * 查询任务关联的车辆
     * 
     * @param taskId 任务ID
     * @return 任务车辆关联列表
     */
    @Override
    public List<SysTaskVehicle> getTaskVehicles(Long taskId) {
        return sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
    }

    /**
     * 查询可用车辆
     * 
     * @param deptId 部门ID
     * @param taskType 任务类型
     * @return 可用车辆列表
     */
    @Override
    public List<SysTaskVehicle> getAvailableVehicles(Long deptId, String taskType) {
        List<SysTaskVehicle> availableVehicles = new ArrayList<>();
        
        try {
            // 查询所有状态为正常的车辆（不限制部门）
            VehicleInfo queryParam = new VehicleInfo();
            queryParam.setStatus("0"); // 0表示正常状态
            // 不设置deptId，查询所有部门的车辆
            
            List<VehicleInfo> vehicles = vehicleInfoMapper.selectVehicleInfoList(queryParam);
            
            // 转换为SysTaskVehicle对象
            for (VehicleInfo vehicle : vehicles) {
                SysTaskVehicle taskVehicle = new SysTaskVehicle();
                taskVehicle.setVehicleId(vehicle.getVehicleId());
                taskVehicle.setVehicleNo(vehicle.getVehicleNo());
                taskVehicle.setVehicleType(vehicle.getVehicleType());
                taskVehicle.setVehicleBrand(vehicle.getVehicleBrand());
                taskVehicle.setVehicleModel(vehicle.getVehicleModel());
                taskVehicle.setDeptName(vehicle.getDeptName()); // 添加部门名称
                availableVehicles.add(taskVehicle);
            }
        } catch (Exception e) {
            // 如果查询失败，记录日志并返回空列表
            System.err.println("查询可用车辆失败: " + e.getMessage());
        }
        
        return availableVehicles;
    }

    /**
     * 查询任务统计信息
     * 
     * @return 任务统计信息
     */
    @Override
    public TaskStatisticsVO getTaskStatistics() {
        return sysTaskMapper.selectTaskStatistics();
    }

    /**
     * 查询超时任务列表
     * 
     * @return 超时任务列表
     */
    @Override
    public List<SysTask> selectOverdueTasks() {
        return sysTaskMapper.selectOverdueTasks();
    }

    /**
     * 查询我的任务列表
     * 
     * @param userId 用户ID
     * @return 我的任务列表
     */
    @Override
    public List<SysTask> selectMyTasks(Long userId) {
        return sysTaskMapper.selectMyTasks(userId);
    }

    /**
     * 获取任务详情（包含关联数据）
     * 
     * @param taskId 任务ID
     * @return 任务详情
     */
    @Override
    public SysTask getTaskDetail(Long taskId) {
        SysTask task = sysTaskMapper.selectSysTaskByTaskId(taskId);
        if (task != null) {
            // 查询关联车辆
            task.setAssignedVehicles(sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId));
            // 查询附件
            task.setAttachments(sysTaskAttachmentMapper.selectSysTaskAttachmentByTaskId(taskId));
            // 查询操作日志
            task.setOperationLogs(sysTaskLogMapper.selectSysTaskLogByTaskId(taskId));
        }
        return task;
    }

    @Autowired
    private TaskCodeGenerator taskCodeGenerator;
    
    /**
     * 生成任务编号
     * 
     * @return 任务编号
     */
    private String generateTaskCode() {
        return taskCodeGenerator.generateTaskCode();
    }

    /**
     * 记录任务操作日志
     * 
     * @param taskId 任务ID
     * @param operationType 操作类型
     * @param operationDesc 操作描述
     * @param oldValue 操作前值
     * @param newValue 操作后值
     * @param operatorId 操作人ID
     * @param operatorName 操作人姓名
     */
    private void recordTaskLog(Long taskId, String operationType, String operationDesc, 
                              String oldValue, String newValue, Long operatorId, String operatorName) {
        SysTaskLog log = new SysTaskLog();
        log.setTaskId(taskId);
        log.setOperationType(operationType);
        log.setOperationDesc(operationDesc);
        log.setOldValue(oldValue);
        log.setNewValue(newValue);
        log.setOperatorId(operatorId);
        log.setOperatorName(operatorName);
        log.setOperationTime(DateUtils.getNowDate());
        // 这里可以获取IP地址
        log.setIpAddress("127.0.0.1");
        
        sysTaskLogMapper.insertSysTaskLog(log);
    }

    /**
     * 构建任务描述
     * 
     * @param task 任务对象
     * @return 任务描述
     */
    private String buildTaskDescription(SysTask task) {
        StringBuilder sb = new StringBuilder();
        sb.append("任务编号：").append(task.getTaskCode()).append("，");
        sb.append("任务类型：").append(task.getTaskType()).append("，");
        sb.append("任务状态：").append(task.getTaskStatus()).append("，");
        if (StringUtils.isNotEmpty(task.getTaskDescription())) {
            sb.append("任务描述：").append(task.getTaskDescription()).append("，");
        }
        return sb.toString();
    }

    /**
     * 获取文件类型
     * 
     * @param fileName 文件名
     * @return 文件类型
     */
    private String getFileType(String fileName) {
        if (StringUtils.isEmpty(fileName)) {
            return "";
        }
        int lastDotIndex = fileName.lastIndexOf(".");
        if (lastDotIndex > 0 && lastDotIndex < fileName.length() - 1) {
            return fileName.substring(lastDotIndex + 1).toLowerCase();
        }
        return "";
    }

    /**
     * 计算预计公里数
     * 
     * @param task 任务对象
     */
    private void calculateEstimatedDistance(SysTask task) {
        if (task.getDepartureLongitude() != null && task.getDepartureLatitude() != null &&
            task.getDestinationLongitude() != null && task.getDestinationLatitude() != null) {
            
            // 验证GPS坐标是否有效
            if (GpsDistanceUtils.isValidCoordinate(task.getDepartureLatitude(), task.getDepartureLongitude()) &&
                GpsDistanceUtils.isValidCoordinate(task.getDestinationLatitude(), task.getDestinationLongitude())) {
                
                // 计算距离
                java.math.BigDecimal distance = GpsDistanceUtils.calculateDistance(
                    task.getDepartureLatitude(), task.getDepartureLongitude(),
                    task.getDestinationLatitude(), task.getDestinationLongitude()
                );
                
                task.setEstimatedDistance(distance);
            } else {
                // 坐标无效，设置为0
                task.setEstimatedDistance(java.math.BigDecimal.ZERO);
            }
        } else {
            // 坐标不完整，设置为0
            task.setEstimatedDistance(java.math.BigDecimal.ZERO);
        }
    }
}