package com.ruoyi.system.service.impl;

import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.domain.SysTaskVehicle;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.mapper.SysTaskVehicleMapper;
import com.ruoyi.system.mapper.VehicleInfoMapper;
import com.ruoyi.system.service.ISysTaskVehicleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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

/**
 * 任务车辆服务实现类
 * 
 * @author ruoyi
 */
@Service
public class SysTaskVehicleServiceImpl implements ISysTaskVehicleService {

    @Autowired
    private SysTaskVehicleMapper sysTaskVehicleMapper;

    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;

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

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

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

    /**
     * 新增任务车辆关联
     * 
     * @param sysTaskVehicle 任务车辆关联
     * @return 结果
     */
    @Override
    public int insertSysTaskVehicle(SysTaskVehicle sysTaskVehicle) {
        return sysTaskVehicleMapper.insertSysTaskVehicle(sysTaskVehicle);
    }

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

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

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

    /**
     * 更新任务车辆关联状态
     * 
     * @param id 任务车辆关联主键
     * @param status 状态
     * @return 结果
     */
    @Override
    public int updateSysTaskVehicleStatus(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 车辆任务状态映射
     */
    @Override
    public Map<Long, Map<String, Object>> batchGetVehicleCurrentTaskStatus(List<Long> vehicleIds) {
        Map<Long, Map<String, Object>> statusMap = new HashMap<>();
        
        if (vehicleIds != null && !vehicleIds.isEmpty()) {
            // 这里可以根据实际需求查询车辆的当前任务状态
            // 由于缺乏具体的业务逻辑，这里简单返回空映射
            for (Long vehicleId : vehicleIds) {
                Map<String, Object> statusInfo = new HashMap<>();
                statusInfo.put("vehicleId", vehicleId);
                statusInfo.put("currentTaskId", null);
                statusInfo.put("currentTaskStatus", "AVAILABLE");
                statusInfo.put("lastUpdateTime", DateUtils.getNowDate());
                statusMap.put(vehicleId, statusInfo);
            }
        }
        
        return statusMap;
    }

    @Override
    @Transactional
    public void saveTaskVehicles(Long taskId, List<Long> vehicleIds, String userName) {
        saveTaskVehicles(taskId, vehicleIds, userName, 
            DateUtils.getNowDate(), DateUtils.getNowDate(), DateUtils.getNowDate());
    }

    @Override
    @Transactional
    public void saveTaskVehicles(Long taskId, List<Long> vehicleIds, String userName,
                                  Date assignTime, Date createTime, Date updateTime) {
        if (vehicleIds == null || vehicleIds.isEmpty()) {
            return;
        }
        
        for (Long vehicleId : vehicleIds) {
            SysTaskVehicle taskVehicle = new SysTaskVehicle();
            taskVehicle.setTaskId(taskId);
            taskVehicle.setVehicleId(vehicleId);
            taskVehicle.setAssignTime(assignTime);
            taskVehicle.setAssignBy(userName);
            taskVehicle.setStatus("ASSIGNED");
            taskVehicle.setCreateBy(userName);
            taskVehicle.setCreateTime(createTime);
            taskVehicle.setUpdateBy(userName);
            taskVehicle.setUpdateTime(updateTime);
            
            sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
        }
    }

    @Override
    @Transactional
    public boolean updateTaskVehicles(Long taskId, List<Long> newVehicleIds, String userName) {
        if (newVehicleIds == null || newVehicleIds.isEmpty()) {
            return false;
        }
        
        // 查询现有的车辆关联
        List<SysTaskVehicle> existingVehicles = sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
        List<Long> existingVehicleIds = existingVehicles.stream()
            .map(SysTaskVehicle::getVehicleId)
            .collect(Collectors.toList());
        
        // 比较新旧车辆ID列表，判断是否有变化
        boolean vehiclesChanged = !new HashSet<>(existingVehicleIds).equals(new HashSet<>(newVehicleIds));
        
        // 只有车辆发生变化时才更新
        if (vehiclesChanged) {
            // 删除旧的车辆关联
            sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(taskId);
            
            // 添加新的车辆关联
            Date now = DateUtils.getNowDate();
            for (Long vehicleId : newVehicleIds) {
                SysTaskVehicle taskVehicle = new SysTaskVehicle();
                taskVehicle.setTaskId(taskId);
                taskVehicle.setVehicleId(vehicleId);
                taskVehicle.setAssignTime(now);
                taskVehicle.setAssignBy(userName);
                taskVehicle.setCreateTime(now);
                sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
            }
            return true;
        }
        
        return false;
    }

    @Override
    @Transactional
    public int assignVehicleToTask(Long taskId, Long vehicleId, String remark, Long userId, String userName) {
        // 检查是否已经分配
        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(userName);
        taskVehicle.setStatus("ASSIGNED");
        taskVehicle.setRemark(remark);
        
        return sysTaskVehicleMapper.insertSysTaskVehicle(taskVehicle);
    }

    @Override
    @Transactional
    public int unassignVehicleFromTask(Long taskId, Long vehicleId) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByTaskIdAndVehicleId(taskId, vehicleId);
    }

    @Override
    @Transactional
    public int assignMultipleVehiclesToTask(Long taskId, List<Long> vehicleIds, String remark, 
                                            Long userId, String userName) {
        List<SysTaskVehicle> taskVehicles = new ArrayList<>();
        Date now = DateUtils.getNowDate();
        
        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(userName);
                taskVehicle.setStatus("ASSIGNED");
                taskVehicle.setRemark(remark);
                taskVehicles.add(taskVehicle);
            }
        }
        
        int result = 0;
        if (!taskVehicles.isEmpty()) {
            result = sysTaskVehicleMapper.batchInsertSysTaskVehicle(taskVehicles);
        }
        
        return result;
    }

    @Override
    public List<SysTaskVehicle> getTaskVehicles(Long taskId) {
        return sysTaskVehicleMapper.selectSysTaskVehicleByTaskId(taskId);
    }

    @Override
    public List<SysTaskVehicle> getAvailableVehicles(Long deptId, String taskType) {
        List<SysTaskVehicle> availableVehicles = new ArrayList<>();
        
        try {
            // 查询所有状态为正常的车辆
            VehicleInfo queryParam = new VehicleInfo();
            queryParam.setStatus("0"); // 0表示正常状态
            queryParam.setDeptId(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;
    }

    @Override
    public int deleteTaskVehiclesByTaskId(Long taskId) {
        return sysTaskVehicleMapper.deleteSysTaskVehicleByTaskId(taskId);
    }

    @Override
    public boolean checkVehicleAssigned(Long taskId, Long vehicleId) {
        return sysTaskVehicleMapper.checkTaskVehicleExists(taskId, vehicleId) > 0;
    }
}