using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using Unity.Collections;

namespace Convention.Collections
{
    namespace Generic
    {
        /// <summary>
        /// 附带有缓存机制的链表类
        /// </summary>
        /// <typeparam name="T">指定链表的元素类型</typeparam>
        public sealed class LinkedCacheList<T> : ICollection<T>, IEnumerable<T>, ICollection, IEnumerable
        {
            private readonly LinkedList<T> m_LinkedList;
            /// <summary>
            /// 之所以需要这套缓存机制，主要有三点好处：
            /// <list type="bullet">减少 GC 压力：大量频繁的插入/删除会产生很多短生命周期的节点对象，通过复用可以显著降低托管堆的分配与回收次数</list>
            /// <list type="bullet">提升性能：避免频繁 new 和 GC，能减少停顿时间，提高链表在高频操作场景下的吞吐</list>
            /// <list type="bullet">便于观察与管理：类中还提供了 CachedNodeCount 方便调试统计缓存规模，必要时可通过 ClearCachedNodes 主动释放</list>
            /// 适用场景是节点使用模式“高频增删但总量有限”，此时缓存能稳定性能；若链表规模始终在增长且很少释放，缓存收益会较低。
            /// </summary>
            private readonly Queue<LinkedListNode<T>> m_CachedNodes;

            /// <summary>
            /// 初始化游戏框架链表类的新实例
            /// </summary>
            public LinkedCacheList()
            {
                m_LinkedList = new LinkedList<T>();
                m_CachedNodes = new Queue<LinkedListNode<T>>();
            }

            /// <summary>
            /// 获取链表中实际包含的结点数量
            /// </summary>
            public int Count
            {
                get
                {
                    return m_LinkedList.Count;
                }
            }

            /// <summary>
            /// 获取链表结点缓存数量
            /// </summary>
            public int CachedNodeCount
            {
                get
                {
                    return m_CachedNodes.Count;
                }
            }

            /// <summary>
            /// 获取链表的第一个结点
            /// </summary>
            public LinkedListNode<T> First
            {
                get
                {
                    return m_LinkedList.First;
                }
            }

            /// <summary>
            /// 获取链表的最后一个结点
            /// </summary>
            public LinkedListNode<T> Last
            {
                get
                {
                    return m_LinkedList.Last;
                }
            }

            /// <summary>
            /// 获取一个值，该值指示 <see cref="ICollection{T}"/> 是否为只读
            /// </summary>
            public bool IsReadOnly
            {
                get
                {
                    return ((ICollection<T>)m_LinkedList).IsReadOnly;
                }
            }

            /// <summary>
            /// 获取可用于同步对 <see cref="ICollection"/> 的访问的对象。
            /// </summary>
            public object SyncRoot
            {
                get
                {
                    return ((ICollection)m_LinkedList).SyncRoot;
                }
            }

            /// <summary>
            /// 获取一个值，该值指示是否同步对 <see cref="ICollection"/> 的访问（线程安全）。
            /// </summary>
            public bool IsSynchronized
            {
                get
                {
                    return ((ICollection)m_LinkedList).IsSynchronized;
                }
            }

            /// <summary>
            /// 在链表中指定的现有结点后添加包含指定值的新结点
            /// </summary>
            /// <param name="node">指定的现有结点</param>
            /// <param name="value">指定值</param>
            /// <returns>包含指定值的新结点</returns>
            public LinkedListNode<T> AddAfter(LinkedListNode<T> node, T value)
            {
                LinkedListNode<T> newNode = AcquireNode(value);
                m_LinkedList.AddAfter(node, newNode);
                return newNode;
            }

            /// <summary>
            /// 在链表中指定的现有结点后添加指定的新结点
            /// </summary>
            /// <param name="node">指定的现有结点</param>
            /// <param name="newNode">指定的新结点</param>
            public void AddAfter(LinkedListNode<T> node, LinkedListNode<T> newNode)
            {
                m_LinkedList.AddAfter(node, newNode);
            }

            /// <summary>
            /// 在链表中指定的现有结点前添加包含指定值的新结点
            /// </summary>
            /// <param name="node">指定的现有结点</param>
            /// <param name="value">指定值</param>
            /// <returns>包含指定值的新结点</returns>
            public LinkedListNode<T> AddBefore(LinkedListNode<T> node, T value)
            {
                LinkedListNode<T> newNode = AcquireNode(value);
                m_LinkedList.AddBefore(node, newNode);
                return newNode;
            }

            /// <summary>
            /// 在链表中指定的现有结点前添加指定的新结点
            /// </summary>
            /// <param name="node">指定的现有结点</param>
            /// <param name="newNode">指定的新结点</param>
            public void AddBefore(LinkedListNode<T> node, LinkedListNode<T> newNode)
            {
                m_LinkedList.AddBefore(node, newNode);
            }

