package com.hotent.baseInfo.manager.impl;

import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.hotent.baseInfo.dao.CostDictDataDao;
import com.hotent.baseInfo.dao.CostDictTypeDao;
import com.hotent.baseInfo.model.CostDictData;
import com.hotent.baseInfo.model.CostDictType;
import com.hotent.baseInfo.manager.CostDictTypeManager;
import com.hotent.base.manager.impl.BaseManagerImpl;
import com.hotent.uc.api.model.IUser;
import com.hotent.uc.exception.BaseException;
import com.hotent.uc.util.ContextUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;
import javax.annotation.Resource;


/**
 * 字典类型表 服务实现类
 *
 * @author 超级管理员
 * @company 山西清众科技股份有限公司
 * @since 2025-09-13
 */
@Service
public class CostDictTypeManagerImpl extends BaseManagerImpl<CostDictTypeDao, CostDictType> implements CostDictTypeManager {

    @Resource
    private CostDictDataDao costDictDataDao;

    @Override
    public CostDictType getDetail(String id) {
        return this.get(id);
    }

    @Override
    @Transactional
    public void create(CostDictType costDictType) {
        if (checkDictTypeUnique(costDictType)) {
            IUser user = ContextUtil.getCurrentUser(); //获取当前用户
            costDictType.setCreateBy(user.getAccount());
            costDictType.setCreateTime(LocalDateTime.now());
            this.save(costDictType);
        }else{
            throw new BaseException("字典类型已存在");
        }

    }

    public void update(CostDictType costDictType) {
        IUser user = ContextUtil.getCurrentUser(); //获取当前用户
        costDictType.setUpdateBy(user.getAccount());
        costDictType.setUpdateTime(LocalDateTime.now());
        this.updateById(costDictType);
    }

    /**
     * 根据条件分页查询字典类型
     *
     * @param dictType 字典类型信息
     * @return 字典类型集合信息
     */
    @Override
    public List<CostDictType> selectDictTypeList(CostDictType dictType) {
        // 使用LambdaQueryWrapper，通过类方法引用获取字段名，避免字符串拼写错误
        LambdaQueryWrapper<CostDictType> queryWrapper = new LambdaQueryWrapper<>();

        // 字典名称模糊查询
        if (StringUtils.isNotBlank(dictType.getDictName())) {
            queryWrapper.like(CostDictType::getDictName, dictType.getDictName());
        }

        // 状态精确查询
        if (StringUtils.isNotBlank(dictType.getStatus())) {
            queryWrapper.eq(CostDictType::getStatus, dictType.getStatus());
        }

        // 字典类型模糊查询
        if (StringUtils.isNotBlank(dictType.getDictType())) {
            queryWrapper.like(CostDictType::getDictType, dictType.getDictType());
        }

        // 执行查询
        return baseMapper.selectList(queryWrapper);
    }

    /**
     * 根据所有字典类型
     *
     * @return 字典类型集合信息
     */
    @Override
    public List<CostDictType> selectDictTypeAll() {
        return this.baseMapper.selectList(new QueryWrapper<>());
    }

    /**
     * 根据字典类型查询字典数据
     *
     * @param dictType 字典类型
     * @return 字典数据集合信息
     */
    @Override
    public List<CostDictData> selectDictDataByType(String dictType) {

        // 创建Lambda查询构造器
        LambdaQueryWrapper<CostDictData> queryWrapper = new LambdaQueryWrapper<>();

        // 添加查询条件：状态为'0'（启用）
        queryWrapper
                //.eq(CostDictData::getStatus, "0")
                // 字典类型等于传入的dictType
                .eq(CostDictData::getDictType, dictType)
                // 按排序号升序排列
                .orderByAsc(CostDictData::getDictSort);

        // 执行查询
        return costDictDataDao.selectList(queryWrapper);
    }


    /**
     * 批量删除字典类型信息
     *
     * @param dictIds 需要删除的字典ID
     */
    @Override
    public void deleteDictTypeByIds(Long[] dictIds) {
        // 校验是否存在父子关系
        for (Long dictId : dictIds) {
            // 根据字典ID查询字典类型
            CostDictType dictType = this.baseMapper.selectById(dictId);
            //为空时
            if (ObjectUtil.isNull(dictType)) {
                continue;
            }
            // 查询父节点 查询dictData表中是否有子节点数量大于0
            int count = this.costDictDataDao.selectCount(new LambdaQueryWrapper<CostDictData>()
                    .eq(CostDictData::getDictType, dictId));
            if (count > 0) {
                throw new BaseException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
            }
            // 删除字典类型
            this.baseMapper.deleteById(dictId);
        }
    }


    /**
     * 校验字典类型称是否唯一
     *
     * @param dict 字典类型
     * @return 结果
     */
    @Override
    public boolean checkDictTypeUnique(CostDictType dict) {
        // 创建Lambda查询构造器
        LambdaQueryWrapper<CostDictType> queryWrapper = new LambdaQueryWrapper<>();

        // 添加查询条件：字典类型等于传入的dictType，并且只查询一条记录
        queryWrapper.eq(CostDictType::getDictType, dict.getDictType())
                .last("limit 1"); // limit 1限制
        CostDictType costDictType = baseMapper.selectOne(queryWrapper);
        if (costDictType == null) {
            return true;
        }
        return false;
    }
}
