using Luban.Common.Utils;
using Luban.Job.Cfg.Datas;
using Luban.Job.Cfg.DataSources.Excel;
using Luban.Job.Cfg.RawDefs;
using Luban.Job.Cfg.Utils;
using Luban.Job.Common.Defs;
using Luban.Job.Common.RawDefs;
using Luban.Job.Common.Types;
using Luban.Server.Common;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace Luban.Job.Cfg.Defs
{
    class CfgDefLoader : CommonDefLoader
    {
        private static readonly NLog.Logger s_logger = NLog.LogManager.GetCurrentClassLogger();

        private readonly List<string> _importExcelTableFiles = new();
        private readonly List<string> _importExcelEnumFiles = new();
        private readonly List<string> _importExcelBeanFiles = new();


        private readonly List<Branch> _branches = new();

        private readonly List<Table> _cfgTables = new List<Table>();

        private readonly List<Service> _cfgServices = new List<Service>();

        private readonly List<Group> _cfgGroups = new List<Group>();

        private readonly List<string> _defaultGroups = new List<string>();

        public CfgDefLoader(RemoteAgent agent) : base(agent)
        {
            RegisterRootDefineHandler("importexcel", AddImportExcel);
            RegisterRootDefineHandler("branch", AddBranch);
            RegisterRootDefineHandler("service", AddService);
            RegisterRootDefineHandler("group", AddGroup);

            RegisterModuleDefineHandler("table", AddTable);


            IsBeanFieldMustDefineId = false;
        }

        public Defines BuildDefines()
        {
            return new Defines()
            {
                TopModule = TopModule,
                Branches = _branches,
                Consts = this._consts,
                Enums = _enums,
                Beans = _beans,
                Tables = _cfgTables,
                Services = _cfgServices,
                Groups = _cfgGroups,
            };
        }

        private static readonly List<string> _excelImportRequireAttrs = new List<string> { "name", "type" };
        private void AddImportExcel(XElement e)
        {
            ValidAttrKeys(e, null, _excelImportRequireAttrs);
            var importName = XmlUtil.GetRequiredAttribute(e, "name");
            if (string.IsNullOrWhiteSpace(importName))
            {
                throw new Exception("importexcel 属性name不能为空");
            }
            var type = XmlUtil.GetRequiredAttribute(e, "type");
            if (string.IsNullOrWhiteSpace(type))
            {
                throw new Exception($"importexcel name:'{importName}' type属性不能为空");
            }
            switch (type)
            {
                case "table": this._importExcelTableFiles.Add(importName); break;
                case "enum": this._importExcelEnumFiles.Add(importName); break;
                case "bean": this._importExcelBeanFiles.Add(importName); break;
                default: throw new Exception($"importexcel name:'{importName}' type:'{type}' 不合法. 有效值为 table|enum|bean");
            }
        }

        private static readonly List<string> _branchRequireAttrs = new List<string> { "name" };
        private void AddBranch(XElement e)
        {
            ValidAttrKeys(e, null, _branchRequireAttrs);
            var branchName = e.Attribute("name").Value;
            if (string.IsNullOrWhiteSpace(branchName))
            {
                throw new Exception("branch 属性name不能为空");
            }
            if (this._branches.Any(b => b.Name == branchName))
            {
                throw new Exception($"branch '{branchName}' 重复");
            }
            _branches.Add(new Branch(branchName));
        }

        private static readonly List<string> _groupOptionalAttrs = new List<string> { "default" };
        private static readonly List<string> _groupRequireAttrs = new List<string> { "name" };

        private void AddGroup(XElement e)
        {
            ValidAttrKeys(e, _groupOptionalAttrs, _groupRequireAttrs);
            List<string> groupNames = CreateGroups(e.Attribute("name").Value);

            foreach (var g in groupNames)
            {
                if (_cfgGroups.Any(cg => cg.Names.Contains(g)))
                {
                    throw new Exception($"group名:'{g}' 重复");
                }
            }

            if (XmlUtil.GetOptionBoolAttribute(e, "default"))
            {
                this._defaultGroups.AddRange(groupNames);
            }
            _cfgGroups.Add(new Group() { Names = groupNames });
        }

        private void FillValueValidator(CfgField f, string attrValue, string validatorName)
        {
            if (!string.IsNullOrWhiteSpace(attrValue))
            {
                var validator = new Validator() { Type = validatorName, Rule = attrValue };
                f.Validators.Add(validator);
                f.ValueValidators.Add(validator);
            }
        }

        private void FillValidators(string key, string attr, List<Validator> result)
        {
            if (!string.IsNullOrWhiteSpace(attr))
            {
                foreach (var validatorStr in attr.Split('#', StringSplitOptions.RemoveEmptyEntries))
                {
                    var sepIndex = validatorStr.IndexOf(':');
                    if (sepIndex < 0)
                    {
                        throw new Exception($"定义文件:{CurImportFile} 类型:'{CurDefine}' key:'{key}' attr:'{attr}' 不是合法的 validator 定义 (key1:value1#key2:value2 ...)");
                    }
                    result.Add(new Validator() { Type = validatorStr[..sepIndex], Rule = validatorStr[(sepIndex + 1)..] });
                }
            }
        }

        private readonly List<string> _serviceAttrs = new List<string> { "name", "manager", "group" };

        private void AddService(XElement e)
        {
            var name = XmlUtil.GetRequiredAttribute(e, "name");
            var manager = XmlUtil.GetRequiredAttribute(e, "manager");
            List<string> groups = CreateGroups(XmlUtil.GetOptionalAttribute(e, "group"));
            var refs = new List<string>();

            s_logger.Trace("service name:{name} manager:{manager}", name, manager);
            ValidAttrKeys(e, _serviceAttrs, _serviceAttrs);
            foreach (XElement ele in e.Elements())
            {
                string tagName = ele.Name.LocalName;
                s_logger.Trace("service {service_name} tag: {name} {value}", name, tagName, ele);
                switch (tagName)
                {
                    case "ref":
                    {
                        refs.Add(XmlUtil.GetRequiredAttribute(ele, "name"));
                        break;
                    }
                    default:
                    {
                        throw new Exception($"service:'{name}' tag:'{tagName}' 非法");
                    }
                }
            }
            if (!ValidGroup(groups, out var invalidGroup))
            {
                throw new Exception($"service:'{name}' group:'{invalidGroup}' 不存在");
            }
            _cfgServices.Add(new Service() { Name = name, Manager = manager, Groups = groups, Refs = refs });
        }


        private readonly Dictionary<string, Table> _name2CfgTable = new Dictionary<string, Table>();

        private static List<string> CreateGroups(string s)
        {
            return s.Split(',', ';').Select(x => x.Trim()).Where(x => !string.IsNullOrWhiteSpace(x)).ToList();
        }

        private bool ValidGroup(List<string> groups, out string invalidGroup)
        {
            foreach (var g in groups)
            {
                if (!this._cfgGroups.Any(cg => cg.Names.Contains(g)))
                {
                    invalidGroup = g;
                    return false;
                }
            }
            invalidGroup = null;
            return true;
        }

        private ETableMode ConvertMode(string tableName, string modeStr, string indexStr)
        {
            ETableMode mode;
            switch (modeStr)
            {
                case "one":
                {
                    if (!string.IsNullOrWhiteSpace(indexStr))
                    {
                        throw new Exception($"定义文件:{CurImportFile} table:'{tableName}' mode=one 是单例表，不支持定义index属性");
                    }
                    mode = ETableMode.ONE;
                    break;
                }
                case "map":
                {
                    //if ((string.IsNullOrWhiteSpace(indexStr) || indexStr.Split(',').Length != 1))
                    //{
                    //    throw new Exception($"定义文件:{CurImportFile} table:{tableName} 是单键表，必须在index属性里指定1个key");
                    //}
                    mode = ETableMode.MAP;
                    break;
                }
                case "":
                {
                    mode = ETableMode.MAP;
                    break;
                }
                default:
                {
                    throw new ArgumentException($"不支持的 mode:{modeStr}");
                }
            }
            return mode;
        }

        private readonly List<string> _tableOptionalAttrs = new List<string> { "index", "mode", "group", "branch_input", "comment", "define_from_file" };
        private readonly List<string> _tableRequireAttrs = new List<string> { "name", "value", "input" };

        private void AddTable(XElement e)
        {
            ValidAttrKeys(e, _tableOptionalAttrs, _tableRequireAttrs);
            string name = XmlUtil.GetRequiredAttribute(e, "name");
            string module = CurNamespace;
            string valueType = XmlUtil.GetRequiredAttribute(e, "value");
            bool defineFromFile = XmlUtil.GetOptionBoolAttribute(e, "define_from_file");
            string index = XmlUtil.GetOptionalAttribute(e, "index");
            string group = XmlUtil.GetOptionalAttribute(e, "group");
            string comment = XmlUtil.GetOptionalAttribute(e, "comment");
            string input = XmlUtil.GetRequiredAttribute(e, "input");
            string branchInput = XmlUtil.GetOptionalAttribute(e, "branch_input");
            string mode = XmlUtil.GetOptionalAttribute(e, "mode");
            AddTable(name, module, valueType, index, mode, group, comment, defineFromFile, input, branchInput);
        }

        private void AddTable(string name, string module, string valueType, string index, string mode, string group,
            string comment, bool defineFromExcel, string input, string branchInput)
        {
            var p = new Table()
            {
                Name = name,
                Namespace = module,
                ValueType = valueType,
                LoadDefineFromFile = defineFromExcel,
                Index = index,
                Groups = CreateGroups(group),
                Comment = comment,
                Mode = ConvertMode(name, mode, index),
            };

            if (p.Groups.Count == 0)
            {
                p.Groups = this._defaultGroups;
            }
            else if (!ValidGroup(p.Groups, out var invalidGroup))
            {
                throw new Exception($"定义文件:{CurImportFile} table:'{p.Name}' group:'{invalidGroup}' 不存在");
            }
            p.InputFiles.AddRange(input.Split(','));

            if (!string.IsNullOrWhiteSpace(branchInput))
            {
                foreach (var subBranchStr in branchInput.Split('|').Select(s => s.Trim()).Where(s => !string.IsNullOrWhiteSpace(s)))
                {
                    var nameAndDirs = subBranchStr.Split(':');
                    if (nameAndDirs.Length != 2)
                    {
                        throw new Exception($"定义文件:{CurImportFile} table:'{p.Name}' branch_input:'{subBranchStr}' 定义不合法");
                    }
                    var branchDirs = nameAndDirs[1].Split(',', ';').ToList();
                    if (!p.BranchInputFiles.TryAdd(nameAndDirs[0], branchDirs))
                    {
                        throw new Exception($"定义文件:{CurImportFile} table:'{p.Name}' branch_input:'{subBranchStr}' 子branch:'{nameAndDirs[0]}' 重复");
                    }
                }
            }

            AddTableList(p);
        }

        private void AddTableList(Table p)
        {
            if (!_name2CfgTable.TryAdd(p.Name, p))
            {
                var exist = _name2CfgTable[p.Name];
                throw new Exception($"定义文件:{CurImportFile} table:'{p.Namespace}.{p.Name}' 与 '{exist.Namespace}.{exist.Name}' 名称不能重复");
            }
            _cfgTables.Add(p);
        }

        private async Task<CfgBean> LoadTableRecordDefineFromFileAsync(Table table, string dataDir)
        {
            var inputFileInfos = await DataLoaderUtil.CollectInputFilesAsync(this.Agent, table.InputFiles, dataDir);
            var file = inputFileInfos[0];

            var source = new ExcelDataSource();
            var stream = new MemoryStream(await this.Agent.GetFromCacheOrReadAllBytesAsync(file.ActualFile, file.MD5));
            var sheet = source.LoadFirstSheet(file.OriginFile, file.SheetName, stream);

            var cb = new CfgBean() { Namespace = table.Namespace, Name = table.ValueType, };

            var rc = sheet.RowColumns;
            var attrRow = sheet.RowColumns[0];
            var titleRow = sheet.RowColumns[1];
            // 有可能没有注释行，此时使用标题行，这个是必须有的
            var descRow = sheet.TitleRows >= 3 ? sheet.RowColumns[2] : titleRow;
            foreach (var f in sheet.RootFields)
            {
                var cf = new CfgField() { Name = f.Name, Id = 0 };


                string[] attrs = (attrRow[f.FromIndex].Value?.ToString() ?? "").Trim().Split('&').Select(s => s.Trim()).ToArray();

                if (attrs.Length == 0 || string.IsNullOrWhiteSpace(attrs[0]))
                {
                    throw new Exception($"table:'{table.Name}' file:{file.OriginFile} title:'{f.Name}' type missing!");
                }

                // 优先取desc行，如果为空,则取title行

                cf.Comment = descRow[f.FromIndex].Value?.ToString();
                if (string.IsNullOrWhiteSpace(cf.Comment))
                {
                    cf.Comment = titleRow[f.FromIndex].Value?.ToString();
                }
                if (string.IsNullOrWhiteSpace(cf.Comment))
                {
                    cf.Comment = "";
                }

                cf.Type = attrs[0];

                for (int i = 1; i < attrs.Length; i++)
                {
                    var pair = attrs[i].Split('=');
                    if (pair.Length != 2)
                    {
                        throw new Exception($"table:'{table.Name}' file:{file.OriginFile} title:'{f.Name}' attr:'{attrs[i]}' is invalid!");
                    }
                    var attrName = pair[0].Trim();
                    var attrValue = pair[1].Trim();
                    switch (attrName)
                    {
                        case "index":
                        {
                            cf.Index = attrValue;
                            break;
                        }
                        case "sep":
                        {
                            cf.Sep = attrValue;
                            break;
                        }
                        case "ref":
                        case "path":
                        case "range":
                        {
                            var validator = new Validator() { Type = attrName, Rule = attrValue };
                            cf.Validators.Add(validator);
                            cf.ValueValidators.Add(validator);
                            break;
                        }
                        case "multi_lines":
                        {
                            cf.IsMultiRow = attrValue == "1" || attrValue.Equals("true", StringComparison.OrdinalIgnoreCase);
                            break;
                        }
                        case "group":
                        {
                            cf.Groups = attrValue.Split(',').Select(s => s.Trim()).Where(s => !string.IsNullOrWhiteSpace(s)).ToList();
                            break;
                        }
                        case "comment":
                        {
                            cf.Comment = attrValue;
                            break;
                        }
                        case "convert":
                        {
                            cf.Converter = attrValue;
                            break;
                        }
                        default:
                        {
                            throw new Exception($"table:'{table.Name}' file:{file.OriginFile} title:'{f.Name}' attr:'{attrs[i]}' is invalid!");
                        }
                    }
                }

                cb.Fields.Add(cf);
            }
            return cb;
        }

        private async Task LoadTableRecordDefinesFromFileAsync(string dataDir)
        {
            var loadTasks = new List<Task<CfgBean>>();
            foreach (var table in this._cfgTables.Where(t => t.LoadDefineFromFile))
            {
                loadTasks.Add(Task.Run(async () => await this.LoadTableRecordDefineFromFileAsync(table, dataDir)));
            }

            foreach (var task in loadTasks)
            {
                this._beans.Add(await task);
            }
        }

        private async Task LoadTableListFromFileAsync(string dataDir)
        {
            if (this._importExcelTableFiles.Count == 0)
            {
                return;
            }
            var inputFileInfos = await DataLoaderUtil.CollectInputFilesAsync(this.Agent, this._importExcelTableFiles, dataDir);

            var defTableRecordType = new DefBean(new CfgBean()
            {
                Namespace = "__intern__",
                Name = "__TableRecord__",
                Parent = "",
                Alias = "",
                IsValueType = false,
                Sep = "",
                TypeId = 0,
                IsSerializeCompatible = false,
                Fields = new List<Field>
                {
                    new CfgField() { Name = "full_name", Type = "string" },
                    new CfgField() { Name = "value_type", Type = "string" },
                    new CfgField() { Name = "index", Type = "string" },
                    new CfgField() { Name = "mode", Type = "string" },
                    new CfgField() { Name = "group", Type = "string" },
                    new CfgField() { Name = "comment", Type = "string" },
                    new CfgField() { Name = "define_from_excel", Type = "bool" },
                    new CfgField() { Name = "input", Type = "string" },
                    new CfgField() { Name = "branch_input", Type = "string" },
                }
            })
            {
                AssemblyBase = new DefAssembly("", null, true, Agent),
            };
            defTableRecordType.PreCompile();
            defTableRecordType.Compile();
            defTableRecordType.PostCompile();
            var tableRecordType = new TBean(defTableRecordType, false);

            foreach (var file in inputFileInfos)
            {
                var source = new ExcelDataSource();
                var bytes = await this.Agent.GetFromCacheOrReadAllBytesAsync(file.ActualFile, file.MD5);
                var records = DataLoaderUtil.LoadCfgRecords(tableRecordType, file.OriginFile, null, bytes, true, false);
                foreach (var r in records)
                {
                    DBean data = r.Data;
                    //s_logger.Info("== read text:{}", r.Data);
                    string fullName = (data.GetField("full_name") as DString).Value.Trim();
                    if (string.IsNullOrWhiteSpace(fullName))
                    {
                        throw new Exception($"file:{file.ActualFile} 定义了一个空的table类名");
                    }
                    string name = TypeUtil.GetName(fullName);
                    string module = TypeUtil.GetNamespace(fullName);
                    string valueType = (data.GetField("value_type") as DString).Value.Trim();
                    string index = (data.GetField("index") as DString).Value.Trim();
                    string mode = (data.GetField("mode") as DString).Value.Trim();
                    string group = (data.GetField("group") as DString).Value.Trim();
                    string comment = (data.GetField("comment") as DString).Value.Trim();
                    bool isDefineFromExcel = (data.GetField("define_from_excel") as DBool).Value;
                    string inputFile = (data.GetField("input") as DString).Value.Trim();
                    string branchInput = (data.GetField("branch_input") as DString).Value.Trim();
                    AddTable(name, module, valueType, index, mode, group, comment, isDefineFromExcel, inputFile, branchInput);
                };
            }
        }

        private async Task LoadEnumListFromFileAsync(string dataDir)
        {
            if (this._importExcelEnumFiles.Count == 0)
            {
                return;
            }
            var inputFileInfos = await DataLoaderUtil.CollectInputFilesAsync(this.Agent, this._importExcelEnumFiles, dataDir);

            var defTableRecordType = new DefBean(new CfgBean()
            {
                Namespace = "__intern__",
                Name = "__EnumInfo__",
                Parent = "",
                Alias = "",
                IsValueType = false,
                Sep = "",
                TypeId = 0,
                IsSerializeCompatible = false,
                Fields = new List<Field>
                {
                    new CfgField() { Name = "full_name", Type = "string" },
                    new CfgField() { Name = "item", Type = "string" },
                    new CfgField() { Name = "alias", Type = "string" },
                    new CfgField() { Name = "value", Type = "string" },
                    new CfgField() { Name = "comment", Type = "string" },
                }
            })
            {
                AssemblyBase = new DefAssembly("", null, true, Agent),
            };
            defTableRecordType.PreCompile();
            defTableRecordType.Compile();
            defTableRecordType.PostCompile();
            var tableRecordType = new TBean(defTableRecordType, false);

            foreach (var file in inputFileInfos)
            {
                var source = new ExcelDataSource();
                var bytes = await this.Agent.GetFromCacheOrReadAllBytesAsync(file.ActualFile, file.MD5);
                var records = DataLoaderUtil.LoadCfgRecords(tableRecordType, file.OriginFile, null, bytes, true, false);

                PEnum curEnum = null;
                foreach (var r in records)
                {
                    DBean data = r.Data;
                    //s_logger.Info("== read text:{}", r.Data);
                    string fullName = (data.GetField("full_name") as DString).Value.Trim();
                    if (string.IsNullOrWhiteSpace(fullName))
                    {
                        throw new Exception($"file:{file.ActualFile} 定义了一个空的enum类名");
                    }
                    string name = TypeUtil.GetName(fullName);
                    string module = TypeUtil.GetNamespace(fullName);

                    if (curEnum == null || curEnum.Name != name || curEnum.Namespace != module)
                    {
                        curEnum = new PEnum() { Name = name, Namespace = module, IsFlags = false, Comment = "", IsUniqueItemId = true };
                        this._enums.Add(curEnum);
                    }

                    string item = (data.GetField("item") as DString).Value.Trim();
                    if (string.IsNullOrWhiteSpace(item))
                    {
                        throw new Exception($"file:{file.ActualFile} module:'{module}' name:'{name}' 定义了一个空枚举项");
                    }
                    string alias = (data.GetField("alias") as DString).Value.Trim();
                    string value = (data.GetField("value") as DString).Value.Trim();
                    string comment = (data.GetField("comment") as DString).Value.Trim();
                    curEnum.Items.Add(new EnumItem() { Name = item, Alias = alias, Value = value, Comment = comment });
                };
            }
        }

        private async Task LoadBeanListFromFileAsync(string dataDir)
        {
            if (this._importExcelBeanFiles.Count == 0)
            {
                return;
            }
            var inputFileInfos = await DataLoaderUtil.CollectInputFilesAsync(this.Agent, this._importExcelBeanFiles, dataDir);


            var ass = new DefAssembly("", null, true, Agent);

            var defBeanFieldType = new DefBean(new CfgBean()
            {
                Namespace = "__intern__",
                Name = "__FieldInfo__",
                Parent = "",
                Alias = "",
                IsValueType = false,
                Sep = "",
                TypeId = 0,
                IsSerializeCompatible = false,
                Fields = new List<Field>
                {
                    new CfgField() { Name = "name", Type = "string" },
                    new CfgField() { Name = "type", Type = "string" },
                    new CfgField() { Name = "sep", Type = "string" },
                    new CfgField() { Name = "is_multi_rows", Type = "bool" },
                    new CfgField() { Name = "group", Type = "string" },
                    new CfgField() { Name = "reference", Type = "string" },
                    new CfgField() { Name = "path", Type = "string" },
                    new CfgField() { Name = "comment", Type = "string" },
                }
            })
            {
                AssemblyBase = ass,
            };

            defBeanFieldType.PreCompile();
            defBeanFieldType.Compile();
            defBeanFieldType.PostCompile();

            ass.AddType(defBeanFieldType);

            var defTableRecordType = new DefBean(new CfgBean()
            {
                Namespace = "__intern__",
                Name = "__BeanInfo__",
                Parent = "",
                Alias = "",
                IsValueType = false,
                Sep = "",
                TypeId = 0,
                IsSerializeCompatible = false,
                Fields = new List<Field>
                {
                    new CfgField() { Name = "full_name", Type = "string" },
                    new CfgField() { Name = "sep", Type = "string" },
                    new CfgField() { Name = "comment", Type = "string" },
                    new CfgField() { Name = "fields", Type = "list,__FieldInfo__", IsMultiRow = true },
                }
            })
            {
                AssemblyBase = ass,
            };
            ass.AddType(defTableRecordType);
            defTableRecordType.PreCompile();
            defTableRecordType.Compile();
            defTableRecordType.PostCompile();
            ass.MarkMultiRows();
            var tableRecordType = new TBean(defTableRecordType, false);

            foreach (var file in inputFileInfos)
            {
                var source = new ExcelDataSource();
                var bytes = await this.Agent.GetFromCacheOrReadAllBytesAsync(file.ActualFile, file.MD5);
                var records = DataLoaderUtil.LoadCfgRecords(tableRecordType, file.OriginFile, null, bytes, true, false);

                foreach (var r in records)
                {
                    DBean data = r.Data;
                    //s_logger.Info("== read text:{}", r.Data);
                    string fullName = (data.GetField("full_name") as DString).Value.Trim();
                    if (string.IsNullOrWhiteSpace(fullName))
                    {
                        throw new Exception($"file:{file.ActualFile} 定义了一个空的bean类名");
                    }
                    string name = TypeUtil.GetName(fullName);
                    string module = TypeUtil.GetNamespace(fullName);

                    if (string.IsNullOrWhiteSpace(name))
                    {
                        throw new Exception($"file:{file.ActualFile} 定义了一个空bean类名");
                    }

                    string sep = (data.GetField("sep") as DString).Value.Trim();
                    string comment = (data.GetField("comment") as DString).Value.Trim();
                    DList fields = data.GetField("fields") as DList;
                    var curBean = new CfgBean()
                    {
                        Name = name,
                        Namespace = module,
                        Sep = sep,
                        Comment = comment,
                        Parent = "",
                        Fields = fields.Datas.Select(d => (DBean)d).Select(b => this.CreateField(
                            (b.GetField("name") as DString).Value.Trim(),
                            (b.GetField("type") as DString).Value.Trim(),
                            "",
                            (b.GetField("sep") as DString).Value.Trim(),
                            (b.GetField("is_multi_rows") as DBool).Value,
                            (b.GetField("group") as DString).Value,
                            "",
                            "",
                            (b.GetField("comment") as DString).Value.Trim(),
                            (b.GetField("reference") as DString).Value.Trim(),
                            (b.GetField("path") as DString).Value.Trim(),
                            "",
                            "",
                            "",
                            ""
                            )).ToList(),
                    };
                    this._beans.Add(curBean);
                };
            }
        }

        public async Task LoadDefinesFromFileAsync(string dataDir)
        {
            await Task.WhenAll(LoadTableListFromFileAsync(dataDir), LoadEnumListFromFileAsync(dataDir), LoadBeanListFromFileAsync(dataDir));
            await LoadTableRecordDefinesFromFileAsync(dataDir);
        }

        private static readonly List<string> _fieldOptionalAttrs = new List<string> {
            "index", "sep", "validator", "key_validator", "value_validator",
            "ref", "path", "range", "multi_rows", "group", "res", "convert", "comment" };

        private static readonly List<string> _fieldRequireAttrs = new List<string> { "name", "type" };

        protected override Field CreateField(XElement e)
        {
            ValidAttrKeys(e, _fieldOptionalAttrs, _fieldRequireAttrs);

            return CreateField(XmlUtil.GetRequiredAttribute(e, "name"),
                XmlUtil.GetRequiredAttribute(e, "type"),
                XmlUtil.GetOptionalAttribute(e, "index"),
                 XmlUtil.GetOptionalAttribute(e, "sep"),
                 XmlUtil.GetOptionBoolAttribute(e, "multi_rows"),
                 XmlUtil.GetOptionalAttribute(e, "group"),
                 XmlUtil.GetOptionalAttribute(e, "res"),
                 XmlUtil.GetOptionalAttribute(e, "convert"),
                 XmlUtil.GetOptionalAttribute(e, "comment"),
                 XmlUtil.GetOptionalAttribute(e, "ref"),
                 XmlUtil.GetOptionalAttribute(e, "path"),
                 XmlUtil.GetOptionalAttribute(e, "range"),
                 XmlUtil.GetOptionalAttribute(e, "key_validator"),
                 XmlUtil.GetOptionalAttribute(e, "value_validator"),
                 XmlUtil.GetOptionalAttribute(e, "validator")
                );
        }

        private Field CreateField(string name, string type, string index, string sep, bool isMultiRow, string group, string resource, string converter,
            string comment, string refs, string path, string range, string keyValidator, string valueValidator, string validator)
        {
            var f = new CfgField()
            {
                Name = name,
                Index = index,
                Sep = sep,
                IsMultiRow = isMultiRow,
                Groups = CreateGroups(group),
                Resource = resource,
                Converter = converter,
                Comment = comment,
            };

            // 字段与table的默认组不一样。
            // table 默认只属于default=1的组
            // 字段默认属于所有组
            if (f.Groups.Count == 0)
            {

            }
            else if (!ValidGroup(f.Groups, out var invalidGroup))
            {
                throw new Exception($"定义文件:{CurImportFile} field:'{name}' group:'{invalidGroup}' 不存在");
            }
            f.Type = type;


            FillValueValidator(f, refs, "ref");
            FillValueValidator(f, path, "path"); // (ue4|unity|normal|regex);xxx;xxx
            FillValueValidator(f, range, "range");

            FillValidators("key_validator", keyValidator, f.KeyValidators);
            FillValidators("value_validator", valueValidator, f.ValueValidators);
            FillValidators("validator", validator, f.Validators);
            return f;
        }

        private static readonly List<string> _beanOptinsAttrs = new List<string> { "value_type", "alias", "sep", "comment" };
        private static readonly List<string> _beanRequireAttrs = new List<string> { "name" };

        protected override void AddBean(XElement e, string parent)
        {
            ValidAttrKeys(e, _beanOptinsAttrs, _beanRequireAttrs);

            var b = new CfgBean()
            {
                Name = XmlUtil.GetRequiredAttribute(e, "name"),
                Namespace = CurNamespace,
                Parent = parent.Length > 0 ? parent : "",
                TypeId = 0,
                IsSerializeCompatible = true,
                IsValueType = XmlUtil.GetOptionBoolAttribute(e, "value_type"),
                Alias = XmlUtil.GetOptionalAttribute(e, "alias"),
                Sep = XmlUtil.GetOptionalAttribute(e, "sep"),
                Comment = XmlUtil.GetOptionalAttribute(e, "comment"),
            };
            var childBeans = new List<XElement>();

            bool defineAnyChildBean = false;
            foreach (XElement fe in e.Elements())
            {
                switch (fe.Name.LocalName)
                {
                    case "var":
                    {
                        if (defineAnyChildBean)
                        {
                            throw new LoadDefException($"定义文件:{CurImportFile} 类型:{b.FullName} 的多态子bean必须在所有成员字段 <var> 之前定义");
                        }
                        b.Fields.Add(CreateField(fe)); ;
                        break;
                    }
                    case "bean":
                    {
                        defineAnyChildBean = true;
                        childBeans.Add(fe);
                        break;
                    }
                    default:
                    {
                        throw new LoadDefException($"定义文件:{CurImportFile} 类型:{b.FullName} 不支持 tag:{fe.Name}");
                    }
                }
            }
            s_logger.Trace("add bean:{@bean}", b);
            _beans.Add(b);

            var fullname = b.FullName;
            foreach (var cb in childBeans)
            {
                AddBean(cb, fullname);
            }
        }
    }
}