package com.tcm.training.admin.app.settings.service;

import cn.dev33.satoken.stp.SaTokenInfo;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.tcm.training.admin.app.auth.dto.AppWechatLoginRequest;
import com.tcm.training.admin.app.auth.service.AppAuthSessionService;
import com.tcm.training.admin.app.auth.vo.AppLoginResponse;
import com.tcm.training.admin.app.auth.vo.AppLoginUserVO;
import com.tcm.training.admin.app.auth.service.AppSmsCodeService;
import com.tcm.training.admin.app.auth.service.AppWechatAuthClient;
import com.tcm.training.admin.app.auth.service.AppWechatUserProfile;
import com.tcm.training.admin.app.settings.dto.AppSettingsNotificationUpdateRequest;
import com.tcm.training.admin.app.settings.dto.AppSettingsPasswordUpdateRequest;
import com.tcm.training.admin.app.settings.dto.AppSettingsPhoneBindRequest;
import com.tcm.training.admin.app.settings.dto.AppSettingsPhoneCodeRequest;
import com.tcm.training.admin.app.settings.dto.AppSettingsPhoneUpdateRequest;
import com.tcm.training.admin.app.settings.dto.AppSettingsProfileUpdateRequest;
import com.tcm.training.admin.app.settings.entity.AppUserNotificationSetting;
import com.tcm.training.admin.app.settings.mapper.AppUserNotificationSettingMapper;
import com.tcm.training.admin.app.settings.vo.AppSettingsNotificationVO;
import com.tcm.training.admin.app.settings.vo.AppSettingsProfileVO;
import com.tcm.training.admin.app.settings.vo.AppSettingsWechatBindingVO;
import com.tcm.training.admin.app.share.service.AppShareService;
import com.tcm.training.admin.member.entity.AppUser;
import com.tcm.training.admin.member.mapper.UserMapper;
import com.tcm.training.admin.upload.ObsUploadService;
import com.tcm.training.admin.upload.UploadController;
import com.tcm.training.admin.upload.UploadFileResult;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.time.LocalDateTime;
import java.util.HashSet;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

/**
 * APP 设置页服务。
 */
@Service
public class AppSettingsService {

    private static final Pattern PHONE_PATTERN = Pattern.compile("^1\\d{10}$");
    private static final Pattern PASSWORD_PATTERN = Pattern.compile("^(?![0-9]+$)(?![a-zA-Z]+$)(?![^0-9a-zA-Z]+$).{8,32}$");
    private static final List<Integer> SUPPORTED_ADVANCE_MINUTES = Arrays.asList(15, 30, 60, 120, 180);
    private static final long AVATAR_MAX_SIZE = 5 * 1024 * 1024L;
    private static final Set<String> ALLOWED_IMAGE_TYPES = new HashSet<String>(
            Arrays.asList("image/jpeg", "image/png", "image/gif", "image/webp")
    );

    private final AppAuthSessionService appAuthSessionService;
    private final UserMapper userMapper;
    private final AppSmsCodeService appSmsCodeService;
    private final BCryptPasswordEncoder passwordEncoder;
    private final AppWechatAuthClient appWechatAuthClient;
    private final AppShareService appShareService;
    private final AppUserNotificationSettingMapper appUserNotificationSettingMapper;
    private final ObsUploadService obsUploadService;

    /**
     * 注入 APP 设置页所需依赖。
     */
    public AppSettingsService(AppAuthSessionService appAuthSessionService,
                              UserMapper userMapper,
                              AppSmsCodeService appSmsCodeService,
                              BCryptPasswordEncoder passwordEncoder,
                              AppWechatAuthClient appWechatAuthClient,
                              AppShareService appShareService,
                              AppUserNotificationSettingMapper appUserNotificationSettingMapper,
                              ObsUploadService obsUploadService) {
        this.appAuthSessionService = appAuthSessionService;
        this.userMapper = userMapper;
        this.appSmsCodeService = appSmsCodeService;
        this.passwordEncoder = passwordEncoder;
        this.appWechatAuthClient = appWechatAuthClient;
        this.appShareService = appShareService;
        this.appUserNotificationSettingMapper = appUserNotificationSettingMapper;
        this.obsUploadService = obsUploadService;
    }

