Clean Architecture: How to reduce complexity when writing application business rules?

Let’s assume we have the following “Create User” scenario:

1. Users can signup to the application using Facebook, Google+ or LinkedIn;
2. The backend should retrieve some basic profile information in order to register the user(email, firstName and lastName);
3. Users are registered with a “client Id” (Just adding complexity to the business rule);
4. When a signup process is done the data should be sent to a notification topic.

I can imagine a create user request with the following structure:

{
  "clientId": "someClientId",
  "authProvider": "FACEBOOK | GOOGLE | LINKEDIN",
  "accessToken": "someAccessToken"
}

So, thinking about the registration/validation flow we would have:

1. Check if the create user request is valid;
2. Check if the clientId is valid;
3. Try to retrieve the profile information from the social network api;
4. Check if all the required profile information is filled;
5. Check if the user exists in the database;
6. Register the user;
7. Send the data to the notification topic;
8. Pass the data to the presenter.

Jumping straight to the use case, we would have a constructor like:

CreateUserUseCase(
    ApplicationClientGateway applicationClientGateway, 
    SocialNetworkGateway socialNetworkGateway,
    UserGateway userGateway,
    NotificationGateway notificationGateway,
    Presenter presenter
)

and an execute method:

execute(CreateUserRequest request)

    // validates the payload
    // something like
    if (request == null)
      presenter.setError(someError);

    // validates the clientId
    applicationClientGateway.findById(request.getClientId())    

    // retrieves the profile information
    // how to inject dinamically the implementation for
    // Facebook, Google or LinkeIn based on a request parameter?
    profile = socialNetworkGateway.findByAccessToken(request.getAccessToken());

    // checks if the user exists
    userGateway.findByEmailAndAuthProvider(profile.getEmail(), request.getAuthProvider());

    //register the user
    userGateway.insert(user);

    //sends the notification
    notificationGateway.send(user);

    // sets the result
    presenter.setResult(user);

Now, we have a constructor with lots of arguments(code smells?) and at least 5 validation steps in the execute method.

It looks like a violation of the SRP, so, how can we decompose this code in order to reduce complexity in the interactor?