Refactoring Long Methods in C++ for Improved Code Maintenance and Readability

#include <iostream>
#include <regex>
#include <string>
#include <stdexcept>
#include <ctime>

struct UserData {
    std::string username;
    std::string email;
    std::string password;
    std::string dateOfBirth;
    struct Address {
        std::string street;
        std::string city;
        std::string country;
        std::string postalCode;
    } address;
};

struct RegistrationResponse {
    bool success;
    std::string message;
    std::string userId;
};

class IDataStore {
public:
    virtual void store(const UserData& userData) = 0;
    virtual ~IDataStore() = default;
};

class UserRegistrationService {
private:
    IDataStore* dataStore;

public:
    UserRegistrationService(IDataStore* dataStore) : dataStore(dataStore) {}

    RegistrationResponse processUserRegistration(const UserData& userData) {
        try {
            // User validation
            if (userData.username.empty() || userData.username.length() < 3 || userData.username.length() > 20) {
                return {"Invalid username. Must be between 3 and 20 characters.", false, ""};
            }

            if (userData.email.empty() || userData.email.find('@') == std::string::npos || userData.email.find('.') == std::string::npos) {
                return {"Invalid email format.", false, ""};
            }

            if (userData.password.empty() || userData.password.length() < 8 ||
                !std::regex_search(userData.password, std::regex("[A-Z]")) ||
                !std::regex_search(userData.password, std::regex("[0-9]")) ||
                !std::regex_search(userData.password, std::regex("[!@#$%^&*]"))) {
                return {"Password must be at least 8 characters and contain uppercase, number, and special character.", false, ""};
            }

            // Date validation
            std::tm tm = {};
            std::istringstream ss(userData.dateOfBirth);
            ss >> std::get_time(&tm, "%Y-%m-%d");
            if (ss.fail()) {
                throw std::runtime_error("Date parsing error");
            }
            std::time_t t = std::time(nullptr);
            std::tm* now = std::localtime(&t);
            int age = now->tm_year + 1900 - tm.tm_year;
            if (age < 18 || age > 120) {
                return {"Invalid date of birth or user must be 18+", false, ""};
            }

            // Address validation
            if (userData.address.street.empty() || userData.address.street.length() < 5) {
                return {"Invalid street address", false, ""};
            }
            if (userData.address.city.empty() || userData.address.city.length() < 2) {
                return {"Invalid city", false, ""};
            }
            if (userData.address.country.empty() || userData.address.country.length() < 2) {
                return {"Invalid country", false, ""};
            }
            if (userData.address.postalCode.empty() || !std::regex_match(userData.address.postalCode, std::regex("^[A-Z0-9]{3,10}$"))) {
                return {"Invalid postal code", false, ""};
            }

            // Data transformation
            std::string userId = "USER_" + std::to_string(std::rand() % 100000000);
            UserData normalizedData = userData;
            std::transform(normalizedData.username.begin(), normalizedData.username.end(), normalizedData.username.begin(), ::tolower);
            std::transform(normalizedData.email.begin(), normalizedData.email.end(), normalizedData.email.begin(), ::tolower);

            dataStore->store(normalizedData);

            return {"User registered successfully", true, userId};
        }
        catch (const std::exception& e) {
            return {"Registration failed: " + std::string(e.what()), false, ""};
        }
    }
};