    /**
     * 获取当前登录用户设置页资料。
     */
    public AppSettingsProfileVO getProfile() {
        return toProfileVO(requireCurrentEnabledUser());
    }

    /**
     * 上传当前登录用户头像。
     */
    public UploadController.UploadResult uploadAvatar(MultipartFile file) throws IOException {
        // APP 路由默认允许游客访问，因此头像上传必须在业务层显式校验登录用户。
        requireCurrentEnabledUser();
        validateAvatarImage(file);
        UploadFileResult uploadResult = obsUploadService.upload(file, "app/avatar", null);
        return new UploadController.UploadResult(uploadResult.getUrl(), uploadResult.getFileName());
    }

    /**
     * 更新当前登录用户设置页资料。
     */
    @Transactional
    public AppSettingsProfileVO updateProfile(AppSettingsProfileUpdateRequest request) {
        AppUser user = requireCurrentEnabledUser();
        user.setNickname(normalizeNickname(request.getNickname()));
        user.setAvatar(normalizeAvatar(request.getAvatar()));
        user.setIntro(normalizeIntro(request.getIntro()));
        userMapper.updateById(user);
        return toProfileVO(user);
    }

    /**
     * 发送修改手机号验证码。
     */
    public void sendPhoneChangeCode(AppSettingsPhoneCodeRequest request) {
        AppUser currentUser = requireCurrentEnabledUser();
        String newPhone = normalizePhone(request.getNewPhone());
        if (newPhone.equals(trimToEmpty(currentUser.getPhone()))) {
            throw new IllegalArgumentException("新手机号不能与当前手机号一致");
        }
        if (trimToNull(currentUser.getPhone()) == null) {
            validateThirdPartyPhoneBindable(currentUser, newPhone);
        } else {
            requirePhoneAvailable(newPhone, currentUser.getId());
        }
        appSmsCodeService.createPhoneChangeCode(newPhone);
    }

    /**
     * 修改当前登录用户手机号。
     */
    @Transactional
    public AppSettingsProfileVO updatePhone(AppSettingsPhoneUpdateRequest request) {
        AppUser user = requireCurrentEnabledUser();
        String oldPhone = normalizePhone(request.getOldPhone());
        String newPhone = normalizePhone(request.getNewPhone());
        String code = normalizeRequired(request.getCode(), "请输入验证码");
        if (!oldPhone.equals(trimToEmpty(user.getPhone()))) {
            // 设置页保留旧手机号输入框，因此服务端需要显式校验，避免用户误改其它账号手机号。
            throw new IllegalArgumentException("旧手机号校验失败");
        }
        if (newPhone.equals(oldPhone)) {
            throw new IllegalArgumentException("新手机号不能与当前手机号一致");
        }
        requirePhoneAvailable(newPhone, user.getId());
        appSmsCodeService.validatePhoneChangeCode(newPhone, code);
        user.setPhone(newPhone);
        userMapper.updateById(user);
        return toProfileVO(user);
    }

    /**
     * 首次绑定当前登录用户手机号，供微信登录未绑定手机号场景使用。
     */
    @Transactional
    public AppLoginResponse bindPhone(AppSettingsPhoneBindRequest request) {
        AppUser user = requireCurrentEnabledUser();
        String newPhone = normalizePhone(request.getNewPhone());
        String code = normalizeRequired(request.getCode(), "请输入验证码");
        if (trimToNull(user.getPhone()) != null) {
            throw new IllegalArgumentException("当前账号已绑定手机号");
        }
        AppUser occupiedUser = findUserByPhone(newPhone);
        validatePhoneBindTarget(user, occupiedUser);
        appSmsCodeService.validatePhoneChangeCode(newPhone, code);
        AppUser loginUser = occupiedUser == null
                ? bindPhoneToCurrentUser(user, newPhone, request.getInviteCode())
                : mergeThirdPartyUserToPhoneUser(user, occupiedUser, request.getInviteCode());
        return createLoginResponse(loginUser);
    }

