using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using AlicizaX.UI.Runtime;
using UnityEditor;
using UnityEditor.Callbacks;
using UnityEditor.SceneManagement;
using UnityEngine;

namespace AlicizaX.UI.Editor
{
    public enum EBindType
    {
        None,
        Widget,
        ListCom
    }

    [Serializable]
    public class UIBindData
    {
        public UIBindData(string name, List<GameObject> objs, Type componentType = null, EBindType bindType = EBindType.None)
        {
            Name = name;
            Objs = objs ?? new List<GameObject>();
            BindType = bindType;
            ComponentType = componentType;
            ResolvedComponentTypes = new List<Type>();

            if (componentType != null && Objs.Count > 0)
            {
                for (var i = 0; i < Objs.Count; i++)
                {
                    ResolvedComponentTypes.Add(componentType);
                }
            }
        }

        public UIBindData(string name, GameObject obj, Type componentType = null, EBindType bindType = EBindType.None)
            : this(name, new List<GameObject> { obj }, componentType, bindType)
        {
        }

        public string Name { get; }

        public List<GameObject> Objs { get; set; }

        public EBindType BindType { get; }

        public Type ComponentType { get; private set; }

        public List<Type> ResolvedComponentTypes { get; }

        public bool IsGameObject => ComponentType == typeof(GameObject);

        public string TypeName => ComponentType?.FullName ?? string.Empty;

        public Type GetFirstOrDefaultType() => ComponentType;

        public void SetComponentType(Type componentType)
        {
            ComponentType = componentType;
        }

        public void AddResolvedObject(GameObject obj, Type componentType)
        {
            if (obj == null)
            {
                return;
            }

            Objs.Add(obj);
            ResolvedComponentTypes.Add(componentType ?? ComponentType);
        }

        public Type GetResolvedComponentType(int index)
        {
            if (index >= 0 && index < ResolvedComponentTypes.Count && ResolvedComponentTypes[index] != null)
            {
                return ResolvedComponentTypes[index];
            }

            return ComponentType;
        }
    }

    public static class UIScriptGeneratorHelper
    {
        private const string GenerateTypeNameKey = "AlicizaX.UI.Generate.TypeName";
        private const string GenerateInstanceIdKey = "AlicizaX.UI.Generate.InstanceId";
        private const string GenerateAssetPathKey = "AlicizaX.UI.Generate.AssetPath";
        private static UIGenerateConfiguration _uiGenerateConfiguration;
        private static IUIIdentifierFormatter _identifierFormatter;
        private static IUIResourcePathResolver _resourcePathResolver;
        private static IUIScriptCodeEmitter _scriptCodeEmitter;
        private static IUIScriptFileWriter _scriptFileWriter;
        private static readonly List<UIBindData> _uiBindDatas = new List<UIBindData>();
        private static readonly HashSet<string> _arrayComponents = new HashSet<string>(StringComparer.Ordinal);
        private static readonly Dictionary<string, Type> _componentTypeCache = new Dictionary<string, Type>(StringComparer.Ordinal);

        private static UIGenerateConfiguration UIConfiguration =>
            _uiGenerateConfiguration ??= UIGenerateConfiguration.Instance;

        private static IUIIdentifierFormatter IdentifierFormatter =>
            ResolveConfiguredService(
                ref _identifierFormatter,
                UIConfiguration.UIIdentifierFormatterTypeName,
                typeof(DefaultUIIdentifierFormatter),
                nameof(IUIIdentifierFormatter));

        private static IUIResourcePathResolver ResourcePathResolver =>
            ResolveConfiguredService(
                ref _resourcePathResolver,
                UIConfiguration.UIResourcePathResolverTypeName,
                typeof(DefaultUIResourcePathResolver),
                nameof(IUIResourcePathResolver));

        private static IUIScriptCodeEmitter ScriptCodeEmitter =>
            ResolveConfiguredService(
                ref _scriptCodeEmitter,
                UIConfiguration.UIScriptCodeEmitterTypeName,
                typeof(DefaultUIScriptCodeEmitter),
                nameof(IUIScriptCodeEmitter));

