using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Pool;
using Object = UnityEngine.Object;

namespace XericUI.ReflectionUIGenerator
{
    /// <summary>
    /// 节点下生成反射属性管理器 — MVM (Metadata-Driven View Model)
    /// 负责：构建 Entry → 创建组容器（树状嵌套）→ 生成 UI → 绑定数据
    /// </summary>
    public class XuiavrgInspectorManager : MonoBehaviour
    {
        #region 对象池

        private Dictionary<GameObject, ObjectPool<GameObject>> _prefabPools
            = new Dictionary<GameObject, ObjectPool<GameObject>>();

        public GameObject PrefabPoolGet(GameObject prefab)
        {
            if (prefab == null) return null;

            if (!_prefabPools.TryGetValue(prefab, out var pool))
            {
                pool = new ObjectPool<GameObject>(
                    createFunc: () =>
                        prefab != null
                            ? Object.Instantiate(prefab, transform)
                            : new GameObject("PropertyItem", typeof(RectTransform)),
                    actionOnGet: go => go.SetActive(true),
                    actionOnRelease: go => go.SetActive(false),
                    actionOnDestroy: go =>
                    {
                        if (go) Destroy(go);
                    },
                    collectionCheck: false,
                    defaultCapacity: 4,
                    maxSize: 64
                );
                _prefabPools[prefab] = pool;
            }

            return pool.Get();
        }

        public void PrefabPoolRelease(GameObject prefab, GameObject instance)
        {
            if (prefab == null || instance == null) return;
            if (_prefabPools.TryGetValue(prefab, out var pool))
            {
                pool.Release(instance);
            }
            else
            {
                if (instance) Destroy(instance);
            }
        }

        public void ClearAllPrefabPools()
        {
            foreach (var pool in _prefabPools.Values)
            {
                pool.Clear();
            }

            _prefabPools.Clear();
        }

        #endregion

        #region 字段

        public List<IFieldEntry> CurrentEntries { get; private set; } = new List<IFieldEntry>();
        public AvrgMvvmBindingCollection CurrentBindingCollection { get; private set; }
        public AvrgMemberMetaDataSet CurrentMetaDataSet { get; private set; }

        /// <summary>
        /// 编组叶节点字典 — 完整 GroupPath → 对应层级的 XuiAvrgMDGroup
        /// </summary>
        private Dictionary<string, XuiAvrgMDGroup> _leafGroupMap = new Dictionary<string, XuiAvrgMDGroup>();

        [Tooltip("类型-预制体映射配置 ScriptableObject")]
        public AvrgTypePrefabMappingConfig typePrefabMappingConfig;

        #endregion

        #region Unity 生命周期

        private void OnEnable()
        {
            XuiavrgStyleDefaults.EnsureDefaults();
        }

        private void OnDestroy()
        {
            ClearAll();
        }

        #endregion

        #region 核心生命周期

        public void BuildFromMetaDataSet(AvrgMemberMetaDataSet metaDataSet,
            AvrgMvvmBindingCollection bindingCollection = null)
        {
            ClearCurrentEntries();
            CurrentMetaDataSet = metaDataSet;
            CurrentBindingCollection = bindingCollection;

            if (metaDataSet == null)
            {
                Debug.LogError("[Xuiavrg] 未指定元数据集，无法构建 Entry");
                return;
            }

            foreach (var metaData in metaDataSet.MetaDataList)
            {
                if (metaData.Hide)
                    continue;

                var entry = XuiFieldTempEntry.Get();
                entry.Initialize(
                    string.IsNullOrEmpty(metaData.GroupPath) ? metaData.MemberName : metaData.GroupPath,
                    metaData.Tag,
                    metaData.TagIndex);

                if (bindingCollection != null)
                {
                    var scheduler = bindingCollection.Scheduler;
                    var matchedBinding = bindingCollection.FindByMemberName(metaData.MemberName);
                    if (matchedBinding != null)
                    {
                        entry.AddBinding(matchedBinding, scheduler);
                    }
                    else
                    {
                        foreach (var binding in bindingCollection)
                        {
                            entry.AddBinding(binding, scheduler);
                            break;
                        }
                    }
                }

                entry.FieldOrder = metaData.FieldOrder;
                CurrentEntries.Add(entry);
            }

            OnPostBuildEntries(CurrentEntries);
            SortEntries();
        }

        public void SetBindingCollection(AvrgMvvmBindingCollection bindingCollection)
        {
            CurrentBindingCollection = bindingCollection;

            if (CurrentEntries != null && bindingCollection != null)
            {
                var scheduler = bindingCollection.Scheduler;
                foreach (var entry in CurrentEntries)
                {
                    if (entry is XuiFieldTempEntry tempEntry)
                    {
                        var matched = bindingCollection.FindByMemberName(entry.EntryName);
                        if (matched != null)
                            tempEntry.AddBinding(matched, scheduler);
                    }
                }
            }
        }

