package org.xyzh.system.role.service.impl;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.xyzh.common.core.domain.ResultDomain;
import org.xyzh.common.dto.permission.TbSysPermission;
import org.xyzh.common.dto.role.TbSysRole;
import org.xyzh.common.utils.IDUtils;
import org.xyzh.common.vo.DeptRoleVO;
import org.xyzh.system.mapper.RolePermissionMapper;
import org.xyzh.system.mapper.RoleMapper;
import org.xyzh.system.mapper.UserDeptRoleMapper;
import org.xyzh.system.role.service.SysRoleService;

import java.util.Date;
import java.util.List;

/**
 * @description SysRoleServiceImpl.java文件描述 系统角色服务实现类
 * @filename SysRoleServiceImpl.java
 * @author yslg
 * @copyright xyzh
 * @since 2025-09-28
 */
@Service
public class SysRoleServiceImpl implements SysRoleService {

    private static final Logger logger = LoggerFactory.getLogger(SysRoleServiceImpl.class);

    @Autowired
    private RoleMapper roleMapper;

    @Autowired
    private RolePermissionMapper rolePermissionMapper;

    @Autowired
    private UserDeptRoleMapper userDeptRoleMapper;

    @Override
    public ResultDomain<TbSysRole> getAllRoles() {
        ResultDomain<TbSysRole> resultDomain = new ResultDomain<>();

        try {
            logger.info("开始查询所有角色");
            
            List<TbSysRole> roles = roleMapper.selectAllRoles();
            
            logger.info("查询所有角色完成，共找到{}个角色", roles.size());
            resultDomain.success("查询成功", roles);
            return resultDomain;
            
        } catch (Exception e) {
            logger.error("查询所有角色失败", e);
            resultDomain.fail("查询角色失败：" + e.getMessage());
            return resultDomain;
        }
    }

    @Override
    public ResultDomain<TbSysRole> getRoleList(TbSysRole filter) {
        ResultDomain<TbSysRole> resultDomain = new ResultDomain<>();
        try {
            logger.info("开始根据过滤条件查询角色列表：{}", filter);
            
            List<TbSysRole> roles = roleMapper.selectRole(filter);
            
            logger.info("查询角色列表完成，共找到{}个角色", roles.size());
            resultDomain.success("查询成功", roles);
            return resultDomain;
            
        } catch (Exception e) {
            logger.error("根据过滤条件查询角色列表失败：{}", filter, e);
            resultDomain.fail("查询角色失败：" + e.getMessage());
            return resultDomain;
        }
    }

    @Override
    public ResultDomain<TbSysRole> createRole(TbSysRole role) {
        ResultDomain<TbSysRole> resultDomain = new ResultDomain<>();
        try {
            logger.info("开始创建角色：{}", role.getName());
            
            // 参数校验
            if (!StringUtils.hasText(role.getName())) {
                resultDomain.fail("角色名称不能为空");
                return resultDomain;
            }
            
            
            // 检查角色名称是否已存在
            ResultDomain<Boolean> nameCheckResult = checkRoleNameExists(role.getName(), null);
            if (!nameCheckResult.isSuccess()) {
                resultDomain.fail(nameCheckResult.getMessage());
                return resultDomain;
            }
            if (nameCheckResult.getData()) {
                resultDomain.fail("角色名称已存在");
                return resultDomain;
            }
            
            // 设置基础信息
            role.setID(IDUtils.generateID());
            role.setRoleID(IDUtils.generateID());
            role.setCreateTime(new Date());
            role.setDeleted(false);

            // 插入数据库
            int result = roleMapper.insertRole(role);
            
            if (result > 0) {
                logger.info("创建角色成功：{}", role.getName());
                resultDomain.success("创建角色成功", role);
                return resultDomain;
            } else {
                logger.warn("创建角色失败：{}", role.getName());
                resultDomain.fail("创建角色失败");
            }
            
            return resultDomain;
        } catch (Exception e) {
            logger.error("创建角色异常：{}", role.getName(), e);
            resultDomain.fail("创建角色失败：" + e.getMessage());
            return resultDomain;
        }
    }

