package com.sundot.airport.system.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import cn.hutool.core.util.ObjectUtil;
import com.sundot.airport.common.config.LevelConfig;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.sundot.airport.common.constant.UserConstants;
import com.sundot.airport.common.exception.ServiceException;
import com.sundot.airport.common.utils.StringUtils;
import com.sundot.airport.system.domain.SysPost;
import com.sundot.airport.system.mapper.SysPostMapper;
import com.sundot.airport.system.mapper.SysUserPostMapper;
import com.sundot.airport.system.service.ISysPostService;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

/**
 * 岗位信息 服务层处理
 *
 * @author ruoyi
 */
@Service
public class SysPostServiceImpl implements ISysPostService {
    @Autowired
    private LevelConfig levelConfig;

    @Autowired
    private SysPostMapper postMapper;

    @Autowired
    private SysUserPostMapper userPostMapper;

    /**
     * 查询岗位信息集合
     *
     * @param post 岗位信息
     * @return 岗位信息集合
     */
    @Override
    public List<SysPost> selectPostList(SysPost post) {
        return postMapper.selectPostList(post);
    }

    /**
     * 查询所有岗位
     *
     * @return 岗位列表
     */
    @Override
    public List<SysPost> selectPostAll() {
        return postMapper.selectPostAll();
    }

    /**
     * 通过岗位ID查询岗位信息
     *
     * @param postId 岗位ID
     * @return 角色对象信息
     */
    @Override
    public SysPost selectPostById(Long postId) {
        return postMapper.selectPostById(postId);
    }

    /**
     * 根据用户ID获取岗位选择框列表
     *
     * @param userId 用户ID
     * @return 选中岗位ID列表
     */
    @Override
    public List<Long> selectPostListByUserId(Long userId) {
        return postMapper.selectPostListByUserId(userId);
    }