        private static IUIScriptFileWriter ScriptFileWriter =>
            ResolveConfiguredService(
                ref _scriptFileWriter,
                UIConfiguration.UIScriptFileWriterTypeName,
                typeof(DefaultUIScriptFileWriter),
                nameof(IUIScriptFileWriter));

        private static T ResolveConfiguredService<T>(ref T cachedService, string configuredTypeName, Type defaultType, string serviceName)
            where T : class
        {
            var resolvedTypeName = string.IsNullOrWhiteSpace(configuredTypeName) ? defaultType.FullName : configuredTypeName;
            if (cachedService != null && cachedService.GetType().FullName == resolvedTypeName)
            {
                return cachedService;
            }

            var configuredType = AlicizaX.Utility.Assembly.GetType(resolvedTypeName);
            if (configuredType == null || !typeof(T).IsAssignableFrom(configuredType))
            {
                if (!string.Equals(resolvedTypeName, defaultType.FullName, StringComparison.Ordinal))
                {
                    Debug.LogError(
                        $"UIScriptGeneratorHelper: Could not load {serviceName} type '{resolvedTypeName}'. Falling back to {defaultType.FullName}.");
                }

                configuredType = defaultType;
            }

            cachedService = Activator.CreateInstance(configuredType, true) as T;
            if (cachedService != null)
            {
                return cachedService;
            }

            if (configuredType != defaultType)
            {
                Debug.LogError(
                    $"UIScriptGeneratorHelper: Failed to instantiate {resolvedTypeName} as {serviceName}. Falling back to {defaultType.FullName}.");
                cachedService = Activator.CreateInstance(defaultType, true) as T;
            }

            if (cachedService == null)
            {
                Debug.LogError($"UIScriptGeneratorHelper: Failed to instantiate fallback {defaultType.FullName} as {serviceName}.");
            }

            return cachedService;
        }

        private static bool EnsureGenerationStrategyReady()
        {
            return IdentifierFormatter != null &&
                   ResourcePathResolver != null &&
                   ScriptCodeEmitter != null &&
                   ScriptFileWriter != null;
        }

        private static bool EnsureVariableGenerationStrategyReady()
        {
            return IdentifierFormatter != null &&
                   ScriptCodeEmitter != null;
        }

        private static Type ResolveUIElementComponentType(string uiName)
        {
            if (string.IsNullOrEmpty(uiName))
            {
                return null;
            }

            var componentTypeName = UIConfiguration.UIElementRegexConfigs
                ?.Where(pair => !string.IsNullOrEmpty(pair?.uiElementRegex))
                .FirstOrDefault(pair => uiName.StartsWith(pair.uiElementRegex, StringComparison.Ordinal))
                ?.componentType;

            if (string.IsNullOrWhiteSpace(componentTypeName))
            {
                return null;
            }

            if (_componentTypeCache.TryGetValue(componentTypeName, out var componentType))
            {
                return componentType;
            }

            componentType = ResolveConfiguredComponentType(componentTypeName);

            if (componentType == null)
            {
                Debug.LogError($"UIScriptGeneratorHelper: Could not resolve component type '{componentTypeName}' for '{uiName}'.");
                return null;
            }

            _componentTypeCache[componentTypeName] = componentType;
            return componentType;
        }

