How to make wall jump work.

So i've got this script from an tutorial on YouTube. I've made some changes to it so that the player walks automatically and walks in the opposite direction once it hits a wall. I want the gameplay to be that you only need to jump and avoid traps etc. So now I wanted to add wall jump but I don't seem to get it working. Since the player starts walking in the opposite direction it doesn't stick to a wall. I want it to be that if the player jumps against a wall it sticks to the wall so you can jump. But if the player is walking against a wall it still changes direction. Here's my script:

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 
 public class PlayerController : MonoBehaviour
 {
 
     private float movementInputDirection;
     private float jumpTimer;
     private float turnTimer;
     private float wallJumpTimer;
 
     private int amountOfJumpsLeft;
     private int facingDirection = 1;
     private int lastWallJumpDirection;
 
     private bool isFacingRight = true;
     private bool isGrounded;
     private bool isTouchingWall;
     private bool isWallSliding;
     private bool canNormalJump;
     private bool canWallJump;
     private bool isAttemptingToJump;
     private bool checkJumpMultiplier;
     private bool canMove;
     private bool canFlip;
     private bool hasWallJumped;
 
     private Rigidbody2D rb;
     private Animator anim;
 
     public int amountOfJumps = 1;
 
     public float movementSpeed = 10.0f;
     public float jumpForce = 16.0f;
     public float groundCheckRadius;
     public float wallCheckDistance;
     public float wallSlideSpeed;
     public float movementForceInAir;
     public float airDragMultiplier = 0.95f;
     public float variableJumpHeightMultiplier = 0.5f;
     public float wallHopForce;
     public float wallJumpForce;
     public float jumpTimerSet = 0.15f;
     public float turnTimerSet = 0.1f;
     public float wallJumpTimerSet = 0.5f;
 
     public Vector2 wallHopDirection;
     public Vector2 wallJumpDirection;
 
     public Transform groundCheck;
 
     public float playerdirection = 1; // for right
 
     public Transform wallCheck;
 
     public LayerMask whatIsGround;
 
     // Start is called before the first frame update
     void Start()
     {
         rb = GetComponent<Rigidbody2D>();
         anim = GetComponent<Animator>();
         amountOfJumpsLeft = amountOfJumps;
         wallHopDirection.Normalize();
         wallJumpDirection.Normalize();
     }
 
     // Update is called once per frame
     void Update()
     {
         CheckInput();
         UpdateAnimations();
         CheckIfCanJump();
         CheckIfWallSliding();
         CheckJump();
     }
 
     private void FixedUpdate()
     {
         ApplyMovement();
         CheckSurroundings();
 
         transform.position += transform.right * playerdirection * movementSpeed * Time.deltaTime;
     }
 
     private void CheckIfWallSliding()
     {
         if (isTouchingWall && movementInputDirection == facingDirection && rb.velocity.y < 0)
         {
             isWallSliding = true;
         }
         else
         {
             isWallSliding = false;
         }
     }
 
     private void CheckSurroundings()
     {
         isGrounded = Physics2D.OverlapCircle(groundCheck.position, groundCheckRadius, whatIsGround);
 
         isTouchingWall = Physics2D.Raycast(wallCheck.position, transform.right, wallCheckDistance, whatIsGround);
     }
 
     private void CheckIfCanJump()
     {
         if (isGrounded && rb.velocity.y <= 0.01f)
         {
             amountOfJumpsLeft = amountOfJumps;
         }
 
         if (isTouchingWall)
         {
             checkJumpMultiplier = false;
             canWallJump = true;
         }
 
         if (amountOfJumpsLeft <= 0)
         {
             canNormalJump = false;
         }
         else
         {
             canNormalJump = true;
         }
 
     }
 
     private void UpdateAnimations()
     {
         anim.SetBool("isGrounded", isGrounded);
         anim.SetFloat("yVelocity", rb.velocity.y);
         anim.SetBool("isWallSliding", isWallSliding);
     }
 
 
     void OnCollisionEnter2D(Collision2D other)
     {
         if (other.gameObject.tag == "wallright" && !isWallSliding)
         {
             playerdirection = -1;
             Vector2 theScale = transform.localScale;
             theScale.x *= -1;
             transform.localScale = theScale;
         }
         if (other.gameObject.tag == "wallleft" && !isWallSliding)
         {
             playerdirection = 1;
             Vector2 theScale = transform.localScale;
             theScale.x *= -1;
             transform.localScale = theScale;
         }
     }
 
     private void CheckInput()
     {
 
         if (Input.GetButtonDown("Jump"))
         {
             if (isGrounded || (amountOfJumpsLeft > 0 && isTouchingWall))
             {
                 NormalJump();
             }
             else
             {
                 jumpTimer = jumpTimerSet;
                 isAttemptingToJump = true;
             }
         }
 
         if (Input.GetButtonDown("Jump") && isTouchingWall)
         {
             if (!isGrounded && movementInputDirection != facingDirection)
             {
                 canMove = false;
                 canFlip = false;
 
                 turnTimer = turnTimerSet;
             }
         }
 
         if (!canMove)
         {
             turnTimer -= Time.deltaTime;
 
             if (turnTimer <= 0)
             {
                 canMove = true;
                 canFlip = true;
             }
         }
 
         if (checkJumpMultiplier && !Input.GetButton("Jump"))
         {
             checkJumpMultiplier = false;
             rb.velocity = new Vector2(rb.velocity.x, rb.velocity.y * variableJumpHeightMultiplier);
         }
 
     }
 
     private void CheckJump()
     {
         if (jumpTimer > 0)
         {
             //WallJump
             if (!isGrounded && isTouchingWall && movementInputDirection != 0 && movementInputDirection != facingDirection)
             {
                 WallJump();
             }
             else if (isGrounded)
             {
                 NormalJump();
             }
         }
 
         if (isAttemptingToJump)
         {
             jumpTimer -= Time.deltaTime;
         }
 
         if (wallJumpTimer > 0)
         {
             if (hasWallJumped && movementInputDirection == -lastWallJumpDirection)
             {
                 rb.velocity = new Vector2(rb.velocity.x, 0.0f);
                 hasWallJumped = false;
             }
             else if (wallJumpTimer <= 0)
             {
                 hasWallJumped = false;
             }
             else
             {
                 wallJumpTimer -= Time.deltaTime;
             }
         }
     }
 
     private void NormalJump()
     {
         if (canNormalJump)
         {
             rb.velocity = new Vector2(rb.velocity.x, jumpForce);
             amountOfJumpsLeft--;
             jumpTimer = 0;
             isAttemptingToJump = false;
             checkJumpMultiplier = true;
         }
     }
 
     private void WallJump()
     {
         if (canWallJump)
         {
             rb.velocity = new Vector2(rb.velocity.x, 0.0f);
             isWallSliding = false;
             amountOfJumpsLeft = amountOfJumps;
             amountOfJumpsLeft--;
             Vector2 forceToAdd = new Vector2(wallJumpForce * wallJumpDirection.x * movementInputDirection, wallJumpForce * wallJumpDirection.y);
             rb.AddForce(forceToAdd, ForceMode2D.Impulse);
             jumpTimer = 0;
             isAttemptingToJump = false;
             checkJumpMultiplier = true;
             turnTimer = 0;
             canMove = true;
             canFlip = true;
             hasWallJumped = true;
             wallJumpTimer = wallJumpTimerSet;
             lastWallJumpDirection = -facingDirection;
 
         }
     }
 
     private void ApplyMovement()
     {
 
         if (!isGrounded && !isWallSliding && movementInputDirection == 0)
         {
             rb.velocity = new Vector2(rb.velocity.x * airDragMultiplier, rb.velocity.y);
         }
         else if (canMove)
         {
             rb.velocity = new Vector2(movementSpeed * movementInputDirection, rb.velocity.y);
         }
 
 
         if (isWallSliding)
         {
             if (rb.velocity.y < -wallSlideSpeed)
             {
                 rb.velocity = new Vector2(rb.velocity.x, -wallSlideSpeed);
             }
         }
     }
 
     private void Flip()
     {
         if (!isWallSliding && canFlip)
         {
             facingDirection *= -1;
             isFacingRight = !isFacingRight;
             transform.Rotate(0.0f, 180.0f, 0.0f);
         }
     }
 
     private void OnDrawGizmos()
     {
         Gizmos.DrawWireSphere(groundCheck.position, groundCheckRadius);
 
         Gizmos.DrawLine(wallCheck.position, new Vector3(wallCheck.position.x + wallCheckDistance, wallCheck.position.y, wallCheck.position.z));
     }
 }