using System.Collections.Concurrent;
using System.Reflection;
using System.Runtime.Loader;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using Exporter;
using Exporter.Excel;
using Fantasy;
using Fantasy.Assembly;
using Fantasy.ConfigTable;
using Fantasy.DataStructure.Collection;
using Fantasy.Exporter;
using Fantasy.Helper;
using Fantasy.Serialize;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using OfficeOpenXml;
using static System.String;
// ReSharper disable InconsistentNaming
#pragma warning disable CS8625 // Cannot convert null literal to non-nullable reference type.
#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
#pragma warning disable CS8602 // Dereference of a possibly null reference.
#pragma warning disable CS8601 // Possible null reference assignment.
#pragma warning disable CS8604 // Possible null reference argument.
#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.

namespace Fantasy.Tools.ConfigTable;
using TableDictionary = SortedDictionary<string, List<int>>;
/// <summary>
/// Excel 数据导出器，用于从 Excel 文件导出数据到二进制格式和生成 C# 类文件。
/// </summary>
public sealed class ExcelExporter
{
    public ExportType ExportType;
    private readonly string _excelProgramPath;
    private readonly string _versionFilePath;
    private readonly string _excelClientFileDirectory;
    private readonly string _excelServerFileDirectory;
    public readonly string ClientCustomExportDirectory;
    public readonly string ServerCustomExportDirectory;
    private readonly string _excelServerBinaryDirectory;
    private readonly string _excelClientBinaryDirectory;
    private readonly string _excelServerJsonDirectory;
    private readonly string _excelClientJsonDirectory;
    public VersionInfo VersionInfo; // 存储 Excel 文件的版本信息。
    private readonly Regex _regexName = new Regex("^[a-zA-Z][a-zA-Z0-9_]*$"); // 用于验证 Excel 表名的正则表达式。
    private readonly HashSet<string> _loadFiles = [".xlsx", ".xlsm", ".csv"]; // 加载的支持文件扩展名。
    private readonly OneToManyList<string, ExportInfo> _tables = new OneToManyList<string, ExportInfo>(); // 存储 Excel 表及其导出信息。
    private readonly ConcurrentDictionary<string, ExcelTable> _excelTables = new ConcurrentDictionary<string, ExcelTable>(); // 存储解析后的 Excel 表。
    public readonly ConcurrentDictionary<string, ExcelWorksheet> Worksheets = new ConcurrentDictionary<string, ExcelWorksheet>(); // 存储已加载的 Excel 工作表。
    public readonly Dictionary<string, string> IgnoreTable = new Dictionary<string, string>(); // 存储以#开头的的表和路径
    /// <summary>
    /// 导表支持的数据类型集合。
    /// </summary>
    public static readonly HashSet<string> ColTypeSet =
    [
        "", "0", "bool", "byte", "short", "ushort", "int", "uint", "long", "ulong", "float", "string",
        "IntDictionaryConfig", "StringDictionaryConfig",
        "short[]", "int[]", "long[]", "float[]", "string[]", "uint[]"
    ];
    /// <summary>
    /// 导出完成后自动删除的配置表代码文件。
    /// </summary>
    private static readonly HashSet<string> RemoveConfigSet =
    [
        "WorldConfig.cs", "ServerConfig.cs", "SceneConfig.cs", "MachineConfig.cs", "ProcessConfig.cs"
    ];
    static ExcelExporter()
    {
        ExcelPackage.License.SetNonCommercialOrganization("Fantasy");
    }
    /// <summary>
    /// 根据指定的 exportType 初始化 ExcelExporter 类的新实例。
    /// </summary>
    /// <param name="exportType">要执行的导出类型（AllExcel 或 AllExcelIncrement）。</param>
    public ExcelExporter(ExportType exportType)
    {
        ExportType = exportType;

        if (ExporterSettingsHelper.ExcelVersionFile == null || ExporterSettingsHelper.ExcelVersionFile.Trim() == "")
        {
            Log.Info($"ExcelVersionFile Can not be empty!");
            return;
        }

        if (ExporterSettingsHelper.ExcelProgramPath == null || ExporterSettingsHelper.ExcelProgramPath.Trim() == "")
        {
            Log.Info($"ExcelProgramPath Can not be empty!");
            return;
        }

        _excelProgramPath = FileHelper.GetFullPath(ExporterSettingsHelper.ExcelProgramPath);
        _versionFilePath = FileHelper.GetFullPath(ExporterSettingsHelper.ExcelVersionFile);

        if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Client))
        {
            if (ExporterSettingsHelper.ExcelClientBinaryDirectory == null ||
                ExporterSettingsHelper.ExcelClientBinaryDirectory.Trim() == "")
            {
                Log.Info($"ExcelClientBinaryDirectory Can not be empty!");
                return;
            }

            if (ExporterSettingsHelper.ExcelClientJsonDirectory == null ||
                ExporterSettingsHelper.ExcelClientJsonDirectory.Trim() == "")
            {
                Log.Info($"ExcelClientJsonDirectory Can not be empty!");
                return;
            }

            if (ExporterSettingsHelper.ExcelClientFileDirectory == null ||
                ExporterSettingsHelper.ExcelClientFileDirectory.Trim() == "")
            {
                Log.Info($"ExcelServerFileDirectory Can not be empty!");
                return;
            }

            if (ExporterSettingsHelper.ClientCustomExportDirectory == null ||
                ExporterSettingsHelper.ClientCustomExportDirectory.Trim() == "")
            {
                Log.Info($"ClientCustomExportDirectory Can not be empty!");
                return;
            }

            _excelClientJsonDirectory = FileHelper.GetFullPath(ExporterSettingsHelper.ExcelClientJsonDirectory);
            _excelClientBinaryDirectory = FileHelper.GetFullPath(ExporterSettingsHelper.ExcelClientBinaryDirectory);
            ClientCustomExportDirectory = FileHelper.GetFullPath(ExporterSettingsHelper.ClientCustomExportDirectory);
            _excelClientFileDirectory = FileHelper.GetFullPath(ExporterSettingsHelper.ExcelClientFileDirectory);
            // FileHelper.ClearDirectoryFile(_excelClientFileDirectory);
        }

        if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Server))
        {
            if (ExporterSettingsHelper.ExcelServerFileDirectory == null || ExporterSettingsHelper.ExcelServerFileDirectory.Trim() == "")
            {
                Log.Info($"ExcelServerFileDirectory Can not be empty!");
                return;
            }

            if (ExporterSettingsHelper.ExcelServerJsonDirectory == null || ExporterSettingsHelper.ExcelServerJsonDirectory.Trim() == "")
            {
                Log.Info($"ExcelServerJsonDirectory Can not be empty!");
                return;
            }

            if (ExporterSettingsHelper.ExcelServerBinaryDirectory == null || ExporterSettingsHelper.ExcelServerBinaryDirectory.Trim() == "")
            {
                Log.Info($"ExcelServerBinaryDirectory Can not be empty!");
                return;
            }

            if (ExporterSettingsHelper.ServerCustomExportDirectory == null || ExporterSettingsHelper.ServerCustomExportDirectory.Trim() == "")
            {
                Log.Info($"ServerCustomExportDirectory Can not be empty!");
                return;
            }

            _excelServerJsonDirectory = FileHelper.GetFullPath(ExporterSettingsHelper.ExcelServerJsonDirectory);
            _excelServerBinaryDirectory = FileHelper.GetFullPath(ExporterSettingsHelper.ExcelServerBinaryDirectory);
            ServerCustomExportDirectory = FileHelper.GetFullPath(ExporterSettingsHelper.ServerCustomExportDirectory);
            _excelServerFileDirectory = FileHelper.GetFullPath(ExporterSettingsHelper.ExcelServerFileDirectory);
            // FileHelper.ClearDirectoryFile(_excelServerFileDirectory);
        }
        
        switch (ExportType)
        {
            case ExportType.AllExcelIncrement:
            {
                break;
            }
            case ExportType.AllExcel:
            {
                if (File.Exists(_versionFilePath))
                {
                    File.Delete(_versionFilePath);
                }

                break;
            }
        }
        
        SerializerManager.Initialize();
        
    }

    public void Run()
    {
        Find();
        Parsing();
        ExportToBinary();
        File.WriteAllText(_versionFilePath, JsonConvert.SerializeObject(VersionInfo));
        CustomExport();
        RemoveConfigCS();
    }
    private static void RemoveConfigCS()
    {
        foreach (var removeConfigFile in RemoveConfigSet)
        {
            var serverFile = Path.Combine(ExporterSettingsHelper.ExcelServerFileDirectory, removeConfigFile);
            var clientFile = Path.Combine(ExporterSettingsHelper.ExcelClientFileDirectory, removeConfigFile);
            
            if (File.Exists(serverFile))
            {
                File.Delete(serverFile);
            }
        
            if (File.Exists(clientFile))
            {
                File.Delete(clientFile);
            }
        }
    }
    
    private void CustomExport()
    {
        var task = new List<Task>();
        var excelWorksheets = new ExcelWorksheets(this);
        var customConfigure = $"{_excelProgramPath}Custom.txt";

        if (!File.Exists(customConfigure))
        {
            using var streamWriter = File.CreateText(customConfigure);
            var stringBuilder = new StringBuilder();
            stringBuilder.AppendLine("// 自定义导出配置文件,用于配置自定义导出自定义程序的路径,每行一个路径,路径是导表应用的相对路径。如:../../Config/Custom/1.cs");
            streamWriter.Write(stringBuilder);
            return;
        }

        var lineNumber = 0;
        var oneDynamicAssembly = new OneDynamicAssembly();
        using var reader = new StreamReader(customConfigure);
        
        while (reader.ReadLine() is { } lineStr)
        {
            if (++lineNumber == 1 || string.IsNullOrEmpty(lineStr) || lineStr.StartsWith("#"))
            {
                continue;
            }
            
            oneDynamicAssembly.Load(FileHelper.GetFullPath(lineStr));
        }
        
        long AssemblyIdentity(System.Reflection.Assembly assembly)
        {
            var assemblyName = assembly.GetName();
            var name = assemblyName.Name;
            var version = assemblyName.Version.ToString();
            var culture = assemblyName.CultureInfo?.Name ?? "neutral";
            var publicKeyToken = BitConverter.ToString(assemblyName.GetPublicKeyToken()).Replace("-", string.Empty);
            var assemblyIdentity = $"{name}|{version}|{culture}|{publicKeyToken}";
            var hashBytes = SHA256.HashData(Encoding.UTF8.GetBytes(assemblyIdentity));
            return BitConverter.ToInt64(hashBytes, 0);
        }
        
        void AddCustomExportTask(System.Reflection.Assembly assembly)
        {
            var assemblyIdentity = AssemblyIdentity(assembly);
            var assemblyInfo = new AssemblyInfo(assemblyIdentity);
            assemblyInfo.Load(assembly);
            
            if (!assemblyInfo.AssemblyTypeGroupList.TryGetValue(typeof(ICustomExport), out var customExportList))
            {
                return;
            }
                
            foreach (var type in customExportList)
            {
                var customExport = (ICustomExport)Activator.CreateInstance(type);
                   
                if (customExport != null)
                {
                    customExport.Init(this, excelWorksheets);
                    task.Add(Task.Run(customExport.Run));
                }
            }
        }
        
        // 生成一个系统内置的自定义导出类
        var sceneTypeConfigToEnum = new SceneTypeConfigToEnum();
        sceneTypeConfigToEnum.Init(this, excelWorksheets);
        task.Add(Task.Run(sceneTypeConfigToEnum.Run));
        // task.Add(Task.Run(constValueToConst.Run));
        // 加载自定义导出程序集
        AddCustomExportTask(oneDynamicAssembly.Assembly);
        // 执行自定义导出任务
        Task.WaitAll(task.ToArray());
    }
    
    /// <summary>
    /// 查找配置文件
    /// </summary>
    private void Find()
    {
        VersionInfo = File.Exists(_versionFilePath) ? JsonConvert.DeserializeObject<VersionInfo>(File.ReadAllText(_versionFilePath)) : new VersionInfo();
        
        var dir = new DirectoryInfo(_excelProgramPath);
        var excelFiles = dir.GetFiles("*", SearchOption.AllDirectories);
        
        if (excelFiles.Length <= 0)
        {
            return;
        }

        foreach (var excelFile in excelFiles)
        {
            // 过滤掉非指定后缀的文件

            if (!_loadFiles.Contains(excelFile.Extension))
            {
                continue;
            }

            var lastIndexOf = excelFile.Name.LastIndexOf(".", StringComparison.Ordinal);

            if (lastIndexOf < 0)
            {
                continue;
            }

            var fullName = excelFile.FullName;
            var excelName = excelFile.Name.Substring(0, lastIndexOf);
            var path = fullName.Substring(0, fullName.Length - excelFile.Name.Length);

            // 过滤~开头文件
            
            if (excelName.StartsWith("~", StringComparison.Ordinal))
            {
                continue;
            }

            // 如果文件名以#开头，那么这个文件夹下的所有文件都不导出
            
            if (excelName.StartsWith("#", StringComparison.Ordinal))
            {
                IgnoreTable.Add(excelName, fullName);
                continue;
            }
            
            // 如果文件夹名包含#，那么这个文件夹下的所有文件都不导出

            if (path.Contains("#", StringComparison.Ordinal))
            {
                continue;
            }

            if (!_regexName.IsMatch(excelName))
            {
                Log.Info($"{excelName} 配置文件名非法");
                continue;
            }

            var exportInfo = new ExportInfo()
            {
                Name = excelName, FileInfo = excelFile
            };
            
            _tables.Add(excelName.Split('_')[0], exportInfo);
        }
        
        var removeTables = new List<string>();

        foreach (var (tableName, tableList) in _tables)
        {
            var isNeedExport = false;

            foreach (var exportInfo in tableList)
            {
                var key = HashCodeHelper.ComputeHash64(exportInfo.Name);
                var timer = TimeHelper.Transition(exportInfo.FileInfo.LastWriteTime);

                if (!isNeedExport)
                {
                    
                    if (VersionInfo.Tables.TryGetValue(key, out var lastWriteTime))
                    {
                        isNeedExport = lastWriteTime != timer;
                    }
                    else
                    {
                        isNeedExport = true;
                    }
                }
                
                VersionInfo.Tables[key] = timer;
            }

            if (!isNeedExport)
            {
                removeTables.Add(tableName);
            }
        }
        
        foreach (var removeTable in removeTables)
        {
            _tables.Remove(removeTable);
        }
        
        foreach (var (_, exportInfo) in _tables)
        {
            exportInfo.Sort((x, y) => Compare(x.Name, y.Name, StringComparison.Ordinal));
        }
    }
    /// <summary>
    /// 生成配置文件
    /// </summary>
    private void Parsing()
    {
        var generateTasks = new List<Task>();

        foreach (var (tableName, tableList) in _tables)
        {
            var task = Task.Run(() =>
            {
                var writeToClassTask = new List<Task>();
                var excelTable = new ExcelTable(tableName);

                // 筛选需要导出的列

                foreach (var exportInfo in tableList)
                {
                    try
                    {
                        var serverColInfoList = new List<int>();
                        var clientColInfoList = new List<int>();
                        var worksheet = LoadExcel(exportInfo.FileInfo.FullName, true);

                        for (var col = 3; col <= worksheet.Columns.EndColumn; col++)
                        {
                            // 列名字第一个字符是#不参与导出

                            var colName = worksheet.GetCellValue(5, col);
                            if (colName.StartsWith("#", StringComparison.Ordinal))
                            {
                                continue;
                            }

                            // 数值列不参与导出

                            var numericalCol = worksheet.GetCellValue(3, col);
                            if (numericalCol != "" && numericalCol != "0")
                            {
                                continue;
                            }

                            var serverType = worksheet.GetCellValue(1, col);
                            var clientType = worksheet.GetCellValue(2, col);
                            var isExportServer = !IsNullOrEmpty(serverType) && serverType != "0";
                            var isExportClient = !IsNullOrEmpty(clientType) && clientType != "0";

                            if (!isExportServer && !isExportClient)
                            {
                                continue;
                            }

                            if (isExportServer && isExportClient & serverType != clientType)
                            {
                                Log.Info($"配置表 {exportInfo.Name} {col} 列 [{colName}] 客户端类型 {clientType} 和 服务端类型 {serverType} 不一致");
                                continue;
                            }

                            if (!ColTypeSet.Contains(serverType) || !ColTypeSet.Contains(clientType))
                            {
                                Log.Info($"配置表 {exportInfo.Name} {col} 列 [{colName}] 客户端类型 {clientType}, 服务端类型 {serverType} 不合法");
                                continue;
                            }

                            if (!_regexName.IsMatch(colName))
                            {
                                Log.Info($"配置表 {exportInfo.Name} {col} 列 [{colName}] 列名非法");
                                continue;
                            }

                            serverColInfoList.Add(col);

                            if (isExportClient)
                            {
                                clientColInfoList.Add(col);
                            }
                        }

                        if (clientColInfoList.Count > 0)
                        {
                            excelTable.ClientColInfos.Add(exportInfo.FileInfo.FullName, clientColInfoList);
                        }

                        if (serverColInfoList.Count > 0)
                        {
                            excelTable.ServerColInfos.Add(exportInfo.FileInfo.FullName, serverColInfoList);
                        }
                    }
                    catch (Exception e)
                    {
                        Log.Error($"Config : {tableName}, Name : {exportInfo.Name}, Error : {e}");
                    }
                }

                // 生成cs文件

                if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Server))
                {
                    writeToClassTask.Add(Task.Run(() =>
                    {
                        WriteToClass(excelTable.ServerColInfos, _excelServerFileDirectory, true);
                    }));
                }

                if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Client))
                {
                    writeToClassTask.Add(Task.Run(() =>
                    {
                        WriteToClass(excelTable.ClientColInfos, _excelClientFileDirectory, false);
                    }));
                }

                Task.WaitAll(writeToClassTask.ToArray());
                _excelTables.TryAdd(tableName, excelTable);
            });

            generateTasks.Add(task);
        }

        Task.WaitAll(generateTasks.ToArray());
    }
    /// <summary>
    /// 把数据和实体类转换二进制导出到文件中
    /// </summary>
    private void ExportToBinary()
    {
        System.Reflection.Assembly dynamicServerAssembly = null;
        System.Reflection.Assembly dynamicClientAssembly = null;
        var exportToBinaryTasks = new List<Task>();
        
        if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Server) && Directory.Exists(_excelServerFileDirectory))
        {
            dynamicServerAssembly = DynamicAssembly.Load(_excelServerFileDirectory);
        }

        if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Client) && Directory.Exists(_excelClientFileDirectory))
        {
            dynamicClientAssembly = DynamicAssembly.Load(_excelClientFileDirectory);
        }
        
        foreach (var (tableName, tableList) in _tables)
        {
            var task = Task.Run(() =>
            {
                DynamicConfigDataType serverDynamicInfo = null;
                DynamicConfigDataType clientDynamicInfo = null;
                
                var idCheck = new HashSet<string>();
                var excelTable = _excelTables[tableName];
                var csName = Path.GetFileNameWithoutExtension(tableName);
                
                if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Server))
                {
                    var serverColInfoCount = excelTable.ServerColInfos.Sum(d => d.Value.Count);
                    serverDynamicInfo = serverColInfoCount == 0 ? null : DynamicAssembly.GetDynamicInfo(dynamicServerAssembly, csName);
                }

                if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Client))
                {
                    var clientColInfoCount = excelTable.ClientColInfos.Sum(d => d.Value.Count);
                    clientDynamicInfo = clientColInfoCount == 0 ? null : DynamicAssembly.GetDynamicInfo(dynamicClientAssembly, csName);
                }

                for (var i = 0; i < tableList.Count; i++)
                {
                    var tableListName = tableList[i];

                    try
                    {
                        var fileInfoFullName = tableListName.FileInfo.FullName;
                        var excelWorksheet = LoadExcel(fileInfoFullName, false);
                        var rows = excelWorksheet.Dimension.Rows;
                        excelTable.ServerColInfos.TryGetValue(fileInfoFullName, out var serverCols);
                        excelTable.ClientColInfos.TryGetValue(fileInfoFullName, out var clientCols);

                        for (var row = 7; row <= rows; row++)
                        {
                            if (excelWorksheet.GetCellValue(row, 1).StartsWith("#", StringComparison.Ordinal))
                            {
                                continue;
                            }
                            
                            var id = excelWorksheet.GetCellValue(row, 3);

                            if (idCheck.Contains(id))
                            {
                                Log.Info($"{tableListName.Name} 存在重复Id {id} 行号 {row}");
                                continue;
                            }

                            idCheck.Add(id);
                            var isLast = row == rows && (i == tableList.Count - 1);
                            
                            if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Server))
                            {
                                GenerateBinary(fileInfoFullName, excelWorksheet, serverDynamicInfo, serverCols, id, row, isLast, true);
                            }

                            if (ExporterAges.Instance.ExportPlatform.HasFlag(ExportPlatform.Client))
                            {
                                GenerateBinary(fileInfoFullName, excelWorksheet, clientDynamicInfo, clientCols, id, row, isLast, false);
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Log.Error($"Table:{tableListName} error! \n{e}");
                        throw;
                    }
                }

                if (serverDynamicInfo?.ConfigData != null)
                {
                    var memoryStream = new MemoryStreamBuffer();
                    SerializerManager.GetSerializer(FantasySerializerType.ProtoBuf).Serialize(serverDynamicInfo.ConfigData, memoryStream);
                    if (!Directory.Exists(_excelServerBinaryDirectory))
                    {
                        Directory.CreateDirectory(_excelServerBinaryDirectory);
                    }
                    var asSpan = memoryStream.GetBuffer().AsSpan(0, (int)memoryStream.Position);
                    File.WriteAllBytes(Path.Combine(_excelServerBinaryDirectory, $"{csName}Data.bytes"), asSpan.ToArray());
                    if (serverDynamicInfo.Json.Length > 0)
                    {
                        if (!Directory.Exists(_excelServerJsonDirectory))
                        {
                            Directory.CreateDirectory(_excelServerJsonDirectory);
                        }
                        using var sw = new StreamWriter(Path.Combine(_excelServerJsonDirectory, $"{csName}Data.Json"));
                        sw.WriteLine("{\"List\":[");
                        sw.Write(serverDynamicInfo.Json.ToString());
                        sw.WriteLine("]}");
                    }
                }
                
                if (clientDynamicInfo?.ConfigData != null)
                {
                    var memoryStream = new MemoryStreamBuffer();
                    SerializerManager.GetSerializer(FantasySerializerType.ProtoBuf).Serialize(clientDynamicInfo.ConfigData, memoryStream);
                    if (!Directory.Exists(_excelClientBinaryDirectory))
                    {
                        Directory.CreateDirectory(_excelClientBinaryDirectory);
                    }
                    var asSpan = memoryStream.GetBuffer().AsSpan(0, (int)memoryStream.Position);
                    File.WriteAllBytes(Path.Combine(_excelClientBinaryDirectory, $"{csName}Data.bytes"), asSpan.ToArray());
                
                    if (clientDynamicInfo.Json.Length > 0)
                    {
                        if (!Directory.Exists(_excelClientJsonDirectory))
                        {
                            Directory.CreateDirectory(_excelClientJsonDirectory);
                        }
                        using var sw = new StreamWriter(Path.Combine(_excelClientJsonDirectory, $"{csName}Data.Json"));
                        sw.WriteLine("{\"List\":[");
                        sw.Write(clientDynamicInfo.Json.ToString());
                        sw.WriteLine("]}");
                    }
                }
            });
            exportToBinaryTasks.Add(task);
        }

        Task.WaitAll(exportToBinaryTasks.ToArray());
    }
    private void GenerateBinary(string fileInfoFullName, ExcelWorksheet excelWorksheet, DynamicConfigDataType dynamicInfo, List<int> cols, string id, int row, bool isLast, bool isServer)
    {
        if (cols == null || IsNullOrEmpty(id) || cols.Count <= 0 || dynamicInfo?.ConfigType == null)
        {
            return;
        }

        var config = DynamicAssembly.CreateInstance(dynamicInfo.ConfigType);

        for (var i = 0; i < cols.Count; i++)
        {
            string colType;
            var colIndex = cols[i];
            var colName = excelWorksheet.GetCellValue(5, colIndex);
            var value = excelWorksheet.GetCellValue(row, colIndex);
            
            if (isServer)
            {
                colType = excelWorksheet.GetCellValue(1, colIndex);
                    
                if (IsNullOrEmpty(colType) || colType == "0")
                {
                    colType = excelWorksheet.GetCellValue(2, colIndex);
                }
            }
            else
            {
                colType = excelWorksheet.GetCellValue(2, colIndex);
            }

            try
            {
                SetNewValue(dynamicInfo.ConfigType.GetProperty(colName), config, colType, value);
            }
            catch (Exception e)
            {
                Log.Error($"Error Table {fileInfoFullName} Col:{colName} colType:{colType} Row:{row} value:{value} {e}");
                throw;
            }
        }
        
        dynamicInfo.Method.Invoke(dynamicInfo.Obj, new object[] {config});
                
        var json = JsonConvert.SerializeObject(config);

        if (isLast)
        {
            dynamicInfo.Json.AppendLine(json);
        }
        else
        {
            dynamicInfo.Json.AppendLine($"{json},");
        }
    }
    /// <summary>
    /// 从 Excel 文件加载工作表并返回 ExcelWorksheet 对象。
    /// </summary>
    /// <param name="name">工作表的名称或文件路径。</param>
    /// <param name="isAddToDic">是否将加载的工作表添加到缓存字典中。</param>
    /// <returns>表示 Excel 工作表的 ExcelWorksheet 对象。</returns>
    public ExcelWorksheet LoadExcel(string name, bool isAddToDic)
    {
        if (Worksheets.TryGetValue(name, out var worksheet))
        {
            return worksheet;
        }

        var workbookWorksheets = ExcelHelper.LoadExcel(name).Workbook.Worksheets;
        worksheet = workbookWorksheets[0];

        if (isAddToDic)
        {
            Worksheets.TryAdd(name, worksheet);
            
            foreach (var workbookWorksheet in workbookWorksheets)
            {
                VersionInfo.WorksheetNames.Add(HashCodeHelper.ComputeHash64(workbookWorksheet.Name));
                Worksheets.TryAdd(workbookWorksheet.Name, workbookWorksheet);
            }
        }
        
        Log.Info(name);
        return workbookWorksheets[0];
    }
    /// <summary>
    /// 写入到cs
    /// </summary>
    /// <param name="colInfos"></param>
    /// <param name="exportPath"></param>
    /// <param name="isServer"></param>
    private void WriteToClass(TableDictionary colInfos, string exportPath, bool isServer)
    {
        if (colInfos.Count <= 0)
        {
            return;
        }

        var index = 0;
        var fileBuilder = new StringBuilder();
        var colNameSet = new HashSet<string>();

        if (colInfos.Count == 0)
        {
            return;
        }

        var csName = Path.GetFileNameWithoutExtension(colInfos.First().Key)?.Split('_')[0];

        foreach (var (tableName, cols) in colInfos)
        {
            if (cols == null || cols.Count == 0)
            {
                continue;
            }

            var excelWorksheet = LoadExcel(tableName, false);

            foreach (var colIndex in cols)
            {
                var colName = excelWorksheet.GetCellValue(5, colIndex);

                if (colNameSet.Contains(colName))
                {
                    continue;
                }

                colNameSet.Add(colName);

                string colType;

                if (isServer)
                {
                    colType = excelWorksheet.GetCellValue(1, colIndex);

                    if (IsNullOrEmpty(colType) || colType == "0")
                    {
                        colType = excelWorksheet.GetCellValue(2, colIndex);
                    }
                }
                else
                {
                    colType = excelWorksheet.GetCellValue(2, colIndex);
                }

                var remarks = excelWorksheet.GetCellValue(4, colIndex);

                // 解决不同平台换行符不一致的问题
                
                switch (Environment.OSVersion.Platform)
                {
                    case PlatformID.Win32NT:
                    case PlatformID.Win32S:
                    case PlatformID.Win32Windows:
                    case PlatformID.WinCE:
                    {
                        fileBuilder.Append($"\r\n\t\t[ProtoMember({++index})]\r\n");
                        break;
                    }
                    default:
                    {
                        fileBuilder.Append($"\n\t\t[ProtoMember({++index})]\n");
                        break;
                    }
                }
                
                fileBuilder.Append(
                    IsArray(colType,out var t)
                        ? $"\t\tpublic {colType} {colName} {{ get; set; }} = Array.Empty<{t}>(); // {remarks}"
                        : $"\t\tpublic {colType} {colName} {{ get; set; }} // {remarks}");
            }
        }
        
        var template = ExcelTemplate.Template;
        
        if (fileBuilder.Length > 0)
        {
            if (!Directory.Exists(exportPath))
            {
                FileHelper.CreateDirectory(exportPath);
            }

            var content = template.Replace("(namespace)", "Fantasy")
                .Replace("(ConfigName)", csName)
                .Replace("(Fields)", fileBuilder.ToString());
            File.WriteAllText(Path.Combine(exportPath, $"{csName}.cs"), content);
        }
    }
    private void SetNewValue(PropertyInfo propertyInfo, object config, string type, string value)
    {
        if (IsNullOrWhiteSpace(value))
        {
            return;
        }

        switch (type)
        {
            case "short":
            {
                propertyInfo.SetValue(config, Convert.ToInt16(value));
                return;
            }
            case "ushort":
            {
                propertyInfo.SetValue(config, Convert.ToUInt16(value));
                return;
            }
            case "uint":
            {
                propertyInfo.SetValue(config, Convert.ToUInt32(value));
                return;
            }
            case "int":
            {
                propertyInfo.SetValue(config, Convert.ToInt32(value));
                return;
            }
            case "decimal":
            {
                propertyInfo.SetValue(config, Convert.ToDecimal(value));
                return;
            }
            case "string":
            {
                try
                {
                    propertyInfo.SetValue(config, value);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    throw;
                }
                
                return;
            }
            case "bool":
            {
                // 空字符串

                value = value.ToLower();

                if (IsNullOrEmpty(value))
                {
                    propertyInfo.SetValue(config, false);
                }
                else if (bool.TryParse(value, out bool b))
                {
                    propertyInfo.SetValue(config, b);
                }
                else if (int.TryParse(value, out int v))
                {
                    propertyInfo.SetValue(config, v != 0);
                }
                else
                {
                    propertyInfo.SetValue(config, false);
                }

                return;
            }
            case "ulong":
            {
                propertyInfo.SetValue(config, Convert.ToUInt64(value));
                return;
            }
            case "long":
            {
                propertyInfo.SetValue(config, Convert.ToInt64(value));
                return;
            }
            case "double":
            {
                propertyInfo.SetValue(config, Convert.ToDouble(value));
                return;
            }
            case "float":
            {
                propertyInfo.SetValue(config, Convert.ToSingle(value));
                return;
            }
            case "int32[]":
            case "int[]":
            {
                if (value != "0")
                {
                    propertyInfo.SetValue(config, value.Split(",").Select(d => Convert.ToInt32(d)).ToArray());
                }

                return;
            }
            case "uint[]":
            {
                if (value != "0")
                {
                    propertyInfo.SetValue(config, value.Split(",").Select(d => Convert.ToUInt32(d)).ToArray());
                }
                return;
            }
            case "long[]":
            {
                if (value != "0")
                {
                    propertyInfo.SetValue(config, value.Split(",").Select(d => Convert.ToInt64(d)).ToArray());
                }

                return;
            }
            case "double[]":
            {
                if (value != "0")
                {
                    propertyInfo.SetValue(config, value.Split(",").Select(d => Convert.ToDouble(d)).ToArray());
                }

                return;
            }
            case "string[]":
            {
                if (value == "0")
                {
                    return;
                }

                var list = value.Split(",").ToArray();

                for (var i = 0; i < list.Length; i++)
                {
                    list[i] = list[i].Replace("\"", "");
                }

                propertyInfo.SetValue(config, value.Split(",").ToArray());

                return;
            }
            case "float[]":
            {
                if (value != "0")
                {
                    propertyInfo.SetValue(config, value.Split(",").Select(d => Convert.ToSingle(d)).ToArray());
                }

                return;
            }
            case "IntDictionaryConfig":
            {
                if (value.Trim() == "" || value.Trim() == "{}")
                {
                    propertyInfo.SetValue(config, null);
                    return;
                }

                var attr = new IntDictionaryConfig {Dic = JsonConvert.DeserializeObject<Dictionary<int, int>>(value)};

                propertyInfo.SetValue(config, attr);

                return;
            }
            case "StringDictionaryConfig":
            {
                if (value.Trim() == "" || value.Trim() == "{}")
                {
                    propertyInfo.SetValue(config, null);
                    return;
                }

                var attr = new StringDictionaryConfig {Dic = JsonConvert.DeserializeObject<Dictionary<int, string>>(value)};

                propertyInfo.SetValue(config, attr);

                return;
            }
            default:
                throw new NotSupportedException($"不支持此类型: {type}");
        }
    }
    private bool IsArray(string type, out string t)
    {
        t = null;
        var index = type.IndexOf("[]", StringComparison.Ordinal);

        if (index >= 0)
        {
            t = type.Remove(index, 2);
        }

        return index >= 0;
    }
}