using System.Collections.Generic;
using UnityEngine;

namespace Normal.Realtime {
    /// <summary>
    /// Forked version of RealtimePool that does NOT pool avatar prefabs.
    /// Avatars are destroyed normally to allow OnDestroy() to execute properly.
    /// All other prefabs are pooled as normal.
    /// 
    /// Drop this beside a Realtime component to pool all prefab views managed by that Realtime component.
    /// It maintains one pool per prefab. Prefab instances are set to inactive when they're despawned.
    /// </summary>
    [RequireComponent(typeof(Realtime))]
    public class ForkedRealtimePool : MonoBehaviour, IRealtimePrefabInstantiateDelegate {
        /// <summary>
        /// Manages the pool for a specific prefab.
        /// Created on demand when a prefab is first spawned.
        /// </summary>
        private class Pool {
            /// <summary>
            /// The prefab that this pool manages.
            /// </summary>
            private readonly GameObject _prefab;

            /// <summary>
            /// Instances that are ready to be recycled.
            /// </summary>
            private readonly Queue<GameObject> _inactiveInstances = new Queue<GameObject>();

            public Pool(GameObject prefab) {
                _prefab = prefab;
            }

            /// <summary>
            /// Creates or recycles a new instance.
            /// </summary>
            public GameObject AcquireFromPool() {
                if (TryRecycle(out var prefabInstance)) {
                    return prefabInstance;
                } else {
                    return Instantiate(_prefab);
                }
            }

            /// <summary>
            /// Returns an instance to the pool.
            /// </summary>
            public void ReturnToPool(GameObject prefabInstance) {
                _inactiveInstances.Enqueue(prefabInstance);

                // Deactivate
                // Also triggers OnDisable on components
                prefabInstance.SetActive(false);
            }

            /// <summary>
            /// Creates an amount of inactive instances and places them into the pool.
            /// </summary>
            public void Preload(int count) {
                for (var i = 0; i < count; i++) {
                    var prefabInstance = Instantiate(_prefab);
                    ReturnToPool(prefabInstance);
                }
            }

// InstantiateAsync was backported to 2022.3.20f1.
// But Unity only provides a UNITY_X_Y_OR_NEWER define (not UNITY_X_Y_Z_OR_NEWER).
// So we can't safely compile it for 2022.3 and we use Unity 6 as the cutoff instead.
#if UNITY_6000_0_OR_NEWER
            /// <summary>
            /// Creates an amount of inactive instances and places them into the pool using <see cref="UnityEngine.Object.InstantiateAsync{T}(T, int)"/>.
            /// </summary>
            public AsyncInstantiateOperation<GameObject> PreloadAsync(int count) {
                var operation = InstantiateAsync(_prefab, count);

                // Handle case where the operation has finished synchronously
                if (operation.isDone) {
                    OnPreloadAsyncComplete(operation);
                } else {
                    operation.completed += OnPreloadAsyncComplete;
                }

                return operation;
            }

            /// <summary>
            /// Processes the results of an AsyncInstantiateOperation.
            /// </summary>
            private void OnPreloadAsyncComplete(AsyncOperation operation) {
                var instantiateOperation = (AsyncInstantiateOperation)operation;

                foreach (var result in instantiateOperation.Result) {
                    var prefabInstance = (GameObject)result;
                    ReturnToPool(prefabInstance);
                }
            }
#endif

            /// <summary>
            /// Destroys all inactive instances in the pool.
            /// </summary>
            public void Clear() {
                while (_inactiveInstances.Count > 0) {
                    var prefabInstance = _inactiveInstances.Dequeue();

                    // Destroy the GameObject
                    UnityEngine.Object.Destroy(prefabInstance);
                }
            }

            /// <summary>
            /// Tries to recycle an inactive instance.
            /// </summary>
            private bool TryRecycle(out GameObject prefabInstance) {
                if (_inactiveInstances.Count == 0) {
                    prefabInstance = null;
                    return false;
                } else {
                    prefabInstance = _inactiveInstances.Dequeue();

                    // Activate
                    // Also triggers OnEnable on components
                    prefabInstance.SetActive(true);

                    return true;
                }
            }

            /// <summary>
            /// Creates a new instance.
            /// </summary>
            private GameObject Instantiate(GameObject prefab) {
                // Instantiate the prefab
                return UnityEngine.Object.Instantiate(prefab);
            }
        }

        /// <summary>
        /// Maps a prefab to its <see cref="Pool"/> using the prefab's name.
        /// </summary>
        private readonly Dictionary<string, Pool> _pools = new Dictionary<string, Pool>();

        /// <summary>
        /// Used to avoid allocation for GetComponents.
        /// </summary>
        private static readonly List<IRealtimePoolCallbacks> _tempPoolCallbacks = new List<IRealtimePoolCallbacks>(20);

        /// <summary>
        /// When preloading prefabs by name, used to resolve the name to a prefab we can instantiate.
        /// </summary>
        private IRealtimePrefabLoadDelegate _prefabLoader;

        private void Awake() {
            // Use the same one that is being used by Realtime
            if (!TryGetComponent(out _prefabLoader)) {
                _prefabLoader = new DefaultRealtimePrefabDelegate();
            }
        }

        /// <inheritdoc/>
        public GameObject InstantiateRealtimePrefab(GameObject prefab) {
            var pool = GetOrCreatePool(prefab);
            var prefabInstance = pool.AcquireFromPool();

            InvokeWillReuseFromPool(prefabInstance);

            return prefabInstance;
        }

