package com.sinata.appointment.service;

import cn.dev33.satoken.stp.StpUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sinata.appointment.constants.BizErrorCode;
import com.sinata.appointment.dto.ResetPasswordRequest;
import com.sinata.appointment.dto.SysUserCreateRequest;
import com.sinata.appointment.dto.SysUserDetailVo;
import com.sinata.appointment.dto.SysUserListVo;
import com.sinata.appointment.dto.SysUserUpdateRequest;
import com.sinata.appointment.dto.UserRoleLabelRow;
import com.sinata.appointment.dto.UserStatusPatchRequest;
import com.sinata.appointment.entity.SysRole;
import com.sinata.appointment.entity.SysUser;
import com.sinata.appointment.entity.SysUserRole;
import com.sinata.appointment.exception.BizException;
import com.sinata.appointment.mapper.SysRoleMapper;
import com.sinata.appointment.mapper.SysUserMapper;
import com.sinata.appointment.mapper.SysUserRoleMapper;
import com.sinata.appointment.util.MobileMaskUtil;
import com.sinata.appointment.util.UuidAssert;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

@Service
@RequiredArgsConstructor
public class SysUserApplicationService {

    private final SysUserMapper sysUserMapper;
    private final SysRoleMapper sysRoleMapper;
    private final SysUserRoleMapper sysUserRoleMapper;
    private final BCryptPasswordEncoder bcrypt;

    public IPage<SysUserListVo> pageUsers(
            long page,
            long size,
            String realName,
            String mobile,
            Long roleId,
            Integer status) {
        LambdaQueryWrapper<SysUser> q = new LambdaQueryWrapper<>();
        q.eq(SysUser::getDelFlag, 0);
        if (StringUtils.hasText(realName)) {
            q.like(SysUser::getRealName, realName.trim());
        }
        if (StringUtils.hasText(mobile)) {
            q.like(SysUser::getMobile, mobile.trim());
        }
        if (roleId != null) {
            q.apply(
                    "id IN (SELECT user_id FROM sys_user_role WHERE role_id = {0} AND del_flag = 0)",
                    roleId);
        }
        if (status != null) {
            q.eq(SysUser::getStatus, status);
        }
        q.orderByDesc(SysUser::getCreateTime);
        Page<SysUser> p = sysUserMapper.selectPage(new Page<>(page, size), q);

        List<Long> userIds = p.getRecords().stream().map(SysUser::getId).toList();
        Map<Long, String> roleLine = roleDisplayByUserIds(userIds);

        return p.convert(
                u -> {
                    SysUserListVo vo = new SysUserListVo();
                    vo.setId(u.getId());
                    vo.setUuid(u.getUuid());
                    vo.setUsername(u.getUsername());
                    vo.setRealName(u.getRealName());
                    vo.setMobileMasked(MobileMaskUtil.mask(u.getMobile()));
                    vo.setRolesDisplay(roleLine.getOrDefault(u.getId(), "—"));
                    vo.setStatus(u.getStatus());
                    vo.setCreateTime(u.getCreateTime());
                    return vo;
                });
    }

    private Map<Long, String> roleDisplayByUserIds(List<Long> userIds) {
        if (userIds.isEmpty()) {
            return Map.of();
        }
        List<UserRoleLabelRow> rows = sysUserMapper.listRoleLabelsByUserIds(userIds);
        return rows.stream()
                .collect(
                        Collectors.groupingBy(
                                UserRoleLabelRow::getUserId,
                                Collectors.mapping(
                                        UserRoleLabelRow::getRoleName,
                                        Collectors.joining("、"))));
    }

    public SysUserDetailVo getDetail(Long id, String uuid) {
        SysUser u = loadActiveWithUuid(id, uuid);
        SysUserDetailVo vo = new SysUserDetailVo();
        vo.setId(u.getId());
        vo.setUuid(u.getUuid());
        vo.setUsername(u.getUsername());
        vo.setRealName(u.getRealName());
        vo.setMobile(u.getMobile());
        vo.setAvatarUrl(u.getAvatarUrl());
        vo.setStatus(u.getStatus());
        vo.setRoleIds(listRoleIds(id));
        return vo;
    }

    @Transactional(rollbackFor = Exception.class)
    public Map<String, Object> createUser(SysUserCreateRequest req) {
        long exists =
                sysUserMapper.selectCount(
                        new LambdaQueryWrapper<SysUser>()
                                .eq(SysUser::getUsername, req.getUsername().trim())
                                .eq(SysUser::getDelFlag, 0));
        if (exists > 0) {
            throw new BizException(BizErrorCode.DUPLICATE_USERNAME, "登录账号已存在");
        }
        validateRoleIds(req.getRoleIds());

        SysUser u = new SysUser();
        u.setUsername(req.getUsername().trim());
        u.setPasswordHash(bcrypt.encode(req.getPassword()));
        u.setRealName(trimToNull(req.getRealName()));
        u.setMobile(trimToNull(req.getMobile()));
        u.setAvatarUrl(trimToNull(req.getAvatarUrl()));
        u.setStatus(1);
        sysUserMapper.insert(u);
        SysUser fresh = sysUserMapper.selectById(u.getId());
        if (fresh == null || !StringUtils.hasText(fresh.getUuid())) {
            throw new BizException(BizErrorCode.AUTH_FORBIDDEN, "创建后读取用户失败");
        }
        replaceRoles(fresh.getId(), req.getRoleIds());
        Map<String, Object> m = new HashMap<>();
        m.put("id", fresh.getId());
        m.put("uuid", fresh.getUuid());
        return m;
    }

