package com.tourguide.modules.user.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tourguide.common.api.PageResponse;
import com.tourguide.common.exception.BusinessException;
import com.tourguide.modules.user.dto.UserCreateRequest;
import com.tourguide.modules.user.dto.AdminPasswordResetRequest;
import com.tourguide.modules.user.dto.RoleOptionResponse;
import com.tourguide.modules.user.dto.UserResponse;
import com.tourguide.modules.user.dto.UserUpdateRequest;
import com.tourguide.modules.user.entity.AdminUser;
import com.tourguide.modules.user.entity.SysRole;
import com.tourguide.modules.user.mapper.AdminUserMapper;
import com.tourguide.modules.user.mapper.SysRoleMapper;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import java.util.List;
import java.util.stream.Collectors;

/** 仅处理管理后台账号，禁止读写小程序用户表。 */
@Service
public class AdminUserService {
    private final AdminUserMapper userMapper;
    private final SysRoleMapper roleMapper;
    private final PasswordEncoder passwordEncoder;

    public AdminUserService(AdminUserMapper userMapper, SysRoleMapper roleMapper, PasswordEncoder passwordEncoder) {
        this.userMapper = userMapper;
        this.roleMapper = roleMapper;
        this.passwordEncoder = passwordEncoder;
    }

    public AdminUser findEnabledById(Long id) {
        AdminUser user = userMapper.selectById(id);
        if (user == null || user.getStatus() == null || user.getStatus() != 1) {
            throw new BusinessException(401, "后台用户不存在或已停用");
        }
        return user;
    }

    public AdminUser findByUsername(String username) {
        return userMapper.selectOne(new LambdaQueryWrapper<AdminUser>().eq(AdminUser::getUsername, username).last("LIMIT 1"));
    }

    public PageResponse<UserResponse> page(long page, long size, String nickname, String username,
                                           String roleCode, Integer status) {
        LambdaQueryWrapper<AdminUser> query = new LambdaQueryWrapper<AdminUser>()
                .like(StringUtils.hasText(nickname), AdminUser::getNickname, nickname == null ? null : nickname.trim())
                .like(StringUtils.hasText(username), AdminUser::getUsername, username == null ? null : username.trim())
                .eq(StringUtils.hasText(roleCode), AdminUser::getRoleCode, roleCode)
                .eq(status != null, AdminUser::getStatus, status)
                .orderByDesc(AdminUser::getId);
        Page<AdminUser> result = userMapper.selectPage(new Page<AdminUser>(page, size), query);
        return new PageResponse<UserResponse>(result.getRecords().stream().map(UserResponse::from).collect(Collectors.toList()),
                result.getTotal(), result.getCurrent(), result.getSize());
    }

    @Transactional
    public UserResponse create(UserCreateRequest request) {
        ensureUsernameAvailable(request.getUsername());
        ensureRoleEnabled(request.getRoleCode());
        AdminUser user = new AdminUser();
        user.setUsername(request.getUsername());
        user.setPassword(passwordEncoder.encode(request.getPassword()));
        user.setNickname(request.getNickname());
        user.setMobile(request.getMobile());
        user.setRoleCode(request.getRoleCode());
        user.setStatus(request.getStatus());
        user.setDeleted(0);
        userMapper.insert(user);
        return UserResponse.from(user);
    }

    @Transactional
    public UserResponse update(Long id, UserUpdateRequest request, Long operatorId) {
        if (id.equals(operatorId) && request.getStatus() == 0) {
            throw new BusinessException(409, "不能禁用当前登录账号");
        }
        AdminUser user = getRequired(id);
        ensureUsernameAvailable(request.getUsername(), id);
        ensureRoleEnabled(request.getRoleCode());
        user.setUsername(request.getUsername());
        user.setNickname(request.getNickname());
        user.setRoleCode(request.getRoleCode());
        user.setStatus(request.getStatus());
        userMapper.updateById(user);
        return UserResponse.from(user);
    }

    @Transactional
    public UserResponse updateStatus(Long id, Integer status, Long operatorId) {
        if (id.equals(operatorId) && status == 0) throw new BusinessException(409, "不能禁用当前登录账号");
        AdminUser user = getRequired(id);
        user.setStatus(status);
        userMapper.updateById(user);
        return UserResponse.from(user);
    }

    @Transactional
    public void resetPassword(Long id, AdminPasswordResetRequest request) {
        if (!request.getNewPassword().equals(request.getConfirmPassword())) {
            throw new BusinessException(400, "两次输入的密码不一致");
        }
        AdminUser user = getRequired(id);
        user.setPassword(passwordEncoder.encode(request.getNewPassword()));
        userMapper.updateById(user);
    }

    public List<RoleOptionResponse> roleOptions() {
        return roleMapper.selectList(new LambdaQueryWrapper<SysRole>()
                        .eq(SysRole::getStatus, 1)
                        .orderByAsc(SysRole::getId))
                .stream().map(RoleOptionResponse::new).collect(Collectors.toList());
    }

    @Transactional
    public void delete(Long id, Long operatorId) {
        if (id.equals(operatorId)) throw new BusinessException(409, "不能删除当前登录账号");
        if (userMapper.deleteById(id) == 0) { throw new BusinessException(404, "后台用户不存在"); }
    }

    private AdminUser getRequired(Long id) {
        AdminUser user = userMapper.selectById(id);
        if (user == null) { throw new BusinessException(404, "后台用户不存在"); }
        return user;
    }

    private void ensureUsernameAvailable(String username) {
        ensureUsernameAvailable(username, null);
    }

    private void ensureUsernameAvailable(String username, Long excludedId) {
        if (userMapper.selectCount(new LambdaQueryWrapper<AdminUser>()
                .eq(AdminUser::getUsername, username)
                .ne(excludedId != null, AdminUser::getId, excludedId)) > 0) {
            throw new BusinessException(409, "后台用户名已存在");
        }
    }

    private void ensureRoleEnabled(String roleCode) {
        if (roleMapper.selectCount(new LambdaQueryWrapper<SysRole>()
                .eq(SysRole::getRoleCode, roleCode)
                .eq(SysRole::getStatus, 1)) == 0) {
            throw new BusinessException(400, "所选角色不存在或已停用");
        }
    }
}