package com.ruoyi.system.service.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.mapper.SysTaskVehicleMapper;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.mapper.VehicleInfoMapper;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.SysTaskVehicle;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.service.ISysTaskVehicleService;

/**
 * 任务车辆关联Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-01-15
 */
@Service
public class SysTaskVehicleServiceImpl implements ISysTaskVehicleService {
    
    private static final Logger logger = LoggerFactory.getLogger(SysTaskVehicleServiceImpl.class);
    
    @Autowired
    private SysTaskVehicleMapper sysTaskVehicleMapper;
    
    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;
    
    @Autowired
    private SysTaskMapper sysTaskMapper;

    /**
     * 查询任务车辆关联
     * 
     * @param id 任务车辆关联主键
     * @return 任务车辆关联
     */
    @Override
    public SysTaskVehicle selectSysTaskVehicleById(Long id) {
        return sysTaskVehicleMapper.selectSysTaskVehicleById(id);
    }

    /**
     * 查询任务车辆关联列表
     * 
     * @param sysTaskVehicle 任务车辆关联
     * @return 任务车辆关联
     */
    @Override
    public List<SysTaskVehicle> selectSysTaskVehicleList(SysTaskVehicle sysTaskVehicle) {
        return sysTaskVehicleMapper.selectSysTaskVehicleList(sysTaskVehicle);
    }

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

    /**
     * 新增任务车辆关联
     * 
     * @param sysTaskVehicle 任务车辆关联
     * @return 结果
     */
    @Override
    @Transactional
    public int insertSysTaskVehicle(SysTaskVehicle sysTaskVehicle) {
        // 设置分配时间和分配人
        if (sysTaskVehicle.getAssignTime() == null) {
            sysTaskVehicle.setAssignTime(DateUtils.getNowDate());
        }
        if (sysTaskVehicle.getAssignBy() == null || sysTaskVehicle.getAssignBy().isEmpty()) {
            sysTaskVehicle.setAssignBy(SecurityUtils.getUsername());
        }
        // 设置默认状态
        if (sysTaskVehicle.getStatus() == null || sysTaskVehicle.getStatus().isEmpty()) {
            sysTaskVehicle.setStatus("ASSIGNED");
        }
        sysTaskVehicle.setCreateTime(DateUtils.getNowDate());
        return sysTaskVehicleMapper.insertSysTaskVehicle(sysTaskVehicle);
    }

    /**
     * 修改任务车辆关联
     * 
     * @param sysTaskVehicle 任务车辆关联
     * @return 结果
     */
    @Override
    @Transactional
    public int updateSysTaskVehicle(SysTaskVehicle sysTaskVehicle) {
        sysTaskVehicle.setUpdateTime(DateUtils.getNowDate());
        return sysTaskVehicleMapper.updateSysTaskVehicle(sysTaskVehicle);
    }