        private static Type ResolveConfiguredComponentType(string componentTypeName)
        {
            if (string.IsNullOrWhiteSpace(componentTypeName))
            {
                return null;
            }

            if (componentTypeName == nameof(GameObject))
            {
                return typeof(GameObject);
            }

            Type componentType = AlicizaX.Utility.Assembly.GetType(componentTypeName);
            if (componentType != null && typeof(Component).IsAssignableFrom(componentType))
            {
                return componentType;
            }

            return AlicizaX.Utility.Assembly.GetTypes()
                .Where(type => type != null && !type.IsAbstract && !type.IsInterface)
                .Where(type => typeof(Component).IsAssignableFrom(type))
                .Where(type => string.Equals(type.FullName, componentTypeName, StringComparison.Ordinal)
                    || string.Equals(type.Name, componentTypeName, StringComparison.Ordinal))
                .OrderBy(type => string.Equals(type.FullName, componentTypeName, StringComparison.Ordinal) ? 0 : 1)
                .ThenBy(type => string.Equals(type.Namespace, "UnityEngine.UI", StringComparison.Ordinal) ? 0 : 1)
                .ThenBy(type => type.FullName, StringComparer.Ordinal)
                .FirstOrDefault();
        }

        private static string[] SplitComponentName(string name)
        {
            if (string.IsNullOrEmpty(name)) return null;

            var common = UIConfiguration.UIGenerateCommonData;
            if (string.IsNullOrEmpty(common?.ComCheckEndName) || !name.Contains(common.ComCheckEndName))
                return null;

            var endIndex = name.IndexOf(common.ComCheckEndName, StringComparison.Ordinal);
            if (endIndex <= 0) return null;

            var comStr = name.Substring(0, endIndex);
            var split = common.ComCheckSplitName ?? "#";

            return comStr.Split(new[] { split }, StringSplitOptions.RemoveEmptyEntries);
        }

        private static bool TryResolveActualComponentType(GameObject source, Type componentType, out Type actualComponentType)
        {
            actualComponentType = null;

            if (source == null || componentType == null)
            {
                return false;
            }

            if (componentType == typeof(GameObject))
            {
                actualComponentType = typeof(GameObject);
                return true;
            }

            var component = ResolveAssignableComponent(source, componentType);
            if (component == null)
            {
                return false;
            }

            actualComponentType = component.GetType();
            return actualComponentType != null;
        }

        private static Type ResolveBindComponentType(Type configuredType, IEnumerable<Type> actualComponentTypes)
        {
            if (configuredType == typeof(GameObject))
            {
                return typeof(GameObject);
            }

            var resolvedTypes = actualComponentTypes?
                .Where(type => type != null)
                .Distinct()
                .ToList();

            if (resolvedTypes == null || resolvedTypes.Count == 0)
            {
                return configuredType;
            }

            if (resolvedTypes.Count == 1)
            {
                return resolvedTypes[0];
            }

            return FindCommonComponentBaseType(resolvedTypes) ?? configuredType;
        }

        private static Type FindCommonComponentBaseType(IReadOnlyList<Type> componentTypes)
        {
            if (componentTypes == null || componentTypes.Count == 0)
            {
                return null;
            }

            var candidateType = componentTypes[0];
            while (candidateType != null && candidateType != typeof(object))
            {
                if (typeof(Component).IsAssignableFrom(candidateType) &&
                    componentTypes.All(type => candidateType.IsAssignableFrom(type)))
                {
                    return candidateType;
                }

                candidateType = candidateType.BaseType;
            }

            return null;
        }

        private static void CollectBindData(Transform root)
        {
            if (root == null) return;

            foreach (Transform child in root.Cast<Transform>().Where(child => child != null))
            {
                if (ShouldSkipChild(child)) continue;
                var hasWidget = child.GetComponent<UIHolderObjectBase>() != null;
                var isArrayComponent = IsArrayComponent(child.name);

                if (hasWidget)
                {
                    CollectWidget(child);
                }
                else if (isArrayComponent)
                {
                    ProcessArrayComponent(child, root);
                }
                else
                {
                    CollectComponent(child);
                    CollectBindData(child);
                }
            }
        }

        private static bool ShouldSkipChild(Transform child)
        {
            var keywords = UIConfiguration.UIGenerateCommonData.ExcludeKeywords;
            return keywords?.Any(k =>
                !string.IsNullOrEmpty(k) &&
                child.name.IndexOf(k, StringComparison.OrdinalIgnoreCase) >= 0) == true;
        }