    /**
     * 用户尚未绑定诊所关系时，根据医生邀请码补齐上下级关系。
     */
    private void bindInviteRelationIfAbsent(AppUser user, String inviteCode) {
        if (user.getClinicId() != null || user.getSuperiorClinicUserId() != null) {
            return;
        }
        String normalizedInviteCode = normalizeInviteCode(inviteCode);
        if (normalizedInviteCode == null) {
            return;
        }
        AppShareService.InviteBindingTarget bindingTarget = appShareService.resolveInviteBindingTarget(normalizedInviteCode);
        user.setClinicId(bindingTarget.getClinicId());
        user.setSuperiorClinicUserId(bindingTarget.getSuperiorClinicUserId());
    }

    /**
     * 将手机号直接绑定到当前临时账号。
     */
    private AppUser bindPhoneToCurrentUser(AppUser user, String phone, String inviteCode) {
        user.setPhone(phone);
        bindInviteRelationIfAbsent(user, inviteCode);
        userMapper.updateById(user);
        return user;
    }

    /**
     * 将当前第三方临时账号合并到已存在的手机号账号。
     */
    private AppUser mergeThirdPartyUserToPhoneUser(AppUser currentUser, AppUser targetUser, String inviteCode) {
        requireEnabledUser(targetUser);
        copyThirdPartyBinding(currentUser, targetUser);
        fillMissingProfile(targetUser, currentUser);
        bindInviteRelationIfAbsent(targetUser, inviteCode);
        userMapper.updateById(targetUser);
        disableMergedTemporaryUser(currentUser);
        return targetUser;
    }

    /**
     * 校验首次绑定手机号时目标手机号是否允许承接当前第三方身份。
     */
    private void validateThirdPartyPhoneBindable(AppUser currentUser, String phone) {
        validatePhoneBindTarget(currentUser, findUserByPhone(phone));
    }

    /**
     * 校验目标手机号账号未绑定当前第三方类型。
     */
    private void validatePhoneBindTarget(AppUser currentUser, AppUser targetUser) {
        if (targetUser == null || targetUser.getId().equals(currentUser.getId())) {
            return;
        }
        if (hasWechatBinding(currentUser) || hasAppleBinding(currentUser)) {
            return;
        }
        throw new IllegalArgumentException("该手机号已注册");
    }

    /**
     * 将当前临时账号上的第三方票据写入目标手机号账号。
     */
    private void copyThirdPartyBinding(AppUser sourceUser, AppUser targetUser) {
        if (hasWechatBinding(sourceUser)) {
            targetUser.setWechatOpenid(sourceUser.getWechatOpenid());
            targetUser.setWechatNickname(sourceUser.getWechatNickname());
            targetUser.setWechatAvatar(sourceUser.getWechatAvatar());
            targetUser.setWechatBoundAt(sourceUser.getWechatBoundAt() == null ? LocalDateTime.now() : sourceUser.getWechatBoundAt());
        }
        if (hasAppleBinding(sourceUser)) {
            targetUser.setAppleUserIdentifier(sourceUser.getAppleUserIdentifier());
            targetUser.setAppleIdentitySubject(sourceUser.getAppleIdentitySubject());
            targetUser.setAppleBoundAt(sourceUser.getAppleBoundAt() == null ? LocalDateTime.now() : sourceUser.getAppleBoundAt());
        }
    }

    /**
     * 目标账号资料为空时，复用临时第三方账号资料补齐展示信息。
     */
    private void fillMissingProfile(AppUser targetUser, AppUser sourceUser) {
        if (trimToNull(targetUser.getNickname()) == null) {
            targetUser.setNickname(resolveNickname(sourceUser));
        }
        if (trimToNull(targetUser.getAvatar()) == null) {
            targetUser.setAvatar(resolveAvatar(sourceUser));
        }
        if (targetUser.getGender() == null) {
            targetUser.setGender(sourceUser.getGender());
        }
    }

