using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Xml.Linq;
using UnityEngine;
using Utils;

namespace Data
{
    public class DefineManager:Utils.Singleton<DefineManager>
    {
        
        static readonly string[] dataSetFilePath = { "Data", "Mod" };
        const string coreNamespace = "Data";
        
        public Dictionary<string, Dictionary<string, Define>> defines = new();
        
        public void Init()
        {
            // 加载所有 XML 文件路径
            var xmlFilePaths = FileHandler.LoadXmlFilesFromPaths(dataSetFilePath);

            // 遍历并加载每个 XML 文件
            foreach (var xmlFilePath in xmlFilePaths)
            {
                LoadXmlData(xmlFilePath);
            }
            
        }
        public void LoadXmlData(string xmlFilePath)
        {
            // 检查文件是否存在
            if (!File.Exists(xmlFilePath))
            {
                Debug.LogWarning($"XML文件不存在: {xmlFilePath}");
                return;
            }
            var xdoc = XDocument.Load(xmlFilePath);
            // 解析Define节点
            var rootElement = xdoc.Root;

            if (rootElement != null)
            {
                if (rootElement.Name == "Define")
                {
                    foreach (var element in rootElement.Elements())
                    {
                        var def = LoadDefine(element);
                        var className = element.Name.ToString();
                        var name = element.Element("defName")?.Value;
                        if (def != null && !string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(className))
                        {
                            defines.TryAdd(className, new Dictionary<string, Define>());
                            defines[className][name] = (Define)def;
                        }
                    }
                }
            }

        }
        public object LoadDefine(XElement xElement)
        {
            var className = xElement.Name.ToString();
            var assembly = Assembly.GetExecutingAssembly();

            Type type;
            if (!className.Contains('.'))
            {
                // 尝试拼接默认命名空间   
                var fullClassName = coreNamespace + className;
                type = assembly.GetType(fullClassName);

                // 如果拼接命名空间后仍找不到，尝试直接查找（可能是全局命名空间下的类）
                
                if (type == null)
                {
                    type = assembly.GetType(className);
                }
            }
            else
            {
                // 直接查找
                type = assembly.GetType(className);
            }

            if (type == null)
            {
                Debug.LogError($"未定义的类型: {className}");
                return null;
            }

            var constructor = type.GetConstructor(Type.EmptyTypes);
            if (constructor == null)
            {
                Debug.LogError($"{className} 必须包含无参构造函数");
                return null;
            }

            // 3. 创建实例
            object instance;
            try
            {
                instance = Activator.CreateInstance(type);
            }
            catch (Exception ex)
            {
                Debug.LogError($"创建 {className} 实例失败: {ex.Message}");
                return null;
            }

            // 4. 检查是否继承自 Define
            if (instance is not Define define)
            {
                Debug.LogError($"{className} 必须继承自 Define");
                return null;
            }

            if (define.Init(xElement))
            {
                return define;
            }
            // 获取类的所有字段（不包括私有字段）
            var fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);

            // 遍历字段并尝试从 XElement 中赋值
            foreach (var field in fields)
            {
                // 查找对应的 XElement 子元素
                var element = xElement.Element(field.Name);
                if (element != null)
                {
                    try
                    {
                        // 将子元素的值转换为目标类型并赋值
                        object value = Convert.ChangeType(element.Value, field.FieldType);
                        field.SetValue(define, value);
                    }
                    catch (Exception ex)
                    {
                        Debug.LogWarning($"Error setting field {field.Name}: {ex.Message}");
                    }
                }
            }
            return define;
        }

        public static void SetField(object obj, string fieldName, object value)
        {
            var type = obj.GetType();
            var field = type.GetField(fieldName);

            if (field != null)
            {
                field.SetValue(obj, Convert.ChangeType(value, field.FieldType));
            }
            else
            {
                Debug.LogWarning($"Field '{fieldName}' not found.");
            }
        }
    }
    
}