        private static bool IsArrayComponent(string componentName)
        {
            var splitName = UIConfiguration.UIGenerateCommonData.ArrayComSplitName;
            return !string.IsNullOrEmpty(splitName) &&
                   componentName.StartsWith(splitName, StringComparison.Ordinal);
        }

        private static void ProcessArrayComponent(Transform child, Transform root)
        {
            var splitCode = UIConfiguration.UIGenerateCommonData.ArrayComSplitName;
            if (!TryGetArrayComponentGroupName(child.name, splitCode, out var groupName))
            {
                return;
            }

            var groupKey = $"{root.GetInstanceID()}::{groupName}";
            if (!_arrayComponents.Add(groupKey))
            {
                return;
            }

            var arrayComponents = root.Cast<Transform>()
                .Where(sibling => IsArrayGroupMember(sibling.name, splitCode, groupName))
                .ToList();

            CollectArrayComponent(arrayComponents, groupName);
        }

        private static void CollectComponent(Transform node)
        {
            if (node == null) return;

            var componentArray = SplitComponentName(node.name);
            if (componentArray == null || componentArray.Length == 0) return;

            foreach (var com in componentArray.Where(com => !string.IsNullOrEmpty(com)))
            {
                var componentType = ResolveUIElementComponentType(com);
                if (componentType == null)
                {
                    continue;
                }

                if (!TryResolveActualComponentType(node.gameObject, componentType, out var actualComponentType))
                {
                    Debug.LogError($"{node.name} does not have component of type {componentType.FullName}");
                    continue;
                }

                var keyName = GetPrivateComponentName(com, node.name, EBindType.None);
                if (_uiBindDatas.Exists(data => data.Name == keyName))
                {
                    Debug.LogError($"Duplicate key found: {keyName}");
                    continue;
                }

                _uiBindDatas.Add(new UIBindData(keyName, node.gameObject, actualComponentType));
            }
        }

        private static void CollectWidget(Transform node)
        {
            if (node == null) return;

            var common = UIConfiguration.UIGenerateCommonData;
            if (node.name.Contains(common.ComCheckEndName, StringComparison.Ordinal) &&
                node.name.Contains(common.ComCheckSplitName, StringComparison.Ordinal))
            {
                Debug.LogWarning($"{node.name} child component cannot contain rule definition symbols!");
                return;
            }

            var component = node.GetComponent<UIHolderObjectBase>();
            if (component == null)
            {
                Debug.LogError($"{node.name} expected to be a widget but does not have UIHolderObjectBase.");
                return;
            }

            var keyName = GetPrivateComponentName(string.Empty, node.name, EBindType.Widget);
            if (_uiBindDatas.Exists(data => data.Name == keyName))
            {
                Debug.LogError($"Duplicate key found: {keyName}");
                return;
            }

            _uiBindDatas.Add(new UIBindData(keyName, component.gameObject, component.GetType(), EBindType.Widget));
        }

        private static void CollectArrayComponent(List<Transform> arrayNode, string nodeName)
        {
            if (arrayNode == null || !arrayNode.Any()) return;

            var componentArray = SplitComponentName(nodeName);
            if (componentArray == null || componentArray.Length == 0)
            {
                Debug.LogWarning($"CollectArrayComponent: {nodeName} has no component definitions.");
                return;
            }

            var orderedNodes = OrderArrayNodes(arrayNode);
            var tempBindDatas = CreateTempBindDatas(componentArray, nodeName);

            PopulateArrayComponents(componentArray, orderedNodes, tempBindDatas);
            _uiBindDatas.AddRange(tempBindDatas);
        }

        private static List<Transform> OrderArrayNodes(List<Transform> arrayNode)
        {
            var splitCode = UIConfiguration.UIGenerateCommonData.ArrayComSplitName;
            return arrayNode
                .Select(node => new { Node = node, Index = ExtractArrayIndex(node.name, splitCode) })
                .OrderBy(x => x.Index ?? int.MaxValue)
                .Select(x => x.Node)
                .ToList();
        }