            /// <summary>
            /// 在链表的开头处添加包含指定值的新结点
            /// </summary>
            /// <param name="value">指定值</param>
            /// <returns>包含指定值的新结点</returns>
            public LinkedListNode<T> AddFirst(T value)
            {
                LinkedListNode<T> node = AcquireNode(value);
                m_LinkedList.AddFirst(node);
                return node;
            }

            /// <summary>
            /// 在链表的开头处添加指定的新结点
            /// </summary>
            /// <param name="node">指定的新结点</param>
            public void AddFirst(LinkedListNode<T> node)
            {
                m_LinkedList.AddFirst(node);
            }

            /// <summary>
            /// 在链表的结尾处添加包含指定值的新结点
            /// </summary>
            /// <param name="value">指定值</param>
            /// <returns>包含指定值的新结点</returns>
            public LinkedListNode<T> AddLast(T value)
            {
                LinkedListNode<T> node = AcquireNode(value);
                m_LinkedList.AddLast(node);
                return node;
            }

            /// <summary>
            /// 在链表的结尾处添加指定的新结点
            /// </summary>
            /// <param name="node">指定的新结点</param>
            public void AddLast(LinkedListNode<T> node)
            {
                m_LinkedList.AddLast(node);
            }

            /// <summary>
            /// 从链表中移除所有结点
            /// </summary>
            public void Clear()
            {
                LinkedListNode<T> current = m_LinkedList.First;
                while (current != null)
                {
                    ReleaseNode(current);
                    current = current.Next;
                }

                m_LinkedList.Clear();
            }

            /// <summary>
            /// 清除链表结点缓存
            /// </summary>
            public void ClearCachedNodes()
            {
                m_CachedNodes.Clear();
            }

            /// <summary>
            /// 确定某值是否在链表中
            /// </summary>
            /// <param name="value">指定值</param>
            /// <returns>某值是否在链表中</returns>
            public bool Contains(T value)
            {
                return m_LinkedList.Contains(value);
            }

            /// <summary>
            /// 从目标数组的指定索引处开始将整个链表复制到兼容的一维数组
            /// </summary>
            /// <param name="array">一维数组，它是从链表复制的元素的目标。数组必须具有从零开始的索引</param>
            /// <param name="index">array 中从零开始的索引，从此处开始复制</param>
            public void CopyTo(T[] array, int index)
            {
                m_LinkedList.CopyTo(array, index);
            }

            /// <summary>
            /// 从特定的 ICollection 索引开始，将数组的元素复制到一个数组中
            /// </summary>
            /// <param name="array">一维数组，它是从 ICollection 复制的元素的目标。数组必须具有从零开始的索引</param>
            /// <param name="index">array 中从零开始的索引，从此处开始复制</param>
            public void CopyTo(Array array, int index)
            {
                ((ICollection)m_LinkedList).CopyTo(array, index);
            }

            /// <summary>
            /// 查找包含指定值的第一个结点
            /// </summary>
            /// <param name="value">要查找的指定值</param>
            /// <returns>包含指定值的第一个结点</returns>
            public LinkedListNode<T> Find(T value)
            {
                return m_LinkedList.Find(value);
            }

            /// <summary>
            /// 查找包含指定值的最后一个结点
            /// </summary>
            /// <param name="value">要查找的指定值</param>
            /// <returns>包含指定值的最后一个结点</returns>
            public LinkedListNode<T> FindLast(T value)
            {
                return m_LinkedList.FindLast(value);
            }

            /// <summary>
            /// 从链表中移除指定值的第一个匹配项
            /// </summary>
            /// <param name="value">指定值</param>
            /// <returns>是否移除成功</returns>
            public bool Remove(T value)
            {
                LinkedListNode<T> node = m_LinkedList.Find(value);
                if (node != null)
                {
                    m_LinkedList.Remove(node);
                    ReleaseNode(node);
                    return true;
                }

                return false;
            }

            /// <summary>
            /// 从链表中移除指定的结点
            /// </summary>
            /// <param name="node">指定的结点</param>
            public void Remove(LinkedListNode<T> node)
            {
                m_LinkedList.Remove(node);
                ReleaseNode(node);
            }

            /// <summary>
            /// 移除位于链表开头处的结点
            /// </summary>
            public void RemoveFirst()
            {
                LinkedListNode<T> first = m_LinkedList.First;
                if (first == null)
                {
                    throw new InvalidOperationException("Rmove first is invalid.");
                }

                m_LinkedList.RemoveFirst();
                ReleaseNode(first);
            }

            /// <summary>
            /// 移除位于链表结尾处的结点。
            /// </summary>
            public void RemoveLast()
            {
                LinkedListNode<T> last = m_LinkedList.Last;
                if (last == null)
                {
                    throw new InvalidOperationException("Remove last is invalid.");
                }

                m_LinkedList.RemoveLast();
                ReleaseNode(last);
            }

            /// <summary>
            /// 返回循环访问集合的枚举数
            /// </summary>
            /// <returns>循环访问集合的枚举数</returns>
            public Enumerator GetEnumerator()
            {
                return new Enumerator(m_LinkedList);
            }