    /**
     * 合并后清空第三方票据并逻辑删除临时账号，避免同一 openid 或苹果 subject 命中多个账号。
     */
    private void disableMergedTemporaryUser(AppUser currentUser) {
        userMapper.update(null, new LambdaUpdateWrapper<AppUser>()
                .eq(AppUser::getId, currentUser.getId())
                .set(AppUser::getStatus, 0)
                .set(AppUser::getWechatOpenid, null)
                .set(AppUser::getWechatNickname, null)
                .set(AppUser::getWechatAvatar, null)
                .set(AppUser::getWechatBoundAt, null)
                .set(AppUser::getAppleUserIdentifier, null)
                .set(AppUser::getAppleIdentitySubject, null)
                .set(AppUser::getAppleBoundAt, null)
                .set(AppUser::getDeleted, 1));
    }

    /**
     * 修改当前登录用户密码，并在成功后使当前登录态失效。
     */
    @Transactional
    public void updatePassword(AppSettingsPasswordUpdateRequest request) {
        AppUser user = requireCurrentEnabledUser();
        String oldPassword = normalizeRequired(request.getOldPassword(), "请输入原密码");
        String newPassword = normalizePassword(request.getNewPassword(), "请输入新密码");
        String confirmPassword = normalizePassword(request.getConfirmPassword(), "请再次输入密码");
        if (!passwordEncoder.matches(oldPassword, trimToEmpty(user.getPassword()))) {
            throw new IllegalArgumentException("原密码错误");
        }
        if (!newPassword.equals(confirmPassword)) {
            throw new IllegalArgumentException("两次密码输入不一致");
        }
        user.setPassword(passwordEncoder.encode(newPassword));
        userMapper.updateById(user);
        appAuthSessionService.logout();
    }

    /**
     * 绑定或换绑当前登录用户微信信息。
     */
    @Transactional
    public AppSettingsWechatBindingVO bindWechat(AppWechatLoginRequest request) {
        AppUser currentUser = requireCurrentEnabledUser();
        AppWechatUserProfile profile = appWechatAuthClient.resolveUserProfile(request);
        AppUser occupiedUser = userMapper.selectOne(new LambdaQueryWrapper<AppUser>()
                .eq(AppUser::getWechatOpenid, profile.getOpenid())
                .eq(AppUser::getDeleted, 0)
                .last("limit 1"));
        // 同一个 openid 只允许归属一个有效账号，避免微信账号被多个本地账号共用。
        if (occupiedUser != null && !occupiedUser.getId().equals(currentUser.getId())) {
            throw new IllegalArgumentException("该微信已绑定其他账号");
        }

        String wechatNickname = trimToNull(profile.getNickname());
        String wechatAvatar = trimToNull(profile.getAvatar());
        currentUser.setWechatOpenid(profile.getOpenid());
        currentUser.setWechatNickname(wechatNickname);
        currentUser.setWechatAvatar(wechatAvatar);
        currentUser.setWechatBoundAt(LocalDateTime.now());
        if (trimToNull(currentUser.getNickname()) == null && wechatNickname != null) {
            currentUser.setNickname(wechatNickname);
        }
        if (trimToNull(currentUser.getAvatar()) == null && wechatAvatar != null) {
            currentUser.setAvatar(wechatAvatar);
        }
        if (currentUser.getGender() == null) {
            currentUser.setGender(resolveWechatGender(profile.getSex()));
        }
        userMapper.updateById(currentUser);
        return buildWechatBinding(currentUser);
    }

    /**
     * 获取当前登录用户通知设置，没有记录时按默认值初始化。
     */
    @Transactional
    public AppSettingsNotificationVO getNotificationSettings() {
        return toNotificationVO(requireNotificationSetting(requireCurrentEnabledUser().getId()));
    }

