using System;
using System.Collections.Generic;
using AlicizaX;

namespace AlicizaX.ObjectPool
{
    internal sealed partial class ObjectPoolService : IObjectPoolService
    {
        /// <summary>
        /// 内部对象。
        /// </summary>
        /// <typeparam name="T">对象类型。</typeparam>
        private sealed class Object<T> : IMemory where T : ObjectBase
        {
            private string m_Name;
            private T m_Object;
            private int m_SpawnCount;
            private LinkedListNode<Object<T>> m_NameNode;

            /// <summary>
            /// 初始化内部对象的新实例。
            /// </summary>
            public Object()
            {
                m_Name = null;
                m_Object = null;
                m_SpawnCount = 0;
                m_NameNode = null;
            }

            /// <summary>
            /// 获取对象名称。
            /// </summary>
            public string Name
            {
                get { return m_Name; }
            }

            /// <summary>
            /// 获取对象是否被加锁。
            /// </summary>
            public bool Locked
            {
                get { return m_Object.Locked; }
                internal set { m_Object.Locked = value; }
            }

            /// <summary>
            /// 获取对象的优先级。
            /// </summary>
            public int Priority
            {
                get { return m_Object.Priority; }
                internal set { m_Object.Priority = value; }
            }

            /// <summary>
            /// 获取自定义释放检查标记。
            /// </summary>
            public bool CustomCanReleaseFlag
            {
                get { return m_Object.CustomCanReleaseFlag; }
            }

            /// <summary>
            /// 获取对象上次使用时间。
            /// </summary>
            public DateTime LastUseTime
            {
                get { return m_Object.LastUseTime; }
            }

            /// <summary>
            /// 获取对象是否正在使用。
            /// </summary>
            public bool IsInUse
            {
                get { return m_SpawnCount > 0; }
            }

            /// <summary>
            /// 获取对象的获取计数。
            /// </summary>
            public int SpawnCount
            {
                get { return m_SpawnCount; }
            }

            /// <summary>
            /// 获取或设置对象在名字桶中的链表结点。
            /// </summary>
            public LinkedListNode<Object<T>> NameNode
            {
                get { return m_NameNode; }
                internal set { m_NameNode = value; }
            }

            /// <summary>
            /// 创建内部对象。
            /// </summary>
            /// <param name="obj">对象。</param>
            /// <param name="spawned">对象是否已被获取。</param>
            /// <returns>创建的内部对象。</returns>
            public static Object<T> Create(T obj, bool spawned)
            {
                if (obj == null)
                {
                    throw new GameFrameworkException("Object is invalid.");
                }

                Object<T> internalObject = MemoryPool.Acquire<Object<T>>();
                internalObject.m_Name = obj.Name;
                internalObject.m_Object = obj;
                internalObject.m_SpawnCount = spawned ? 1 : 0;
                if (spawned)
                {
                    obj.OnSpawn();
                }

                return internalObject;
            }

            /// <summary>
            /// 清理内部对象。
            /// </summary>
            public void Clear()
            {
                m_Name = null;
                m_Object = null;
                m_SpawnCount = 0;
                m_NameNode = null;
            }

            /// <summary>
            /// 查看对象。
            /// </summary>
            /// <returns>对象。</returns>
            public T Peek()
            {
                return m_Object;
            }

            /// <summary>
            /// 获取对象。
            /// </summary>
            /// <returns>对象。</returns>
            public T Spawn()
            {
                m_SpawnCount++;
                m_Object.LastUseTime = DateTime.UtcNow;
                m_Object.OnSpawn();
                return m_Object;
            }

            /// <summary>
            /// 回收对象。
            /// </summary>
            public void Unspawn()
            {
                m_Object.OnUnspawn();
                m_Object.LastUseTime = DateTime.UtcNow;
                m_SpawnCount--;
                if (m_SpawnCount < 0)
                {
                    throw new GameFrameworkException(Utility.Text.Format("Object '{0}' spawn count is less than 0.", Name));
                }
            }

            /// <summary>
            /// 释放对象。
            /// </summary>
            /// <param name="isShutdown">是否是关闭对象池时触发。</param>
            public void Release(bool isShutdown)
            {
                m_Object.Release(isShutdown);
                MemoryPool.Release(m_Object);
            }
        }
    }
}