package com.ruoyi.project.tr.region.service;

import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.exception.BusinessException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.framework.aspectj.lang.annotation.DataScope;
import com.ruoyi.framework.web.domain.Ztree;
import com.ruoyi.project.system.role.domain.Role;
import com.ruoyi.project.tr.region.domain.Region;
import com.ruoyi.project.tr.region.mapper.RegionMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

/**
 * 区域/位置管理 服务实现
 * 
 * @author ruoyi
 */
@Service
public class RegionServiceImpl implements IRegionService
{
    @Autowired
    private RegionMapper regionMapper;

    /**
     * 查询区域/位置管理数据
     * 
     * @param region 区域/位置信息
     * @return 区域/位置信息集合
     */
    @Override
    @DataScope(deptAlias = "d")
    public List<Region> selectRegionList(Region region)
    {
        return regionMapper.selectRegionList(region);
    }

    @Override
    public List<Region> selectRegionListByCompanyId(Long companyId)
    {
        Region region = new Region();
        region.setCompanyId(companyId);
        return regionMapper.selectRegionList(region);
    }

    /**
     * 查询区域/位置管理树
     * 
     * @param region 区域/位置信息
     * @return 所有区域/位置信息
     */
    @Override
    @DataScope(deptAlias = "d")
    public List<Ztree> selectRegionTree(Region region)
    {
        List<Region> regionList = regionMapper.selectRegionList(region);
        List<Ztree> ztrees = initZtree(regionList);
        return ztrees;
    }

    /**
     * 根据角色ID查询区域/位置（数据权限）
     *
     * @param role 角色对象
     * @return 区域/位置列表（数据权限）
     */
    @Override
    public List<Ztree> roleRegionTreeData(Role role)
    {
        Long roleId = role.getRoleId();
        List<Ztree> ztrees = new ArrayList<Ztree>();

        Region region = new Region();
        region.setCompanyId(role.getCompanyId());
        List<Region> regionList = selectRegionList(region);

        if (StringUtils.isNotNull(roleId))
        {
            List<String> roleRegionList = regionMapper.selectRoleRegionTree(roleId,role.getCompanyId());
            ztrees = initZtree(regionList, roleRegionList);
        }
        else
        {
            ztrees = initZtree(regionList);
        }
        return ztrees;
    }

    /**
     * 对象转区域/位置树
     *
     * @param regionList 区域/位置列表
     * @return 树结构列表
     */
    public List<Ztree> initZtree(List<Region> regionList)
    {
        return initZtree(regionList, null);
    }

    /**
     * 对象转区域/位置树
     *
     * @param regionList 区域/位置列表
     * @param roleRegionList 角色已存在菜单列表
     * @return 树结构列表
     */
    public List<Ztree> initZtree(List<Region> regionList, List<String> roleRegionList)
    {
        List<Ztree> ztrees = new ArrayList<Ztree>();
        boolean isCheck = StringUtils.isNotNull(roleRegionList);
        for (Region region : regionList)
        {
            if (UserConstants.DEPT_NORMAL.equals(region.getStatus()))
            {
                Ztree ztree = new Ztree();
                ztree.setId(region.getRegionId());
                ztree.setpId(region.getParentId());
                ztree.setName(region.getRegionName());
                ztree.setTitle(region.getRegionName());
                if (isCheck)
                {
                    ztree.setChecked(roleRegionList.contains(region.getRegionId() + region.getRegionName()));
                }
                ztrees.add(ztree);
            }
        }
        return ztrees;
    }

    /**
     * 查询区域/位置人数
     * 
     * @param parentId 区域/位置ID
     * @return 结果
     */
    @Override
    public int selectRegionCount(Long parentId)
    {
        Region region = new Region();
        region.setParentId(parentId);
        return regionMapper.selectRegionCount(region);
    }

    /**
     * 查询区域/位置是否存在用户
     * 
     * @param regionId 区域/位置ID
     * @return 结果 true 存在 false 不存在
     */
    @Override
    public boolean checkRegionExistUser(Long regionId)
    {
        int result = regionMapper.checkRegionExistUser(regionId);
        return result > 0;
    }

    /**
     * 删除区域/位置管理信息
     * 
     * @param regionId 区域/位置ID
     * @return 结果
     */
    @Override
    public int deleteRegionById(Long regionId)
    {
        return regionMapper.deleteRegionById(regionId);
    }

