UserService.java

package com.gamzabat.algohub.feature.user.service;

import static com.gamzabat.algohub.constants.ApiConstants.*;

import java.security.SecureRandom;
import java.time.Duration;
import java.time.LocalDateTime;
import java.util.Base64;
import java.util.List;
import java.util.regex.Pattern;

import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.core.Authentication;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.HttpClientErrorException;
import org.springframework.web.client.HttpServerErrorException;
import org.springframework.web.client.RestClient;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;

import com.gamzabat.algohub.common.jwt.TokenProvider;
import com.gamzabat.algohub.common.jwt.dto.JwtDTO;
import com.gamzabat.algohub.common.jwt.dto.ReissueTokenRequest;
import com.gamzabat.algohub.common.logging.DiscordWebhookService;
import com.gamzabat.algohub.common.redis.RedisService;
import com.gamzabat.algohub.enums.EmailType;
import com.gamzabat.algohub.enums.ImageType;
import com.gamzabat.algohub.enums.Role;
import com.gamzabat.algohub.exception.UserValidationException;
import com.gamzabat.algohub.feature.group.studygroup.exception.CannotFoundUserException;
import com.gamzabat.algohub.feature.image.service.ImageService;
import com.gamzabat.algohub.feature.solution.repository.SolutionRepository;
import com.gamzabat.algohub.feature.user.domain.ResetPassword;
import com.gamzabat.algohub.feature.user.domain.User;
import com.gamzabat.algohub.feature.user.dto.DeleteUserRequest;
import com.gamzabat.algohub.feature.user.dto.EditUserPasswordRequest;
import com.gamzabat.algohub.feature.user.dto.GetSolutionCommentActivity;
import com.gamzabat.algohub.feature.user.dto.GetSolutionCommentActivityList;
import com.gamzabat.algohub.feature.user.dto.RegisterBjNickNameRequest;
import com.gamzabat.algohub.feature.user.dto.RegisterRequest;
import com.gamzabat.algohub.feature.user.dto.ResetPasswordRequest;
import com.gamzabat.algohub.feature.user.dto.SignInRequest;
import com.gamzabat.algohub.feature.user.dto.TokenResponse;
import com.gamzabat.algohub.feature.user.dto.UpdateUserRequest;
import com.gamzabat.algohub.feature.user.dto.UserInfoResponse;
import com.gamzabat.algohub.feature.user.exception.BOJServerErrorException;
import com.gamzabat.algohub.feature.user.exception.CheckBjNicknameValidationException;
import com.gamzabat.algohub.feature.user.exception.CheckEmailFormException;
import com.gamzabat.algohub.feature.user.exception.CheckNicknameValidationException;
import com.gamzabat.algohub.feature.user.exception.CheckPasswordFormException;
import com.gamzabat.algohub.feature.user.exception.InvalidDeleteUserRequestException;
import com.gamzabat.algohub.feature.user.exception.InvalidEmailException;
import com.gamzabat.algohub.feature.user.exception.ResetPasswordValidationError;
import com.gamzabat.algohub.feature.user.exception.UncorrectedPasswordException;
import com.gamzabat.algohub.feature.user.repository.ResetPasswordRepository;
import com.gamzabat.algohub.feature.user.repository.UserRepository;

import jakarta.servlet.http.HttpServletRequest;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
@RequiredArgsConstructor
public class UserService {
	private final UserRepository userRepository;
	private final PasswordEncoder passwordEncoder;
	private final ImageService imageService;
	private final TokenProvider tokenProvider;
	private final AuthenticationManagerBuilder authManager;
	private final RedisService redisService;
	private final RestTemplate restTemplate;
	private final ResetPasswordRepository resetPasswordRepository;
	private final EmailService emailService;
	private final DiscordWebhookService webhookService;
	private final SolutionRepository solutionRepository;
	private final RestClient.Builder builder;

	@Transactional
	public void register(RegisterRequest request, MultipartFile profileImage, String token) {

		String email = redisService.getValues(token);
		checkNickname(request.nickname());
		checkEmailForm(email);
		checkPasswordForm(request.password());
		validateBjNickname(request.bjNickname());

		String encodedPassword = passwordEncoder.encode(request.password());

		User user = userRepository.save(User.builder()
			.email(email)
			.password(encodedPassword)
			.nickname(request.nickname())
			.bjNickname(request.bjNickname())
			.role(Role.USER)
			.build());

		saveProfileImage(profileImage, user);
		log.info("success to register user_id={}", user.getId());

		webhookService.sendRegisterMessage(user.getNickname(), "SignUp", user.getId());
	}

