using System;
using System.Collections.Generic;
using System.IO;
using Data;
using UnityEngine;
using Utils;

namespace Managers
{
    public class DefineManager : Singleton<DefineManager>
    {
        private static readonly string[] dataSetFilePath = { "Data", "Mod" };

        public Dictionary<string, Dictionary<string, Define>> defines = new();
        public Dictionary<string, DefinePack> packs = new();
        /// <summary>
        /// 初始化定义管理器，加载所有定义包并构建定义字典。
        /// </summary>
        /// <remarks>
        /// 该方法执行以下操作：
        /// 1. 获取指定路径下的所有子文件夹，每个子文件夹代表一个定义包。
        /// 2. 遍历每个定义包，尝试加载其中的定义数据。
        /// 3. 将加载的定义数据按类型分类，并存储到定义字典中。
        /// </remarks>
        public void Init()
        {
            var packFolder = Configs.ConfigProcessor.GetSubFolders(new(dataSetFilePath));
            foreach (var folder in packFolder)
            {
                var pack = new DefinePack();
                if (pack.LoadPack(folder)) packs.Add(pack.packID, pack);
            }
            List<Tuple<Define,DefineReference>> defineRefs = new();
            foreach (var pack in packs)
            {
                foreach (var define in pack.Value.defines)
                {
                    var typeName=define.Key;
                    var defList=define.Value;
                    if (!defines.ContainsKey(typeName))
                        defines[typeName] = new Dictionary<string, Define>();
                    foreach (var def in defList)
                    {
                        defines[typeName][def.defName] = def;
                        if (def is DefineReference reference)
                        {
                            defineRefs.Add(new(def,reference));
                        }
                    }
                }
            }

            foreach (var defineRef in defineRefs)
            {
                var define = defineRef.Item1;
                var reference = defineRef.Item2;
                var referenceDef=FindDefine(reference.className,define.defName);
                
                var property = define.GetType().GetProperty(reference.fieldName);
                if (property != null && property.CanWrite)
                {
                    property.SetValue(define, referenceDef);
                }
                else
                {
                    // 如果是字段而不是属性
                    var field = define.GetType().GetField(reference.fieldName);
                    if (field != null)
                    {
                        field.SetValue(define, referenceDef);
                    }
                    else
                    {
                        // 处理找不到成员的情况
                        Debug.LogError($"Could not find field or property '{reference.fieldName}' in type {define.GetType().Name}");
                    }
                }
            }
        }
        /// <summary>
        /// 查找指定定义类型的定义名对应的 Define 对象。
        /// </summary>
        /// <param name="defineType">定义类型</param>
        /// <param name="defineName">定义名</param>
        /// <returns>如果找到，返回 Define 对象；否则返回 null。</returns>
        public Define FindDefine(string defineType, string defineName)
        {
            if (defines.TryGetValue(defineType, out var typeDict))
            {
                if (typeDict.TryGetValue(defineName, out var define))
                {
                    return define;
                }
            }
            return null;
        }
        public override string ToString()
        {
            if (packs == null || packs.Count == 0)
            {
                return "No packs available"; // 如果集合为空或为 null，返回默认信息
            }
            
            var result = new System.Text.StringBuilder();

            foreach (var definePack in packs)
            {
                result.AppendLine(definePack.ToString()); // 每个元素占一行
            }

            return result.ToString(); 
        }
    }
}