    @Transactional(rollbackFor = Exception.class)
    public void updateUser(Long id, SysUserUpdateRequest req) {
        SysUser u = loadActiveWithUuid(id, req.getUuid());
        validateRoleIds(req.getRoleIds());
        u.setRealName(trimToNull(req.getRealName()));
        u.setMobile(trimToNull(req.getMobile()));
        u.setAvatarUrl(trimToNull(req.getAvatarUrl()));
        sysUserMapper.updateById(u);
        replaceRoles(id, req.getRoleIds());
    }

    @Transactional(rollbackFor = Exception.class)
    public void resetPassword(Long id, ResetPasswordRequest req) {
        if (!Objects.equals(req.getNewPassword(), req.getNewPasswordConfirm())) {
            throw new BizException(BizErrorCode.PASSWORD_CONFIRM_MISMATCH, "两次输入的新密码不一致");
        }
        SysUser u = loadActiveWithUuid(id, req.getUuid());
        u.setPasswordHash(bcrypt.encode(req.getNewPassword()));
        sysUserMapper.updateById(u);
        kickSysUserOffline(id);
    }

    @Transactional(rollbackFor = Exception.class)
    public void patchStatus(Long id, UserStatusPatchRequest req, long operatorUserId) {
        int st = req.getStatus();
        if (st != 0 && st != 1) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "状态无效");
        }
        if (st == 0 && id == operatorUserId) {
            throw new BizException(BizErrorCode.USER_SELF_FORBIDDEN, "不能禁用自己的账号");
        }
        SysUser u = loadActiveWithUuid(id, req.getUuid());
        u.setStatus(st);
        sysUserMapper.updateById(u);
        if (st == 0) {
            kickSysUserOffline(id);
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void deleteUser(Long id, String uuid, long operatorUserId) {
        if (id == operatorUserId) {
            throw new BizException(BizErrorCode.USER_SELF_FORBIDDEN, "不能删除自己的账号");
        }
        SysUser u = loadActiveWithUuid(id, uuid);
        sysUserRoleMapper.delete(
                new LambdaQueryWrapper<SysUserRole>()
                        .eq(SysUserRole::getUserId, id)
                        .eq(SysUserRole::getDelFlag, 0));
        int affected = sysUserMapper.deleteById(u.getId());
        if (affected <= 0) {
            throw new BizException(BizErrorCode.RESOURCE_VERIFY_FAILED, "删除失败，请刷新后重试");
        }
        kickSysUserOffline(id);
    }

    private static void kickSysUserOffline(Long sysUserId) {
        StpUtil.kickout(sysUserId);
    }

    private SysUser loadActiveWithUuid(Long id, String uuid) {
        SysUser u = sysUserMapper.selectById(id);
        if (u == null || u.getDelFlag() != null && u.getDelFlag() == 1) {
            throw new BizException(BizErrorCode.RESOURCE_VERIFY_FAILED, "资源不存在或无权访问");
        }
        UuidAssert.match(u, uuid);
        return u;
    }

    private void validateRoleIds(List<Long> roleIds) {
        if (roleIds == null || roleIds.isEmpty()) {
            throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "至少选择一个角色");
        }
        for (Long rid : roleIds) {
            SysRole r = sysRoleMapper.selectById(rid);
            if (r == null || r.getDelFlag() != null && r.getDelFlag() == 1) {
                throw new BizException(BizErrorCode.AUTH_INVALID_CREDENTIALS, "角色不存在: " + rid);
            }
        }
    }

    private List<Long> listRoleIds(Long userId) {
        return sysUserRoleMapper
                .selectList(
                        new LambdaQueryWrapper<SysUserRole>()
                                .eq(SysUserRole::getUserId, userId)
                                .eq(SysUserRole::getDelFlag, 0))
                .stream()
                .map(SysUserRole::getRoleId)
                .toList();
    }

    private void replaceRoles(Long userId, List<Long> roleIds) {
        sysUserRoleMapper.delete(
                new LambdaQueryWrapper<SysUserRole>()
                        .eq(SysUserRole::getUserId, userId)
                        .eq(SysUserRole::getDelFlag, 0));
        for (Long rid : roleIds) {
            SysUserRole ur = new SysUserRole();
            ur.setUserId(userId);
            ur.setRoleId(rid);
            sysUserRoleMapper.insert(ur);
        }
    }

    private static String trimToNull(String s) {
        if (!StringUtils.hasText(s)) {
            return null;
        }
        String t = s.trim();
        return t.isEmpty() ? null : t;
    }
}