Object Pooling is not working perfectly together with Array and Random.Range

So I am trying to learn Object Pooling together with Arrays. The Object Pool is trying to access the Arrays to spawn 3 Balls. The Problem is using the method to return them to the Pool and reusing them again.

So in the video above, I’m not trying to return the balls back to the pool and as you can see, all 3 balls(red, blue and green) are being instantiated. But if I try to return them BACK to the pool…

As you can see, my code literally stops instantiating the ball Red, The code just repeatedly uses the balls Green and Blue(more often).

It seems to me, that the object pool will only reuse the balls that have already been instantiated before being sent back to the pool. For example, if only a red ball was repeatedly instantiated and then returned back to the pool then the code will only reuse that red ball and never instantiate the green and blue ones.

But if both Green and Blue balls are spawned before being returned back to the pool then, and then returned, then the code will only keep reusing Green and Blue balls and never the red ones.

Here are my codes:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Pool;

public class SpawnManager : MonoBehaviour
{
    [SerializeField]
    private BallScript[] _ballPrefabs;
    Vector3 _randomBallSpawnSelector;
    private int _ballSpawnCountdown;

    public ObjectPool<BallScript> _ballObjectPooling;

    // Start is called before the first frame update
    void Start()
    {
        _ballObjectPooling = new ObjectPool<BallScript>(CreateBalls, OnGetBallsFromPool, OnReleaseBallsFromPool, OnDestroyGameObject, true, 10, 20); //the object pool itself
        StartCoroutine(SpawnBallIntervals());//activates coroutine
    }

    // controls the spawn of balls
    IEnumerator SpawnBallIntervals()
    {
        while (true)
        {
            _ballObjectPooling.Get();
            //_ballSpawnCountdown = Random.Range(3, 6);
            _ballSpawnCountdown = 1;
            yield return new WaitForSeconds(_ballSpawnCountdown);
        }
    }

    //instantiate ball if pool is empty
    private BallScript CreateBalls()
    {
        _randomBallSpawnSelector = new Vector3(Random.Range(-39, 9), 32, 0);
        var _randomBallSelector = Random.Range(0, _ballPrefabs.Length);
        var _randomBallPrefabs = _ballPrefabs[_randomBallSelector];

        var ball = Instantiate(_randomBallPrefabs, _randomBallSpawnSelector, _randomBallPrefabs.transform.rotation);
        ball.SetPool(_ballObjectPooling);

        return ball;
    }

    //take balls from pool
    public void OnGetBallsFromPool(BallScript ball)
    {
        _randomBallSpawnSelector = new Vector3(Random.Range(-39, 9), 32, 0);

        ball.transform.position = _randomBallSpawnSelector;
        ball.gameObject.SetActive(true);
    }

    //release ball back to the pool
    public void OnReleaseBallsFromPool(BallScript ball)
    {
        ball.gameObject.SetActive(false);
    }

    //destroys ball of pool is max capacity
    public void OnDestroyGameObject(BallScript ball)
    {
        Destroy(ball.gameObject);
    }

}

So In this script above, this is where the Object Pooling is made.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Pool;

public class BallScript : MonoBehaviour
{

    public ObjectPool<BallScript> _pool;

    public void SetPool(ObjectPool<BallScript> pool)
    {
        _pool = pool;
    }

    void Update()
    {
       //DestroyOutOfBoundsBall(); //activates coroutine
    }

    //coroutine that returns ball from pool if out of bounds
    private void DestroyOutOfBoundsBall()
    {
        if (transform.position.y <= -3)
        {
            _pool.Release(this);
        }
    }

    //coroutine that returns ball from pool collide with dog
    private void OnTriggerEnter(Collider other)
    {
        _pool.Release(this);
    }
}

And in this script, this is where I release the ball back to the Pool.

So what I want to happen for this project is, that all 3(green, red and blue) balls are to be instantiated continuously regardless if they have been instantiated before they are returned to the pool or not because currently, only the balls that are instantiated before being returned are used.

Also, Random.Range isn’t completely random. The array has 3 balls so balls 0, 1 and 2. For some reason balls 0 and 2 are often called and 1 is rarely called for some reason.