How do I balance a large AVL tree?

I am trying to relearn how to balance AVL trees. After watching many tutorials, I thought I got the gist of it, but then I came across a particular scenario and now I'm stumped.

I am building an AVL tree using the numbers 5, 2, 3, 9, 4, 1, 6, 8, 10, 7, inserted in that order. The tree balances without any issues all the way up to 10, but my algorithm cannot balance the tree after adding 7. Here is what the tree looks like before I balance it after adding 7:

    3
  ┌─┴──┐
  2    8 <-- Unbalanced subtree
┌─┘  ┌─┴──┐
1    5    9
    ┌┴─┐  └─┐
    4  6   10
       └─┐
         7 <-- Node causing the tree to be unbalanced 

I know from using USFCA's AVL Tree Visualizer that my tree is suppose to look like this after I balance it, but I do not know how to achieve this result:

      5
   ┌──┴───┐
   3      8
  ┌┴─┐  ┌─┴──┐
  2  4  6    9
┌─┘     └─┐  └─┐
1         7   10

This tutorial indicates that I should perform a left-right rotation on 8, which results in something inconsistent with the desired result:

     8
   ┌─┴──┐
   3    9
  ┌┴─┐  └─┐
  2  4   10
┌─┘  └─┐
1      5
       └─┐
         6
         └─┐
           7

This is the logic I am using to determine which rotations to use for a given node (let me know if I should include the code for my rotate methods - I am not sure if it is necessary for an MCVE):

private void balance(Node node) {
	if (node == null)
		return;

	int balanceFactor = balanceFactor(node);
	if (balanceFactor > 1) {
        // Left subtree is heavier
		balanceFactor = balanceFactor(node.left);
		if (balanceFactor > 0) {
			rightRotate(node.left.left);
		} else {
			leftRotate(node.left.right);
			rightRotate(node.left);
		}
	} else if (balanceFactor < -1) {
        // Right subtree is heavier
		balanceFactor = balanceFactor(node.right);
		if (balanceFactor > 0) {
			leftRotate(node.right);
			rightRotate(node.right.left);
		} else {
			leftRotate(node.right);
		}
	}

	balance(node.parent);
}

It would seem to me that the logic works well until the root node becomes right-heavy.

What do I need to do differently to balance this tree?

The code block for the case where balanceFactor < -1 should mirror the other block in terms of left/right and balance factor comparisons. This is currently not the case. So change it to:

} else if (balanceFactor < -1) {
    // Right subtree is heavier
    balanceFactor = balanceFactor(node.right);
    if (balanceFactor <= 0) {
        leftRotate(node.right.right);
    } else {
        rightRotate(node.right.left);
        leftRotate(node.right);
    }
}

Note that I used <=. This can also be done in the first case (>=), as even when the balance factor at the child is zero, you can suffice with one rotation.

See also Wikipedia on rebalancing. Be aware that they use an opposite sign for the balance factor.

According to wikipedia you have to use a double rotation because the inner subtree of 8 is the longest.

So you have

       3
 ...         8
          5     ...
       longest

After the double rotation, 5 have resp. 3 and 8 for its children, and the
right child branch of 5 becomes the left child branch of 3, and the same the left child branch of 5 becomes the right child branch of 8. Which gives:

         5
    3          8
  2   4    6     9
1            7     10

Win! After the double rotation the tree is AVL balanced....