        protected virtual void OnPostBuildEntries(List<IFieldEntry> entries)
        {
        }

        private void SortEntries()
        {
            CurrentEntries.Sort((a, b) =>
            {
                int orderCompare = a.FieldOrder.CompareTo(b.FieldOrder);
                if (orderCompare != 0) return orderCompare;
                return string.Compare(a.EntryName, b.EntryName, StringComparison.Ordinal);
            });
        }

        // ============ 四阶段 GenerateUI ============

        /// <summary>
        /// 生成 UI — 四阶段流程
        /// Phase A: 按 GroupPath 分组
        /// Phase B: 构建路径树，创建嵌套的 XuiAvrgMDGroup 容器
        /// Phase C: 在叶节点容器内生成 UI 组件并绑定
        /// Phase D: 处理非编组 Entry 直接放进根目录
        /// </summary>
        public void GenerateUI()
        {
            if (CurrentEntries == null || CurrentEntries.Count == 0)
            {
                Debug.LogWarning("[Xuiavrg] 没有可生成的 Entry，请先调用 BuildFromMetaDataSet");
                return;
            }

            // Phase A: 按完整 GroupPath 分组
            var groupedEntries = new Dictionary<string, List<IFieldEntry>>();
            var ungroupedEntries = new List<IFieldEntry>();

            foreach (var entry in CurrentEntries)
            {
                string groupPath = GetGroupPathFromEntry(entry);

                if (!string.IsNullOrEmpty(groupPath))
                {
                    if (!groupedEntries.ContainsKey(groupPath))
                        groupedEntries[groupPath] = new List<IFieldEntry>();
                    groupedEntries[groupPath].Add(entry);
                }
                else
                {
                    ungroupedEntries.Add(entry);
                }
            }

            // Phase B: 构建树状嵌套组容器
            _leafGroupMap.Clear();
            BuildGroupTree(groupedEntries.Keys);

            // Phase C: 在叶节点容器内生成 UI
            foreach (var kvp in groupedEntries)
            {
                string groupPath = kvp.Key;
                var entries = kvp.Value;

                if (!_leafGroupMap.TryGetValue(groupPath, out var leafGroup)) continue;

                foreach (var entry in entries)
                {
                    GenerateSingleUI(entry, leafGroup.contentRoot);
                }
            }

            // Phase D: 非编组 Entry 直接放进根
            foreach (var entry in ungroupedEntries)
            {
                GenerateSingleUI(entry, transform);
            }
        }

        // ============ 树状编组容器构建 ============

        private void BuildGroupTree(IEnumerable<string> allGroupPaths)
        {
            var rootNode = new GroupTreeNode(null);

            foreach (var fullPath in allGroupPaths)
            {
                if (string.IsNullOrEmpty(fullPath)) continue;

                var segments = fullPath.Split('/');
                var current = rootNode;

                for (int i = 0; i < segments.Length; i++)
                {
                    string seg = segments[i];
                    if (!current.Children.ContainsKey(seg))
                        current.Children[seg] = new GroupTreeNode(seg);
                    current = current.Children[seg];
                }
            }

            CreateGroupGameObjects(rootNode, null, transform, "");
        }

        private void CreateGroupGameObjects(
            GroupTreeNode node,
            XuiAvrgMDGroup parentGroup,
            Transform parentTransform,
            string accumulatedPath)
        {
            foreach (var kvp in node.Children)
            {
                string segName = kvp.Key;
                var childNode = kvp.Value;

                string childFullPath = string.IsNullOrEmpty(accumulatedPath)
                    ? segName
                    : accumulatedPath + "/" + segName;

                var groupGo = new GameObject($"Group [{childFullPath}]", typeof(RectTransform));
                groupGo.transform.SetParent(parentTransform, false);

                var rect = groupGo.GetComponent<RectTransform>();
                rect.anchorMin = new Vector2(0, 1);
                rect.anchorMax = new Vector2(1, 1);
                rect.pivot = new Vector2(0.5f, 1);
                rect.sizeDelta = new Vector2(0, 0);

                var group = groupGo.AddComponent<XuiAvrgMDGroup>();
                group.Initialize(childFullPath, 0, parentGroup);

                if (childNode.Children.Count == 0)
                {
                    _leafGroupMap[childFullPath] = group;
                }

                CreateGroupGameObjects(childNode, group, group.contentRoot, childFullPath);
            }
        }

        private class GroupTreeNode
        {
            public string SegmentName { get; }
            public Dictionary<string, GroupTreeNode> Children { get; }

            public GroupTreeNode(string name)
            {
                SegmentName = name;
                Children = new Dictionary<string, GroupTreeNode>();
            }
        }

