using CapMachine.Model;
using CapMachine.Model.CANLIN;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace CapMachine.Wpf.Services
{
    /// <summary>
    /// CAN/LIN 配置导入模式。
    /// </summary>
    public enum CanLinImportMode
    {
        /// <summary>
        /// 覆盖导入：同名同类型配置先删除后导入。
        /// </summary>
        Overwrite = 1,

        /// <summary>
        /// 增量导入：同名同类型配置自动重命名后导入。
        /// </summary>
        IncrementalRename = 2,
    }

    /// <summary>
    /// 导入导出执行结果。
    /// </summary>
    public class CanLinConfigImExportResult
    {
        /// <summary>
        /// 执行是否成功。
        /// </summary>
        public bool IsSuccess { get; set; }

        /// <summary>
        /// 结果消息。
        /// </summary>
        public string Message { get; set; } = string.Empty;

        /// <summary>
        /// 导出配置数量。
        /// </summary>
        public int ExportedConfigCount { get; set; }

        /// <summary>
        /// 导入配置数量。
        /// </summary>
        public int ImportedConfigCount { get; set; }

        /// <summary>
        /// 覆盖配置数量。
        /// </summary>
        public int OverwrittenConfigCount { get; set; }

        /// <summary>
        /// 重命名配置数量。
        /// </summary>
        public int RenamedConfigCount { get; set; }

        /// <summary>
        /// 新增规则数量。
        /// </summary>
        public int InsertedRuleCount { get; set; }

        /// <summary>
        /// 覆盖规则数量。
        /// </summary>
        public int UpdatedRuleCount { get; set; }

        /// <summary>
        /// 重命名后的配置明细。
        /// </summary>
        public List<string> RenamedConfigs { get; set; } = new List<string>();
    }

    /// <summary>
    /// CAN/CANFD/LIN 配置导入导出服务。
    /// </summary>
    public class CanLinConfigImExportService
    {
        /// <summary>
        /// 文件结构版本。
        /// </summary>
        private const string SchemaVersion = "1.0";

        /// <summary>
        /// 初始化导入导出服务。
        /// </summary>
        /// <param name="freeSql">数据库实例。</param>
        /// <param name="logService">日志服务。</param>
        public CanLinConfigImExportService(IFreeSql freeSql, ILogService logService)
        {
            FreeSql = freeSql;
            LogService = logService;
        }

        /// <summary>
        /// 数据库访问对象。
        /// </summary>
        public IFreeSql FreeSql { get; }

        /// <summary>
        /// 日志服务。
        /// </summary>
        public ILogService LogService { get; }

        /// <summary>
        /// 导出当前 CAN/CANFD/LIN 配置到 JSON 文件。
        /// </summary>
        /// <param name="filePath">目标文件路径。</param>
        /// <returns>执行结果。</returns>
        public CanLinConfigImExportResult ExportToFile(string filePath)
        {
            var result = new CanLinConfigImExportResult();
            try
            {
                if (string.IsNullOrWhiteSpace(filePath))
                {
                    result.Message = "导出路径不能为空";
                    return result;
                }

                var package = BuildExportPackage();
                var json = JsonConvert.SerializeObject(package, Formatting.Indented);

                var dir = Path.GetDirectoryName(filePath);
                if (!string.IsNullOrWhiteSpace(dir) && !Directory.Exists(dir))
                {
                    Directory.CreateDirectory(dir);
                }

                File.WriteAllText(filePath, json, Encoding.UTF8);

                result.IsSuccess = true;
                result.ExportedConfigCount = package.CanLinConfigPros.Count;
                result.Message = $"导出成功，配置数量：{result.ExportedConfigCount}";
                return result;
            }
            catch (Exception ex)
            {
                LogService.Error($"导出 CAN/LIN 配置失败：{ex}");
                result.Message = $"导出失败：{ex.Message}";
                return result;
            }
        }

        /// <summary>
        /// 从 JSON 文件导入 CAN/CANFD/LIN 配置到数据库。
        /// </summary>
        /// <param name="filePath">源文件路径。</param>
        /// <param name="importMode">导入模式。</param>
        /// <returns>执行结果。</returns>
        public CanLinConfigImExportResult ImportFromFile(string filePath, CanLinImportMode importMode)
        {
            var result = new CanLinConfigImExportResult();
            try
            {
                if (string.IsNullOrWhiteSpace(filePath))
                {
                    result.Message = "导入文件路径不能为空";
                    return result;
                }

                if (!File.Exists(filePath))
                {
                    result.Message = "导入文件不存在";
                    return result;
                }

                var json = File.ReadAllText(filePath, Encoding.UTF8);
                var package = JsonConvert.DeserializeObject<CanLinConfigPackageSnapshot>(json);
                if (package == null)
                {
                    result.Message = "导入文件解析失败";
                    return result;
                }

                if (package.CanLinConfigPros == null || package.CanLinConfigPros.Count == 0)
                {
                    result.Message = "导入文件中没有 CAN/CANFD/LIN 配置数据";
                    return result;
                }

                FreeSql.Transaction(() =>
                {
                    var ruleMaps = UpsertLogicRules(package.LogicRules ?? new List<LogicRuleSnapshot>(), result);
                    foreach (var configSnapshot in package.CanLinConfigPros)
                    {
                        ImportSingleConfig(configSnapshot, importMode, ruleMaps, result);
                    }
                });

                result.IsSuccess = true;
                result.Message =
                    $"导入成功：新增配置 {result.ImportedConfigCount}，覆盖配置 {result.OverwrittenConfigCount}，重命名配置 {result.RenamedConfigCount}，新增规则 {result.InsertedRuleCount}，覆盖规则 {result.UpdatedRuleCount}";
                return result;
            }
            catch (Exception ex)
            {
                LogService.Error($"导入 CAN/LIN 配置失败：{ex}");
                result.Message = $"导入失败：{ex.Message}";
                return result;
            }
        }

        /// <summary>
        /// 构建导出快照对象。
        /// </summary>
        /// <returns>导出快照。</returns>
        private CanLinConfigPackageSnapshot BuildExportPackage()
        {
            var logicRules = FreeSql.Select<LogicRule>().OrderBy(a => a.Id).ToList();

            var canConfigPros = FreeSql.Select<CanLinConfigPro>()
                .Where(a => a.CANLINInfo == CANLIN.CAN)
                .Include(a => a.CANConfigExd)
                .IncludeMany(a => a.CanLinConfigContents, then => then.Include(b => b.LogicRule))
                .IncludeMany(a => a.CanScheduleConfigs)
                .ToList();

            var canFdConfigPros = FreeSql.Select<CanLinConfigPro>()
                .Where(a => a.CANLINInfo == CANLIN.CANFD)
                .Include(a => a.CANFdConfigExd)
                .IncludeMany(a => a.CanLinConfigContents, then => then.Include(b => b.LogicRule))
                .IncludeMany(a => a.CanFdScheduleConfigs)
                .ToList();

            var linConfigPros = FreeSql.Select<CanLinConfigPro>()
                .Where(a => a.CANLINInfo == CANLIN.LIN)
                .Include(a => a.LINConfigExd)
                .IncludeMany(a => a.CanLinConfigContents, then => then.Include(b => b.LogicRule))
                .IncludeMany(a => a.LinScheduleConfigs)
                .ToList();

            var allConfigPros = new List<CanLinConfigPro>();
            allConfigPros.AddRange(canConfigPros);
            allConfigPros.AddRange(canFdConfigPros);
            allConfigPros.AddRange(linConfigPros);

            return new CanLinConfigPackageSnapshot
            {
                SchemaVersion = SchemaVersion,
                ExportTime = DateTime.Now,
                LogicRules = logicRules.Select(MapLogicRuleSnapshot).ToList(),
                CanLinConfigPros = allConfigPros.Select(MapConfigSnapshot).ToList(),
            };
        }

        /// <summary>
        /// 导入单个配置程序。
        /// </summary>
        /// <param name="snapshot">配置快照。</param>
        /// <param name="importMode">导入模式。</param>
        /// <param name="ruleMaps">规则映射。</param>
        /// <param name="result">结果对象。</param>
        private void ImportSingleConfig(
            CanLinConfigProSnapshot snapshot,
            CanLinImportMode importMode,
            ImportRuleMaps ruleMaps,
            CanLinConfigImExportResult result)
        {
            if (snapshot == null)
            {
                return;
            }

            var sourceName = (snapshot.ConfigName ?? string.Empty).Trim();
            if (string.IsNullOrWhiteSpace(sourceName))
            {
                throw new InvalidOperationException("导入文件中存在空配置名称");
            }

            var canlinInfo = snapshot.CANLINInfo;
            var finalConfigName = sourceName;

            var sameConfigExists = FreeSql.Select<CanLinConfigPro>()
                .Where(a => a.CANLINInfo == canlinInfo)
                .Where(a => a.ConfigName == sourceName)
                .Any();

            if (sameConfigExists)
            {
                if (importMode == CanLinImportMode.Overwrite)
                {
                    DeleteExistingConfig(sourceName, canlinInfo);
                    result.OverwrittenConfigCount++;
                }
                else
                {
                    finalConfigName = BuildUniqueImportName(sourceName, canlinInfo);
                    result.RenamedConfigCount++;
                    result.RenamedConfigs.Add($"{sourceName} -> {finalConfigName} ({canlinInfo})");
                }
            }

            var configExdIds = CreateConfigExd(snapshot, canlinInfo);

            var insertPro = FreeSql.Insert(new CanLinConfigPro
            {
                ConfigName = finalConfigName,
                CANLINInfo = canlinInfo,
                CANConfigExdId = configExdIds.CANConfigExdId,
                CANFdConfigExdId = configExdIds.CANFdConfigExdId,
                LINConfigExdId = configExdIds.LINConfigExdId,
            }).ExecuteInserted().FirstOrDefault();

            if (insertPro == null)
            {
                throw new InvalidOperationException($"配置程序导入失败：{finalConfigName}");
            }

            var rwConfigs = snapshot.CanLinConfigContents ?? new List<CanLinRWConfigSnapshot>();
            foreach (var rwConfig in rwConfigs)
            {
                var logicRuleId = ResolveLogicRuleId(rwConfig, ruleMaps);
                var rwInsertResult = FreeSql.Insert(new CanLinRWConfig
                {
                    RWInfo = rwConfig.RWInfo,
                    Name = string.IsNullOrWhiteSpace(rwConfig.Name) ? rwConfig.SignalName : rwConfig.Name,
                    MsgFrameName = rwConfig.MsgFrameName ?? string.Empty,
                    SignalName = rwConfig.SignalName ?? string.Empty,
                    DefautValue = rwConfig.DefautValue,
                    CanLinConfigProId = insertPro.Id,
                    LogicRuleId = logicRuleId,
                }).ExecuteAffrows();

                if (rwInsertResult <= 0)
                {
                    throw new InvalidOperationException($"导入读写配置失败：{finalConfigName}/{rwConfig.SignalName}");
                }
            }

            if (canlinInfo == CANLIN.CAN)
            {
                foreach (var sch in snapshot.CanScheduleConfigs ?? new List<CANScheduleConfigSnapshot>())
                {
                    FreeSql.Insert(new CANScheduleConfig
                    {
                        MsgName = sch.MsgName,
                        Cycle = sch.Cycle,
                        OrderSend = sch.OrderSend,
                        SchTabIndex = sch.SchTabIndex,
                        CanLinConfigProId = insertPro.Id,
                    }).ExecuteAffrows();
                }
            }
            else if (canlinInfo == CANLIN.CANFD)
            {
                foreach (var sch in snapshot.CanFdScheduleConfigs ?? new List<CANFdScheduleConfigSnapshot>())
                {
                    FreeSql.Insert(new CANFdScheduleConfig
                    {
                        MsgName = sch.MsgName,
                        Cycle = sch.Cycle,
                        OrderSend = sch.OrderSend,
                        SchTabIndex = sch.SchTabIndex,
                        CanLinConfigProId = insertPro.Id,
                    }).ExecuteAffrows();
                }
            }
            else if (canlinInfo == CANLIN.LIN)
            {
                foreach (var sch in snapshot.LinScheduleConfigs ?? new List<LINScheduleConfigSnapshot>())
                {
                    FreeSql.Insert(new LINScheduleConfig
                    {
                        IsActive = sch.IsActive,
                        IsMsgActived = sch.IsMsgActived,
                        MsgName = sch.MsgName,
                        MsgNameIndex = sch.MsgNameIndex,
                        Cycle = sch.Cycle,
                        SchTabIndex = sch.SchTabIndex,
                        SchTabName = sch.SchTabName,
                        CanLinConfigProId = insertPro.Id,
                    }).ExecuteAffrows();
                }
            }

            result.ImportedConfigCount++;
        }

        /// <summary>
        /// 创建并保存配置扩展信息。
        /// </summary>
        /// <param name="snapshot">配置快照。</param>
        /// <param name="canlinInfo">配置类型。</param>
        /// <returns>扩展配置主键集合。</returns>
        private ConfigExdIds CreateConfigExd(CanLinConfigProSnapshot snapshot, CANLIN canlinInfo)
        {
            var ids = new ConfigExdIds();
            if (canlinInfo == CANLIN.CAN)
            {
                var canExd = snapshot.CANConfigExd ?? new CANConfigExdSnapshot();
                var insert = FreeSql.Insert(new CANConfigExd
                {
                    BaudRate = canExd.BaudRate,
                    Cycle = canExd.Cycle,
                    DbcPath = canExd.DbcPath ?? string.Empty,
                    SchEnable = canExd.SchEnable,
                }).ExecuteInserted().FirstOrDefault();

                if (insert == null)
                {
                    throw new InvalidOperationException("导入 CAN 扩展配置失败");
                }

                ids.CANConfigExdId = insert.Id;
            }
            else if (canlinInfo == CANLIN.CANFD)
            {
                var canFdExd = snapshot.CANFdConfigExd ?? new CANFdConfigExdSnapshot();
                var insert = FreeSql.Insert(new CANFdConfigExd
                {
                    DataBaudRate = canFdExd.DataBaudRate,
                    ArbBaudRate = canFdExd.ArbBaudRate,
                    ISOEnable = canFdExd.ISOEnable,
                    ResEnable = canFdExd.ResEnable,
                    Cycle = canFdExd.Cycle,
                    DbcPath = canFdExd.DbcPath ?? string.Empty,
                    SchEnable = canFdExd.SchEnable,
                }).ExecuteInserted().FirstOrDefault();

                if (insert == null)
                {
                    throw new InvalidOperationException("导入 CANFD 扩展配置失败");
                }

                ids.CANFdConfigExdId = insert.Id;
            }
            else
            {
                var linExd = snapshot.LINConfigExd ?? new LINConfigExdSnapshot();
                var insert = FreeSql.Insert(new LINConfigExd
                {
                    BaudRate = linExd.BaudRate,
                    Cycle = linExd.Cycle,
                    LdfPath = linExd.LdfPath ?? string.Empty,
                    SchEnable = linExd.SchEnable,
                }).ExecuteInserted().FirstOrDefault();

                if (insert == null)
                {
                    throw new InvalidOperationException("导入 LIN 扩展配置失败");
                }

                ids.LINConfigExdId = insert.Id;
            }

            return ids;
        }

        /// <summary>
        /// 删除同名同类型的旧配置。
        /// </summary>
        /// <param name="configName">配置名称。</param>
        /// <param name="canlinInfo">配置类型。</param>
        private void DeleteExistingConfig(string configName, CANLIN canlinInfo)
        {
            var oldConfigs = FreeSql.Select<CanLinConfigPro>()
                .Where(a => a.CANLINInfo == canlinInfo)
                .Where(a => a.ConfigName == configName)
                .ToList();

            foreach (var oldConfig in oldConfigs)
            {
                FreeSql.Delete<CanLinRWConfig>().Where(a => a.CanLinConfigProId == oldConfig.Id).ExecuteAffrows();
                FreeSql.Delete<CANScheduleConfig>().Where(a => a.CanLinConfigProId == oldConfig.Id).ExecuteAffrows();
                FreeSql.Delete<CANFdScheduleConfig>().Where(a => a.CanLinConfigProId == oldConfig.Id).ExecuteAffrows();
                FreeSql.Delete<LINScheduleConfig>().Where(a => a.CanLinConfigProId == oldConfig.Id).ExecuteAffrows();
                FreeSql.Delete<CanLinConfigPro>(oldConfig.Id).ExecuteAffrows();

                if (canlinInfo == CANLIN.CAN && oldConfig.CANConfigExdId > 0)
                {
                    FreeSql.Delete<CANConfigExd>(oldConfig.CANConfigExdId).ExecuteAffrows();
                }
                else if (canlinInfo == CANLIN.CANFD && oldConfig.CANFdConfigExdId > 0)
                {
                    FreeSql.Delete<CANFdConfigExd>(oldConfig.CANFdConfigExdId).ExecuteAffrows();
                }
                else if (canlinInfo == CANLIN.LIN && oldConfig.LINConfigExdId > 0)
                {
                    FreeSql.Delete<LINConfigExd>(oldConfig.LINConfigExdId).ExecuteAffrows();
                }
            }
        }

        /// <summary>
        /// 生成可用的增量重命名配置名。
        /// </summary>
        /// <param name="originalName">原始名称。</param>
        /// <param name="canlinInfo">配置类型。</param>
        /// <returns>可用名称。</returns>
        private string BuildUniqueImportName(string originalName, CANLIN canlinInfo)
        {
            var baseName = $"{originalName}_import_{DateTime.Now:yyyyMMddHHmmss}";
            var candidate = baseName;
            var suffix = 1;

            while (FreeSql.Select<CanLinConfigPro>()
                .Where(a => a.CANLINInfo == canlinInfo)
                .Where(a => a.ConfigName == candidate)
                .Any())
            {
                candidate = $"{baseName}_{suffix}";
                suffix++;
            }

            return candidate;
        }

        /// <summary>
        /// 导入并覆盖逻辑规则。
        /// </summary>
        /// <param name="logicRules">规则快照集合。</param>
        /// <param name="result">执行结果。</param>
        /// <returns>规则映射。</returns>
        private ImportRuleMaps UpsertLogicRules(List<LogicRuleSnapshot> logicRules, CanLinConfigImExportResult result)
        {
            var maps = new ImportRuleMaps();
            foreach (var snapshot in logicRules)
            {
                if (snapshot == null)
                {
                    continue;
                }

                var ruleName = (snapshot.Name ?? string.Empty).Trim();
                if (string.IsNullOrWhiteSpace(ruleName))
                {
                    continue;
                }

                var oldRule = FreeSql.Select<LogicRule>().Where(a => a.Name == ruleName).First();
                if (oldRule != null)
                {
                    FreeSql.Update<LogicRule>()
                        .Set(a => a.Description, snapshot.Description)
                        .Set(a => a.Expression, snapshot.Expression)
                        .Set(a => a.ParameterType, snapshot.ParameterType)
                        .Where(a => a.Id == oldRule.Id)
                        .ExecuteAffrows();

                    maps.NameToTargetId[ruleName] = oldRule.Id;
                    if (snapshot.Id > 0)
                    {
                        maps.SourceIdToTargetId[snapshot.Id] = oldRule.Id;
                    }
                    result.UpdatedRuleCount++;
                }
                else
                {
                    var insertRule = FreeSql.Insert(new LogicRule
                    {
                        Name = ruleName,
                        Description = snapshot.Description,
                        Expression = snapshot.Expression,
                        ParameterType = snapshot.ParameterType,
                    }).ExecuteInserted().FirstOrDefault();

                    if (insertRule == null)
                    {
                        throw new InvalidOperationException($"导入逻辑规则失败：{ruleName}");
                    }

                    maps.NameToTargetId[ruleName] = insertRule.Id;
                    if (snapshot.Id > 0)
                    {
                        maps.SourceIdToTargetId[snapshot.Id] = insertRule.Id;
                    }

                    result.InsertedRuleCount++;
                }
            }

            return maps;
        }

        /// <summary>
        /// 解析读写配置对应的目标规则 Id。
        /// </summary>
        /// <param name="rwSnapshot">读写配置快照。</param>
        /// <param name="ruleMaps">规则映射。</param>
        /// <returns>规则 Id。</returns>
        private long ResolveLogicRuleId(CanLinRWConfigSnapshot rwSnapshot, ImportRuleMaps ruleMaps)
        {
            if (rwSnapshot == null)
            {
                return 0;
            }

            if (rwSnapshot.LogicRule != null)
            {
                var ruleName = (rwSnapshot.LogicRule.Name ?? string.Empty).Trim();
                if (!string.IsNullOrWhiteSpace(ruleName) && ruleMaps.NameToTargetId.TryGetValue(ruleName, out var byNameId))
                {
                    return byNameId;
                }
            }

            if (rwSnapshot.LogicRuleId > 0 && ruleMaps.SourceIdToTargetId.TryGetValue(rwSnapshot.LogicRuleId, out var bySourceId))
            {
                return bySourceId;
            }

            return 0;
        }

        /// <summary>
        /// 将规则实体映射为快照。
        /// </summary>
        /// <param name="rule">规则实体。</param>
        /// <returns>规则快照。</returns>
        private static LogicRuleSnapshot MapLogicRuleSnapshot(LogicRule rule)
        {
            return new LogicRuleSnapshot
            {
                Id = rule.Id,
                Name = rule.Name,
                Description = rule.Description,
                Expression = rule.Expression,
                ParameterType = rule.ParameterType,
            };
        }

        /// <summary>
        /// 将配置实体映射为快照。
        /// </summary>
        /// <param name="configPro">配置实体。</param>
        /// <returns>配置快照。</returns>
        private static CanLinConfigProSnapshot MapConfigSnapshot(CanLinConfigPro configPro)
        {
            return new CanLinConfigProSnapshot
            {
                ConfigName = configPro.ConfigName,
                CANLINInfo = configPro.CANLINInfo,
                CreateTime = configPro.CreateTime,
                CANConfigExd = configPro.CANConfigExd == null
                    ? null
                    : new CANConfigExdSnapshot
                    {
                        BaudRate = configPro.CANConfigExd.BaudRate,
                        Cycle = configPro.CANConfigExd.Cycle,
                        DbcPath = configPro.CANConfigExd.DbcPath,
                        SchEnable = configPro.CANConfigExd.SchEnable,
                    },
                CANFdConfigExd = configPro.CANFdConfigExd == null
                    ? null
                    : new CANFdConfigExdSnapshot
                    {
                        DataBaudRate = configPro.CANFdConfigExd.DataBaudRate,
                        ArbBaudRate = configPro.CANFdConfigExd.ArbBaudRate,
                        ISOEnable = configPro.CANFdConfigExd.ISOEnable,
                        ResEnable = configPro.CANFdConfigExd.ResEnable,
                        Cycle = configPro.CANFdConfigExd.Cycle,
                        DbcPath = configPro.CANFdConfigExd.DbcPath,
                        SchEnable = configPro.CANFdConfigExd.SchEnable,
                    },
                LINConfigExd = configPro.LINConfigExd == null
                    ? null
                    : new LINConfigExdSnapshot
                    {
                        BaudRate = configPro.LINConfigExd.BaudRate,
                        Cycle = configPro.LINConfigExd.Cycle,
                        LdfPath = configPro.LINConfigExd.LdfPath,
                        SchEnable = configPro.LINConfigExd.SchEnable,
                    },
                CanLinConfigContents = (configPro.CanLinConfigContents ?? new List<CanLinRWConfig>())
                    .Select(a => new CanLinRWConfigSnapshot
                    {
                        RWInfo = a.RWInfo,
                        Name = a.Name,
                        MsgFrameName = a.MsgFrameName,
                        SignalName = a.SignalName,
                        DefautValue = a.DefautValue,
                        LogicRuleId = a.LogicRuleId,
                        LogicRule = a.LogicRule == null ? null : MapLogicRuleSnapshot(a.LogicRule),
                    }).ToList(),
                CanScheduleConfigs = (configPro.CanScheduleConfigs ?? new List<CANScheduleConfig>())
                    .Select(a => new CANScheduleConfigSnapshot
                    {
                        MsgName = a.MsgName,
                        Cycle = a.Cycle,
                        OrderSend = a.OrderSend,
                        SchTabIndex = a.SchTabIndex,
                    }).ToList(),
                CanFdScheduleConfigs = (configPro.CanFdScheduleConfigs ?? new List<CANFdScheduleConfig>())
                    .Select(a => new CANFdScheduleConfigSnapshot
                    {
                        MsgName = a.MsgName,
                        Cycle = a.Cycle,
                        OrderSend = a.OrderSend,
                        SchTabIndex = a.SchTabIndex,
                    }).ToList(),
                LinScheduleConfigs = (configPro.LinScheduleConfigs ?? new List<LINScheduleConfig>())
                    .Select(a => new LINScheduleConfigSnapshot
                    {
                        IsActive = a.IsActive,
                        IsMsgActived = a.IsMsgActived,
                        MsgName = a.MsgName,
                        MsgNameIndex = a.MsgNameIndex,
                        Cycle = a.Cycle,
                        SchTabIndex = a.SchTabIndex,
                        SchTabName = a.SchTabName,
                    }).ToList(),
            };
        }

        /// <summary>
        /// 规则映射上下文。
        /// </summary>
        private class ImportRuleMaps
        {
            /// <summary>
            /// 规则名称到目标库规则 Id 的映射。
            /// </summary>
            public Dictionary<string, long> NameToTargetId { get; set; } = new Dictionary<string, long>(StringComparer.OrdinalIgnoreCase);

            /// <summary>
            /// 源文件规则 Id 到目标库规则 Id 的映射。
            /// </summary>
            public Dictionary<long, long> SourceIdToTargetId { get; set; } = new Dictionary<long, long>();
        }

        /// <summary>
        /// 扩展配置主键集合。
        /// </summary>
        private class ConfigExdIds
        {
            /// <summary>
            /// CAN 扩展主键。
            /// </summary>
            public long CANConfigExdId { get; set; }

            /// <summary>
            /// CANFD 扩展主键。
            /// </summary>
            public long CANFdConfigExdId { get; set; }

            /// <summary>
            /// LIN 扩展主键。
            /// </summary>
            public long LINConfigExdId { get; set; }
        }
    }

    /// <summary>
    /// CAN/LIN 配置导入导出文件根对象。
    /// </summary>
    public class CanLinConfigPackageSnapshot
    {
        /// <summary>
        /// 文件结构版本。
        /// </summary>
        public string SchemaVersion { get; set; } = string.Empty;

        /// <summary>
        /// 导出时间。
        /// </summary>
        public DateTime ExportTime { get; set; }

        /// <summary>
        /// 规则集合。
        /// </summary>
        public List<LogicRuleSnapshot> LogicRules { get; set; } = new List<LogicRuleSnapshot>();

        /// <summary>
        /// 配置程序集合。
        /// </summary>
        public List<CanLinConfigProSnapshot> CanLinConfigPros { get; set; } = new List<CanLinConfigProSnapshot>();
    }

    /// <summary>
    /// 逻辑规则快照。
    /// </summary>
    public class LogicRuleSnapshot
    {
        /// <summary>
        /// 主键。
        /// </summary>
        public long Id { get; set; }

        /// <summary>
        /// 规则名称。
        /// </summary>
        public string? Name { get; set; }

        /// <summary>
        /// 规则描述。
        /// </summary>
        public string? Description { get; set; }

        /// <summary>
        /// 规则表达式。
        /// </summary>
        public string? Expression { get; set; }

        /// <summary>
        /// 参数类型。
        /// </summary>
        public string? ParameterType { get; set; }
    }

    /// <summary>
    /// 配置程序快照。
    /// </summary>
    public class CanLinConfigProSnapshot
    {
        /// <summary>
        /// 配置名称。
        /// </summary>
        public string? ConfigName { get; set; }

        /// <summary>
        /// 配置分类。
        /// </summary>
        public CANLIN CANLINInfo { get; set; }

        /// <summary>
        /// 创建时间。
        /// </summary>
        public DateTime CreateTime { get; set; }

        /// <summary>
        /// CAN 扩展配置。
        /// </summary>
        public CANConfigExdSnapshot? CANConfigExd { get; set; }

        /// <summary>
        /// CANFD 扩展配置。
        /// </summary>
        public CANFdConfigExdSnapshot? CANFdConfigExd { get; set; }

        /// <summary>
        /// LIN 扩展配置。
        /// </summary>
        public LINConfigExdSnapshot? LINConfigExd { get; set; }

        /// <summary>
        /// 读写配置集合。
        /// </summary>
        public List<CanLinRWConfigSnapshot>? CanLinConfigContents { get; set; }

        /// <summary>
        /// CAN 调度配置。
        /// </summary>
        public List<CANScheduleConfigSnapshot>? CanScheduleConfigs { get; set; }

        /// <summary>
        /// CANFD 调度配置。
        /// </summary>
        public List<CANFdScheduleConfigSnapshot>? CanFdScheduleConfigs { get; set; }

        /// <summary>
        /// LIN 调度配置。
        /// </summary>
        public List<LINScheduleConfigSnapshot>? LinScheduleConfigs { get; set; }
    }

    /// <summary>
    /// CAN 扩展快照。
    /// </summary>
    public class CANConfigExdSnapshot
    {
        /// <summary>
        /// 波特率。
        /// </summary>
        public int BaudRate { get; set; }

        /// <summary>
        /// 周期。
        /// </summary>
        public int Cycle { get; set; }

        /// <summary>
        /// DBC 路径。
        /// </summary>
        public string? DbcPath { get; set; }

        /// <summary>
        /// 调度启用。
        /// </summary>
        public bool SchEnable { get; set; }
    }

    /// <summary>
    /// CANFD 扩展快照。
    /// </summary>
    public class CANFdConfigExdSnapshot
    {
        /// <summary>
        /// 数据波特率。
        /// </summary>
        public int DataBaudRate { get; set; }

        /// <summary>
        /// 仲裁波特率。
        /// </summary>
        public int ArbBaudRate { get; set; }

        /// <summary>
        /// ISO 开关。
        /// </summary>
        public bool ISOEnable { get; set; }

        /// <summary>
        /// 终端电阻开关。
        /// </summary>
        public bool ResEnable { get; set; }

        /// <summary>
        /// 周期。
        /// </summary>
        public int Cycle { get; set; }

        /// <summary>
        /// DBC 路径。
        /// </summary>
        public string? DbcPath { get; set; }

        /// <summary>
        /// 调度启用。
        /// </summary>
        public bool SchEnable { get; set; }
    }

    /// <summary>
    /// LIN 扩展快照。
    /// </summary>
    public class LINConfigExdSnapshot
    {
        /// <summary>
        /// 波特率。
        /// </summary>
        public int BaudRate { get; set; }

        /// <summary>
        /// 周期。
        /// </summary>
        public int Cycle { get; set; }

        /// <summary>
        /// LDF 路径。
        /// </summary>
        public string? LdfPath { get; set; }

        /// <summary>
        /// 调度启用。
        /// </summary>
        public bool SchEnable { get; set; }
    }

    /// <summary>
    /// 读写配置快照。
    /// </summary>
    public class CanLinRWConfigSnapshot
    {
        /// <summary>
        /// 读写类型。
        /// </summary>
        public RW RWInfo { get; set; }

        /// <summary>
        /// 配置名称。
        /// </summary>
        public string? Name { get; set; }

        /// <summary>
        /// 帧名。
        /// </summary>
        public string? MsgFrameName { get; set; }

        /// <summary>
        /// 信号名。
        /// </summary>
        public string? SignalName { get; set; }

        /// <summary>
        /// 默认值。
        /// </summary>
        public string? DefautValue { get; set; }

        /// <summary>
        /// 规则 Id。
        /// </summary>
        public long LogicRuleId { get; set; }

        /// <summary>
        /// 规则对象。
        /// </summary>
        public LogicRuleSnapshot? LogicRule { get; set; }
    }

    /// <summary>
    /// CAN 调度快照。
    /// </summary>
    public class CANScheduleConfigSnapshot
    {
        /// <summary>
        /// 消息名。
        /// </summary>
        public string? MsgName { get; set; }

        /// <summary>
        /// 周期。
        /// </summary>
        public int Cycle { get; set; }

        /// <summary>
        /// 发送方式。
        /// </summary>
        public int OrderSend { get; set; }

        /// <summary>
        /// 调度表索引。
        /// </summary>
        public int SchTabIndex { get; set; }
    }

    /// <summary>
    /// CANFD 调度快照。
    /// </summary>
    public class CANFdScheduleConfigSnapshot
    {
        /// <summary>
        /// 消息名。
        /// </summary>
        public string? MsgName { get; set; }

        /// <summary>
        /// 周期。
        /// </summary>
        public int Cycle { get; set; }

        /// <summary>
        /// 发送方式。
        /// </summary>
        public int OrderSend { get; set; }

        /// <summary>
        /// 调度表索引。
        /// </summary>
        public int SchTabIndex { get; set; }
    }

    /// <summary>
    /// LIN 调度快照。
    /// </summary>
    public class LINScheduleConfigSnapshot
    {
        /// <summary>
        /// 是否启用。
        /// </summary>
        public bool IsActive { get; set; }

        /// <summary>
        /// 是否消息激活。
        /// </summary>
        public bool IsMsgActived { get; set; }

        /// <summary>
        /// 消息名。
        /// </summary>
        public string? MsgName { get; set; }

        /// <summary>
        /// 消息索引。
        /// </summary>
        public int MsgNameIndex { get; set; }

        /// <summary>
        /// 周期。
        /// </summary>
        public int Cycle { get; set; }

        /// <summary>
        /// 调度索引。
        /// </summary>
        public int SchTabIndex { get; set; }

        /// <summary>
        /// 调度名。
        /// </summary>
        public string? SchTabName { get; set; }
    }
}