    /**
     * 新增保存区域/位置信息
     * 
     * @param region 区域/位置信息
     * @return 结果
     */
    @Override
    public int insertRegion(Region region)
    {
        if (region.getParentId()!=0L){
            Region info = regionMapper.selectRegionById(region.getParentId());

            // 如果父节点不为"正常"状态,则不允许新增子节点
            if (!UserConstants.DEPT_NORMAL.equals(info.getStatus()))
            {
                throw new BusinessException("区域/位置停用，不允许新增");
            }else{
                region.setAncestors("0");
            }
            region.setAncestors(info.getAncestors() + "," + region.getParentId());
        }

        region.setCreateBy(ShiroUtils.getLoginName());

        return regionMapper.insertRegion(region);
    }

    /**
     * 修改保存区域/位置信息
     * 
     * @param region 区域/位置信息
     * @return 结果
     */
    @Override
    @Transactional
    public int updateRegion(Region region)
    {
        Region newParentRegion = regionMapper.selectRegionById(region.getParentId());
        Region oldRegion = selectRegionById(region.getRegionId());
        if (StringUtils.isNotNull(newParentRegion) && StringUtils.isNotNull(oldRegion))
        {
            String newAncestors = newParentRegion.getAncestors() + "," + newParentRegion.getRegionId();
            String oldAncestors = oldRegion.getAncestors();
            region.setAncestors(newAncestors);
            updateRegionChildren(region.getRegionId(), newAncestors, oldAncestors);
        }
        region.setUpdateBy(ShiroUtils.getLoginName());
        int result = regionMapper.updateRegion(region);
        if (UserConstants.DEPT_NORMAL.equals(region.getStatus()))
        {
            // 如果该区域/位置是启用状态，则启用该区域/位置的所有上级区域/位置
            updateParentRegionStatus(region);
        }
        return result;
    }

    /**
     * 修改该区域/位置的父级区域/位置状态
     * 
     * @param region 当前区域/位置
     */
    private void updateParentRegionStatus(Region region)
    {
        String updateBy = region.getUpdateBy();
        region = regionMapper.selectRegionById(region.getRegionId());
        region.setUpdateBy(updateBy);
        regionMapper.updateRegionStatus(region);
    }

    /**
     * 修改子元素关系
     * 
     * @param regionId 被修改的区域/位置ID
     * @param newAncestors 新的父ID集合
     * @param oldAncestors 旧的父ID集合
     */
    public void updateRegionChildren(Long regionId, String newAncestors, String oldAncestors)
    {
        List<Region> children = regionMapper.selectChildrenRegionById(regionId);
        for (Region child : children)
        {
            child.setAncestors(child.getAncestors().replace(oldAncestors, newAncestors));
        }
        if (children.size() > 0)
        {
            regionMapper.updateRegionChildren(children);
        }
    }

    /**
     * 修改子元素关系
     * 
     * @param regionId 区域/位置ID
     * @param ancestors 元素列表
     */
    public void updateRegionChildren(Long regionId, String ancestors)
    {
        Region region = new Region();
        region.setParentId(regionId);
        List<Region> childrens = regionMapper.selectRegionList(region);
        for (Region children : childrens)
        {
            children.setAncestors(ancestors + "," + region.getParentId());
        }
        if (childrens.size() > 0)
        {
            regionMapper.updateRegionChildren(childrens);
        }
    }

    /**
     * 根据区域/位置ID查询信息
     * 
     * @param regionId 区域/位置ID
     * @return 区域/位置信息
     */
    @Override
    public Region selectRegionById(Long regionId)
    {
        return regionMapper.selectRegionById(regionId);
    }

    /**
     * 校验区域/位置名称是否唯一
     * 
     * @param region 区域/位置信息
     * @return 结果
     */
    @Override
    public String checkRegionNameUnique(Region region)
    {
        Long regionId = StringUtils.isNull(region.getRegionId()) ? -1L : region.getRegionId();
        Region info = regionMapper.checkRegionNameUnique(region.getRegionName(), region.getParentId(),region.getCompanyId());
        if (StringUtils.isNotNull(info) && info.getRegionId().longValue() != regionId.longValue())
        {
            return UserConstants.DEPT_NAME_NOT_UNIQUE;
        }
        return UserConstants.DEPT_NAME_UNIQUE;
    }
}