            private LinkedListNode<T> AcquireNode(T value)
            {
                LinkedListNode<T> node = null;
                if (m_CachedNodes.Count > 0)
                {
                    node = m_CachedNodes.Dequeue();
                    node.Value = value;
                }
                else
                {
                    node = new LinkedListNode<T>(value);
                }

                return node;
            }

            private void ReleaseNode(LinkedListNode<T> node)
            {
                node.Value = default(T);
                m_CachedNodes.Enqueue(node);
            }

            /// <summary>
            /// 将值添加到 ICollection`1 的结尾处
            /// </summary>
            /// <param name="value">要添加的值</param>
            void ICollection<T>.Add(T value)
            {
                AddLast(value);
            }

            /// <summary>
            /// 返回循环访问集合的枚举数
            /// </summary>
            /// <returns>循环访问集合的枚举数</returns>
            IEnumerator<T> IEnumerable<T>.GetEnumerator()
            {
                return GetEnumerator();
            }

            /// <summary>
            /// 返回循环访问集合的枚举数
            /// </summary>
            /// <returns>循环访问集合的枚举数</returns>
            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }

            /// <summary>
            /// 循环访问集合的枚举数
            /// </summary>
            [StructLayout(LayoutKind.Auto)]
            public struct Enumerator : IEnumerator<T>, IEnumerator
            {
                private LinkedList<T>.Enumerator m_Enumerator;

                internal Enumerator(LinkedList<T> linkedList)
                {
                    if (linkedList == null)
                    {
                        throw new InvalidOperationException("Linked list is invalid.");
                    }

                    m_Enumerator = linkedList.GetEnumerator();
                }

                /// <summary>
                /// 获取当前结点
                /// </summary>
                public T Current
                {
                    get
                    {
                        return m_Enumerator.Current;
                    }
                }

                /// <summary>
                /// 获取当前的枚举数
                /// </summary>
                object IEnumerator.Current
                {
                    get
                    {
                        return m_Enumerator.Current;
                    }
                }

                /// <summary>
                /// 清理枚举数
                /// </summary>
                public void Dispose()
                {
                    m_Enumerator.Dispose();
                }

                /// <summary>
                /// 获取下一个结点
                /// </summary>
                /// <returns>返回下一个结点</returns>
                public bool MoveNext()
                {
                    return m_Enumerator.MoveNext();
                }