    /**
     * 保存当前登录用户通知设置。
     */
    @Transactional
    public AppSettingsNotificationVO updateNotificationSettings(AppSettingsNotificationUpdateRequest request) {
        AppUser user = requireCurrentEnabledUser();
        AppUserNotificationSetting setting = requireNotificationSetting(user.getId());
        Integer advanceMinutes = normalizeAdvanceMinutes(request.getAdvanceMinutes());
        setting.setOrderStatusUpdateEnabled(booleanToInteger(request.getOrderStatusUpdateEnabled()));
        setting.setActivityNoticeEnabled(booleanToInteger(request.getActivityNoticeEnabled()));
        setting.setCourseUpdateEnabled(booleanToInteger(request.getCourseUpdateEnabled()));
        setting.setLiveReservationEnabled(booleanToInteger(request.getLiveReservationEnabled()));
        setting.setAdvanceNoticeMinutes(advanceMinutes);
        appUserNotificationSettingMapper.updateById(setting);
        return toNotificationVO(setting);
    }

    /**
     * 注销当前登录账号，保留历史业务记录用于审计和数据回溯。
     */
    @Transactional
    public void cancelAccount() {
        AppUser user = requireCurrentEnabledUser();
        user.setStatus(0);
        user.setDeleted(1);
        userMapper.updateById(user);
        appAuthSessionService.logout();
    }

    /**
     * 校验当前登录用户存在且启用。
     */
    private AppUser requireCurrentEnabledUser() {
        Long userId = appAuthSessionService.requireLoginUserId();
        AppUser user = userMapper.selectById(userId);
        if (user == null || user.getDeleted() == null || user.getDeleted().intValue() != 0) {
            throw new IllegalArgumentException("用户不存在");
        }
        if (user.getStatus() == null || user.getStatus().intValue() != 1) {
            throw new IllegalArgumentException("用户已禁用");
        }
        return user;
    }

    /**
     * 读取当前用户通知设置，不存在时自动创建默认值。
     */
    private AppUserNotificationSetting requireNotificationSetting(Long userId) {
        AppUserNotificationSetting setting = appUserNotificationSettingMapper.selectOne(new LambdaQueryWrapper<AppUserNotificationSetting>()
                .eq(AppUserNotificationSetting::getAppUserId, userId)
                .eq(AppUserNotificationSetting::getDeleted, 0)
                .last("limit 1"));
        if (setting != null) {
            return setting;
        }
        AppUserNotificationSetting created = new AppUserNotificationSetting();
        created.setAppUserId(userId);
        created.setOrderStatusUpdateEnabled(1);
        created.setActivityNoticeEnabled(0);
        created.setCourseUpdateEnabled(0);
        created.setLiveReservationEnabled(1);
        created.setAdvanceNoticeMinutes(60);
        created.setDeleted(0);
        appUserNotificationSettingMapper.insert(created);
        return created;
    }

    /**
     * 将用户实体转换为设置页资料响应。
     */
    private AppSettingsProfileVO toProfileVO(AppUser user) {
        AppSettingsProfileVO result = new AppSettingsProfileVO();
        result.setId(user.getId());
        result.setNickname(resolveNickname(user));
        result.setAvatar(resolveAvatar(user));
        result.setPhone(trimToEmpty(user.getPhone()));
        result.setIntro(trimToEmpty(user.getIntro()));
        result.setType(user.getType());
        result.setWechatBinding(buildWechatBinding(user));
        return result;
    }

    /**
     * 将通知设置实体转换为响应结构。
     */
    private AppSettingsNotificationVO toNotificationVO(AppUserNotificationSetting setting) {
        AppSettingsNotificationVO result = new AppSettingsNotificationVO();
        result.setOrderStatusUpdateEnabled(integerToBoolean(setting.getOrderStatusUpdateEnabled()));
        result.setActivityNoticeEnabled(integerToBoolean(setting.getActivityNoticeEnabled()));
        result.setCourseUpdateEnabled(integerToBoolean(setting.getCourseUpdateEnabled()));
        result.setLiveReservationEnabled(integerToBoolean(setting.getLiveReservationEnabled()));
        result.setAdvanceMinutes(setting.getAdvanceNoticeMinutes());
        return result;
    }

