com.alicizax.unity.framework/Runtime/UI/Manager/UIService.Open.cs

using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using AlicizaX;
using Cysharp.Threading.Tasks;

namespace AlicizaX.UI.Runtime
{
    readonly struct LayerData
    {
        public readonly List<UIMetadata> OrderList; // 维护插入顺序
        public readonly HashSet<RuntimeTypeHandle> HandleSet; // O(1)存在性检查
        public readonly Dictionary<RuntimeTypeHandle, int> IndexMap; // O(1)索引查找

        public LayerData(int initialCapacity)
        {
            OrderList = new List<UIMetadata>(initialCapacity);
            HandleSet = new HashSet<RuntimeTypeHandle>();
            IndexMap = new Dictionary<RuntimeTypeHandle, int>(initialCapacity);
        }
    }

    internal sealed partial class UIService
    {
        private readonly LayerData[] _openUI = new LayerData[(int)UILayer.All];

        private async UniTask<UIBase> ShowUIImplAsync(UIMetadata metaInfo, params object[] userDatas)
        {
            CreateMetaUI(metaInfo);
            await UIHolderFactory.CreateUIResourceAsync(metaInfo, UICacheLayer);
            if (metaInfo.View == null || metaInfo.State == UIState.Uninitialized || metaInfo.State == UIState.Destroyed)
            {
                return null;
            }

            FinalizeShow(metaInfo, userDatas);
            await UpdateVisualState(metaInfo, metaInfo.CancellationToken);
            return metaInfo.View;
        }

        private UIBase ShowUIImplSync(UIMetadata metaInfo, params object[] userDatas)
        {
            CreateMetaUI(metaInfo);
            UIHolderFactory.CreateUIResourceSync(metaInfo, UICacheLayer);
            if (metaInfo.View == null || metaInfo.State == UIState.Uninitialized || metaInfo.State == UIState.Destroyed)
            {
                return null;
            }

            FinalizeShow(metaInfo, userDatas);
            UpdateVisualState(metaInfo).Forget();
            return metaInfo.View;
        }

        private async UniTask CloseUIImpl(UIMetadata meta, bool force)
        {
            if (meta.State == UIState.Uninitialized)
            {
                return;
            }

            if (meta.State == UIState.CreatedUI)
            {
                meta.CancelAsyncOperations();
                meta.Dispose();
                return;
            }

            if (meta.State == UIState.Loaded || meta.State == UIState.Initialized)
            {
                meta.CancelAsyncOperations();
                Pop(meta);
                SortWindowVisible(meta.MetaInfo.UILayer);
                SortWindowDepth(meta.MetaInfo.UILayer);
                meta.View.Visible = false;
                CacheWindow(meta, force);
                return;
            }

            meta.CancelAsyncOperations();
            await meta.View.InternalClose();
            if (meta.State != UIState.Closed)
            {
                return;
            }

            Pop(meta);
            SortWindowVisible(meta.MetaInfo.UILayer);
            SortWindowDepth(meta.MetaInfo.UILayer);
            CacheWindow(meta, force);
        }