    @Override
    public ResultDomain<TbSysRole> updateRole(TbSysRole role) {
        ResultDomain<TbSysRole> resultDomain = new ResultDomain<>();
        try {
            logger.info("开始更新角色：{}", role.getRoleID());
            
            // 参数校验
            if (!StringUtils.hasText(role.getRoleID())) {
                resultDomain.fail("角色ID不能为空");
                return resultDomain;
            }
            if (!StringUtils.hasText(role.getName())) {
                resultDomain.fail("角色名称不能为空");
                return resultDomain;
            }
            
            // 检查角色是否存在
            ResultDomain<TbSysRole> existResult = getRoleById(role.getRoleID());
            if (!existResult.isSuccess()) {
                resultDomain.fail(existResult.getMessage());
                return resultDomain;
            }
            
            // 检查角色名称是否已存在（排除自身）
            ResultDomain<Boolean> nameCheckResult = checkRoleNameExists(role.getName(), role.getID());
            if (!nameCheckResult.isSuccess()) {
                resultDomain.fail(nameCheckResult.getMessage());
                return resultDomain;
            }
            if (nameCheckResult.getData()) {
                resultDomain.fail("角色名称已存在");
                return resultDomain;
            }
            
            // 设置更新时间
            role.setUpdateTime(new Date());
            
            // 更新数据库
            int result = roleMapper.updateRole(role);
            
            if (result > 0) {
                logger.info("更新角色成功：{}", role.getRoleID());
                resultDomain.success("更新角色成功", role);
                return resultDomain;
            } else {
                logger.warn("更新角色失败：{}", role.getRoleID());
                resultDomain.fail("更新角色失败");
                return resultDomain;
            }
            
        } catch (Exception e) {
            logger.error("更新角色异常：{}", role.getRoleID(), e);
            resultDomain.fail("更新角色失败：" + e.getMessage());
            return resultDomain;
        }
    }

    @Override
    public ResultDomain<TbSysRole> deleteRole(TbSysRole role) {
        ResultDomain<TbSysRole> resultDomain = new ResultDomain<>();
        try {
            logger.info("开始删除角色：{}", role.getRoleID());
            
            if (!StringUtils.hasText(role.getRoleID())) {
                resultDomain.fail("角色ID不能为空");
                return resultDomain;
            }
            
            // 检查角色是否存在
            ResultDomain<TbSysRole> existResult = getRoleById(role.getRoleID());
            if (!existResult.isSuccess()) {
                resultDomain.fail(existResult.getMessage());
                return resultDomain;
            }
            
            int result = roleMapper.deleteRole(role);
            
            if (result > 0) {
                logger.info("删除角色成功：{}", role.getRoleID());
                resultDomain.success("删除角色成功", role);
                return resultDomain;
            } else {
                logger.warn("删除角色失败：{}", role.getRoleID());
                resultDomain.fail("删除角色失败");
                return resultDomain;
            }
            
        } catch (Exception e) {
            logger.error("删除角色异常：{}", role.getRoleID(), e);
            resultDomain.fail("删除角色失败：" + e.getMessage());
            return resultDomain;
        }
    }


    @Override
    public ResultDomain<TbSysRole> getRoleById(String roleId) {
        ResultDomain<TbSysRole> resultDomain = new ResultDomain<>();
        try {
            logger.info("开始根据ID查询角色：{}", roleId);
            
            if (!StringUtils.hasText(roleId)) {
                resultDomain.fail("角色ID不能为空");
                return resultDomain;
            }
            TbSysRole filter = new TbSysRole();
            filter.setRoleID(roleId);
            filter.setDeleted(false);
            List<TbSysRole> roles = roleMapper.selectRole(filter);
            TbSysRole role = roles.isEmpty() ? null : roles.get(0);
            
            if (role == null) {
                logger.warn("未找到角色：{}", roleId);
                resultDomain.fail("未找到指定角色");
                return resultDomain;
            }
            
            logger.info("根据ID查询角色完成：{}", roleId);
            resultDomain.success("查询成功", role);
            return resultDomain;
            
        } catch (Exception e) {
            logger.error("根据ID查询角色失败：{}", roleId, e);
            resultDomain.fail("查询角色失败：" + e.getMessage());
            return resultDomain;
        }
    }

