package cn.yinlihupo.controller.system;

import cn.dev33.satoken.annotation.SaCheckPermission;
import cn.yinlihupo.common.core.BaseResponse;
import cn.yinlihupo.common.util.ResultUtils;
import cn.yinlihupo.domain.entity.SysRole;
import cn.yinlihupo.domain.entity.SysUser;
import cn.yinlihupo.domain.entity.SysUserRole;
import cn.yinlihupo.mapper.SysRoleMapper;
import cn.yinlihupo.mapper.SysUserMapper;
import cn.yinlihupo.mapper.SysUserRoleMapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 用户角色管理控制器
 */
@Slf4j
@RestController
@RequestMapping("/api/v1/system/user")
@RequiredArgsConstructor
public class UserRoleController {

    private final SysUserMapper userMapper;
    private final SysRoleMapper roleMapper;
    private final SysUserRoleMapper userRoleMapper;

    /**
     * 分页查询用户列表
     */
    @SaCheckPermission("system:user:list")
    @GetMapping("/list")
    public BaseResponse<Page<SysUser>> list(
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize,
            @RequestParam(required = false) String keyword) {

        Page<SysUser> page = new Page<>(pageNum, pageSize);
        // 使用MyBatis-Plus分页插件，将page作为第一个参数传入
        Page<SysUser> resultPage = userMapper.selectPage(page, new LambdaQueryWrapper<SysUser>()
                .eq(SysUser::getDeleted, 0)
                .and(StringUtils.hasText(keyword), qw -> qw
                        .like(SysUser::getUsername, keyword)
                        .or()
                        .like(SysUser::getRealName, keyword)
                        .or()
                        .like(SysUser::getPhone, keyword)
                )
                .orderByDesc(SysUser::getCreateTime));

        return ResultUtils.success("查询成功", resultPage);
    }

    /**
     * 根据ID查询用户
     */
    @SaCheckPermission("system:user:view")
    @GetMapping("/{id}")
    public BaseResponse<SysUser> getById(@PathVariable Long id) {
        SysUser user = userMapper.selectById(id);
        if (user == null || user.getDeleted() == 1) {
            return ResultUtils.error("用户不存在");
        }
        // 不返回密码
        user.setPassword(null);
        return ResultUtils.success("查询成功", user);
    }

    /**
     * 查询用户的角色列表
     */
    @SaCheckPermission("system:user:view")
    @GetMapping("/{id}/roles")
    public BaseResponse<List<SysRole>> getUserRoles(@PathVariable Long id) {
        SysUser user = userMapper.selectById(id);
        if (user == null || user.getDeleted() == 1) {
            return ResultUtils.error("用户不存在");
        }
        
        // 查询用户角色关联
        LambdaQueryWrapper<SysUserRole> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysUserRole::getUserId, id);
        List<SysUserRole> userRoles = userRoleMapper.selectList(wrapper);
        
        if (userRoles.isEmpty()) {
            return ResultUtils.success("查询成功", List.of());
        }
        
        // 查询角色详情
        List<Long> roleIds = userRoles.stream()
                .map(SysUserRole::getRoleId)
                .collect(Collectors.toList());
        
        LambdaQueryWrapper<SysRole> roleWrapper = new LambdaQueryWrapper<>();
        roleWrapper.in(SysRole::getId, roleIds)
                .eq(SysRole::getDeleted, 0)
                .eq(SysRole::getStatus, 1);
        List<SysRole> roles = roleMapper.selectList(roleWrapper);
        