        /// <inheritdoc/>
        public void DestroyRealtimePrefab(GameObject prefabInstance) {
            // Check if this is an avatar prefab - if so, destroy it instead of pooling
            if (prefabInstance.GetComponent<RealtimeAvatar>() != null) {
                // Invoke callbacks before destroying
                InvokeWillReturnToPool(prefabInstance);
                
                // Destroy the avatar normally to allow OnDestroy() to execute
                UnityEngine.Object.Destroy(prefabInstance);
                return;
            }

            // For non-avatar prefabs, use normal pooling behavior
            var rootView = prefabInstance.GetComponent<RealtimeView>();
            var prefabName = rootView.prefabName;

            // Use the opposite order of InstantiateRealtimePrefab:
            // first InvokeOnWillReturnToPool and then ReturnToPool (which triggers OnDisable)

            InvokeWillReturnToPool(prefabInstance);

            var pool = GetPool(prefabName);
            pool.ReturnToPool(prefabInstance);
        }

        /// <summary>
        /// Creates an amount of inactive instances of a prefab and places them into the pool.
        /// </summary>
        /// <remarks>
        /// Uses the specific <see cref="IRealtimePrefabLoadDelegate"/> used by the <see cref="Realtime"/> that this pool belongs to,
        /// or a default implementation if it doesn't have one.
        /// </remarks>
        public void PreloadPrefab(string prefabName, int count) {
            RealtimePrefabMetadata prefabMetadata = new RealtimePrefabMetadata() {
                prefabName = prefabName,
            };

            var prefab = _prefabLoader.LoadRealtimePrefab(prefabMetadata);

            PreloadPrefab(prefab, count);
        }

        /// <summary>
        /// Creates an amount of inactive instances of a prefab and places them into the pool.
        /// </summary>
        public void PreloadPrefab(GameObject prefab, int count) {
            var pool = GetOrCreatePool(prefab);
            pool.Preload(count);
        }

#if UNITY_6000_0_OR_NEWER
        /// <summary>
        /// <para>
        /// Creates an amount of inactive instances and places them into the pool using <see cref="UnityEngine.Object.InstantiateAsync{T}(T, int)"/>.
        /// </para>
        /// <para>
        /// </para>
        /// This method avoids the possibility of dropping frames while preloading instances:
        /// Call it for each prefab you'd like to load and wait for all the operations to complete before connecting to a room.
        /// </summary>
        /// <remarks>
        /// Uses the specific <see cref="IRealtimePrefabLoadDelegate"/> used by the <see cref="Realtime"/> that this pool belongs to,
        /// or a default implementation if it doesn't have one.
        /// </remarks>
        public AsyncInstantiateOperation<GameObject> PreloadPrefabAsync(string prefabName, int count) {
            RealtimePrefabMetadata prefabMetadata = new RealtimePrefabMetadata() {
                prefabName = prefabName,
            };

            var prefab = _prefabLoader.LoadRealtimePrefab(prefabMetadata);

            return PreloadPrefabAsync(prefab, count);
        }

        /// <summary>
        /// <para>
        /// Creates an amount of inactive instances and places them into the pool using <see cref="UnityEngine.Object.InstantiateAsync{T}(T, int)"/>.
        /// </para>
        /// <para>
        /// </para>
        /// This method avoids the possibility of dropping frames while preloading instances:
        /// Call it for each prefab you'd like to load and wait for all the operations to complete before connecting to a room.
        /// </summary>
        public AsyncInstantiateOperation<GameObject> PreloadPrefabAsync(GameObject prefab, int count) {
            var pool = GetOrCreatePool(prefab);
            return pool.PreloadAsync(count);
        }
#endif

        /// <summary>
        /// Destroys all inactive instances of a prefab.
        /// </summary>
        public void Clear(GameObject prefab) {
            var prefabName = prefab.name;
            var pool = GetPool(prefabName);

            // We don't necessarily have a pool for this prefab, ex if InstantiateRealtimePrefab was never called for it
            pool?.Clear();
        }

        /// <summary>
        /// Destroys all inactive instances of all prefabs.
        /// </summary>
        public void Clear() {
            foreach (var pair in _pools) {
                var pool = pair.Value;
                pool.Clear();
            }
        }

        /// <summary>
        /// Finds an existing pool for the prefab (by name).
        /// </summary>
        private Pool GetPool(string prefabName) {
            return _pools[prefabName];
        }

        /// <summary>
        /// Creates or finds an existing pool for the prefab.
        /// </summary>
        private Pool GetOrCreatePool(GameObject prefab) {
            var prefabName = prefab.name;

            if (_pools.TryGetValue(prefabName, out var pool) == false) {
                pool = new Pool(prefab);
                _pools[prefabName] = pool;
            }
            return pool;
        }

        /// <summary>
        /// Invokes <see cref="IRealtimePoolCallbacks.PrefabWillReuseFromPool"/> on all components in the prefab instance root
        /// deriving from <see cref="IRealtimePoolCallbacks"/>.
        /// </summary>
        private void InvokeWillReuseFromPool(GameObject prefabInstance) {
            prefabInstance.GetComponents(_tempPoolCallbacks);

            foreach (var poolCallback in _tempPoolCallbacks) {
                poolCallback.PrefabWillReuseFromPool();
            }
        }

        /// <summary>
        /// Invokes <see cref="IRealtimePoolCallbacks.PrefabWillReturnToPool"/> on all components in the prefab instance root
        /// deriving from <see cref="IRealtimePoolCallbacks"/>.
        /// </summary>
        private void InvokeWillReturnToPool(GameObject prefabInstance) {
            prefabInstance.GetComponents(_tempPoolCallbacks);

            foreach (var poolCallback in _tempPoolCallbacks) {
                poolCallback.PrefabWillReturnToPool();
            }
        }
    }
}