        private static List<UIBindData> CreateTempBindDatas(string[] componentArray, string nodeName)
        {
            return componentArray.Select(com =>
            {
                var keyName = GetPrivateComponentName(com, nodeName, EBindType.ListCom);
                return new UIBindData(keyName, new List<GameObject>(), null, EBindType.ListCom);
            }).ToList();
        }

        private static void PopulateArrayComponents(string[] componentArray, List<Transform> orderedNodes, List<UIBindData> tempBindDatas)
        {
            for (var index = 0; index < componentArray.Length; index++)
            {
                var com = componentArray[index];
                if (string.IsNullOrEmpty(com)) continue;

                var componentType = ResolveUIElementComponentType(com);
                if (componentType == null) continue;

                foreach (var node in orderedNodes)
                {
                    if (TryResolveActualComponentType(node.gameObject, componentType, out var actualComponentType))
                    {
                        tempBindDatas[index].AddResolvedObject(node.gameObject, actualComponentType);
                    }
                    else
                    {
                        Debug.LogError($"{node.name} does not have component of type {componentType.FullName}");
                    }
                }

                tempBindDatas[index].SetComponentType(
                    ResolveBindComponentType(componentType, tempBindDatas[index].ResolvedComponentTypes));
            }
        }

        private static bool TryGetArrayComponentGroupName(string nodeName, string splitCode, out string groupName)
        {
            groupName = null;
            if (string.IsNullOrEmpty(nodeName) || string.IsNullOrEmpty(splitCode))
            {
                return false;
            }

            var firstIndex = nodeName.IndexOf(splitCode, StringComparison.Ordinal);
            var lastIndex = nodeName.LastIndexOf(splitCode, StringComparison.Ordinal);
            if (firstIndex < 0 || lastIndex <= firstIndex)
            {
                return false;
            }

            groupName = nodeName.Substring(firstIndex + splitCode.Length, lastIndex - (firstIndex + splitCode.Length));
            return !string.IsNullOrEmpty(groupName);
        }

        private static bool IsArrayGroupMember(string nodeName, string splitCode, string groupName)
        {
            return TryGetArrayComponentGroupName(nodeName, splitCode, out var candidateGroupName) &&
                   candidateGroupName.Equals(groupName, StringComparison.Ordinal) &&
                   ExtractArrayIndex(nodeName, splitCode).HasValue;
        }

        private static int? ExtractArrayIndex(string nodeName, string splitCode)
        {
            if (string.IsNullOrEmpty(nodeName) || string.IsNullOrEmpty(splitCode)) return null;

            var lastIndex = nodeName.LastIndexOf(splitCode, StringComparison.Ordinal);
            if (lastIndex < 0) return null;

            var suffix = nodeName.Substring(lastIndex + splitCode.Length);
            return int.TryParse(suffix, out var idx) ? idx : (int?)null;
        }

        public static void GenerateUIBindScript(GameObject targetObject, UIScriptGenerateData scriptGenerateData)
        {
            if (targetObject == null) throw new ArgumentNullException(nameof(targetObject));
            if (scriptGenerateData == null) throw new ArgumentNullException(nameof(scriptGenerateData));

            if (!PrefabChecker.IsPrefabAsset(targetObject))
            {
                Debug.LogWarning("Please save the UI as a prefab asset before generating bindings.");
                return;
            }

            if (!EnsureGenerationStrategyReady())
            {
                return;
            }

            InitializeGenerationContext(targetObject);
            CollectBindData(targetObject.transform);

            var generationContext = new UIGenerationContext(targetObject, scriptGenerateData, _uiBindDatas)
            {
                AssetPath = UIGenerateQuick.GetPrefabAssetPath(targetObject),
                ClassName = GetClassGenerateName(targetObject, scriptGenerateData)
            };

            if (!CheckCanGenerate(generationContext))
            {
                CleanupContext();
                return;
            }

            var validationResult = ValidateGeneration(generationContext);
            if (!validationResult.IsValid)
            {
                Debug.LogError(validationResult.Message);
                CleanupContext();
                return;
            }

            GenerateScript(generationContext);
        }