    /**
     * 构造微信绑定展示信息。
     */
    private AppSettingsWechatBindingVO buildWechatBinding(AppUser user) {
        AppSettingsWechatBindingVO result = new AppSettingsWechatBindingVO();
        result.setBound(trimToNull(user.getWechatOpenid()) != null);
        result.setNickname(trimToEmpty(user.getWechatNickname()));
        result.setAvatar(trimToEmpty(user.getWechatAvatar()));
        result.setBoundAt(user.getWechatBoundAt());
        return result;
    }

    /**
     * 按手机号查询未删除的 APP 用户。
     */
    private AppUser findUserByPhone(String phone) {
        return userMapper.selectOne(new LambdaQueryWrapper<AppUser>()
                .eq(AppUser::getPhone, phone)
                .eq(AppUser::getDeleted, 0)
                .last("limit 1"));
    }

    /**
     * 校验用户启用状态。
     */
    private void requireEnabledUser(AppUser user) {
        if (user.getStatus() == null || user.getStatus().intValue() != 1) {
            throw new IllegalArgumentException("账号已被禁用");
        }
    }

    /**
     * 判断账号是否已绑定微信。
     */
    private boolean hasWechatBinding(AppUser user) {
        return trimToNull(user.getWechatOpenid()) != null;
    }

    /**
     * 判断账号是否已绑定苹果。
     */
    private boolean hasAppleBinding(AppUser user) {
        return trimToNull(user.getAppleIdentitySubject()) != null;
    }

    /**
     * 为绑定后的用户签发新的 APP 登录态。
     */
    private AppLoginResponse createLoginResponse(AppUser user) {
        appAuthSessionService.login(user.getId());
        SaTokenInfo tokenInfo = appAuthSessionService.getTokenInfo();
        return new AppLoginResponse(
                tokenInfo.getTokenValue(),
                "Bearer",
                tokenInfo.getTokenTimeout(),
                buildLoginUser(user)
        );
    }

    /**
     * 将用户实体转换为登录响应中的用户摘要。
     */
    private AppLoginUserVO buildLoginUser(AppUser user) {
        AppLoginUserVO loginUser = new AppLoginUserVO();
        loginUser.setId(user.getId());
        loginUser.setNickname(resolveNickname(user));
        loginUser.setPhone(trimToEmpty(user.getPhone()));
        loginUser.setAvatar(resolveAvatar(user));
        loginUser.setType(user.getType());
        loginUser.setStatus(user.getStatus());
        loginUser.setClinicId(user.getClinicId());
        loginUser.setMemberExpireAt(user.getMemberExpireAt());
        return loginUser;
    }

    /**
     * 校验手机号未被其他有效用户占用。
     */
    private void requirePhoneAvailable(String phone, Long currentUserId) {
        AppUser occupiedUser = userMapper.selectOne(new LambdaQueryWrapper<AppUser>()
                .eq(AppUser::getPhone, phone)
                .eq(AppUser::getDeleted, 0)
                .last("limit 1"));
        if (occupiedUser != null && !occupiedUser.getId().equals(currentUserId)) {
            throw new IllegalArgumentException("该手机号已注册");
        }
    }

    /**
     * 归一化昵称输入。
     */
    private String normalizeNickname(String nickname) {
        String normalized = trimToNull(nickname);
        if (normalized == null) {
            throw new IllegalArgumentException("请输入姓名");
        }
        return normalized;
    }

    /**
     * 校验头像图片大小与格式。
     */
    private void validateAvatarImage(MultipartFile file) {
        if (file == null || file.isEmpty()) {
            throw new IllegalArgumentException("请选择要上传的文件");
        }
        if (file.getSize() > AVATAR_MAX_SIZE) {
            throw new IllegalArgumentException("文件大小超出限制");
        }
        String contentType = file.getContentType();
        if (contentType == null || !ALLOWED_IMAGE_TYPES.contains(contentType)) {
            throw new IllegalArgumentException("仅支持 JPG、PNG、GIF、WebP 格式");
        }
    }