        // ============ 生成单个 UI ============

        private void GenerateSingleUI(IFieldEntry entry, Transform parent)
        {
            if (entry is not XuiFieldTempEntry tempEntry) return;

            var prefab = ResolvePrefab(entry);
            if (prefab == null)
            {
                Debug.LogWarning($"[Xuiavrg] 未找到 Entry '{entry.EntryName}' 的匹配预制体，跳过");
                return;
            }

            entry.BoundPrefab = prefab;
            var uiInstance = PrefabPoolGet(prefab);

            if (uiInstance == null) return;

            uiInstance.name = entry.EntryName;
            uiInstance.transform.SetParent(parent, false);

            if (uiInstance.GetComponentInChildren<XUIAvrgMDValue>(true) == null)
            {
                Debug.LogError(
                    $"[Xuiavrg] 预制体 '{prefab.name}' 不符合生成要求：缺少 XUIAvrgMDValue 组件。请确保预制体根节点或其子节点包含 XUIAvrgMDValue 脚本。");
                PrefabPoolRelease(prefab, uiInstance);
                return;
            }

            entry.BindUIComponent(uiInstance, null);
            entry.OnEntryBind();
        }

        private string GetGroupPathFromEntry(IFieldEntry entry)
        {
            if (entry.Bindings != null && entry.Bindings.Count > 0)
            {
                var metaData = entry.Bindings[0].MetaData;
                if (metaData != null && !string.IsNullOrEmpty(metaData.GroupPath))
                    return metaData.GroupPath;
            }

            return null;
        }

        // ============ 预制体解析 (Tag + 类型匹配) ============

        /// <summary>
        /// 预制体解析优先级：
        /// 1. Tag != None → 按 Tag + 类型匹配（无匹配时报错）
        /// 2. Tag == None → 按类型匹配
        /// 3. defaultPrefab 回退
        /// PrefabOverrideName 已移除，由 Tag + 类型匹配替代
        /// </summary>
        private GameObject ResolvePrefab(IFieldEntry entry)
        {
            if (typePrefabMappingConfig == null)
            {
                Debug.LogError("[Xuiavrg] 未配置 typePrefabMappingConfig");
                return null;
            }

            var bindings = entry.Bindings;
            var valueType = bindings?.Count > 0 ? bindings[0].MetaData?.ValueType : null;

            // 优先级 1: Tag != None → Tag + 类型匹配
            if (entry.Tag != XuiavrgFieldTag.None && valueType != null)
            {
                var taggedPrefab = typePrefabMappingConfig.FindPrefabByTypeAndTag(valueType, entry.Tag);
                if (taggedPrefab != null)
                    return taggedPrefab;

                Debug.LogError(
                    $"[Xuiavrg] 指定 Tag '{entry.Tag}' 的预制体不存在 " +
                    $"(Entry: '{entry.EntryName}', 类型: {valueType.Name})，跳过 UI 生成");
                return null;
            }

            // 优先级 2: Tag == None → 按类型匹配
            if (valueType != null)
            {
                var typeMatch = typePrefabMappingConfig.FindPrefabByType(valueType);
                if (typeMatch != null)
                    return typeMatch;
            }

            // 优先级 3: defaultPrefab 回退
            if (typePrefabMappingConfig.defaultPrefab != null)
            {
                Debug.LogWarning(
                    $"[Xuiavrg] 类型 '{valueType?.Name ?? "未知"}' 无精确匹配，使用默认预制体 '{typePrefabMappingConfig.defaultPrefab.name}'");
                return typePrefabMappingConfig.defaultPrefab;
            }

            Debug.LogError(
                $"[Xuiavrg] 类型 '{valueType?.Name ?? "未知"}' 无匹配预制体，且未配置 defaultPrefab");
            return null;
        }

        // ============ 清理 ============

        public void ClearAll()
        {
            ClearCurrentEntries();
            ClearAllPrefabPools();
            ClearGroups();
            CurrentMetaDataSet = null;
            CurrentBindingCollection = null;
        }

        private void ClearCurrentEntries()
        {
            foreach (var entry in CurrentEntries)
            {
                if (entry.UIInstance != null && entry.BoundPrefab != null)
                {
                    PrefabPoolRelease(entry.BoundPrefab, entry.UIInstance);
                }

                if (entry is XuiFieldTempEntry tempEntry)
                {
                    XuiFieldTempEntry.Release(tempEntry);
                }
            }

            CurrentEntries.Clear();
        }

        private void ClearGroups()
        {
            foreach (var kvp in _leafGroupMap)
            {
                if (kvp.Value != null && kvp.Value.gameObject != null)
                {
                    Destroy(kvp.Value.gameObject);
                }
            }

            _leafGroupMap.Clear();
        }
        
        #endregion
    }
}