package com.ruoyi.system.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.dto.asset.AssetTypeDTO;
import com.ruoyi.system.mapper.AssetTypeMapper;
import com.ruoyi.system.model.AssetMain;
import com.ruoyi.system.model.AssetType;
import com.ruoyi.system.service.AssetMainService;
import com.ruoyi.system.service.AssetTypeService;
import com.ruoyi.system.vo.asset.AssetTypeTreeVO;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * <p>
 * 资产类型表 服务实现类
 * </p>
 *
 * @author WuGuanFengYue
 * @since 2025-09-15
 */
@Service
@RequiredArgsConstructor
public class AssetTypeServiceImpl extends ServiceImpl<AssetTypeMapper, AssetType> implements AssetTypeService {

    private final AssetMainService assetMainService;

    @Override
    public List<AssetTypeTreeVO> getAssetTypeTree() {
        // 查询所有未删除的资产类型数据
        LambdaQueryWrapper<AssetType> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.orderByAsc(AssetType::getLevel)
                .orderByAsc(AssetType::getId);
        
        List<AssetType> allAssetTypes = this.list(queryWrapper);
        
        if (CollUtil.isEmpty(allAssetTypes)) {
            return new ArrayList<>();
        }
        
        // 转换为VO对象
        List<AssetTypeTreeVO> assetTypeVOs = BeanUtil.copyToList(allAssetTypes, AssetTypeTreeVO.class);
        
        // 按父级ID分组
        Map<Integer, List<AssetTypeTreeVO>> parentIdMap = assetTypeVOs.stream()
                .collect(Collectors.groupingBy(AssetTypeTreeVO::getParentId));
        
        // 构建树形结构
        List<AssetTypeTreeVO> rootNodes = parentIdMap.get(0);
        if (CollUtil.isEmpty(rootNodes)) {
            return new ArrayList<>();
        }
        
        // 为每个根节点设置子节点
        for (AssetTypeTreeVO rootNode : rootNodes) {
            List<AssetTypeTreeVO> children = parentIdMap.get(rootNode.getId());
            rootNode.setChildren(children != null ? children : new ArrayList<>());
        }
        
        return rootNodes;
    }

    @Override
    public void addAssetType(AssetTypeDTO dto) {
        // 校验资产类型名称是否重复
        LambdaQueryWrapper<AssetType> nameQueryWrapper = new LambdaQueryWrapper<>();
        nameQueryWrapper.eq(AssetType::getTypeName, dto.getTypeName());
        AssetType existingByName = this.getOne(nameQueryWrapper);
        if (Objects.nonNull(existingByName)) {
            throw new ServiceException("资产类型名称已存在");
        }

        // 校验资产简写是否重复
        LambdaQueryWrapper<AssetType> codeQueryWrapper = new LambdaQueryWrapper<>();
        codeQueryWrapper.eq(AssetType::getTypeCode, dto.getTypeCode());
        AssetType existingByCode = this.getOne(codeQueryWrapper);
        if (Objects.nonNull(existingByCode)) {
            throw new ServiceException("资产类型简写已存在");
        }

        // 创建资产类型对象
        AssetType assetType = new AssetType();
        assetType.setTypeName(dto.getTypeName());
        assetType.setTypeCode(dto.getTypeCode());
        
        // 处理层级逻辑
        if (Objects.isNull(dto.getParentId()) || dto.getParentId().equals(0)) {
            // 添加一级资产类型
            assetType.setParentId(0);
            assetType.setLevel(1);
        } else {
            // 添加二级资产类型，先校验父级是否存在
            AssetType parentAssetType = this.getById(dto.getParentId());
            if (Objects.isNull(parentAssetType)) {
                throw new ServiceException("父级资产类型不存在");
            }
            if (!parentAssetType.getLevel().equals(1)) {
                throw new ServiceException("只能在一级资产类型下添加二级资产类型");
            }
            assetType.setParentId(dto.getParentId());
            assetType.setLevel(2);
        }

        // 设置创建信息
        String username = SecurityUtils.getUsername();
        assetType.setCreateBy(username);
        
        // 保存资产类型
        this.save(assetType);
    }

