package com.qaup.system.service.impl;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
import com.qaup.common.utils.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.qaup.system.mapper.SysVehicleTypeMapper;
import com.qaup.system.domain.SysVehicleType;
import com.qaup.system.service.ISysVehicleTypeService;

/**
 * 车辆类型（路径编码模式）Service业务层处理
 * 
 * @author Claude Code
 * @date 2025-07-13
 */
@Service
public class SysVehicleTypeServiceImpl implements ISysVehicleTypeService 
{
    @Autowired
    private SysVehicleTypeMapper sysVehicleTypeMapper;

    /**
     * 查询车辆类型
     * 
     * @param id 车辆类型主键
     * @return 车辆类型
     */
    @Override
    public SysVehicleType selectSysVehicleTypeById(Long id)
    {
        return sysVehicleTypeMapper.selectSysVehicleTypeById(id);
    }

    /**
     * 根据类型编码查询车辆类型
     * 
     * @param typeCode 类型编码
     * @return 车辆类型
     */
    @Override
    public SysVehicleType selectSysVehicleTypeByCode(String typeCode)
    {
        return sysVehicleTypeMapper.selectSysVehicleTypeByCode(typeCode);
    }

    /**
     * 查询车辆类型列表
     * 
     * @param sysVehicleType 车辆类型
     * @return 车辆类型
     */
    @Override
    public List<SysVehicleType> selectSysVehicleTypeList(SysVehicleType sysVehicleType)
    {
        return sysVehicleTypeMapper.selectSysVehicleTypeList(sysVehicleType);
    }

    /**
     * 根据父编码查询子类型列表
     * 
     * @param parentCode 父类型编码
     * @return 车辆类型集合
     */
    @Override
    public List<SysVehicleType> selectChildTypesByParentCode(String parentCode)
    {
        return sysVehicleTypeMapper.selectChildTypesByParentCode(parentCode);
    }

    /**
     * 根据层级查询车辆类型列表
     * 
     * @param pathLevel 路径层级
     * @return 车辆类型集合
     */
    @Override
    public List<SysVehicleType> selectSysVehicleTypeByLevel(Integer pathLevel)
    {
        return sysVehicleTypeMapper.selectSysVehicleTypeByLevel(pathLevel);
    }

    /**
     * 查询所有一级分类
     * 
     * @return 一级分类集合
     */
    @Override
    public List<SysVehicleType> selectTopLevelTypes()
    {
        return sysVehicleTypeMapper.selectTopLevelTypes();
    }

    /**
     * 查询所有叶子节点
     * 
     * @return 叶子节点集合
     */
    @Override
    public List<SysVehicleType> selectLeafTypes()
    {
        return sysVehicleTypeMapper.selectLeafTypes();
    }

    /**
     * 根据一级分类编码查询所有子类型
     * 
     * @param topLevelCode 一级分类编码（UV、SP、NM）
     * @return 子类型集合
     */
    @Override
    public List<SysVehicleType> selectTypesByTopLevel(String topLevelCode)
    {
        return sysVehicleTypeMapper.selectTypesByTopLevel(topLevelCode);
    }

    /**
     * 查询所有无人车类型
     * 
     * @return 无人车类型集合
     */
    @Override
    public List<SysVehicleType> selectUnmannedVehicleTypes()
    {
        return selectTypesByTopLevel("UV");
    }

    /**
     * 查询所有特勤车类型
     * 
     * @return 特勤车类型集合
     */
    @Override
    public List<SysVehicleType> selectSpecialVehicleTypes()
    {
        return selectTypesByTopLevel("SP");
    }

    /**
     * 查询所有普通车类型
     * 
     * @return 普通车类型集合
     */
    @Override
    public List<SysVehicleType> selectNormalVehicleTypes()
    {
        return selectTypesByTopLevel("NM");
    }

    /**
     * 新增车辆类型
     * 
     * @param sysVehicleType 车辆类型
     * @return 结果
     */
    @Override
    public int insertSysVehicleType(SysVehicleType sysVehicleType)
    {
        sysVehicleType.setCreateTime(DateUtils.getNowDate());
        sysVehicleType.setVersion(0L);
        return sysVehicleTypeMapper.insertSysVehicleType(sysVehicleType);
    }

    /**
     * 修改车辆类型
     * 
     * @param sysVehicleType 车辆类型
     * @return 结果
     */
    @Override
    public int updateSysVehicleType(SysVehicleType sysVehicleType)
    {
        sysVehicleType.setUpdateTime(DateUtils.getNowDate());
        return sysVehicleTypeMapper.updateSysVehicleType(sysVehicleType);
    }