                /// <summary>
                /// 重置枚举数
                /// </summary>
                void IEnumerator.Reset()
                {
                    ((IEnumerator<T>)m_Enumerator).Reset();
                }
            }
        }
    }

    namespace Cache
    {
        /// <summary>
        /// Native LRUCache - 基于Unity.Collections的高性能最近最少使用缓存
        /// Burst兼容，需要手动Dispose
        /// </summary>
        /// <typeparam name="TKey">键类型（必须是unmanaged类型）</typeparam>
        /// <typeparam name="TValue">值类型（必须是unmanaged类型）</typeparam>
        public struct NativeLRUCache<TKey, TValue> : IDisposable
            where TKey : unmanaged, IEquatable<TKey>
            where TValue : unmanaged
        {
            // 链表节点
            private struct Node
            {
                public TKey key;
                public TValue value;
                public int prevIndex;  // 前一个节点索引
                public int nextIndex;  // 后一个节点索引
            }

            private NativeList<Node> nodes;                     // 节点池
            private readonly NativeHashMap<TKey, int> hashMap;  // key -> 节点索引
            private readonly NativeList<int> freeList;          // 空闲节点索引池

            private readonly int capacity;
            private int headIndex;                         // 链表头（最久未使用）
            private int tailIndex;                         // 链表尾（最近使用）
            private int count;

            // 是否为有效节点索引
            private readonly bool IsValidIndex(int index) => index >= 0;

            public NativeLRUCache(int capacity, Allocator allocator)
            {
                this.capacity = capacity;
                this.count = 0;
                this.headIndex = -1;
                this.tailIndex = -1;

                hashMap = new NativeHashMap<TKey, int>(capacity, allocator);
                nodes = new NativeList<Node>(capacity, allocator);
                freeList = new NativeList<int>(capacity, allocator);

                // 预分配节点池
                nodes.Length = capacity;
                for (int i = capacity - 1; i >= 0; i--)
                {
                    freeList.Add(i);
                }
            }

            /// <summary>
            /// 获取缓存值
            /// </summary>
            public bool TryGetValue(TKey key, out TValue value)
            {
                if (hashMap.TryGetValue(key, out int nodeIndex))
                {
                    MoveToTail(nodeIndex);  // 移动到尾部（最近使用）
                    value = nodes[nodeIndex].value;
                    return true;
                }

                value = default;
                return false;
            }

            /// <summary>
            /// 添加或更新缓存
            /// </summary>
            public void Put(TKey key, TValue value)
            {
                // 已存在则更新并移动到尾部
                if (hashMap.TryGetValue(key, out int nodeIndex))
                {
                    Node node = nodes[nodeIndex];
                    node.value = value;
                    nodes[nodeIndex] = node;
                    MoveToTail(nodeIndex);
                    return;
                }

                // 容量已满，淘汰头部节点
                if (count >= capacity)
                {
                    EvictHead();
                }

                // 创建新节点
                nodeIndex = AllocateNode();
                nodes[nodeIndex] = new Node
                {
                    key = key,
                    value = value,
                    prevIndex = tailIndex,
                    nextIndex = -1
                };

                hashMap.Add(key, nodeIndex);
                AddToTail(nodeIndex);
                count++;
            }

            /// <summary>
            /// 删除缓存项
            /// </summary>
            public bool Remove(TKey key)
            {
                if (!hashMap.TryGetValue(key, out int nodeIndex))
                    return false;

                hashMap.Remove(key);
                RemoveFromList(nodeIndex);
                FreeNode(nodeIndex);
                count--;
                return true;
            }

            /// <summary>
            /// 清空缓存
            /// </summary>
            public void Clear()
            {
                hashMap.Clear();

                // 重置所有节点到空闲列表
                freeList.Clear();
                for (int i = 0; i < capacity; i++)
                {
                    freeList.Add(i);
                }

                headIndex = -1;
                tailIndex = -1;
                count = 0;
            }

            // 分配节点索引
            private readonly int AllocateNode()
            {
                int index = freeList[^1];
                freeList.RemoveAtSwapBack(freeList.Length - 1);
                return index;
            }

            // 释放节点索引
            private readonly void FreeNode(int index)
            {
                freeList.Add(index);
            }

            // 将节点移动到链表尾部（标记为最近使用）
            private void MoveToTail(int nodeIndex)
            {
                if (nodeIndex == tailIndex)
                    return;

                RemoveFromList(nodeIndex);
                AddToTail(nodeIndex);
            }

            // 将节点添加到尾部
            private void AddToTail(int nodeIndex)
            {
                Node node = nodes[nodeIndex];
                node.prevIndex = tailIndex;
                node.nextIndex = -1;
                nodes[nodeIndex] = node;

                if (IsValidIndex(tailIndex))
                {
                    Node tail = nodes[tailIndex];
                    tail.nextIndex = nodeIndex;
                    nodes[tailIndex] = tail;
                }

                tailIndex = nodeIndex;

                // 如果链表为空，头尾指向同一节点
                if (!IsValidIndex(headIndex))
                {
                    headIndex = nodeIndex;
                }
            }

            // 从链表中移除节点
            private void RemoveFromList(int nodeIndex)
            {
                Node node = nodes[nodeIndex];

                // 更新前一个节点的next指针
                if (IsValidIndex(node.prevIndex))
                {
                    Node prev = nodes[node.prevIndex];
                    prev.nextIndex = node.nextIndex;
                    nodes[node.prevIndex] = prev;
                }
                else
                {
                    // 没有前一个节点，说明是头节点
                    headIndex = node.nextIndex;
                }

                // 更新后一个节点的prev指针
                if (IsValidIndex(node.nextIndex))
                {
                    Node next = nodes[node.nextIndex];
                    next.prevIndex = node.prevIndex;
                    nodes[node.nextIndex] = next;
                }
                else
                {
                    // 没有后一个节点，说明是尾节点
                    tailIndex = node.prevIndex;
                }
            }

            // 淘汰头部节点（最久未使用）
            private void EvictHead()
            {
                if (!IsValidIndex(headIndex)) return;

                int oldHead = headIndex;
                Node headNode = nodes[oldHead];

                hashMap.Remove(headNode.key);
                headIndex = headNode.nextIndex;

                if (IsValidIndex(headIndex))
                {
                    Node newHead = nodes[headIndex];
                    newHead.prevIndex = -1;
                    nodes[headIndex] = newHead;
                }
                else
                {
                    tailIndex = -1;  // 链表为空
                }

                FreeNode(oldHead);
                count--;
            }

            public void Dispose()
            {
                if (hashMap.IsCreated) hashMap.Dispose();
                if (nodes.IsCreated) nodes.Dispose();
                if (freeList.IsCreated) freeList.Dispose();

                headIndex = -1;
                tailIndex = -1;
                count = 0;
            }

            // 属性访问器
            public readonly int Count => count;
            public readonly int Capacity => capacity;
            public readonly bool IsCreated => hashMap.IsCreated;
        }

        /// <summary>
        /// Native LFUCache - 基于Unity.Collections的高性能最不频繁使用缓存
        /// Burst兼容，需要手动Dispose
        /// </summary>
        /// <typeparam name="TKey">键类型（必须是unmanaged类型）</typeparam>
        /// <typeparam name="TValue">值类型（必须是unmanaged类型）</typeparam>
        public struct NativeLFUCache<TKey, TValue> : IDisposable
            where TKey : unmanaged, IEquatable<TKey>
            where TValue : unmanaged
        {
            // 缓存节点
            private struct Node
            {
                public TKey key;
                public TValue value;
                public int frequency;      // 访问频率
                public int prevIndex;      // 同频率链表中的前一个节点
                public int nextIndex;      // 同频率链表中的后一个节点
            }

            // 频率链表头尾
            private struct FrequencyList
            {
                public int headIndex;  // 该频率链表的头节点（最久未使用）
                public int tailIndex;  // 该频率链表的尾节点（最近使用）

                public readonly bool IsEmpty => headIndex == -1;
            }

            private readonly NativeHashMap<TKey, int> keyToNodeIndex;   // key -> nodeIndex
            private NativeList<Node> nodes;                             // 节点池
            private readonly NativeList<int> freeList;                  // 空闲节点索引
            private NativeHashMap<int, FrequencyList> freqToList;       // frequency -> FrequencyList

            private readonly int capacity;
            private int count;
            private int minFrequency;  // 当前最小频率

            public NativeLFUCache(int capacity, Allocator allocator)
            {
                this.capacity = capacity;
                this.count = 0;
                this.minFrequency = 0;

                keyToNodeIndex = new NativeHashMap<TKey, int>(capacity, allocator);
                nodes = new NativeList<Node>(capacity, allocator);
                freeList = new NativeList<int>(capacity, allocator);
                freqToList = new NativeHashMap<int, FrequencyList>(capacity, allocator);

                // 预分配节点池
                nodes.Length = capacity;
                for (int i = capacity - 1; i >= 0; i--)
                {
                    freeList.Add(i);
                }
            }

            /// <summary>
            /// 获取缓存值并增加频率
            /// </summary>
            public bool TryGetValue(TKey key, out TValue value)
            {
                if (keyToNodeIndex.TryGetValue(key, out int nodeIndex))
                {
                    // 增加访问频率
                    IncreaseFrequency(nodeIndex);

                    value = nodes[nodeIndex].value;
                    return true;
                }

                value = default;
                return false;
            }

            /// <summary>
            /// 添加或更新缓存
            /// </summary>
            public void Put(TKey key, TValue value)
            {
                // 更新现有值
                if (keyToNodeIndex.TryGetValue(key, out int nodeIndex))
                {
                    Node node = nodes[nodeIndex];
                    node.value = value;
                    nodes[nodeIndex] = node;

                    IncreaseFrequency(nodeIndex);
                    return;
                }

                // 容量已满，淘汰最小频率的节点
                if (count >= capacity)
                {
                    EvictMinFrequencyNode();
                }

                // 创建新节点，初始频率为1
                nodeIndex = AllocateNode();
                nodes[nodeIndex] = new Node
                {
                    key = key,
                    value = value,
                    frequency = 1,
                    prevIndex = -1,
                    nextIndex = -1
                };

                keyToNodeIndex.Add(key, nodeIndex);
                AddToFrequencyList(nodeIndex, 1);

                // 更新最小频率
                if (minFrequency == 0)
                {
                    minFrequency = 1;
                }

                count++;
            }

            /// <summary>
            /// 删除缓存项
            /// </summary>
            public bool Remove(TKey key)
            {
                if (!keyToNodeIndex.TryGetValue(key, out int nodeIndex))
                    return false;

                RemoveNode(nodeIndex);
                return true;
            }

            /// <summary>
            /// 清空缓存
            /// </summary>
            public void Clear()
            {
                keyToNodeIndex.Clear();
                freqToList.Clear();

                // 重置所有节点到空闲列表
                freeList.Clear();
                for (int i = 0; i < capacity; i++)
                {
                    freeList.Add(i);
                }

                minFrequency = 0;
                count = 0;
            }

            /// <summary>
            /// 释放所有内存
            /// </summary>
            public void Dispose()
            {
                if (keyToNodeIndex.IsCreated) keyToNodeIndex.Dispose();
                if (nodes.IsCreated) nodes.Dispose();
                if (freeList.IsCreated) freeList.Dispose();
                if (freqToList.IsCreated) freqToList.Dispose();

                minFrequency = 0;
                count = 0;
            }

            #region 内部辅助方法

            private int AllocateNode()
            {
                int index = freeList[^1];
                freeList.RemoveAtSwapBack(freeList.Length - 1);
                return index;
            }

            private void FreeNode(int index)
            {
                freeList.Add(index);
            }

            /// <summary>
            /// 增加节点的访问频率
            /// </summary>
            private void IncreaseFrequency(int nodeIndex)
            {
                Node node = nodes[nodeIndex];
                int oldFreq = node.frequency;
                int newFreq = oldFreq + 1;

                // 从旧频率链表移除
                RemoveFromFrequencyList(nodeIndex, oldFreq);

                // 检查是否需要更新最小频率
                if (oldFreq == minFrequency && GetFrequencyListHead(oldFreq) == -1)
                {
                    minFrequency = newFreq;
                }

                // 更新节点频率
                node.frequency = newFreq;
                nodes[nodeIndex] = node;

                // 添加到新频率链表
                AddToFrequencyList(nodeIndex, newFreq);
            }

            /// <summary>
            /// 从频率链表中移除节点
            /// </summary>
            private void RemoveFromFrequencyList(int nodeIndex, int frequency)
            {
                if (!freqToList.TryGetValue(frequency, out var list))
                    return;

                Node node = nodes[nodeIndex];

                // 如果是头节点
                if (node.prevIndex == -1)
                {
                    list.headIndex = node.nextIndex;
                }
                else
                {
                    // 更新前一个节点的next指针
                    Node prevNode = nodes[node.prevIndex];
                    prevNode.nextIndex = node.nextIndex;
                    nodes[node.prevIndex] = prevNode;
                }

                // 如果是尾节点
                if (node.nextIndex == -1)
                {
                    list.tailIndex = node.prevIndex;
                }
                else
                {
                    // 更新后一个节点的prev指针
                    Node nextNode = nodes[node.nextIndex];
                    nextNode.prevIndex = node.prevIndex;
                    nodes[node.nextIndex] = nextNode;
                }

                // 如果链表变空，移除该频率
                if (list.headIndex == -1)
                {
                    freqToList.Remove(frequency);
                }
                else
                {
                    freqToList[frequency] = list;
                }
            }

            /// <summary>
            /// 将节点添加到频率链表尾部
            /// </summary>
            private void AddToFrequencyList(int nodeIndex, int frequency)
            {
                if (!freqToList.TryGetValue(frequency, out var list))
                {
                    // 创建新的频率链表
                    list = new FrequencyList { headIndex = nodeIndex, tailIndex = nodeIndex };
                    freqToList.Add(frequency, list);

                    // 设置节点指针
                    Node node = nodes[nodeIndex];
                    node.prevIndex = -1;
                    node.nextIndex = -1;
                    nodes[nodeIndex] = node;
                }
                else
                {
                    // 添加到链表尾部
                    int oldTail = list.tailIndex;

                    // 更新原尾节点
                    Node oldTailNode = nodes[oldTail];
                    oldTailNode.nextIndex = nodeIndex;
                    nodes[oldTail] = oldTailNode;

                    // 设置新节点
                    Node newNode = nodes[nodeIndex];
                    newNode.prevIndex = oldTail;
                    newNode.nextIndex = -1;
                    nodes[nodeIndex] = newNode;

                    // 更新链表尾
                    list.tailIndex = nodeIndex;
                    freqToList[frequency] = list;
                }
            }

            /// <summary>
            /// 获取频率链表的头节点
            /// </summary>
            private int GetFrequencyListHead(int frequency)
            {
                if (freqToList.TryGetValue(frequency, out var list))
                {
                    return list.headIndex;
                }
                return -1;
            }

            /// <summary>
            /// 淘汰最小频率的节点（淘汰该频率链表的头节点）
            /// </summary>
            private void EvictMinFrequencyNode()
            {
                // 找到有节点的最小频率
                while (minFrequency <= capacity && GetFrequencyListHead(minFrequency) == -1)
                {
                    minFrequency++;
                }

                if (minFrequency > capacity) return;

                int headIndex = GetFrequencyListHead(minFrequency);
                if (headIndex == -1) return;

                RemoveNode(headIndex);
            }

            /// <summary>
            /// 移除完整节点（从所有数据结构中删除）
            /// </summary>
            private void RemoveNode(int nodeIndex)
            {
                Node node = nodes[nodeIndex];

                // 从频率链表移除
                RemoveFromFrequencyList(nodeIndex, node.frequency);

                // 从主HashMap移除
                keyToNodeIndex.Remove(node.key);

                // 回收节点
                FreeNode(nodeIndex);
                count--;
            }

            #endregion

            // 属性访问器
            public readonly int Count => count;
            public readonly int Capacity => capacity;
            public readonly bool IsCreated => keyToNodeIndex.IsCreated;
        }

        public struct NativeARCCache<TKey, TValue> : IDisposable
            where TKey : unmanaged, IEquatable<TKey>
            where TValue : unmanaged
        {
            private const int LIST_T1 = 0, LIST_T2 = 1, LIST_B1 = 2, LIST_B2 = 3;

            private struct Node
            {
                public TKey key;
                public TValue value;
                public byte listType;
                public int prevIndex;
                public int nextIndex;
            }

            private NativeHashMap<TKey, int> keyToNode;
            private NativeList<Node> nodes;
            private NativeList<int> freeList;

            // 四个链表头尾指针
            private int t1Head, t1Tail, t2Head, t2Tail, b1Head, b1Tail, b2Head, b2Tail;

            private int capacity, t1Count, t2Count, b1Count, b2Count, p;

            public NativeARCCache(int capacity, Allocator allocator)
            {
                this.capacity = capacity;
                this.t1Count = this.t2Count = this.b1Count = this.b2Count = 0;
                this.p = 0;

                t1Head = t1Tail = t2Head = t2Tail = -1;
                b1Head = b1Tail = b2Head = b2Tail = -1;

                int totalNodes = capacity * 2;
                keyToNode = new NativeHashMap<TKey, int>(totalNodes, allocator);
                nodes = new NativeList<Node>(totalNodes, allocator);
                freeList = new NativeList<int>(totalNodes, allocator);

                nodes.Length = totalNodes;
                for (int i = totalNodes - 1; i >= 0; i--)
                {
                    freeList.Add(i);
                }
            }

            public bool TryGetValue(TKey key, out TValue value)
            {
                if (keyToNode.TryGetValue(key, out int nodeIndex))
                {
                    Node node = nodes[nodeIndex]; // 先读取

                    if (node.listType == LIST_T1 || node.listType == LIST_T2)
                    {
                        MoveToMRU(nodeIndex, LIST_T2);
                        value = node.value;
                        return true;
                    }

                    if (node.listType == LIST_B1)
                    {
                        node = ComputeNewPAndReplace(node, b2Count, b1Count, true);
                        b1Count--; t2Count++;
                        value = node.value;
                        return true;
                    }

                    if (node.listType == LIST_B2)
                    {
                        node = ComputeNewPAndReplace(node, b1Count, b2Count, false);
                        b2Count--; t2Count++;
                        value = node.value;
                        return true;
                    }
                }

                value = default;
                return false;
            }

            public void Put(TKey key, TValue value)
            {
                if (keyToNode.TryGetValue(key, out int nodeIndex))
                {
                    Node node = nodes[nodeIndex];
                    node.value = value;

                    if (node.listType == LIST_T1 || node.listType == LIST_T2)
                    {
                        MoveToMRU(nodeIndex, LIST_T2);
                    }
                    else if (node.listType == LIST_B1)
                    {
                        node = ComputeNewPAndReplace(node, b2Count, b1Count, true);
                        b1Count--; t2Count++;
                    }
                    else if (node.listType == LIST_B2)
                    {
                        node = ComputeNewPAndReplace(node, b1Count, b2Count, false);
                        b2Count--; t2Count++;
                    }

                    nodes[nodeIndex] = node; // 写回
                    return;
                }

                // 容量满，执行Replace
                int totalSize = t1Count + t2Count;
                if (totalSize >= capacity)
                {
                    Replace();
                }

                // 创建新节点到T1
                nodeIndex = AllocateNode();
                nodes[nodeIndex] = new Node
                {
                    key = key,
                    value = value,
                    listType = LIST_T1,
                    prevIndex = -1,
                    nextIndex = -1
                };

                keyToNode.Add(key, nodeIndex);
                AddToHead(nodeIndex, LIST_T1);
                t1Count++;
            }

            private Node ComputeNewPAndReplace(Node node, int oppositeCount, int sameCount, bool isB1)
            {
                int delta = (oppositeCount >= sameCount) ? 1 : oppositeCount / sameCount + 1;

                // 先修改p值
                if (isB1) p = Math.Min(p + delta, capacity);
                else p = Math.Max(p - delta, 0);

                // 执行替换
                Replace();

                // 移动节点
                MoveBetweenLists(node.prevIndex, node.listType, LIST_T2);
                node.listType = LIST_T2;

                return node;
            }

            private void Replace()
            {
                if (t1Count > 0 && (t1Count > p || (b2Count > 0 && t1Count == p)))
                {
                    MoveBetweenLists(t1Head, LIST_T1, LIST_B1);
                    t1Count--; b1Count++;

                    if (b1Count > capacity)
                    {
                        int old = b1Head; Node n = nodes[old];
                        RemoveFromList(old);
                        keyToNode.Remove(n.key);
                        FreeNode(old);
                        b1Count--;
                    }
                }
                else
                {
                    MoveBetweenLists(t2Head, LIST_T2, LIST_B2);
                    t2Count--; b2Count++;

                    if (b2Count > capacity)
                    {
                        int old = b2Head; Node n = nodes[old];
                        RemoveFromList(old);
                        keyToNode.Remove(n.key);
                        FreeNode(old);
                        b2Count--;
                    }
                }
            }

            #region 链表操作

            private void MoveToMRU(int nodeIndex, byte targetList)
            {
                RemoveFromList(nodeIndex);
                AddToHead(nodeIndex, targetList);
            }

            private void MoveBetweenLists(int nodeIndex, byte fromList, byte toList)
            {
                RemoveFromList(nodeIndex);
                AddToHead(nodeIndex, toList);
            }

            private void AddToHead(int nodeIndex, byte listType)
            {
                Node node = nodes[nodeIndex]; // 读取
                node.listType = listType;
                node.prevIndex = -1;

                switch (listType)
                {
                    case LIST_T1:
                        node.nextIndex = t1Head;
                        nodes[nodeIndex] = node; // 写回
                        if (t1Head != -1)
                        {
                            Node headNode = nodes[t1Head];
                            headNode.prevIndex = nodeIndex;
                            nodes[t1Head] = headNode; // 写回
                        }
                        t1Head = nodeIndex;
                        if (t1Tail == -1) t1Tail = nodeIndex;
                        break;

                    case LIST_T2:
                        node.nextIndex = t2Head;
                        nodes[nodeIndex] = node; // 写回
                        if (t2Head != -1)
                        {
                            Node headNode = nodes[t2Head];
                            headNode.prevIndex = nodeIndex;
                            nodes[t2Head] = headNode; // 写回
                        }
                        t2Head = nodeIndex;
                        if (t2Tail == -1) t2Tail = nodeIndex;
                        break;

                    case LIST_B1:
                        node.nextIndex = b1Head;
                        nodes[nodeIndex] = node; // 写回
                        if (b1Head != -1)
                        {
                            Node headNode = nodes[b1Head];
                            headNode.prevIndex = nodeIndex;
                            nodes[b1Head] = headNode; // 写回
                        }
                        b1Head = nodeIndex;
                        if (b1Tail == -1) b1Tail = nodeIndex;
                        break;

                    case LIST_B2:
                        node.nextIndex = b2Head;
                        nodes[nodeIndex] = node; // 写回
                        if (b2Head != -1)
                        {
                            Node headNode = nodes[b2Head];
                            headNode.prevIndex = nodeIndex;
                            nodes[b2Head] = headNode; // 写回
                        }
                        b2Head = nodeIndex;
                        if (b2Tail == -1) b2Tail = nodeIndex;
                        break;
                }
            }

            private void RemoveFromList(int nodeIndex)
            {
                Node node = nodes[nodeIndex]; // 读取
                int prev = node.prevIndex;
                int next = node.nextIndex;

                // 根据类型更新头尾指针
                switch (node.listType)
                {
                    case LIST_T1:
                        if (nodeIndex == t1Head) t1Head = next;
                        if (nodeIndex == t1Tail) t1Tail = prev;
                        break;
                    case LIST_T2:
                        if (nodeIndex == t2Head) t2Head = next;
                        if (nodeIndex == t2Tail) t2Tail = prev;
                        break;
                    case LIST_B1:
                        if (nodeIndex == b1Head) b1Head = next;
                        if (nodeIndex == b1Tail) b1Tail = prev;
                        break;
                    case LIST_B2:
                        if (nodeIndex == b2Head) b2Head = next;
                        if (nodeIndex == b2Tail) b2Tail = prev;
                        break;
                }

                // 更新邻居
                if (prev != -1)
                {
                    Node prevNode = nodes[prev];
                    prevNode.nextIndex = next;
                    nodes[prev] = prevNode; // 写回
                }
                if (next != -1)
                {
                    Node nextNode = nodes[next];
                    nextNode.prevIndex = prev;
                    nodes[next] = nextNode; // 写回
                }

                node.prevIndex = node.nextIndex = -1;
                nodes[nodeIndex] = node; // 写回
            }

            #endregion

            private int AllocateNode()
            {
                int index = freeList[^1];
                freeList.RemoveAtSwapBack(freeList.Length - 1);
                return index;
            }

            private void FreeNode(int index)
            {
                freeList.Add(index);
            }

            public bool Remove(TKey key)
            {
                if (!keyToNode.TryGetValue(key, out int nodeIndex))
                    return false;

                Node node = nodes[nodeIndex]; // 读取

                // 更新计数
                if (node.listType == LIST_T1) t1Count--;
                else if (node.listType == LIST_T2) t2Count--;
                else if (node.listType == LIST_B1) b1Count--;
                else if (node.listType == LIST_B2) b2Count--;

                RemoveFromList(nodeIndex);
                keyToNode.Remove(key);
                FreeNode(nodeIndex);

                return true;
            }

            public void Clear()
            {
                keyToNode.Clear();

                freeList.Clear();
                for (int i = 0; i < nodes.Length; i++)
                {
                    freeList.Add(i);
                }

                t1Head = t1Tail = t2Head = t2Tail = -1;
                b1Head = b1Tail = b2Head = b2Tail = -1;

                t1Count = t2Count = b1Count = b2Count = 0;
                p = 0;
            }

            public void Dispose()
            {
                if (keyToNode.IsCreated) keyToNode.Dispose();
                if (nodes.IsCreated) nodes.Dispose();
                if (freeList.IsCreated) freeList.Dispose();

                t1Head = t1Tail = t2Head = t2Tail = -1;
                b1Head = b1Tail = b2Head = b2Tail = -1;

                t1Count = t2Count = b1Count = b2Count = 0;
                p = 0;
            }

            public int Count => t1Count + t2Count;
            public int Capacity => capacity;
            public bool IsCreated => keyToNode.IsCreated;
            public int T1Count => t1Count;
            public int T2Count => t2Count;
            public int PValue => p;
        }
    }
}