	private void saveProfileImage(MultipartFile profileImage, User user) {
		String imagePrefix = imageService.createImagePrefix(user.getId(), user.getEmail());
		String imageUrl = imageService.saveImage(ImageType.USER, imagePrefix, profileImage);
		user.editProfileImage(imageUrl);
	}

	@Transactional
	public TokenResponse signIn(SignInRequest request) {

		UsernamePasswordAuthenticationToken authenticationToken
			= new UsernamePasswordAuthenticationToken(request.identifier(), request.password());
		Authentication authenticate;
		try {
			authenticate = authManager.getObject().authenticate(authenticationToken);
		} catch (BadCredentialsException e) {
			throw new UncorrectedPasswordException("비밀번호가 틀렸습니다.");
		}
		JwtDTO result = tokenProvider.generateTokens(authenticate);
		log.info("success to sign in identifier = {}", request.identifier());
		return new TokenResponse(result.getAccessToken(), result.getRefreshToken());
	}

	@Transactional(readOnly = true)
	public UserInfoResponse userInfo(User user) {
		return new UserInfoResponse(
			user.getEmail(),
			user.getNickname(),
			user.getProfileImage(),
			user.getBjNickname(),
			user.getGithubName(),
			user.getDescription());
	}

	@Transactional
	public void userUpdate(User user, UpdateUserRequest updateUserRequest, MultipartFile profileImage) {
		editUserProfileImage(user, profileImage, updateUserRequest.getIsDefaultImage());
		checkNickname(updateUserRequest.getNickname());

		if (updateUserRequest.getNickname() != null && !updateUserRequest.getNickname().isEmpty()) {
			user.editNickname(updateUserRequest.getNickname());
		}
		if (updateUserRequest.getBjNickname() != null && !updateUserRequest.getBjNickname().isEmpty()) {
			user.editBjNickname(updateUserRequest.getBjNickname());
		}
		if (updateUserRequest.getDescription() != null && !updateUserRequest.getDescription().isEmpty()) {
			user.editDescription(updateUserRequest.getDescription());
		}

		userRepository.save(user);
		log.info("success to update user user_id={}", user.getId());
	}

	private void editUserProfileImage(User user, MultipartFile inputImage, Boolean isDefaultImage) {
		if (inputImage != null) {
			if (user.getProfileImage() != null) {
				imageService.deleteImage(user.getProfileImage());
			}
			saveProfileImage(inputImage, user);
			log.info("success to update user profile image. profile image : {}", user.getProfileImage());
			return;
		}
		if (isDefaultImage) {
			handleNullInputImage(user);
		}

	}

	private void handleNullInputImage(User user) {
		if (user.getProfileImage() != null) {
			imageService.deleteImage(user.getProfileImage());
			user.editProfileImage(null);
		}
	}

	@Transactional
	public void deleteUser(User user, DeleteUserRequest deleteUserRequest) {
		if (user.getGithubName() != null) {
			validateOAuthUserRequest(deleteUserRequest);
		} else {
			validateNormalUserRequest(user, deleteUserRequest);
		}
		userRepository.delete(user);
		log.info("success to delete user user_id={}", user.getId());
	}

	private void validateOAuthUserRequest(DeleteUserRequest deleteUserRequest) {
		if (deleteUserRequest.password() != null) {
			throw new InvalidDeleteUserRequestException("소셜 로그인 회원의 비밀번호는 존재하지 않습니다.");
		}
	}

	private void validateNormalUserRequest(User user, DeleteUserRequest deleteUserRequest) {
		if (deleteUserRequest.password() == null) {
			throw new InvalidDeleteUserRequestException("일반 회원 탈퇴 시 비밀번호 입력이 필요합니다.");
		}
		if (!passwordEncoder.matches(deleteUserRequest.password(), user.getPassword())) {
			throw new UncorrectedPasswordException("비밀번호가 틀렸습니다.");
		}
	}

	@Transactional
	public void logout(HttpServletRequest request) {
		String accessToken = tokenProvider.resolveToken(request);
		long tokenExpiration = tokenProvider.getAccessTokenExpirationTime();
		redisService.setValues(accessToken, "logout", Duration.ofMillis(tokenExpiration));
		log.info("success to logout");
	}

	@Transactional
	public void editPassword(User user, EditUserPasswordRequest request) {
		if (!passwordEncoder.matches(request.currentPassword(), user.getPassword())) {
			throw new UncorrectedPasswordException("비밀번호가 틀렸습니다.");
		}

		String encodedPassword = passwordEncoder.encode(request.newPassword());
		user.editPassword(encodedPassword);

		userRepository.save(user);
		log.info("success to edit password user_id={}", user.getId());
	}