    /**
     * 批量删除任务车辆关联
     * 
     * @param ids 需要删除的任务车辆关联主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSysTaskVehicleByIds(Long[] ids) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByIds(ids);
    }

    /**
     * 删除任务车辆关联信息
     * 
     * @param id 任务车辆关联主键
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSysTaskVehicleById(Long id) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleById(id);
    }

    /**
     * 根据任务ID删除车辆关联
     * 
     * @param taskId 任务ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSysTaskVehicleByTaskId(Long taskId) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(taskId);
    }

    /**
     * 根据任务ID和车辆ID删除关联
     * 
     * @param taskId 任务ID
     * @param vehicleId 车辆ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteSysTaskVehicleByTaskIdAndVehicleId(Long taskId, Long vehicleId) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByTaskIdAndVehicleId(taskId, vehicleId);
    }

    /**
     * 检查任务车辆关联是否存在
     * 
     * @param taskId 任务ID
     * @param vehicleId 车辆ID
     * @return 结果
     */
    @Override
    public int checkTaskVehicleExists(Long taskId, Long vehicleId) {
        return sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId);
    }

    /**
     * 批量新增任务车辆关联
     * 
     * @param sysTaskVehicleList 任务车辆关联列表
     * @return 结果
     */
    @Override
    @Transactional
    public int batchInsertSysTaskVehicle(List<SysTaskVehicle> sysTaskVehicleList) {
        return sysTaskVehicleMapper.batchInsertSysTaskVehicle(sysTaskVehicleList);
    }

    /**
     * 分配车辆给任务
     * 
     * @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);
        
        return sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
    }

    /**
     * 取消任务车辆分配
     * 
     * @param taskId 任务ID
     * @param vehicleId 车辆ID
     * @return 结果
     */
    @Override
    @Transactional
    public int unassignVehicleFromTask(Long taskId, Long vehicleId) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByTaskIdAndVehicleId(taskId, vehicleId);
    }

    /**
     * 批量分配车辆给任务
     * 
     * @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);
            }
        }
        
        if (!taskVehicles.isEmpty()) {
            return sysTaskVehicleMapper.batchInsertSysTaskVehicle(taskVehicles);
        }
        
        return 0;
    }

    /**
     * 查询可用车辆
     * 
     * @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.setDeptId(deptId);
            queryParam.setStatus("0"); // 0表示正常状态
            
            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.setStatus(vehicle.getStatus());
                availableVehicles.add(taskVehicle);
            }
        } catch (Exception e) {
            logger.error("查询可用车辆失败", e);
        }
        
        return availableVehicles;
    }

    /**
     * 更新任务车辆关联状态
     * 
     * @param id 关联ID
     * @param status 新状态
     * @return 结果
     */
    @Override
    @Transactional
    public int updateTaskVehicleStatus(Long id, String status) {
        SysTaskVehicle taskVehicle = new SysTaskVehicle();
        taskVehicle.setId(id);
        taskVehicle.setStatus(status);
        taskVehicle.setUpdateTime(DateUtils.getNowDate());
        return sysTaskVehicleMapper.updateSysTaskVehicle(taskVehicle);
    }

    /**
     * 批量获取车辆当前任务状态
     * 
     * @param vehicleIds 车辆ID列表
     * @return Map<车辆ID, Map<"taskCode": 任务编号, "taskStatus": 任务状态>>
     */
    @Override
    public Map<Long, Map<String, Object>> batchGetVehicleCurrentTaskStatus(List<Long> vehicleIds) {
        Map<Long, Map<String, Object>> resultMap = new HashMap<>();
        
        if (vehicleIds == null || vehicleIds.isEmpty()) {
            return resultMap;
        }
        
        try {
            // 对每个车辆查询其当前正在进行的任务
            for (Long vehicleId : vehicleIds) {
                if (vehicleId == null) {
                    continue;
                }
                
                // 查询车辆的活跃任务（未完成、未取消的任务）
                List<SysTask> activeTasks = sysTaskMapper.selectActiveTasksByVehicleId(vehicleId);
                
                if (activeTasks != null && !activeTasks.isEmpty()) {
                    // 取第一个活跃任务（最新的）
                    SysTask currentTask = activeTasks.get(0);
                    
                    Map<String, Object> taskInfo = new HashMap<>();
                    taskInfo.put("taskCode", currentTask.getTaskCode());
                    taskInfo.put("taskStatus", currentTask.getTaskStatus());
                    taskInfo.put("taskId", currentTask.getTaskId());
                    
                    resultMap.put(vehicleId, taskInfo);
                } else {
                    // 没有活跃任务
                    resultMap.put(vehicleId, null);
                }
            }
        } catch (Exception e) {
            logger.error("批量查询车辆任务状态失败", e);
        }
        
        return resultMap;
    }

    /**
     * 更新任务车辆关联状态（新方法）
     * 
     * @param id 关联ID
     * @param status 新状态
     * @return 结果
     */
    @Override
    @Transactional
    public int updateSysTaskVehicleStatus(Long id, String status) {
        return updateTaskVehicleStatus(id, status);
    }
}