I am trying to create a leaning mechanic for an FPS game but I have one problem

Hello,

I have some code for a FPS leaning mechanic but there is one issue with it.

I am using the lerp function to smooth the leaning which is controlled by some bools. When the player leans in a direction, once they let go of the lean key, it is supposed to go into a 'recovery' phase before they can lean in the other direction. This is to smooth the camera back to the middle position so it doesn't just snap to the other side instantly.

This works but the issue is that if the player is leaned totally in one direction and then without releasing the lean key and they press the other lean key, it instantly snaps the camera to the opposite lean position without the 'recovery' bool being activated

Code:

 public class CameraLean : MonoBehaviour
 {
 
     public Vector3 defaultRotation;
     public Vector3 targetRotation;
     public float leanAmount = 20f;
     public Vector3 defaultPosition;
     public Vector3 targetPosition;
     public float offsetX = 0.35f;
     public float offsetY = 0.05f;
     public float speed;
     public bool leaningRight;
     public bool leaningLeft;
     public bool recovering;
     [Range(0,1)] public float perc;
 
     // Start is called before the first frame update
     void Start()
     {
         defaultPosition = new Vector3(0, 1.75f, 0);
         defaultRotation = Vector3.zero;
     }
 
     // Update is called once per frame
     void Update()
     {
         //Input
         if (!recovering)
         {
             if (!leaningRight)
             {
                 leaningLeft = Input.GetKey(KeyCode.Q);
             }
             if (!leaningLeft)
             {
                 leaningRight = Input.GetKey(KeyCode.E);
             }
         }
         //Leaning
         if (leaningLeft && !recovering)
         {
             targetRotation = new Vector3(defaultRotation.x, defaultRotation.y, defaultRotation.z + leanAmount);
             targetPosition = new Vector3(defaultPosition.x + -offsetX, defaultPosition.y - offsetY, defaultPosition.z);
             perc += Time.deltaTime * speed;
             perc = Mathf.Clamp(perc, 0, 1);
         }
         if (leaningRight && !recovering)
         {
             targetRotation = new Vector3(defaultRotation.x, defaultRotation.y, defaultRotation.z - leanAmount);
             targetPosition = new Vector3(defaultPosition.x + offsetX, defaultPosition.y - offsetY, defaultPosition.z);
             perc += Time.deltaTime * speed;
             perc = Mathf.Clamp(perc, 0, 1);
         }
         //Not leaning
         if (!leaningLeft && !leaningRight)
         {
             if (perc > 0)
             {
                 recovering = true;
             }
             else
             {
                 recovering = false;
             }
             perc -= Time.deltaTime * speed;
             perc = Mathf.Clamp(perc, 0, 1);
         }
         //Apply Rotation
         transform.localEulerAngles = Vector3.Lerp(defaultRotation, targetRotation, perc);
         //Apply Translation
         transform.localPosition = Vector3.Lerp(defaultPosition, targetPosition, perc);
     }
 }

Would anyone be able to explain why this is behaving like this? Or if there is a better solution?

Thanks