	@Transactional
	public void registerBjNickname(User user, RegisterBjNickNameRequest request) {
		validateBjNickname(request.bjNickName());
		user.editBjNickname(request.bjNickName());
		userRepository.save(user);
		log.info("success to register baekjoon-nickname user_id = {}", user.getId());
	}

	@Transactional(readOnly = true)
	public void checkBjNickname(String bjNickname) {
		validateBjNickname(bjNickname);
		log.info("success to check baekjoon nickname validity nickname = {}", bjNickname);
	}

	@Transactional
	public void deleteBjNickname(User user) {
		if (user.getBjNickname() == null) {
			throw new CheckBjNicknameValidationException(HttpStatus.BAD_REQUEST.value(), "백준 아이디가 등록되어 있지 않습니다.");
		}
		user.editBjNickname(null);
		userRepository.save(user);
		log.info("succes to delete user baekjoon nickname user_id = {}", user.getId());
	}

	@Transactional(readOnly = true)
	public void checkEmailDuplication(String email) {
		if (userRepository.existsByEmail(email))
			throw new UserValidationException("이미 사용 중인 이메일 입니다.");
		log.info("success to validity email = {}", email);
	}

	@Transactional(readOnly = true)
	public void checkNickname(String nickname) {
		if (nickname == null)
			return;

		if (isInvalidNicknameForm(nickname))
			throw new CheckNicknameValidationException(HttpStatus.BAD_REQUEST.value(),
				"닉네임은 영문과 숫자로 구성된 3~16글자여야 합니다.");

		if (userRepository.existsByNickname(nickname))
			throw new CheckNicknameValidationException(HttpStatus.CONFLICT.value(), "이미 사용 중인 닉네임입니다.");

		log.info("success to check nickname validity nickname={}", nickname);
	}

	@Transactional(readOnly = true)
	public UserInfoResponse otherUserInfo(String userNickname) {
		User targetUser = userRepository.findByNickname(userNickname)
			.orElseThrow(() -> new CannotFoundUserException(HttpStatus.NOT_FOUND.value(), "해당 유저는 존재하지 않습니다."));

		return new UserInfoResponse(targetUser.getEmail(), targetUser.getNickname(), targetUser.getProfileImage(),
			targetUser.getBjNickname(),
			targetUser.getGithubName(),
			targetUser.getDescription());
	}

	private boolean isInvalidNicknameForm(String nickname) {
		String regex = "[^a-zA-Z0-9]";
		return nickname.length() < 3 || nickname.length() > 16 || Pattern.compile(regex).matcher(nickname).find();
	}

	@Transactional
	public TokenResponse reissueToken(ReissueTokenRequest request) {
		String expiredToken = request.expiredAccessToken();
		String refreshToken = request.refreshToken();

		TokenResponse response = tokenProvider.reissueTokens(expiredToken, refreshToken);
		log.info("success to reissue tokens");
		return response;
	}

	@Transactional
	public void sendResetPasswordMail(String email) {
		User user = userRepository.findByEmail(email)
			.orElseThrow(() -> new CannotFoundUserException(HttpStatus.NOT_FOUND.value(), "존재하지 않는 이메일의 유저입니다."));
		String token = UserService.generateSecureToken();
		ResetPassword resetPassword = ResetPassword.builder()
			.user(user)
			.token(token)
			.build();
		resetPasswordRepository.save(resetPassword);
		log.info("success to create reset password token. Token: {}", resetPassword.getToken());

		emailService.sendVerificationMail(user.getEmail(), token, EmailType.RESET_PASSWORD).thenAccept(unused ->
			log.info("success to send reset password mail.")
		);
	}

	public void sendEmailVerificationMail(String email) {
		checkEmailDuplication(email);
		String token = UserService.generateSecureToken();
		log.info("success to create email verification token. Token: {}", token);
		redisService.setValues(token, email, Duration.ofMinutes(3));

		emailService.sendVerificationMail(email, token, EmailType.EMAIL_VALIDATION).thenAccept(unused ->
			log.info("success to send email validation mail.")
		).exceptionally(e -> {
			redisService.deleteValues(token);
			return null;
		});
	}

	@Transactional
	public void resetPassword(ResetPasswordRequest request) {
		ResetPassword resetPassword = getValidatedResetPassword(request.token());
		checkPasswordForm(request.password());

		String encodedPassword = passwordEncoder.encode(request.password());
		resetPassword.getUser().editPassword(encodedPassword);
		resetPassword.makeDone();
		log.info("success to reset password.");
	}