    @Override
    public void editAssetType(AssetTypeDTO dto) {
        // 校验资产类型ID是否为空
        if (Objects.isNull(dto.getId())) {
            throw new ServiceException("资产类型ID不能为空");
        }

        // 校验资产类型是否存在
        AssetType existingAssetType = this.getById(dto.getId());
        if (Objects.isNull(existingAssetType)) {
            throw new ServiceException("资产类型不存在");
        }

        // 校验是否有关联的资产记录
        LambdaQueryWrapper<AssetMain> assetMainQueryWrapper = new LambdaQueryWrapper<>();
        assetMainQueryWrapper.eq(AssetMain::getAssetTypeId, dto.getId());
        long assetMainCount = assetMainService.count(assetMainQueryWrapper);
        if (assetMainCount > 0) {
            throw new ServiceException("该资产类型已关联资产记录，不能编辑");
        }

        // 校验资产类型名称是否重复（排除自身）
        LambdaQueryWrapper<AssetType> nameQueryWrapper = new LambdaQueryWrapper<>();
        nameQueryWrapper.eq(AssetType::getTypeName, dto.getTypeName())
                       .ne(AssetType::getId, dto.getId());
        AssetType existingByName = this.getOne(nameQueryWrapper);
        if (Objects.nonNull(existingByName)) {
            throw new ServiceException("资产类型名称已存在");
        }
        
        // 校验资产简写是否重复（排除自身）
        LambdaQueryWrapper<AssetType> codeQueryWrapper = new LambdaQueryWrapper<>();
        codeQueryWrapper.eq(AssetType::getTypeCode, dto.getTypeCode())
                       .ne(AssetType::getId, dto.getId());
        AssetType existingByCode = this.getOne(codeQueryWrapper);
        if (Objects.nonNull(existingByCode)) {
            throw new ServiceException("资产简写已存在");
        }

        // 更新资产类型信息
        AssetType assetType = new AssetType();
        assetType.setId(dto.getId());
        assetType.setTypeName(dto.getTypeName());
        assetType.setTypeCode(dto.getTypeCode());
        
        // 设置更新信息
        String username = SecurityUtils.getUsername();
        assetType.setUpdateBy(username);
        
        // 更新资产类型
        this.updateById(assetType);
    }

    @Override
    public void deleteAssetType(Integer id) {
        // 校验资产类型ID是否为空
        if (Objects.isNull(id)) {
            throw new ServiceException("资产类型ID不能为空");
        }

        // 校验资产类型是否存在
        AssetType existingAssetType = this.getById(id);
        if (Objects.isNull(existingAssetType)) {
            throw new ServiceException("资产类型不存在");
        }

        // 校验是否有子类型
        LambdaQueryWrapper<AssetType> childQueryWrapper = new LambdaQueryWrapper<>();
        childQueryWrapper.eq(AssetType::getParentId, id);
        long childCount = this.count(childQueryWrapper);
        if (childCount > 0) {
            throw new ServiceException(String.format("【%s】存在子类型，不能删除", existingAssetType.getTypeName()));
        }

        // 校验是否有关联的资产记录
        LambdaQueryWrapper<AssetMain> assetMainQueryWrapper = new LambdaQueryWrapper<>();
        assetMainQueryWrapper.eq(AssetMain::getAssetTypeId, id);
        long assetMainCount = assetMainService.count(assetMainQueryWrapper);
        if (assetMainCount > 0) {
            throw new ServiceException(String.format("【%s】已关联资产记录，不能删除", existingAssetType.getTypeName()));
        }

        // 删除资产类型
        this.removeById(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchDeleteAssetType(List<Integer> ids) {
        // 校验ID列表是否为空
        if (CollUtil.isEmpty(ids)) {
            throw new ServiceException("删除的资产类型ID列表不能为空");
        }

        // 收集删除失败的信息
        List<String> failedMessages = new ArrayList<>();
        
        // 逐个删除资产类型
        for (Integer id : ids) {
            try {
                this.deleteAssetType(id);
            } catch (ServiceException e) {
                failedMessages.add(e.getMessage());
            }
        }
        
        // 如果有删除失败的情况，抛出异常
        if (CollUtil.isNotEmpty(failedMessages)) {
            throw new ServiceException("批量删除失败：" + String.join("；", failedMessages));
        }
    }

    @Override
    public String getAssetCodePrefix(Integer assetTypeId) {
        if (assetTypeId == null) {
            throw new ServiceException("资产类型ID不能为空");
        }

        // 查询当前资产类型
        AssetType currentAssetType = this.getById(assetTypeId);
        if (currentAssetType == null) {
            throw new ServiceException("资产类型不存在");
        }

        String parentTypeCode = "";
        String subTypeCode = currentAssetType.getTypeCode();

        // 如果是二级分类，需要获取父级分类的简写
        if (currentAssetType.getLevel() == 2 && currentAssetType.getParentId() != null && currentAssetType.getParentId() != 0) {
            AssetType parentAssetType = this.getById(currentAssetType.getParentId());
            if (parentAssetType != null) {
                parentTypeCode = parentAssetType.getTypeCode();
            }
        } else if (currentAssetType.getLevel() == 1) {
            // 如果是一级分类，父级简写为空，子类简写就是当前类型简写
            parentTypeCode = currentAssetType.getTypeCode();
            subTypeCode = "";
        }

        return parentTypeCode + subTypeCode;
    }

}