    /**
     * 批量删除车辆类型
     * 
     * @param ids 需要删除的车辆类型主键
     * @return 结果
     */
    @Override
    public int deleteSysVehicleTypeByIds(Long[] ids)
    {
        return sysVehicleTypeMapper.deleteSysVehicleTypeByIds(ids);
    }

    /**
     * 删除车辆类型信息
     * 
     * @param id 车辆类型主键
     * @return 结果
     */
    @Override
    public int deleteSysVehicleTypeById(Long id)
    {
        return sysVehicleTypeMapper.deleteSysVehicleTypeById(id);
    }

    /**
     * 根据类型编码删除车辆类型
     * 
     * @param typeCode 类型编码
     * @return 结果
     */
    @Override
    public int deleteSysVehicleTypeByCode(String typeCode)
    {
        return sysVehicleTypeMapper.deleteSysVehicleTypeByCode(typeCode);
    }

    /**
     * 检查类型编码是否已存在
     * 
     * @param typeCode 类型编码
     * @return 是否存在
     */
    @Override
    public boolean checkTypeCodeExists(String typeCode)
    {
        return sysVehicleTypeMapper.checkTypeCodeExists(typeCode) > 0;
    }

    /**
     * 检查是否存在子类型
     * 
     * @param parentCode 父类型编码
     * @return 子类型数量
     */
    @Override
    public int countChildTypes(String parentCode)
    {
        return sysVehicleTypeMapper.countChildTypes(parentCode);
    }

    /**
     * 从数据库初始化标准车辆类型数据（暂时简化实现）
     * 
     * @return 初始化的记录数
     */
    @Override
    public int initDataFromEnum()
    {
        // 暂时简化实现，后续可以从数据库sys_vehicle_type_new表直接查询标准数据
        // 或者通过配置文件方式管理标准车辆类型
        return 0;
    }

    /**
     * 构建树形结构的车辆类型列表
     * 
     * @return 树形结构列表
     */
    @Override
    public List<SysVehicleType> buildVehicleTypeTree()
    {
        // 获取所有启用的车辆类型
        SysVehicleType query = new SysVehicleType();
        query.setEnabled(true);
        List<SysVehicleType> allTypes = selectSysVehicleTypeList(query);
        
        // 按父编码分组
        Map<String, List<SysVehicleType>> typeMap = allTypes.stream()
                .collect(Collectors.groupingBy(type -> 
                    type.getParentCode() == null ? "ROOT" : type.getParentCode()));
        
        // 构建树形结构
        List<SysVehicleType> tree = new ArrayList<>();
        List<SysVehicleType> rootTypes = typeMap.get("ROOT");
        
        if (rootTypes != null) {
            for (SysVehicleType rootType : rootTypes) {
                buildTreeNode(rootType, typeMap);
                tree.add(rootType);
            }
        }
        
        return tree;
    }

    /**
     * 递归构建树节点
     */
    private void buildTreeNode(SysVehicleType parentNode, Map<String, List<SysVehicleType>> typeMap) {
        List<SysVehicleType> children = typeMap.get(parentNode.getTypeCode());
        if (children != null && !children.isEmpty()) {
            // 这里可以考虑为SysVehicleType添加children字段支持树形结构显示
            // 暂时跳过，因为原实体类没有children字段
            for (SysVehicleType child : children) {
                buildTreeNode(child, typeMap);
            }
        }
    }

    /**
     * 根据类型编码获取完整的层级路径
     * 
     * @param typeCode 类型编码
     * @return 层级路径列表（从根到当前节点）
     */
    @Override
    public List<SysVehicleType> getTypeHierarchy(String typeCode)
    {
        List<SysVehicleType> hierarchy = new ArrayList<>();
        
        SysVehicleType currentType = selectSysVehicleTypeByCode(typeCode);
        if (currentType == null) {
            return hierarchy;
        }
        
        // 添加当前节点
        hierarchy.add(0, currentType);
        
        // 递归查找父节点
        String parentCode = currentType.getParentCode();
        while (parentCode != null && !parentCode.trim().isEmpty()) {
            SysVehicleType parentType = selectSysVehicleTypeByCode(parentCode);
            if (parentType != null) {
                hierarchy.add(0, parentType);
                parentCode = parentType.getParentCode();
            } else {
                break;
            }
        }
        
        return hierarchy;
    }
}