        private UIBase GetUIImpl(UIMetadata meta)
        {
            return meta.View;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void CreateMetaUI(UIMetadata meta)
        {
            if (meta.State == UIState.Uninitialized) meta.CreateUI();
        }


        private void FinalizeShow(UIMetadata meta, object[] userDatas)
        {
            if (meta.InCache)
            {
                RemoveFromCache(meta.MetaInfo.RuntimeTypeHandle);
                Push(meta);
            }
            else
            {
                switch (meta.State)
                {
                    case UIState.Loaded:
                        Push(meta);
                        break;
                    case UIState.Opening:
                    case UIState.Closing:
                    case UIState.Opened:
                        MoveToTop(meta);
                        break;
                }
            }

            meta.View.RefreshParams(userDatas);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void Push(UIMetadata meta)
        {
            ref var layer = ref _openUI[meta.MetaInfo.UILayer];
            if (layer.HandleSet.Add(meta.MetaInfo.RuntimeTypeHandle))
            {
                int index = layer.OrderList.Count;
                layer.OrderList.Add(meta);
                layer.IndexMap[meta.MetaInfo.RuntimeTypeHandle] = index;
                UpdateLayerParent(meta);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void Pop(UIMetadata meta)
        {
            ref var layer = ref _openUI[meta.MetaInfo.UILayer];
            if (layer.HandleSet.Remove(meta.MetaInfo.RuntimeTypeHandle))
            {
                if (layer.IndexMap.TryGetValue(meta.MetaInfo.RuntimeTypeHandle, out int index))
                {
                    layer.OrderList.RemoveAt(index);
                    layer.IndexMap.Remove(meta.MetaInfo.RuntimeTypeHandle);

                    // Update indices for all elements after the removed one
                    for (int i = index; i < layer.OrderList.Count; i++)
                    {
                        var m = layer.OrderList[i];
                        layer.IndexMap[m.MetaInfo.RuntimeTypeHandle] = i;
                    }
                }
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void UpdateLayerParent(UIMetadata meta)
        {
            if (meta.View?.Holder != null && meta.View.Holder.IsValid())
            {
                var layerRect = GetLayerRect(meta.MetaInfo.UILayer);
                meta.View.Holder.transform.SetParent(layerRect);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void MoveToTop(UIMetadata meta)
        {
            ref var layer = ref _openUI[meta.MetaInfo.UILayer];
            int lastIdx = layer.OrderList.Count - 1;

            if (!layer.IndexMap.TryGetValue(meta.MetaInfo.RuntimeTypeHandle, out int currentIdx))
                return;

            if (currentIdx != lastIdx && currentIdx >= 0)
            {
                layer.OrderList.RemoveAt(currentIdx);
                layer.OrderList.Add(meta);

                for (int i = currentIdx; i < lastIdx; i++)
                {
                    var m = layer.OrderList[i];
                    layer.IndexMap[m.MetaInfo.RuntimeTypeHandle] = i;
                }

                layer.IndexMap[meta.MetaInfo.RuntimeTypeHandle] = lastIdx;

                SortWindowDepth(meta.MetaInfo.UILayer, currentIdx);
            }
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private async UniTask UpdateVisualState(UIMetadata meta, CancellationToken cancellationToken = default)
        {
            SortWindowVisible(meta.MetaInfo.UILayer);
            SortWindowDepth(meta.MetaInfo.UILayer);
            if (meta.State == UIState.Loaded)
            {
                await meta.View.InternalInitlized(cancellationToken);
            }

            await meta.View.InternalOpen(cancellationToken);
        }

        private void SortWindowVisible(int layer)
        {
            var list = _openUI[layer].OrderList;
            int count = list.Count;

            int fullscreenIdx = -1;
            for (int i = count - 1; i >= 0; i--)
            {
                var meta = list[i];
                if (meta.MetaInfo.FullScreen && UIStateMachine.IsDisplayActive(meta.State))
                {
                    fullscreenIdx = i;
                    break;
                }
            }

            if (fullscreenIdx == -1)
            {
                for (int i = 0; i < count; i++)
                {
                    list[i].View.Visible = true;
                }
            }
            else
            {
                for (int i = 0; i < count; i++)
                {
                    list[i].View.Visible = (i >= fullscreenIdx);
                }
            }
        }

        private void SortWindowDepth(int layer, int startIndex = 0)
        {
            var list = _openUI[layer].OrderList;
            int baseDepth = layer * LAYER_DEEP;

            for (int i = startIndex; i < list.Count; i++)
            {
                int newDepth = baseDepth + i * WINDOW_DEEP;

                if (list[i].View.Depth != newDepth)
                {
                    list[i].View.Depth = newDepth;
                }
            }
        }
    }
}