    @Override
    public ResultDomain<DeptRoleVO> getDeptRolesByUserId(String userId) {
        ResultDomain<DeptRoleVO> resultDomain = new ResultDomain<>();
        try {
            logger.info("开始根据用户ID查询部门角色列表：{}", userId);
            
            if (!StringUtils.hasText(userId)) {
                resultDomain.fail("用户ID不能为空");
                return resultDomain;
            }
            
            List<DeptRoleVO> roles = roleMapper.selectDeptRolesByUserId(userId);
            
            logger.info("根据用户ID查询部门角色列表完成，共找到{}个部门角色", roles.size());
            resultDomain.success("查询成功", roles);
            return resultDomain;
            
        } catch (Exception e) {
            logger.error("根据用户ID查询部门角色列表失败：{}", userId, e);
            resultDomain.fail("查询角色失败：" + e.getMessage());
            return resultDomain;
        }
    }

    @Override
    public ResultDomain<Boolean> checkRoleNameExists(String roleName, String excludeId) {
        ResultDomain<Boolean> resultDomain = new ResultDomain<>();
        try {
            logger.info("检查角色名称是否存在：{}", roleName);
            
            if (!StringUtils.hasText(roleName)) {
                resultDomain.fail("角色名称不能为空");
                return resultDomain;
            }
            
            int count = roleMapper.countByRoleName(roleName, excludeId);
            boolean exists = count > 0;
            
            logger.info("角色名称存在性检查完成：{}，存在：{}", roleName, exists);
            resultDomain.success("检查完成", exists);
            return resultDomain;
            
        } catch (Exception e) {
            logger.error("检查角色名称存在性失败：{}", roleName, e);
            resultDomain.fail("检查失败：" + e.getMessage());
            return resultDomain;
        }
    }

    @Override
    public ResultDomain<TbSysRole> changeRoleStatus(String roleId, Integer status) {
        ResultDomain<TbSysRole> resultDomain = new ResultDomain<>();
        try {
            logger.info("开始修改角色状态：{}，状态：{}", roleId, status);
            
            if (!StringUtils.hasText(roleId)) {
                resultDomain.fail("角色ID不能为空");
                return resultDomain;
            }
            
            if (status == null) {
                resultDomain.fail("角色状态不能为空");
                return resultDomain;
            }
            
            // 检查角色是否存在
            ResultDomain<TbSysRole> existResult = getRoleById(roleId);
            if (!existResult.isSuccess()) {
                resultDomain.fail(existResult.getMessage());
                return resultDomain;
            }
            
            TbSysRole role = existResult.getData();
            role.setUpdateTime(new Date());
            
            int result = roleMapper.updateRole(role);
            
            if (result > 0) {
                logger.info("修改角色状态成功：{}", roleId);
                resultDomain.success("修改角色状态成功", role);
                return resultDomain;
            } else {
                logger.warn("修改角色状态失败：{}", roleId);
                resultDomain.fail("修改角色状态失败");
                return resultDomain;
            }
            
        } catch (Exception e) {
            logger.error("修改角色状态异常：{}", roleId, e);
            resultDomain.fail("修改角色状态失败：" + e.getMessage());
            return resultDomain;
        }
    }

    @Override
    public ResultDomain<TbSysPermission> getRolePermission(String roleId) {
        ResultDomain<TbSysPermission> resultDomain = new ResultDomain<>();
        try {
            logger.info("开始获取角色权限：{}", roleId);

            if (!StringUtils.hasText(roleId)) {
                resultDomain.fail("角色ID不能为空");
                return resultDomain;
            }

            List<TbSysPermission> rolePermissions = rolePermissionMapper.selectByRoleId(roleId);

            logger.info("获取角色权限完成：{}", roleId);
            resultDomain.success("获取角色权限成功", rolePermissions);
            return resultDomain;

        } catch (Exception e) {
            logger.error("获取角色权限异常：{}", roleId, e);
            resultDomain.fail("获取角色权限失败：" + e.getMessage());
            return resultDomain;
        }
    }
}