        return ResultUtils.success("查询成功", roles);
    }

    /**
     * 查询用户角色ID列表（用于回显）
     */
    @SaCheckPermission("system:user:view")
    @GetMapping("/{id}/roleIds")
    public BaseResponse<List<Long>> getUserRoleIds(@PathVariable Long id) {
        SysUser user = userMapper.selectById(id);
        if (user == null || user.getDeleted() == 1) {
            return ResultUtils.error("用户不存在");
        }
        
        LambdaQueryWrapper<SysUserRole> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysUserRole::getUserId, id);
        List<SysUserRole> userRoles = userRoleMapper.selectList(wrapper);
        
        List<Long> roleIds = userRoles.stream()
                .map(SysUserRole::getRoleId)
                .collect(Collectors.toList());
        
        return ResultUtils.success("查询成功", roleIds);
    }

    /**
     * 新增用户
     */
    @SaCheckPermission("system:user:create")
    @PostMapping
    public BaseResponse<Long> create(@RequestBody SysUser user) {
        // 检查用户名是否已存在
        if (user.getUsername() != null && !user.getUsername().isEmpty()) {
            LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(SysUser::getUsername, user.getUsername())
                    .eq(SysUser::getDeleted, 0);
            if (userMapper.selectCount(wrapper) > 0) {
                return ResultUtils.error("用户名已存在");
            }
        }
        
        // 检查手机号是否已存在
        if (user.getPhone() != null && !user.getPhone().isEmpty()) {
            LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(SysUser::getPhone, user.getPhone())
                    .eq(SysUser::getDeleted, 0);
            if (userMapper.selectCount(wrapper) > 0) {
                return ResultUtils.error("手机号已存在");
            }
        }
        
        user.setStatus(1);
        user.setDeleted(0);
        // 设置默认密码
        if (user.getPassword() == null || user.getPassword().isEmpty()) {
            user.setPassword("123456"); // 实际项目中需要加密
        }
        
        userMapper.insert(user);
        
        log.info("新增用户成功, id: {}, username: {}", user.getId(), user.getUsername());
        return ResultUtils.success("新增成功", user.getId());
    }

    /**
     * 修改用户
     */
    @SaCheckPermission("system:user:update")
    @PutMapping
    public BaseResponse<Void> update(@RequestBody SysUser user) {
        if (user.getId() == null) {
            return ResultUtils.error("用户ID不能为空");
        }
        
        SysUser exist = userMapper.selectById(user.getId());
        if (exist == null || exist.getDeleted() == 1) {
            return ResultUtils.error("用户不存在");
        }
        
        // 如果修改了手机号，检查是否与其他用户冲突
        if (user.getPhone() != null && !user.getPhone().isEmpty() 
                && !user.getPhone().equals(exist.getPhone())) {
            LambdaQueryWrapper<SysUser> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(SysUser::getPhone, user.getPhone())
                    .eq(SysUser::getDeleted, 0)
                    .ne(SysUser::getId, user.getId());
            if (userMapper.selectCount(wrapper) > 0) {
                return ResultUtils.error("手机号已存在");
            }
        }
        
        // 不更新密码和敏感字段
        user.setPassword(null);
        user.setCreateTime(null);
        user.setDeleted(null);
        
        userMapper.updateById(user);
        
        log.info("修改用户成功, id: {}", user.getId());
        return ResultUtils.success("修改成功", null);
    }

    /**
     * 删除用户
     */
    @SaCheckPermission("system:user:delete")
    @DeleteMapping("/{id}")
    @Transactional(rollbackFor = Exception.class)
    public BaseResponse<Void> delete(@PathVariable Long id) {
        SysUser user = userMapper.selectById(id);
        if (user == null || user.getDeleted() == 1) {
            return ResultUtils.error("用户不存在");
        }
        
        // 删除用户
        userMapper.deleteById(id);
        
        // 删除用户角色关联
        LambdaQueryWrapper<SysUserRole> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysUserRole::getUserId, id);
        userRoleMapper.delete(wrapper);
        
        log.info("删除用户成功, id: {}", id);
        return ResultUtils.success("删除成功", null);
    }

    /**
     * 为用户绑定角色
     */
    @SaCheckPermission("system:user:bindRole")
    @PostMapping("/{id}/roles")
    @Transactional(rollbackFor = Exception.class)
    public BaseResponse<Void> bindRoles(@PathVariable Long id, @RequestBody List<Long> roleIds) {
        SysUser user = userMapper.selectById(id);
        if (user == null || user.getDeleted() == 1) {
            return ResultUtils.error("用户不存在");
        }
        
        // 删除原有角色关联
        LambdaQueryWrapper<SysUserRole> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysUserRole::getUserId, id);
        userRoleMapper.delete(wrapper);
        
        // 插入新的角色关联
        if (roleIds != null && !roleIds.isEmpty()) {
            for (Long roleId : roleIds) {
                SysRole role = roleMapper.selectById(roleId);
                if (role != null && role.getDeleted() == 0 && role.getStatus() == 1) {
                    SysUserRole ur = new SysUserRole();
                    ur.setUserId(id);
                    ur.setRoleId(roleId);
                    ur.setCreateTime(LocalDateTime.now());
                    userRoleMapper.insert(ur);
                }
            }
        }
        
        log.info("用户绑定角色成功, userId: {}, roleCount: {}", id, 
                roleIds != null ? roleIds.size() : 0);
        return ResultUtils.success("绑定角色成功", null);
    }
}