        public static void CopyVariableContentToClipboard(GameObject targetObject)
        {
            if (targetObject == null) throw new ArgumentNullException(nameof(targetObject));

            if (!EnsureVariableGenerationStrategyReady())
            {
                return;
            }

            string variableContent;
            try
            {
                ResetCollectedBindData();
                CollectBindData(targetObject.transform);
                variableContent = ScriptCodeEmitter.GetVariableContent(_uiBindDatas, GetPublicComponentName);
            }
            finally
            {
                ResetCollectedBindData();
            }

            EditorGUIUtility.systemCopyBuffer = variableContent ?? string.Empty;
            if (string.IsNullOrEmpty(variableContent))
            {
                Debug.LogWarning($"UI生成绑定未找到可复制的属性内容，已清空剪贴板: {targetObject.name}");
                return;
            }

            Debug.Log($"UI生成绑定属性已复制到剪贴板: {targetObject.name}");
        }

        private static void InitializeGenerationContext(GameObject targetObject)
        {
            EditorPrefs.SetInt(GenerateInstanceIdKey, targetObject.GetInstanceID());
            var assetPath = UIGenerateQuick.GetPrefabAssetPath(targetObject);
            if (!string.IsNullOrEmpty(assetPath))
            {
                EditorPrefs.SetString(GenerateAssetPathKey, assetPath);
            }

            ResetCollectedBindData();
        }

        private static UIGenerationValidationResult ValidateGeneration(UIGenerationContext context)
        {
            if (context.TargetObject == null)
            {
                return UIGenerationValidationResult.Fail("UI generation target is null.");
            }

            if (context.ScriptGenerateData == null)
            {
                return UIGenerationValidationResult.Fail("UI generation config is null.");
            }

            if (string.IsNullOrWhiteSpace(context.ClassName))
            {
                return UIGenerationValidationResult.Fail("Generated class name is empty.");
            }

            if (!File.Exists(UIGlobalPath.TemplatePath))
            {
                return UIGenerationValidationResult.Fail($"UI template file not found: {UIGlobalPath.TemplatePath}");
            }

            return UIGenerationValidationResult.Success();
        }

        private static void GenerateScript(UIGenerationContext context)
        {
            var templateText = File.ReadAllText(UIGlobalPath.TemplatePath);
            var processedText = ProcessTemplateText(context, templateText);
            EditorPrefs.SetString(GenerateTypeNameKey, context.FullTypeName);
            WriteScriptContent(context, processedText);
        }

        private static string ProcessTemplateText(UIGenerationContext context, string templateText)
        {
            return templateText
                .Replace("#ReferenceNameSpace#", GetReferenceNamespace(context))
                .Replace("#ClassNameSpace#", context.ScriptGenerateData.NameSpace)
                .Replace("#ClassName#", context.ClassName)
                .Replace("#TagName#", GetResourceSavePath(context))
                .Replace("#LoadType#", context.ScriptGenerateData.LoadType.ToString())
                .Replace("#Variable#", GetVariableContent(context));
        }

        private static string GetClassGenerateName(GameObject targetObject, UIScriptGenerateData scriptGenerateData)
        {
            return IdentifierFormatter.GetClassName(targetObject);
        }

        private static bool CheckCanGenerate(UIGenerationContext context)
        {
            return ResourcePathResolver.CanGenerate(context.TargetObject, context.ScriptGenerateData);
        }

        private static string GetPrivateComponentName(string regexName, string componentName, EBindType bindType)
        {
            return IdentifierFormatter.GetPrivateComponentName(regexName, componentName, bindType);
        }

        private static string GetPublicComponentName(string variableName)
        {
            return IdentifierFormatter.GetPublicComponentName(variableName);
        }

        private static string GetResourceSavePath(UIGenerationContext context)
        {
            return ResourcePathResolver.GetResourcePath(context.TargetObject, context.ScriptGenerateData);
        }