	@Transactional
	public GetSolutionCommentActivityList getSolutionCommentActivity(User user) {
		List<GetSolutionCommentActivity> solutionCommentActivityList = solutionRepository.findFeedSolutionsByUserOrdered(user);
		GetSolutionCommentActivityList response = GetSolutionCommentActivityList.builder().solutionCommentActivityList(solutionCommentActivityList).build();
		return response;
	}

	public void validateResetPasswordToken(String token) {
		this.getValidatedResetPassword(token);
	}

	private ResetPassword getValidatedResetPassword(String token) {
		ResetPassword resetPassword = resetPasswordRepository.findByToken(token)
			.orElseThrow(() -> new ResetPasswordValidationError(HttpStatus.BAD_REQUEST.value(), "유효하지 않은 요청입니다."));
		if (resetPassword.getExpiredAt().isBefore(LocalDateTime.now()))
			throw new ResetPasswordValidationError(HttpStatus.GONE.value(), "기한이 만료된 비밀번호 수정 요청입니다.");
		if (resetPassword.getDone())
			throw new ResetPasswordValidationError(HttpStatus.CONFLICT.value(), "이미 수정이 완료된 요청입니다.");
		return resetPassword;
	}

	private void checkEmailForm(String email) {
		if (!isValidEmailForm(email))
			throw new CheckEmailFormException(HttpStatus.BAD_REQUEST.value(), "이메일 형식이 아닙니다");
	}

	private boolean isValidEmailForm(String email) {

		String EMAIL_REGEX = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"; // 문자 사이에 @를 포함하고 최상위 도메인은 2글자 이상이어야 함
		Pattern EMAIL_PATTERN = Pattern.compile(EMAIL_REGEX);

		if (email == null || email.isEmpty()) {
			return false;
		}
		return EMAIL_PATTERN.matcher(email).matches();
	}

	private void checkPasswordForm(String password) {
		if (!isValidPasswordForm(password))
			throw new CheckPasswordFormException(HttpStatus.BAD_REQUEST.value(), "올바르지 않은 비밀번호 형식입니다");
	}

	private boolean isValidPasswordForm(String password) {

		String passwordPattern = "^(?=.*[A-Za-z])(?=.*\\d)(?=.*[~!@#$%^&*])[A-Za-z\\d~!@#$%^&*]{8,15}$"; // 영문,숫자,특수문자 만으로 이루어져야 하며 모두 포함하여야 하고 8~15글자 사이여야 함

		if (password == null || password.isEmpty()) {
			return false;
		}
		return password.matches(passwordPattern);

	}

	private static String generateSecureToken() {
		final int TOKEN_LENGTH = 32;
		byte[] bytes = new byte[TOKEN_LENGTH];
		new SecureRandom().nextBytes(bytes);
		return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
	}

	public void checkEmailVerification(String token) {
		boolean isTokenExist = redisService.checkExistsValue(token);

		if (!isTokenExist) {
			throw new InvalidEmailException("토큰이 유효하지 않습니다.");
		}

		String email = redisService.getValues(token);

		redisService.deleteValues(token);
		redisService.setValues(token, email, Duration.ofMinutes(30));
	}

	private void validateBjNickname(String bjNickname) {

		String bjUserUrl = BOJ_USER_PROFILE_URL + bjNickname;

		HttpHeaders headers = new HttpHeaders();
		headers.set("User-Agent",
			"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36");
		HttpEntity<String> entity = new HttpEntity<>(headers);

		try {
			restTemplate.exchange(bjUserUrl, HttpMethod.GET, entity, String.class);
			// TODO : 백준 본인 인증 관련 사항 확정 후 로직 수정
			// if (userRepository.existsByBjNickname(bjNickname))
			// 	throw new CheckBjNicknameValidationException(HttpStatus.CONFLICT.value(), "이미 가입된 백준 닉네임 입니다.");
		} catch (HttpClientErrorException e) {
			if (e.getStatusCode() == HttpStatus.NOT_FOUND)
				throw new CheckBjNicknameValidationException(HttpStatus.NOT_FOUND.value(), "백준 닉네임이 유효하지 않습니다.");
		} catch (HttpServerErrorException e) {
			log.error("BOJ server error occurred : " + e.getMessage());
			throw new BOJServerErrorException("현재 백준 서버 오류가 발생했습니다. 잠시 후 다시 시도해주세요.");
		}

	}
}