Refactoring Long Methods with the Extract Method Technique in Go

func (urs *UserRegistrationService) ProcessUserRegistration(userData UserData) RegistrationResponse {
    // TODO: Extract User Validation logic, not including the date logic
    // User validation
    if len(userData.Username) < 3 || len(userData.Username) > 20 {
        return RegistrationResponse{false, "Invalid username. Must be between 3 and 20 characters.", ""}
    }
    
    if !strings.Contains(userData.Email, "@") || !strings.Contains(userData.Email, ".") {
        return RegistrationResponse{false, "Invalid email format.", ""}
    }
    
    hasUpper, _ := regexp.MatchString(`[A-Z]`, userData.Password)
    hasNumber, _ := regexp.MatchString(`[0-9]`, userData.Password)
    hasSpecial, _ := regexp.MatchString(`[!@#$%^&*]`, userData.Password)

    if len(userData.Password) < 8 || !hasUpper || !hasNumber || !hasSpecial {
        return RegistrationResponse{false, "Password must be at least 8 characters and contain uppercase, number, and special character.", ""}
    }
    
    // Date validation
    birthDate, err := time.Parse("2006-01-02", userData.DateOfBirth)
    if err != nil {
        return RegistrationResponse{false, err.Error(), ""}
    }

    if birthDate.AddDate(18, 0, 0).After(time.Now()) || birthDate.AddDate(120, 0, 0).Before(time.Now()) {
        return RegistrationResponse{false, "Invalid date of birth or user must be 18+", ""}
    }
    
    // Address validation
    address := userData.Address
    // Street validation
    if strings.TrimSpace(address.Street) == "" || len(address.Street) < 5 {
        return RegistrationResponse{false, "Invalid street address", ""}
    }

    // City validation
    if strings.TrimSpace(address.City) == "" || len(address.City) < 2 {
        return RegistrationResponse{false, "Invalid city", ""}
    }

    // Country validation
    if strings.TrimSpace(address.Country) == "" || len(address.Country) < 2 {
        return RegistrationResponse{false, "Invalid country", ""}
    }

    // Postal code validation
    var postalCodeRegex = regexp.MustCompile(`^[A-Z0-9]{3,10}$`)
    if strings.TrimSpace(address.PostalCode) == "" || 
       !postalCodeRegex.MatchString(address.PostalCode) {
        return RegistrationResponse{false, "Invalid postal code", ""}
    } 
    
    // Transform and store data
    userId := fmt.Sprintf("USER_%x", time.Now().UnixNano())
    normalizedData := UserData{
        Username:    strings.ToLower(userData.Username),
        Email:       strings.ToLower(userData.Email),
        Password:    userData.Password,
        DateOfBirth: birthDate.Format("2006-01-02"),
        Address: Address{
            Street:    strings.TrimSpace(userData.Address.Street),
            City:      strings.TrimSpace(userData.Address.City),
            Country:   strings.ToUpper(strings.TrimSpace(userData.Address.Country)),
            PostalCode: strings.ToUpper(strings.TrimSpace(userData.Address.PostalCode)),
        },
    }
    urs.dataStore.Store(normalizedData)
    return RegistrationResponse{true, "User registered successfully", userId}
}