    /**
     * 归一化头像地址输入。
     */
    private String normalizeAvatar(String avatar) {
        return trimToNull(avatar);
    }

    /**
     * 归一化简介输入，允许为空。
     */
    private String normalizeIntro(String intro) {
        return trimToNull(intro);
    }

    /**
     * 归一化并校验手机号。
     */
    private String normalizePhone(String phone) {
        String normalized = trimToNull(phone);
        if (normalized == null || !PHONE_PATTERN.matcher(normalized).matches()) {
            throw new IllegalArgumentException("请输入正确的手机号");
        }
        return normalized;
    }

    /**
     * 归一化必填文本。
     */
    private String normalizeRequired(String value, String message) {
        String normalized = trimToNull(value);
        if (normalized == null) {
            throw new IllegalArgumentException(message);
        }
        return normalized;
    }

    /**
     * 归一化并校验密码规则。
     */
    private String normalizePassword(String password, String emptyMessage) {
        String normalized = trimToNull(password);
        if (normalized == null) {
            throw new IllegalArgumentException(emptyMessage);
        }
        if (!PASSWORD_PATTERN.matcher(normalized).matches()) {
            throw new IllegalArgumentException("密码需为8-32位，且包含数字、字母、符号至少2种");
        }
        return normalized;
    }

    /**
     * 归一化医生邀请码，非法时忽略以保持绑定手机号主流程可用。
     */
    private String normalizeInviteCode(String inviteCode) {
        String normalized = trimToNull(inviteCode);
        if (normalized == null) {
            return null;
        }
        String upperInviteCode = normalized.toUpperCase();
        return upperInviteCode.matches("^[A-Z0-9]{6}$") ? upperInviteCode : null;
    }

    /**
     * 校验通知时间仅允许使用页面固定选项。
     */
    private Integer normalizeAdvanceMinutes(Integer advanceMinutes) {
        if (advanceMinutes == null || !SUPPORTED_ADVANCE_MINUTES.contains(advanceMinutes)) {
            throw new IllegalArgumentException("通知时间不合法");
        }
        return advanceMinutes;
    }

    /**
     * 将微信性别值转换为本地性别枚举。
     */
    private Integer resolveWechatGender(Integer sex) {
        if (sex == null) {
            return null;
        }
        if (sex.intValue() == 1) {
            return 1;
        }
        if (sex.intValue() == 2) {
            return 0;
        }
        return null;
    }

    /**
     * 优先使用本地昵称，没有时回退微信昵称和手机号。
     */
    private String resolveNickname(AppUser user) {
        String nickname = trimToNull(user.getNickname());
        if (nickname != null) {
            return nickname;
        }
        String wechatNickname = trimToNull(user.getWechatNickname());
        if (wechatNickname != null) {
            return wechatNickname;
        }
        return trimToEmpty(user.getPhone());
    }

    /**
     * 优先使用本地头像，没有时回退微信头像。
     */
    private String resolveAvatar(AppUser user) {
        String avatar = trimToNull(user.getAvatar());
        if (avatar != null) {
            return avatar;
        }
        return trimToEmpty(user.getWechatAvatar());
    }

    /**
     * 将布尔值转换为数据库使用的 0/1。
     */
    private Integer booleanToInteger(Boolean value) {
        return Boolean.TRUE.equals(value) ? 1 : 0;
    }

    /**
     * 将数据库 0/1 转换为布尔值。
     */
    private Boolean integerToBoolean(Integer value) {
        return value != null && value.intValue() == 1;
    }

    /**
     * 将空白文本归一化为 null。
     */
    private String trimToNull(String value) {
        if (value == null) {
            return null;
        }
        String trimmed = value.trim();
        return trimmed.isEmpty() ? null : trimmed;
    }

    /**
     * 将可空文本转换为空字符串。
     */
    private String trimToEmpty(String value) {
        String normalized = trimToNull(value);
        return normalized == null ? "" : normalized;
    }
}