const _deleteOneToOneRooms = function(userId, teamMembers) {
  return function() {
    return User.findOne({ _id: userId })
    .then((userDeleted) => {
      return Promise.all(teamMembers.map((member) => {
        return User.findOne({ _id: member }).then((user) => {
          return {
            id: user._id,
            commonTeams: Utils.arrayIntersect(user.teams, userDeleted.teams).length !== 0
          };
        });
      }))
      .then((usersNoCommonTeam) => {
        return Promise.all(usersNoCommonTeam.map((user) => {
          if(user.commonTeams) {
            return Promise.resolve();
          }
          return Room.findOneAndRemove(
            {
              $and: [
                { type: 'one-to-one' },
                { owners: { $all: [user.id, userDeleted] } }
              ]
            });
        }));
      });
    })
    .then((roomsToDelete) => {
      return Promise.all(roomsToDelete.map((room) => {
        if(room) {
          return Membership.remove({ room: room._id });
        }
        return Promise.resolve();
      }));
    });
  };
};

someDatabaseLookups.then(_deleteOneToOneRooms(userId, teamMembers))

const _deleteOneToOneRooms = function(userId, teamMembers) {
  return function() {
     return User.findOne({ _id: userId })
     .then((deletedUser) => {
       return _getUsersWithNoCommonTeams(deletedUser, teamMembers);
     })
     .then((usersNoCommonTeam) => {
       return _getOneToOneRooms(userId, usersNoCommonTeam);
     })
     .then(_removeRooms);
  };
};

const _deleteOneToOneRooms = function(userId, teamMembers) {
  return async function() {
     let deletedUser = await User.findOne({ _id: userId });
     let usersNoCommonTeam = await _getUsersWithNoCommonTeams(deletedUser, teamMembers);
     return await _getOneToOneRooms(userId, usersNoCommonTeam);
  };
};

return Promise.all(teamMemberIds.map(teamMemberId => {
  return User.findOne({ _id: teamMemberId }).then(user => ({
    id: user._id,
    commonTeams: Utils.arrayIntersect(user.teams, deletedUser.teams).length !== 0
  }))
})

return Promise.all(teamMembers.map(teamMember => {
  return teamMember.commonTeams ? Promise.resolve() : Room.findOneAndRemove({
    $and: [
      { type: 'one-to-one' },
      { owners: { $all: [teamMember.id, deletedUser] } }
    ]
  })
})

return Promise.all(roomsToDelete.map(room => {
  return room ? Membership.remove({ room: room._id }) : Promise.resolve()
}))

const _deleteOneToOneRooms = function (userId, teamMemberIds) {
  return User.findOne({ _id: userId }).then(deletedUser => {
    return Promise.all(teamMemberIds.map(teamMemberId => {
      return User.findOne({ _id: teamMemberId }).then(user => ({
        id: user._id,
        commonTeams: Utils.arrayIntersect(user.teams, deletedUser.teams).length !== 0
      }))
    })).then((teamMembers) => {
      return Promise.all(teamMembers.map(teamMember => {
        return teamMember.commonTeams ? Promise.resolve() : Room.findOneAndRemove({
          $and: [
            { type: 'one-to-one' },
            { owners: { $all: [teamMember.id, deletedUser] } }
          ]
        })
      }))
    })
  }).then(roomsToDelete => {
    return Promise.all(roomsToDelete.map(roomToDelete => {
      return roomToDelete ? Membership.remove({ room: roomToDelete._id }) : Promise.resolve()
    }))
  })
}