package com.example.registration;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

public class UserRegistrationServiceTest {

  @Mock private UserRepository userRepository;
  @Mock private PasswordHasher passwordHasher;

  private UserRegistrationService registrationService;

  @BeforeEach
  void setUp() {
    MockitoAnnotations.openMocks(this);
    registrationService = new UserRegistrationService(userRepository, passwordHasher);
  }
}

@Test
void shouldRegisterUserWithValidEmailAndPassword() {
  String email = "[email protected]";
  String password = "SecurePass123";
  String hashedPassword = "hashed_password_here";

  when(userRepository.existsByEmail(email)).thenReturn(false);
  when(passwordHasher.hash(password)).thenReturn(hashedPassword);

  RegistrationResult result = registrationService.registerUser(email, password);

  assertTrue(result.isSuccess());
  assertNull(result.getErrorMessage());
  verify(userRepository).save(any(User.class));
}

@Test
void shouldRejectInvalidEmailFormat() {
  String invalidEmail = "not-an-email";
  String password = "ValidPass123";

  RegistrationResult result = registrationService.registerUser(invalidEmail, password);

  assertFalse(result.isSuccess());
  assertEquals("Invalid email format", result.getErrorMessage());
  verify(userRepository, never()).save(any(User.class));
}

// Các test khác tương tự như kiểm tra email trùng, mật khẩu yếu, hash mật khẩu trước khi lưu...

public class RegistrationResult {
  private final boolean success;
  private final String errorMessage;

  private RegistrationResult(boolean success, String errorMessage) {
    this.success = success;
    this.errorMessage = errorMessage;
  }

  public static RegistrationResult success() { return new RegistrationResult(true, null); }
  public static RegistrationResult failure(String errorMessage) { return new RegistrationResult(false, errorMessage); }
  public boolean isSuccess() { return success; }
  public String getErrorMessage() { return errorMessage; }
}

package com.example.registration;

import java.util.regex.Pattern;

public class UserRegistrationService {

  private static final Pattern EMAIL_PATTERN = Pattern.compile("^[A-Za-z0-9+_.-]+@([A-Za-z0-9.-]+\\.[A-Za-z]{2,})$");
  private static final Pattern PASSWORD_PATTERN = Pattern.compile("^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,}$");

  private final UserRepository userRepository;
  private final PasswordHasher passwordHasher;

  public UserRegistrationService(UserRepository userRepository, PasswordHasher passwordHasher) {
    this.userRepository = userRepository;
    this.passwordHasher = passwordHasher;
  }

  public RegistrationResult registerUser(String email, String password) {
    if (!isValidEmail(email)) {
      return RegistrationResult.failure("Invalid email format");
    }

    if (userRepository.existsByEmail(email)) {
      return RegistrationResult.failure("Email already registered");
    }

    if (!isValidPassword(password)) {
      return RegistrationResult.failure("Password must be at least 8 characters with uppercase, lowercase, and number");
    }

    String hashedPassword = passwordHasher.hash(password);
    userRepository.save(new User(email, hashedPassword));
    return RegistrationResult.success();
  }

  private boolean isValidEmail(String email) {
    return email != null && EMAIL_PATTERN.matcher(email).matches();
  }

  private boolean isValidPassword(String password) {
    return password != null && PASSWORD_PATTERN.matcher(password).matches();
  }
}

public class EmailValidator {
  private static final Pattern EMAIL_PATTERN = Pattern.compile("^[A-Za-z0-9+_.-]+@([A-Za-z0-9.-]+\\.[A-Za-z]{2,})$");

  public ValidationResult validate(String email) {
    if (email == null || email.trim().isEmpty()) {
      return ValidationResult.invalid("Email is required");
    }
    if (!EMAIL_PATTERN.matcher(email).matches()) {
      return ValidationResult.invalid("Invalid email format");
    }
    return ValidationResult.valid();
  }
}

public class UserRegistrationService {
  private final UserRepository userRepository;
  private final PasswordHasher passwordHasher;
  private final EmailValidator emailValidator;
  private final PasswordValidator passwordValidator;

  public UserRegistrationService(UserRepository userRepository, PasswordHasher passwordHasher,
                                 EmailValidator emailValidator, PasswordValidator passwordValidator) {
    this.userRepository = userRepository;
    this.passwordHasher = passwordHasher;
    this.emailValidator = emailValidator;
    this.passwordValidator = passwordValidator;
  }

  public RegistrationResult registerUser(String email, String password) {
    ValidationResult emailValidation = emailValidator.validate(email);
    if (!emailValidation.isValid()) {
      return RegistrationResult.failure(emailValidation.getErrorMessage());
    }

    if (userRepository.existsByEmail(email)) {
      return RegistrationResult.failure("Email already registered");
    }

    ValidationResult passwordValidation = passwordValidator.validate(password);
    if (!passwordValidation.isValid()) {
      return RegistrationResult.failure(passwordValidation.getErrorMessage());
    }

    String hashedPassword = passwordHasher.hash(password);
    userRepository.save(new User(email, hashedPassword));
    return RegistrationResult.success();
  }
}

@Test
void shouldRejectNullEmail() {
  RegistrationResult result = registrationService.registerUser(null, "ValidPass123");

  assertFalse(result.isSuccess());
  assertEquals("Email is required", result.getErrorMessage());
}

@Test
void shouldRejectEmptyPassword() {
  RegistrationResult result = registrationService.registerUser("[email protected]", "");

  assertFalse(result.isSuccess());
  assertEquals("Password must be at least 8 characters", result.getErrorMessage());
}

@Test
void shouldHandleRepositoryExceptions() {
  String email = "[email protected]";
  String password = "ValidPass123";

  when(userRepository.existsByEmail(email)).thenReturn(false);
  when(passwordHasher.hash(password)).thenReturn("hashed");
  doThrow(new RuntimeException("Database error")).when(userRepository).save(any(User.class));

  assertThrows(RuntimeException.class, () -> {
    registrationService.registerUser(email, password);
  });
}