        private static string GetReferenceNamespace(UIGenerationContext context)
        {
            return ScriptCodeEmitter.GetReferenceNamespaces(_uiBindDatas);
        }

        private static string GetVariableContent(UIGenerationContext context)
        {
            return ScriptCodeEmitter.GetVariableContent(_uiBindDatas, GetPublicComponentName);
        }

        private static void WriteScriptContent(UIGenerationContext context, string scriptContent)
        {
            ScriptFileWriter.Write(context.TargetObject, context.ClassName, scriptContent, context.ScriptGenerateData);
        }

        [DidReloadScripts]
        public static void BindUIScript()
        {
            if (!EditorPrefs.HasKey(GenerateTypeNameKey)) return;

            var scriptTypeName = EditorPrefs.GetString(GenerateTypeNameKey);
            var targetObject = ResolveGenerationTarget();

            if (targetObject == null)
            {
                Debug.LogWarning("UI script generation attachment object missing.");
                CleanupContext();
                return;
            }

            if (!EnsureGenerationStrategyReady())
            {
                CleanupContext();
                return;
            }

            ResetCollectedBindData();

            var bindSucceeded = false;
            CollectBindData(targetObject.transform);
            try
            {
                bindSucceeded = BindScriptPropertyField(targetObject, scriptTypeName);
            }
            catch (Exception exception)
            {
                Debug.LogException(exception);
            }
            finally
            {
                CleanupContext();
            }

            if (!bindSucceeded)
            {
                return;
            }

            EditorUtility.SetDirty(targetObject);
            Debug.Log($"Generate {scriptTypeName} successfully attached to game object.");
        }

        private static GameObject ResolveGenerationTarget()
        {
            var instanceId = EditorPrefs.GetInt(GenerateInstanceIdKey, -1);
            var instanceTarget = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
            if (instanceTarget != null)
            {
                return instanceTarget;
            }

            var assetPath = EditorPrefs.GetString(GenerateAssetPathKey, string.Empty);
            return string.IsNullOrEmpty(assetPath) ? null : AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
        }

        private static void CleanupContext()
        {
            EditorPrefs.DeleteKey(GenerateTypeNameKey);
            EditorPrefs.DeleteKey(GenerateInstanceIdKey);
            EditorPrefs.DeleteKey(GenerateAssetPathKey);
            ResetCollectedBindData();
        }

        private static void ResetCollectedBindData()
        {
            _uiBindDatas.Clear();
            _arrayComponents.Clear();
            _componentTypeCache.Clear();
        }

        private static bool BindScriptPropertyField(GameObject targetObject, string scriptTypeName)
        {
            if (targetObject == null) throw new ArgumentNullException(nameof(targetObject));
            if (string.IsNullOrEmpty(scriptTypeName)) throw new ArgumentNullException(nameof(scriptTypeName));

            var scriptType = FindScriptType(scriptTypeName);
            if (scriptType == null)
            {
                Debug.LogError($"Could not find the class: {scriptTypeName}");
                return false;
            }

            var targetHolder = targetObject.GetOrAddComponent(scriptType);
            return BindFieldsToComponents(targetHolder, scriptType);
        }

        private static Type FindScriptType(string scriptTypeName)
        {
            var resolvedType = AlicizaX.Utility.Assembly.GetType(scriptTypeName);
            if (resolvedType != null)
            {
                return resolvedType;
            }

            return AppDomain.CurrentDomain.GetAssemblies()
                .Where(assembly => !assembly.GetName().Name.EndsWith(".Editor", StringComparison.Ordinal) &&
                                   !assembly.GetName().Name.Equals("UnityEditor", StringComparison.Ordinal))
                .SelectMany(assembly => assembly.GetTypes())
                .FirstOrDefault(type => type.IsClass && !type.IsAbstract &&
                                        type.FullName.Equals(scriptTypeName, StringComparison.Ordinal));
        }

        private static bool BindFieldsToComponents(Component targetHolder, Type scriptType)
        {
            var fields = scriptType.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).Where(field =>
                field.GetCustomAttributes(typeof(SerializeField), false).Length > 0
            );

