package com.ruoyi.system.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.constant.CacheConstants;
import com.ruoyi.common.constant.ResultConstants;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.enums.coalmineEnums.DeleteStatusEnum;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.system.domain.SysOperateType;
import com.ruoyi.system.domain.bo.SysOperateTypeWholeNameBO;
import com.ruoyi.system.domain.req.OperateTypeEditReqDTO;
import com.ruoyi.system.domain.req.OperateTypeListReqDTO;
import com.ruoyi.system.domain.req.OperateTypeAddReqDTO;
import com.ruoyi.system.mapper.SysOperateTypeMapper;
import com.ruoyi.system.mapper.SysRoleMapper;
import com.ruoyi.system.service.SysOperateTypeService;
import org.apache.ibatis.logging.Log;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author hz
 * @since 2023-09-07 17:10:10
 */
@Service("sysOperateTypeService")
public class SysOperateTypeServiceImpl extends ServiceImpl<SysOperateTypeMapper, SysOperateType> implements SysOperateTypeService {

    @Autowired
    private SysOperateTypeMapper operateTypeMapper;

    @Autowired
    private SysRoleMapper roleMapper;

    @Resource
    private RedisCache redisCache;


    @PostConstruct
    public void init()
    {
        loadingOperateTypeCache();

    }

    @Override
    public void loadingOperateTypeCache() {
        LambdaQueryWrapper<SysOperateType> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysOperateType::getDelFlag, DeleteStatusEnum.NO.getStatus());
        List<SysOperateType> sysOperateTypes = operateTypeMapper.selectList(wrapper);
        if (!CollectionUtils.isEmpty(sysOperateTypes)){
            Map<Long, SysOperateTypeWholeNameBO> map = new HashMap<>();
            for (SysOperateType sysOperateType : sysOperateTypes) {
                SysOperateTypeWholeNameBO nameBO = this.operateTypeWholeNameCacheById(sysOperateType.getId());
                map.put(sysOperateType.getId(),nameBO);
            }
            String info = JSON.toJSONString(map);
            SpringUtils.getBean(RedisCache.class).setCacheObject(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY, info);
        }
    }

    @Override
    public void clearOperateTypeCache() {
        if (SpringUtils.getBean(RedisCache.class).hasKey(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY)){
            SpringUtils.getBean(RedisCache.class).deleteObject(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY);
        }
    }

    @Override
    public void resetOperateTypeCache() {
        clearOperateTypeCache();
        loadingOperateTypeCache();
    }

    /**
     * 查询作业类型管理数据
     */
    @Override
    public List<SysOperateType> selectOperateTypeList(OperateTypeListReqDTO reqDTO) {
        LambdaQueryWrapper<SysOperateType> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysOperateType::getDelFlag, DeleteStatusEnum.NO.getStatus());
        if (reqDTO != null && !StringUtils.isBlank(reqDTO.getName())){
            wrapper.eq(SysOperateType::getName,reqDTO.getName());
        }
        return operateTypeMapper.selectList(wrapper);
    }

    ///**
    // * 查询作业类型树结构信息
    // */
    //@Override
    //public List<TreeSelect> selectDeptTreeList(SysDept dept)
    //{
    //    List<SysDept> depts = SpringUtils.getAopProxy(this).selectDeptList(dept);
    //    return buildDeptTreeSelect(depts);
    //}
    //
    ///**
    // * 构建前端所需要树结构
    // */
    //@Override
    //public List<SysDept> buildDeptTree(List<SysDept> depts)
    //{
    //    List<SysDept> returnList = new ArrayList<SysDept>();
    //    List<Long> tempList = depts.stream().map(SysDept::getDeptId).collect(Collectors.toList());
    //    for (SysDept dept : depts)
    //    {
    //        // 如果是顶级节点, 遍历该父节点的所有子节点
    //        if (!tempList.contains(dept.getParentId()))
    //        {
    //            recursionFn(depts, dept);
    //            returnList.add(dept);
    //        }
    //    }
    //    if (returnList.isEmpty())
    //    {
    //        returnList = depts;
    //    }
    //    return returnList;
    //}
    //
    ///**
    // * 构建前端所需要下拉树结构
    // */
    //@Override
    //public List<TreeSelect> buildDeptTreeSelect(List<SysDept> depts)
    //{
    //    List<SysDept> deptTrees = buildDeptTree(depts);
    //    return deptTrees.stream().map(TreeSelect::new).collect(Collectors.toList());
    //}
    //
    ///**
    // * 根据角色ID查询作业类型树信息
    // */
    //@Override
    //public List<Long> selectDeptListByRoleId(Long roleId)
    //{
    //    SysRole role = roleMapper.selectRoleById(roleId);
    //    return operateTypeMapper.selectDeptListByRoleId(roleId, role.isDeptCheckStrictly());
    //}
    //
    /**
     * 根据作业类型ID查询信息
     */
    @Override
    public SysOperateType selectOperateTypeById(Long operateTypeId) {
        if (operateTypeId == null)
            throw new BusinessException(this.getClass(), ResultConstants.PARAM_ERROR);
        return operateTypeMapper.selectOperateTypeById(operateTypeId);
    }
    //
    ///**
    // * 根据ID查询所有子作业类型（正常状态）
    // */
    //@Override
    //public int selectNormalChildrenDeptById(Long deptId)
    //{
    //    return operateTypeMapper.selectNormalChildrenDeptById(deptId);
    //}
    //
    /**
     * 是否存在子节点
     */
    @Override
    public boolean hasChildByOperateTypeId(Long id)
    {
        int result = operateTypeMapper.hasChildByOperateTypeId(id);
        return result > 0;
    }
    //
    ///**
    // * 查询作业类型是否存在用户
    // */
    //@Override
    //public boolean checkDeptExistUser(Long deptId)
    //{
    //    int result = operateTypeMapper.checkDeptExistUser(deptId);
    //    return result > 0;
    //}
    //
    /**
     * 校验作业类型名称是否唯一
     */
    @Override
    public boolean checkOperateTypeNameUnique(String name,Long parentId) {
        if (StringUtils.isBlank(name) || StringUtils.isNull(parentId))
            throw new BusinessException(this.getClass(),ResultConstants.PARAM_ERROR);
        LambdaQueryWrapper<SysOperateType> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysOperateType::getDelFlag,DeleteStatusEnum.NO.getStatus())
                .eq(SysOperateType::getName,name)
                .eq(SysOperateType::getParentId,parentId)
                .last(" limit 1");
        SysOperateType sysOperateType = operateTypeMapper.selectOne(wrapper);
        if (StringUtils.isNotNull(sysOperateType))
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 新增保存作业类型信息
     */
    @Override
    public int insertOperateType(OperateTypeAddReqDTO type) {
        SysOperateType operateType = new SysOperateType();
        BeanUtils.copyProperties(type,operateType);
        if (type.getParentId() != 0) {
            SysOperateType info = operateTypeMapper.selectOperateTypeById(type.getParentId());
            // 如果父节点不为正常状态,则不允许新增子节点
            if (info == null) {
                throw new BusinessException(this.getClass(), ResultConstants.SYSTEM_ERROR_DATABASE_FAIL, "作业类型不存在，不允许新增");
            }
            operateType.setAncestors(info.getAncestors() + "," + type.getParentId());
            int length = getOperateTypeValue(operateType.getAncestors()).length;
            operateType.setType(length);
        }else {
            operateType.setAncestors("0");
            operateType.setType(1);
        }
        resetOperateTypeCache();
        return operateTypeMapper.insert(operateType);
    }

    private String[] getOperateTypeValue(String ancestors) {
        String[] arr = ancestors.split(",");
        return arr;
    }

    /**
     * 修改保存作业类型信息
     */
    @Override
    public int updateOperateType(OperateTypeEditReqDTO reqDTO)
    {
        SysOperateType newParentOperateType = operateTypeMapper.selectOperateTypeById(reqDTO.getParentId());
        SysOperateType oldOperateType = operateTypeMapper.selectOperateTypeById(reqDTO.getId());
        if ((StringUtils.isNotNull(newParentOperateType) || reqDTO.getParentId() == 0) && StringUtils.isNotNull(oldOperateType))
        {
            String newAncestors;
            if (reqDTO.getParentId() == 0){
                newAncestors =  "0";
            }else {
                newAncestors = newParentOperateType.getAncestors() + "," + newParentOperateType.getId();
            }
            String oldAncestors = oldOperateType.getAncestors();
            BeanUtils.copyProperties(reqDTO,oldOperateType);
            oldOperateType.setAncestors(newAncestors);
            updateOperateTypeChildren(reqDTO.getId(), newAncestors, oldAncestors);
        }
        int result = operateTypeMapper.updateById(oldOperateType);
        resetOperateTypeCache();
        return result;
    }
    //
    ///**
    // * 修改该作业类型的父级作业类型状态
    // *
    // * @param dept 当前作业类型
    // */
    //private void updateParentDeptStatusNormal(SysDept dept)
    //{
    //    String ancestors = dept.getAncestors();
    //    Long[] deptIds = Convert.toLongArray(ancestors);
    //    operateTypeMapper.updateDeptStatusNormal(deptIds);
    //}
    //
    /**
     * 修改子元素关系
     */
    public void updateOperateTypeChildren(Long OperateTypeId, String newAncestors, String oldAncestors)
    {
        List<SysOperateType> children = operateTypeMapper.selectChildrenOperateTypeById(OperateTypeId);
        for (SysOperateType child : children)
        {
            child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors));
        }
        if (children.size() > 0)
        {
            operateTypeMapper.updateOperateTypeChildren(children);
        }
    }

    /**
     * 删除作业类型管理信息
     */
    @Override
    public int deleteOperateTypeById(Long id)
    {
        SysOperateType sysOperateType = operateTypeMapper.selectOperateTypeById(id);
        if (sysOperateType == null)
            return 1;
        sysOperateType.setDelFlag(DeleteStatusEnum.YES.getStatus());
        resetOperateTypeCache();
        return this.operateTypeMapper.updateById(sysOperateType);
    }

    private SysOperateTypeWholeNameBO operateTypeWholeNameCacheById(Long id){
        SysOperateType sysOperateType = operateTypeMapper.selectOperateTypeById(id);
        if (sysOperateType == null)
            return null;
        Integer type = sysOperateType.getType();
        SysOperateTypeWholeNameBO bo = new SysOperateTypeWholeNameBO();
        bo.setType(sysOperateType.getType());
        if (type == 1) {
            bo.setQualificationType(sysOperateType.getName());
            return bo;
        }
        String[] value = getOperateTypeValue(sysOperateType.getAncestors());
        List<Long> list = new ArrayList<>();
        for (int i = 0; i < value.length; i++) {
            if (i>0){
                list.add(Long.valueOf(value[i]));
            }
        }
        list.add(id);
        List<SysOperateType> sysOperateTypes = operateTypeMapper.selectOperateTypeByIds(list);
        for (SysOperateType operateType : sysOperateTypes) {
            if (operateType.getType() == 1)
                bo.setQualificationType(operateType.getName());
            if (operateType.getType() == 2)
                bo.setJobCategory(operateType.getName());
            if (operateType.getType() == 3)
                bo.setOperationItems(operateType.getName());
        }
        return bo;
    }

    @Override
    public SysOperateTypeWholeNameBO getOperateTypeWholeNameById(Long id) {
        String info = redisCache.getCacheObject(CacheConstants.SYS_OPERATE_TYPE_NAME_KEY);
        Map<Long, SysOperateTypeWholeNameBO> map = JSON.parseObject(info, new TypeReference<Map<Long, SysOperateTypeWholeNameBO>>() {});
        if (map != null){
            return map.get(id);
        }
        return null;
    }
    //
    ///**
    // * 递归列表
    // */
    //private void recursionFn(List<SysDept> list, SysDept t)
    //{
    //    // 得到子节点列表
    //    List<SysDept> childList = getChildList(list, t);
    //    t.setChildren(childList);
    //    for (SysDept tChild : childList)
    //    {
    //        if (hasChild(list, tChild))
    //        {
    //            recursionFn(list, tChild);
    //        }
    //    }
    //}
    //
    ///**
    // * 得到子节点列表
    // */
    //private List<SysDept> getChildList(List<SysDept> list, SysDept t)
    //{
    //    List<SysDept> tlist = new ArrayList<SysDept>();
    //    Iterator<SysDept> it = list.iterator();
    //    while (it.hasNext())
    //    {
    //        SysDept n = (SysDept) it.next();
    //        if (StringUtils.isNotNull(n.getParentId()) && n.getParentId().longValue() == t.getDeptId().longValue())
    //        {
    //            tlist.add(n);
    //        }
    //    }
    //    return tlist;
    //}
    //
    ///**
    // * 判断是否有子节点
    // */
    //private boolean hasChild(List<SysDept> list, SysDept t)
    //{
    //    return getChildList(list, t).size() > 0;
    //}

}