// LoginRequest.java
public record LoginRequest(
    @Email @NotBlank String email,
    @NotBlank String password,
    @NotNull String fcmToken
) {}

// SignUpRequest.java
public record SignUpRequest(
    @NotBlank String name,
    @Email @NotBlank String email,
    @NotBlank String password,
    @NotNull Gender gender,
    String patientCode
) {}

// UpdateProfileRequest.java
public record UpdateProfileRequest(
    @NotBlank String name,
    @NotNull Gender gender,
    String currentPassword,
    String newPassword
    ) {
        @AssertTrue(message = "currentPassword is required when newPassword is provided")
        public boolean isPasswordChangeValid() {
            if (newPassword == null || newPassword.isBlank()) return true;
            return currentPassword != null && !currentPassword.isBlank();
        }
    }
}

// LoginResponse.java
public record LoginResponse(String accessToken, String refreshToken) {}

// ProfileResponse.java
public record ProfileResponse(
    String userId,
    String name,
    String email,
    Gender gender,
    String imageUrl,
    String patientCode
    ) {
        public static ProfileResponse create(User user, String imageUrl) {
        return new ProfileResponse(
        user.getUserId(),
        user.getName(),
        user.getEmail(),
        user.getGender(),
        imageUrl,
        user.getPatientCode()
        );
    }
}

// Gender.java
public enum Gender { MALE, FEMALE }

// Role.java
@Getter
public enum Role {
    GUARDIAN("ROLE_GUARDIAN"),
    PATIENT("ROLE_PATIENT");
    private final String name;
    Role(String name) { this.name = name; }
}

// User.java
@Entity
@Table(name = "users")
@Getter
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User extends BaseEntity {
    @Id @Tsid
    private String userId;
    private String name;
    @Column(nullable = false)
    private String email;
    @Column(nullable = false)
    private String password;
    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Role role;
    private String patientCode;
    @Enumerated(EnumType.STRING)
    private Gender gender;
    
    public void updateRole(Role role) {
        this.role = role;
    }
    public void updateProfile(String name, Gender gender, String encodedNewPassword) {
        this.name = name;
        this.gender = gender;
        if (encodedNewPassword != null && !encodedNewPassword.isBlank()) {
            this.password = encodedNewPassword;
        }
    }
}

// UserRepository.java
public interface UserRepository extends JpaRepository<User, String> {

    @Query("select count(u) > 0 from User u where u.email = :email")
    Boolean existsByEmail(@Param("email") String email);

    @Query("select u from User u where u.email = :email")
    Optional<User> findByEmail(@Param("email") String email);

    @Query("select u from User u where u.patientCode = :patientCode")
    Optional<User> findByPatientCode(@Param("patientCode") String patientCode);
}

// UserService.java (발췌)
@Service
@RequiredArgsConstructor
public class UserService {
    private static final Logger log = LoggerFactory.getLogger(UserService.class);
    private final UserRepository userRepository;
    private final PasswordEncoder passwordEncoder;
    private final ImageService imageService;

    public boolean isAlreadyRegistered(String email) {
        return userRepository.existsByEmail(email);
    }
    
    public User save(SignUpRequest req, String code) {
        return userRepository.save(
        User.builder()
            .email(req.email())
            .password(passwordEncoder.encode(req.password()))
            .role(req.patientCode() == null ? Role.PATIENT : Role.GUARDIAN)
            .patientCode(code)
            .gender(req.gender())
            .name(req.name())
            .build()
        );
    }
    
    public ProfileResponse findProfile(String userId) {
        return userRepository.findById(userId)
            .map(u -> ProfileResponse.create(u, imageService.getProfileImageUrl(u)))
            .orElseThrow(() -> new RestApiException(_NOT_FOUND));
    }
}

// UpdateProfileUseCase.java (발췌)
@Service
@Transactional
@RequiredArgsConstructor
public class UpdateProfileUseCase {
    private final UserService userService;
    private final PasswordEncoder passwordEncoder;
    private final ImageService imageService;

    @UseCaseMetric(domain = "user-profile", value = "update-profile", type = "command")
    public ProfileResponse update(String userId, UpdateProfileRequest req) {
        User user = userService.findUser(userId);
        String encodedNewPassword = null;
        
        if (req.newPassword() != null && !req.newPassword().isBlank()) {
            boolean matches = passwordEncoder.matches(req.currentPassword(), user.getPassword());
            if (!matches) {
                log.warn("[UpdateProfile] password mismatch: userId={}", userId);
                throw new RestApiException(_UNAUTHORIZED);
            }
            encodedNewPassword = passwordEncoder.encode(req.newPassword());
        }
    
        user.updateProfile(req.name(), req.gender(), encodedNewPassword);
        return ProfileResponse.create(user, imageService.getProfileImageUrl(user));
    }
}
    
// UserAuthUseCase.login(...) (발췌)
public LoginResponse login(LoginRequest req) {
    User user = userService.findByEmail(req.email());
    if (!passwordEncoder.matches(req.password(), user.getPassword())) {
        throw new RestApiException(LOGIN_ERROR);
    }
    String at = tokenProvider.createAccessToken(user.getUserId(), user.getRole());
    String rt = tokenProvider.createRefreshToken(user.getUserId(), user.getRole());
    Duration exp = tokenProvider.getRemainingDuration(rt)
        .orElseThrow(() -> new RestApiException(EXPIRED_MEMBER_JWT));
    refreshTokenService.saveRefreshToken(user.getUserId(), rt, exp);
    fcmTokenService.upsert(user, req.fcmToken());
    return new LoginResponse(at, rt);
}

// AuthController.java (발췌)
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/users")
public class AuthController {

    private final UserAuthUseCase userAuthUseCase;

    @PostMapping("/sign-up")
    public BaseResponse<Void> signUp(@Valid @RequestBody SignUpRequest req) {
        userAuthUseCase.signUp(req);
        return BaseResponse.onSuccess();
    }
    
    @PostMapping("/login")
    public BaseResponse<LoginResponse> login(@Valid @RequestBody LoginRequest req) {
        return BaseResponse.onSuccess(userAuthUseCase.login(req));
    }
    
    @DeleteMapping("/logout")
    public BaseResponse<Void> logout(HttpServletRequest request) {
        userAuthUseCase.logout(request);
        return BaseResponse.onSuccess();
    }
}

// UserController.java (발췌)
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/users")
@SecurityRequirement(name = "Bearer Authentication")
public class UserController {

    private final UserProfileUseCase userProfileUseCase;
    private final UpdateProfileUseCase updateProfileUseCase;
    
    @GetMapping("/profile")
    public BaseResponse<ProfileResponse> getProfile(@CurrentUser String userId) {
        return BaseResponse.onSuccess(userProfileUseCase.findProfile(userId));
    }
    
    @PatchMapping("/profile")
    public BaseResponse<ProfileResponse> updateProfile(
        @CurrentUser String userId,
        @Valid @RequestBody UpdateProfileRequest req
    ) {
        return BaseResponse.onSuccess(updateProfileUseCase.update(userId, req));
    }
}

// TokenController.java (발췌)
@RestController
@RequiredArgsConstructor
@RequestMapping("/api/token")
@SecurityRequirement(name = "Bearer Authentication")
public class TokenController {

    private final TokenReissueService tokenReissueService;
    
    @PostMapping
    public BaseResponse<TokenReissueResponse> reissue(
        @RefreshToken String refreshToken,
        @CurrentUser String userId
    ) {
        return BaseResponse.onSuccess(tokenReissueService.reissue(refreshToken, userId));
    }
}