            var isSuccessful = true;
            foreach (var field in fields.Where(field => !string.IsNullOrEmpty(field.Name)))
            {
                var bindData = _uiBindDatas.Find(data => data.Name == field.Name);
                if (bindData == null)
                {
                    Debug.LogError($"Field {field.Name} did not find matching component binding.");
                    isSuccessful = false;
                    continue;
                }

                if (!SetFieldValue(field, bindData, targetHolder))
                {
                    isSuccessful = false;
                }
            }

            return isSuccessful;
        }

        private static bool SetFieldValue(FieldInfo field, UIBindData bindData, Component targetComponent)
        {
            if (field.FieldType.IsArray)
            {
                return SetArrayFieldValue(field, bindData, targetComponent);
            }

            return SetSingleFieldValue(field, bindData, targetComponent);
        }

        private static bool SetArrayFieldValue(FieldInfo field, UIBindData bindData, Component targetComponent)
        {
            var elementType = field.FieldType.GetElementType();
            if (elementType == null)
            {
                Debug.LogError($"Field {field.Name} has unknown element type.");
                return false;
            }

            var components = bindData.Objs;
            var array = Array.CreateInstance(elementType, components.Count);
            var isSuccessful = true;
            for (var i = 0; i < components.Count; i++)
            {
                if (components[i] == null) continue;

                var componentObject = ResolveBoundObject(components[i], bindData.GetResolvedComponentType(i));

                if (componentObject != null && elementType.IsInstanceOfType(componentObject))
                {
                    array.SetValue(componentObject, i);
                }
                else
                {
                    Debug.LogError($"Element {i} type mismatch for field {field.Name}");
                    isSuccessful = false;
                }
            }

            field.SetValue(targetComponent, array);
            return isSuccessful;
        }

        private static bool SetSingleFieldValue(FieldInfo field, UIBindData bindData, Component targetComponent)
        {
            if (bindData.Objs.Count == 0)
            {
                return false;
            }

            var firstComponent = ResolveBoundObject(bindData.Objs[0], bindData.GetResolvedComponentType(0));
            if (firstComponent == null)
            {
                return false;
            }

            if (!field.FieldType.IsInstanceOfType(firstComponent))
            {
                Debug.LogError($"Field {field.Name} type mismatch");
                return false;
            }

            field.SetValue(targetComponent, firstComponent);
            return true;
        }

        private static object ResolveBoundObject(GameObject source, Type componentType)
        {
            if (source == null || componentType == null)
            {
                return null;
            }

            return componentType == typeof(GameObject) ? source : ResolveAssignableComponent(source, componentType);
        }

        private static Component ResolveAssignableComponent(GameObject source, Type componentType)
        {
            if (source == null || componentType == null || !typeof(Component).IsAssignableFrom(componentType))
            {
                return null;
            }

            Component component = source.GetComponent(componentType);
            if (component != null)
            {
                return component;
            }

            Component[] components = source.GetComponents<Component>();
            for (int i = 0; i < components.Length; i++)
            {
                Component candidate = components[i];
                if (candidate != null && componentType.IsInstanceOfType(candidate))
                {
                    return candidate;
                }
            }

            return null;
        }

        public static class PrefabChecker
        {
            public static bool IsEditingPrefabAsset(GameObject go)
            {
                var prefabStage = PrefabStageUtility.GetCurrentPrefabStage();
                return prefabStage?.IsPartOfPrefabContents(go) == true;
            }

            public static bool IsPrefabAsset(GameObject go)
            {
                if (go == null) return false;

                var assetType = PrefabUtility.GetPrefabAssetType(go);
                var isRegularPrefab = assetType == PrefabAssetType.Regular ||
                                      assetType == PrefabAssetType.Variant ||
                                      assetType == PrefabAssetType.Model;

                return isRegularPrefab || IsEditingPrefabAsset(go);
            }
        }
    }
}