    /**
     * 校验岗位名称是否唯一
     *
     * @param post 岗位信息
     * @return 结果
     */
    @Override
    public boolean checkPostNameUnique(SysPost post) {
        Long postId = StringUtils.isNull(post.getPostId()) ? -1L : post.getPostId();
        SysPost info = postMapper.checkPostNameUnique(post.getPostName());
        if (StringUtils.isNotNull(info) && info.getPostId().longValue() != postId.longValue()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验岗位编码是否唯一
     *
     * @param post 岗位信息
     * @return 结果
     */
    @Override
    public boolean checkPostCodeUnique(SysPost post) {
        Long postId = StringUtils.isNull(post.getPostId()) ? -1L : post.getPostId();
        SysPost info = postMapper.checkPostCodeUnique(post.getPostCode());
        if (StringUtils.isNotNull(info) && info.getPostId().longValue() != postId.longValue()) {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 通过岗位ID查询岗位使用数量
     *
     * @param postId 岗位ID
     * @return 结果
     */
    @Override
    public int countUserPostById(Long postId) {
        return userPostMapper.countUserPostById(postId);
    }

    /**
     * 删除岗位信息
     *
     * @param postId 岗位ID
     * @return 结果
     */
    @Override
    public int deletePostById(Long postId) {
        return postMapper.deletePostById(postId);
    }

    /**
     * 批量删除岗位信息
     *
     * @param postIds 需要删除的岗位ID
     * @return 结果
     */
    @Override
    public int deletePostByIds(Long[] postIds) {
        for (Long postId : postIds) {
            SysPost post = selectPostById(postId);
            if (countUserPostById(postId) > 0) {
                throw new ServiceException(String.format("%1$s已分配,不能删除", post.getPostName()));
            }
        }
        return postMapper.deletePostByIds(postIds);
    }

    /**
     * 新增保存岗位信息
     *
     * @param post 岗位信息
     * @return 结果
     */
    @Override
    public int insertPost(SysPost post) {
        if (ObjectUtil.isEmpty(post.getParentId()) || post.getParentId().equals(0L)) {
            post.setAncestors("0");
            post.setLevel(1);
        } else {
            SysPost info = postMapper.selectPostById(post.getParentId());
            if (ObjectUtil.isEmpty(info)) {
                throw new ServiceException("父分类不存在，不允许新增");
            }
            post.setAncestors(info.getAncestors() + "," + post.getParentId());
            post.setLevel(post.getAncestors().split(",").length);
        }
        verifyData(post);
        return postMapper.insertPost(post);
    }

    /**
     * 修改保存岗位信息
     *
     * @param post 岗位信息
     * @return 结果
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int updatePost(SysPost post) {
        SysPost newParent = postMapper.selectPostById(post.getParentId());
        SysPost old = postMapper.selectPostById(post.getPostId());
        if (ObjectUtils.isNotEmpty(newParent) && ObjectUtils.isNotEmpty(old)) {
            String newAncestors = newParent.getAncestors() + "," + newParent.getPostId();
            String oldAncestors = old.getAncestors();
            post.setAncestors(newAncestors);
            post.setLevel(post.getAncestors().split(",").length);
            updateChildren(post.getPostId(), newAncestors, oldAncestors);
        }
        verifyData(post);
        return postMapper.updatePost(post);
    }

    /**
     * 查询岗位信息集合树形结构
     *
     * @param post 岗位信息
     * @return 岗位信息集合树形结构
     */
    @Override
    public List<SysPost> selectPostListTree(SysPost post) {
        List<SysPost> list = postMapper.selectPostList(post);
        return buildTree(list);
    }

    /**
     * 构建前端所需要树结构
     *
     * @param list 列表
     * @return 树结构列表
     */
    @Override
    public List<SysPost> buildTree(List<SysPost> list) {
        // 结果列表
        List<SysPost> result = new ArrayList<>();

        // 临时Map，用于快速查找节点
        Map<Long, SysPost> nodeMap = new HashMap<>();

        // 第一次遍历：将所有节点存入Map
        for (SysPost node : list) {
            nodeMap.put(node.getPostId(), node);
        }

        // 第二次遍历：建立父子关系
        for (SysPost node : list) {
            Long parentId = node.getParentId();
            if (parentId == null || parentId == 0L) {
                // 父ID为null或0，说明是根节点
                result.add(node);
            } else {
                // 查找父节点
                SysPost parent = nodeMap.get(parentId);
                if (parent != null) {
                    // 初始化子节点列表
                    if (parent.getChildren() == null) {
                        parent.setChildren(new ArrayList<>());
                    }
                    // 将当前节点添加到父节点的子列表中
                    List<SysPost> children = (List<SysPost>) parent.getChildren();
                    children.add(node);
                }
            }
        }

        return result;
    }

    /**
     * 修改子元素关系
     *
     * @param id           被修改的元素ID
     * @param newAncestors 新的父ID集合
     * @param oldAncestors 旧的父ID集合
     */
    public void updateChildren(Long id, String newAncestors, String oldAncestors) {
        List<SysPost> children = postMapper.selectChildrenById(id);
        for (SysPost child : children) {
            child.setAncestors(child.getAncestors().replaceFirst(oldAncestors, newAncestors));
            child.setLevel(child.getAncestors().split(",").length);
            verifyData(child);
        }
        if (!CollectionUtils.isEmpty(children)) {
            postMapper.updateChildren(children);
        }
    }

    /**
     * 验证数据
     */
    private void verifyData(SysPost post) {
        if (post.getLevel() > levelConfig.getSysPostLevel()) {
            throw new ServiceException("操作失败,层级超过限制" + levelConfig.getSysPostLevel() + "级");
        }
    }

    /**
     * 根据用户ID获取岗位选择框列表
     *
     * @param userId 用户ID
     * @return 选中岗位ID列表
     */
    @Override
    public List<SysPost> selectPostListsByUserId(Long userId) {
        return postMapper.selectPostListsByUserId(userId);
    }
}
