package com.ruoyi.system.service.impl;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.system.mapper.VehicleInfoMapper;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.system.mapper.SysDeptMapper;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.domain.VehicleDept;
import com.ruoyi.system.service.IVehicleInfoService;
import com.ruoyi.system.service.ISysDeptService;

/**
 * 车辆信息Service业务层处理
 */
@Service
public class VehicleInfoServiceImpl implements IVehicleInfoService {
    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;
    
    @Autowired
    private SysUserMapper sysUserMapper;
    
    @Autowired
    private SysDeptMapper sysDeptMapper;
    
    @Autowired
    private ISysDeptService sysDeptService;

    /**
     * 查询车辆信息
     * 
     * @param vehicleId 车辆信息主键
     * @return 车辆信息
     */
    @Override
    public VehicleInfo selectVehicleInfoById(Long vehicleId) {
        return vehicleInfoMapper.selectVehicleInfoById(vehicleId);
    }

    /**
     * 通过车牌号查询车辆信息
     * 
     * @param plateNumber 车牌号
     * @return 车辆信息
     */
    @Override
    public VehicleInfo selectVehicleInfoByPlateNumber(String plateNumber) {
        return vehicleInfoMapper.selectVehicleInfoByPlateNumber(plateNumber);
    }

    /**
     * 查询车辆信息列表
     * 
     * @param vehicleInfo 车辆信息
     * @return 车辆信息
     */
    @Override
    public List<VehicleInfo> selectVehicleInfoList(VehicleInfo vehicleInfo) {
        return vehicleInfoMapper.selectVehicleInfoList(vehicleInfo);
    }

    /**
     * 新增车辆信息
     * 
     * @param vehicleInfo 车辆信息
     * @return 结果
     */
    @Override
    @Transactional
    public int insertVehicleInfo(VehicleInfo vehicleInfo) {
        int rows = vehicleInfoMapper.insertVehicleInfo(vehicleInfo);
        
        // 如果选择了多个分公司，保存到关联表
        if (vehicleInfo.getDeptIds() != null && !vehicleInfo.getDeptIds().isEmpty()) {
            insertVehicleDept(vehicleInfo);
        }
        
        return rows;
    }

    /**
     * 修改车辆信息
     * 
     * @param vehicleInfo 车辆信息
     * @return 结果
     */
    @Override
    @Transactional
    public int updateVehicleInfo(VehicleInfo vehicleInfo) {
        // 先删除旧的关联关系
        vehicleInfoMapper.deleteVehicleDeptByVehicleId(vehicleInfo.getVehicleId());
        
        // 如果选择了多个分公司，保存到关联表
        if (vehicleInfo.getDeptIds() != null && !vehicleInfo.getDeptIds().isEmpty()) {
            insertVehicleDept(vehicleInfo);
        }
        
        return vehicleInfoMapper.updateVehicleInfo(vehicleInfo);
    }
    
    /**
     * 插入车辆-分公司关联关系
     */
    private void insertVehicleDept(VehicleInfo vehicleInfo) {
        List<VehicleDept> vehicleDepts = new ArrayList<>();
        for (Long deptId : vehicleInfo.getDeptIds()) {
            VehicleDept vd = new VehicleDept();
            vd.setVehicleId(vehicleInfo.getVehicleId());
            vd.setDeptId(deptId);
            vd.setCreateBy(vehicleInfo.getCreateBy());
            vehicleDepts.add(vd);
        }
        if (!vehicleDepts.isEmpty()) {
            vehicleInfoMapper.batchInsertVehicleDept(vehicleDepts);
        }
    }

    /**
     * 批量删除车辆信息
     * 
     * @param vehicleIds 需要删除的车辆信息主键
     * @return 结果
     */
    @Override
    public int deleteVehicleInfoByIds(Long[] vehicleIds) {
        return vehicleInfoMapper.deleteVehicleInfoByIds(vehicleIds);
    }

    /**
     * 删除车辆信息信息
     * 
     * @param vehicleId 车辆信息主键
     * @return 结果
     */
    @Override
    public int deleteVehicleInfoById(Long vehicleId) {
        return vehicleInfoMapper.deleteVehicleInfoById(vehicleId);
    }
    
    /**
     * 绑定车辆到用户
     * 
     * @param userId 用户ID
     * @param vehicleId 车辆ID
     * @return 结果
     */
    @Override
    @Transactional
    public int bindVehicleToUser(Long userId, Long vehicleId) {
        // 先解绑用户的所有车辆（业务逻辑：一个用户同时只能绑定一辆车）
        vehicleInfoMapper.unbindAllVehiclesFromUser(userId);
        
        // 绑定新车辆
        String bindBy = "";
        try {
            bindBy = SecurityUtils.getUsername();
        } catch (Exception e) {
            // 如果获取当前用户失败，使用空字符串
        }
        return vehicleInfoMapper.bindVehicleToUser(userId, vehicleId, bindBy);
    }
    
    /**
     * 解绑用户车辆
     * 
     * @param userId 用户ID
     * @param vehicleId 车辆ID
     * @return 结果
     */
    @Override
    public int unbindVehicleFromUser(Long userId, Long vehicleId) {
        return vehicleInfoMapper.unbindVehicleFromUser(userId, vehicleId);
    }
    
    /**
     * 获取用户当前绑定的车辆
     * 
     * @param userId 用户ID
     * @return 车辆信息
     */
    @Override
    public VehicleInfo getUserBoundVehicle(Long userId) {
        return vehicleInfoMapper.getUserBoundVehicle(userId);
    }
    
    /**
     * 根据用户有权限管理的分公司，查询所有可用车辆
     * 逻辑：
     * 1. 查询用户信息
     * 2. 调用sysDeptService.computeBranchCompaniesForUser获取用户管理的所有分公司
     * 3. 通过tb_vehicle_dept关联表查询这些分公司下的所有车辆
     * 
     * @param userId 用户ID
     * @return 车辆列表
     */
    @Override
    public List<VehicleInfo> selectAvailableVehiclesByUser(Long userId) {
        // 1. 查询用户信息
        SysUser user = sysUserMapper.selectUserById(userId);
        if (user == null) {
            return new ArrayList<>();
        }
        
        // 2. 调用sysDeptService获取用户管理的所有分公司
        List<SysDept> branchCompanies = sysDeptService.computeBranchCompaniesForUser(user);
        
        if (branchCompanies.isEmpty()) {
            // 如果没有找到任何分公司，返回空列表
            return new ArrayList<>();
        }
        
        // 3. 根据分公司列表查询车辆，使用Set去重
        Set<Long> vehicleIdSet = new HashSet<>();
        List<VehicleInfo> allVehicles = new ArrayList<>();
        
        for (SysDept branchCompany : branchCompanies) {
            VehicleInfo query = new VehicleInfo();
            query.setDeptId(branchCompany.getDeptId());
            List<VehicleInfo> vehicles = vehicleInfoMapper.selectVehicleInfoList(query);
            
            // 去重添加
            for (VehicleInfo vehicle : vehicles) {
                if (!vehicleIdSet.contains(vehicle.getVehicleId())) {
                    vehicleIdSet.add(vehicle.getVehicleId());
                    allVehicles.add(vehicle);
                }
            }
        }
        
        return allVehicles;
    }
}