ObjectPooler

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

namespace Plugins.ObjectPooler
{
    public class ObjectPooler : MonoBehaviour
    {
        [Header("References")]
        [SerializeField] private Transform _transform;

        [Header("Preferences")]
        [SerializeField] private ObjectPool[] _poolList;

        private Dictionary<Pool, Queue<GameObject>> _pools;

        #region MonoBehaviour

        private void OnValidate()
        {
            _transform ??= GetComponent<Transform>();
        }

        private void Awake()
        {
            Init();
        }

        #endregion

        #region Fill

        private void Init()
        {
            _pools = new Dictionary<Pool, Queue<GameObject>>();

            foreach (var objectPool in _poolList)
            {
                _pools.Add(objectPool.pool, CreatePool(objectPool));
            }
        }

        private Queue<GameObject> CreatePool(ObjectPool pool)
        {
            var objectPool = new Queue<GameObject>();

            Transform poolParent = CreatePoolParent(pool.pool);

            for (int j = 0; j < pool.size; j++)
            {
                GameObject poolObject = InstantiateObject(pool.prefab);

                poolObject.SetActive(false);

                poolObject.transform.SetParent(poolParent);

                objectPool.Enqueue(poolObject);
            }

            return objectPool;
        }

        private GameObject InstantiateObject(GameObject prefab)
        {
            return Instantiate(prefab);
        }

        private Transform CreatePoolParent(Pool pool)
        {
            GameObject poolParentObj = new GameObject(pool.ToString());

            poolParentObj.transform.SetParent(_transform);

            return poolParentObj.transform;
        }

        #endregion

        #region Spawn

        public GameObject Spawn(Pool pool) => Spawn(pool, Vector3.zero, Quaternion.identity);

        public GameObject Spawn(Pool pool, Vector3 position) => Spawn(pool, position, Quaternion.identity);

        public GameObject Spawn(Pool pool, Vector3 position, Quaternion rotation)
        {
            if (_pools.ContainsKey(pool) == false)
            {
                throw new ArgumentException("Pool '" + pool + "' does not exist.");
            }

            GameObject poolObject = GetFromPool(pool);

            if (poolObject.activeSelf) // тут за умови, потім перевірити
            {
                poolObject.SetActive(false);
            }

            poolObject.transform.position = position;
            poolObject.transform.rotation = rotation;

            poolObject.SetActive(true);

            _pools[pool].Enqueue(poolObject);

            return poolObject;
        }

        private GameObject GetFromPool(Pool pool)
        {
            if (IsExpandable(pool) == false)
            {
                return _pools[pool].Dequeue();
            }

            if (TryGetFirstInactive(pool, out GameObject poolObject))
            {
                return poolObject;
            }

            return AddPoolObject(pool, GetPrefab(pool));
        }

        private bool TryGetFirstInactive(Pool pool, out GameObject poolObject)
        {
            for (int i = 0; i < _pools[pool].Count; i++)
            {
                GameObject possibleObject = _pools[pool].Dequeue();

                if (possibleObject.activeSelf == false)
                {
                    _pools[pool].Enqueue(possibleObject);

                    poolObject = possibleObject;
                    return true;
                }

                _pools[pool].Enqueue(possibleObject);
            }

            poolObject = null;
            return false;
        }

        private GameObject GetPrefab(Pool pool)
        {
            foreach (var objectPool in _poolList)
            {
                if (objectPool.pool == pool)
                {
                    return objectPool.prefab;
                }
            }

            throw new ArgumentException("Pool '" + pool + "' does not exist.");
        }

        private bool IsExpandable(Pool pool)
        {
            foreach (var objectPool in _poolList)
            {
                if (objectPool.pool == pool)
                {
                    return objectPool.autoExpand;
                }
            }

            throw new ArgumentException("Pool '" + pool + "' does not exist.");
        }

        private GameObject AddPoolObject(Pool pool, GameObject prefab)
        {
            GameObject newPoolObject = InstantiateObject(prefab);

            newPoolObject.transform.SetParent(GetPoolTransform(pool));

            return newPoolObject;
        }

        #endregion

        #region Utils

        private void DisableAllObjects()
        {
            foreach (Transform poolParent in _transform)
            {
                foreach (Transform poolObject in poolParent)
                {
                    poolObject.gameObject.SetActive(false);
                }
            }
        }

        private void DisablePool(Pool pool)
        {
            foreach (Transform poolObject in GetPoolTransform(pool))
            {
                poolObject.gameObject.SetActive(false);
            }
        }

        private Transform GetPoolTransform(Pool pool)
        {
            GameObject poolObject = _pools[pool].Dequeue();
            _pools[pool].Enqueue(poolObject);

            return poolObject.transform.parent;
        }

        #endregion

        [Serializable]
        private class ObjectPool
        {
            public Pool pool;
            public GameObject prefab;
            public int size;
            public bool autoExpand;
        }
    }
}