using System.Text.Json;
using Microsoft.EntityFrameworkCore;
using TrafagSalesExporter.Data;
using TrafagSalesExporter.Models;

namespace TrafagSalesExporter.Services;

public class ConfigTransferService : IConfigTransferService
{
    private readonly IDbContextFactory<AppDbContext> _dbFactory;
    private static readonly JsonSerializerOptions JsonOptions = new() { WriteIndented = true };

    public ConfigTransferService(IDbContextFactory<AppDbContext> dbFactory)
    {
        _dbFactory = dbFactory;
    }

    public async Task<string> ExportJsonAsync(bool includeSecrets)
    {
        using var db = await _dbFactory.CreateDbContextAsync();
        var sharePoint = await db.SharePointConfigs.FirstOrDefaultAsync();
        var exportSettings = await db.ExportSettings.FirstOrDefaultAsync();
        var sourceSystems = await db.SourceSystemDefinitions.OrderBy(x => x.Code).ToListAsync();
        var exchangeRates = await db.CurrencyExchangeRates
            .OrderBy(x => x.FromCurrency)
            .ThenBy(x => x.ToCurrency)
            .ThenByDescending(x => x.ValidFrom)
            .ToListAsync();
        var financeReferences = await db.FinanceReferences
            .OrderBy(x => x.Year)
            .ThenBy(x => x.Key)
            .ToListAsync();
        var financeIntercompanyRules = await db.FinanceIntercompanyRules
            .OrderBy(x => x.ScopeKey)
            .ThenBy(x => x.CustomerNumber)
            .ThenBy(x => x.CustomerNameContains)
            .ToListAsync();
        var financeRules = await db.FinanceRules
            .OrderBy(x => x.SortOrder)
            .ThenBy(x => x.Id)
            .ToListAsync();
        var hanaServers = await db.HanaServers.OrderBy(x => x.Name).ToListAsync();
        var sites = await db.Sites.OrderBy(x => x.Land).ToListAsync();
        var rules = await db.FieldTransformationRules.OrderBy(x => x.SortOrder).ThenBy(x => x.Id).ToListAsync();
        var sapSources = await db.SapSourceDefinitions.OrderBy(x => x.SortOrder).ThenBy(x => x.Id).ToListAsync();
        var sapJoins = await db.SapJoinDefinitions.OrderBy(x => x.SortOrder).ThenBy(x => x.Id).ToListAsync();
        var sapMappings = await db.SapFieldMappings.OrderBy(x => x.SortOrder).ThenBy(x => x.Id).ToListAsync();
        var manualExcelMappings = await db.ManualExcelColumnMappings.OrderBy(x => x.SortOrder).ThenBy(x => x.Id).ToListAsync();

        var serverKeyMap = hanaServers.ToDictionary(x => x.Id, _ => Guid.NewGuid().ToString("N"));
        var siteKeyMap = sites.ToDictionary(x => x.Id, _ => Guid.NewGuid().ToString("N"));

        var package = new ConfigTransferPackage
        {
            IncludesSecrets = includeSecrets,
            SharePointConfig = sharePoint is null ? null : new ConfigTransferSharePoint
            {
                SiteUrl = sharePoint.SiteUrl,
                ExportFolder = sharePoint.ExportFolder,
                CentralExportFolder = sharePoint.CentralExportFolder,
                TenantId = sharePoint.TenantId,
                ClientId = sharePoint.ClientId,
                ClientSecret = includeSecrets ? sharePoint.ClientSecret : null
            },
            ExportSettings = exportSettings is null ? null : new ConfigTransferExportSettings
            {
                DateFilter = exportSettings.DateFilter,
                TimerHour = exportSettings.TimerHour,
                TimerMinute = exportSettings.TimerMinute,
                TimerEnabled = exportSettings.TimerEnabled,
                DebugLoggingEnabled = exportSettings.DebugLoggingEnabled,
                LocalSiteExportFolder = exportSettings.LocalSiteExportFolder,
                LocalConsolidatedExportFolder = exportSettings.LocalConsolidatedExportFolder
            },
            SourceSystemDefinitions = sourceSystems.Select(system => new ConfigTransferSourceSystemDefinition
            {
                Code = system.Code,
                DisplayName = system.DisplayName,
                ConnectionKind = system.ConnectionKind,
                IsActive = system.IsActive,
                CentralServiceUrl = system.CentralServiceUrl,
                CentralUsername = includeSecrets ? system.CentralUsername : null,
                CentralPassword = includeSecrets ? system.CentralPassword : null
            }).ToList(),
            CurrencyExchangeRates = exchangeRates.Select(rate => new ConfigTransferCurrencyExchangeRate
            {
                FromCurrency = rate.FromCurrency,
                ToCurrency = rate.ToCurrency,
                Rate = rate.Rate,
                ValidFrom = rate.ValidFrom,
                ValidTo = rate.ValidTo,
                Notes = rate.Notes,
                IsActive = rate.IsActive
            }).ToList(),
            FinanceReferences = financeReferences.Select(reference => new ConfigTransferFinanceReference
            {
                Key = reference.Key,
                Label = reference.Label,
                Year = reference.Year,
                LocalCurrencyValue = reference.LocalCurrencyValue,
                CheckValue = reference.CheckValue,
                Notes = reference.Notes,
                IsActive = reference.IsActive
            }).ToList(),
            FinanceIntercompanyRules = financeIntercompanyRules.Select(rule => new ConfigTransferFinanceIntercompanyRule
            {
                ScopeKey = rule.ScopeKey,
                CustomerNumber = rule.CustomerNumber,
                CustomerNameContains = rule.CustomerNameContains,
                Notes = rule.Notes,
                IsActive = rule.IsActive
            }).ToList(),
            FinanceRules = financeRules.Select(rule => new FinanceRule
            {
                ScopeKey = rule.ScopeKey,
                Year = rule.Year,
                RuleType = rule.RuleType,
                FieldName = rule.FieldName,
                MatchType = rule.MatchType,
                MatchValue = rule.MatchValue,
                NumericValue = rule.NumericValue,
                Notes = rule.Notes,
                SortOrder = rule.SortOrder,
                IsActive = rule.IsActive
            }).ToList(),
            HanaServers = hanaServers.Select(server => new ConfigTransferHanaServer
            {
                Key = serverKeyMap[server.Id],
                SourceSystem = server.SourceSystem,
                Name = server.Name,
                Host = server.Host,
                Port = server.Port,
                DatabaseName = server.DatabaseName,
                UseSsl = server.UseSsl,
                ValidateCertificate = server.ValidateCertificate,
                AdditionalParams = server.AdditionalParams
            }).ToList(),
            Sites = sites.Select(site => new ConfigTransferSite
            {
                Key = siteKeyMap[site.Id],
                HanaServerKey = site.HanaServerId.HasValue && serverKeyMap.TryGetValue(site.HanaServerId.Value, out var serverKey) ? serverKey : null,
                Schema = site.Schema,
                TSC = site.TSC,
                Land = site.Land,
                SourceSystem = site.SourceSystem,
                UsernameOverride = includeSecrets ? site.UsernameOverride : null,
                PasswordOverride = includeSecrets ? site.PasswordOverride : null,
                LocalExportFolderOverride = site.LocalExportFolderOverride,
                ManualImportFilePath = site.ManualImportFilePath,
                ManualImportLastUploadedAtUtc = site.ManualImportLastUploadedAtUtc,
                SapServiceUrl = site.SapServiceUrl,
                SapEntitySet = site.SapEntitySet,
                SapEntitySetsCache = site.SapEntitySetsCache,
                SapEntitySetsRefreshedAtUtc = site.SapEntitySetsRefreshedAtUtc,
                IsActive = site.IsActive
            }).ToList(),
            FieldTransformationRules = rules.Select(r => new FieldTransformationRule
            {
                SourceSystem = r.SourceSystem,
                SourceField = r.SourceField,
                TargetField = r.TargetField,
                TransformationType = r.TransformationType,
                RuleScope = r.RuleScope,
                Argument = r.Argument,
                SortOrder = r.SortOrder,
                IsActive = r.IsActive
            }).ToList(),
            SapSourceDefinitions = sapSources.Select(s => new ConfigTransferSapSourceDefinition
            {
                SiteKey = siteKeyMap[s.SiteId],
                Alias = s.Alias,
                EntitySet = s.EntitySet,
                IsPrimary = s.IsPrimary,
                IsActive = s.IsActive,
                SortOrder = s.SortOrder
            }).ToList(),
            SapJoinDefinitions = sapJoins.Select(j => new ConfigTransferSapJoinDefinition
            {
                SiteKey = siteKeyMap[j.SiteId],
                LeftAlias = j.LeftAlias,
                RightAlias = j.RightAlias,
                LeftKeys = j.LeftKeys,
                RightKeys = j.RightKeys,
                JoinType = j.JoinType,
                IsActive = j.IsActive,
                SortOrder = j.SortOrder
            }).ToList(),
            SapFieldMappings = sapMappings.Select(m => new ConfigTransferSapFieldMapping
            {
                SiteKey = siteKeyMap[m.SiteId],
                TargetField = m.TargetField,
                SourceExpression = m.SourceExpression,
                IsRequired = m.IsRequired,
                IsActive = m.IsActive,
                SortOrder = m.SortOrder
            }).ToList(),
            ManualExcelColumnMappings = manualExcelMappings.Select(m => new ConfigTransferManualExcelColumnMapping
            {
                SiteKey = siteKeyMap[m.SiteId],
                TargetField = m.TargetField,
                SourceHeader = m.SourceHeader,
                IsRequired = m.IsRequired,
                IsActive = m.IsActive,
                SortOrder = m.SortOrder
            }).ToList()
        };

        return JsonSerializer.Serialize(package, JsonOptions);
    }

    public async Task ImportJsonAsync(string json)
    {
        var package = JsonSerializer.Deserialize<ConfigTransferPackage>(json, JsonOptions)
            ?? throw new InvalidOperationException("Konfigurationsdatei konnte nicht gelesen werden.");
        var importedSourceSystems = ResolveImportedSourceSystems(json, package);

        using var db = await _dbFactory.CreateDbContextAsync();
        await using var transaction = await db.Database.BeginTransactionAsync();
        var existingSharePoint = await db.SharePointConfigs.FirstOrDefaultAsync();
        var existingSettings = await db.ExportSettings.FirstOrDefaultAsync();
        var existingSourceSystems = await db.SourceSystemDefinitions.ToListAsync();
        var existingServers = await db.HanaServers.ToListAsync();
        var existingExchangeRates = await db.CurrencyExchangeRates.ToListAsync();
        var existingFinanceReferences = await db.FinanceReferences.ToListAsync();
        var existingFinanceIntercompanyRules = await db.FinanceIntercompanyRules.ToListAsync();
        var existingFinanceRules = await db.FinanceRules.ToListAsync();
        var existingSites = await db.Sites.ToListAsync();
        var existingCentralRecords = await db.CentralSalesRecords.AsNoTracking().ToListAsync();
        var existingRules = await db.FieldTransformationRules.ToListAsync();
        var existingSapSources = await db.SapSourceDefinitions.ToListAsync();
        var existingSapJoins = await db.SapJoinDefinitions.ToListAsync();
        var existingSapMappings = await db.SapFieldMappings.ToListAsync();
        var existingManualExcelMappings = await db.ManualExcelColumnMappings.ToListAsync();

        var preservedSharePointSecret = existingSharePoint?.ClientSecret ?? string.Empty;
        var preservedSourceSystemSecrets = existingSourceSystems.ToDictionary(
            x => x.Code,
            x => (CentralUsername: x.CentralUsername, CentralPassword: x.CentralPassword),
            StringComparer.OrdinalIgnoreCase);
        var preservedSiteSecrets = existingSites.ToDictionary(
            x => BuildSiteSignature(x.Land, x.TSC, x.Schema, x.SourceSystem),
            x => (x.UsernameOverride, x.PasswordOverride));
        var existingSiteSignaturesById = existingSites.ToDictionary(
            x => x.Id,
            x => BuildSiteSignature(x.Land, x.TSC, x.Schema, x.SourceSystem));

        if (existingSapMappings.Count > 0) db.SapFieldMappings.RemoveRange(existingSapMappings);
        if (existingManualExcelMappings.Count > 0) db.ManualExcelColumnMappings.RemoveRange(existingManualExcelMappings);
        if (existingSapJoins.Count > 0) db.SapJoinDefinitions.RemoveRange(existingSapJoins);
        if (existingSapSources.Count > 0) db.SapSourceDefinitions.RemoveRange(existingSapSources);
        if (existingRules.Count > 0) db.FieldTransformationRules.RemoveRange(existingRules);
        if (package.FinanceReferences.Count > 0 && existingFinanceReferences.Count > 0)
            db.FinanceReferences.RemoveRange(existingFinanceReferences);
        if (package.FinanceIntercompanyRules.Count > 0 && existingFinanceIntercompanyRules.Count > 0)
            db.FinanceIntercompanyRules.RemoveRange(existingFinanceIntercompanyRules);
        if (package.FinanceRules.Count > 0 && existingFinanceRules.Count > 0)
            db.FinanceRules.RemoveRange(existingFinanceRules);
        if (existingExchangeRates.Count > 0) db.CurrencyExchangeRates.RemoveRange(existingExchangeRates);
        if (existingSites.Count > 0) db.Sites.RemoveRange(existingSites);
        if (existingServers.Count > 0) db.HanaServers.RemoveRange(existingServers);
        if (existingSourceSystems.Count > 0) db.SourceSystemDefinitions.RemoveRange(existingSourceSystems);
        if (existingSharePoint is not null) db.SharePointConfigs.Remove(existingSharePoint);
        if (existingSettings is not null) db.ExportSettings.Remove(existingSettings);
        await db.SaveChangesAsync();

        var newSharePoint = package.SharePointConfig is null ? new SharePointConfig() : new SharePointConfig
        {
            SiteUrl = package.SharePointConfig.SiteUrl,
            ExportFolder = package.SharePointConfig.ExportFolder,
            CentralExportFolder = package.SharePointConfig.CentralExportFolder,
            TenantId = package.SharePointConfig.TenantId,
            ClientId = package.SharePointConfig.ClientId,
            ClientSecret = package.IncludesSecrets ? package.SharePointConfig.ClientSecret ?? string.Empty : preservedSharePointSecret
        };
        db.SharePointConfigs.Add(newSharePoint);

        var importedSettings = package.ExportSettings ?? new ConfigTransferExportSettings();
        db.ExportSettings.Add(new ExportSettings
        {
            DateFilter = importedSettings.DateFilter,
            TimerHour = importedSettings.TimerHour,
            TimerMinute = importedSettings.TimerMinute,
            TimerEnabled = importedSettings.TimerEnabled,
            DebugLoggingEnabled = importedSettings.DebugLoggingEnabled,
            LocalSiteExportFolder = importedSettings.LocalSiteExportFolder,
            LocalConsolidatedExportFolder = importedSettings.LocalConsolidatedExportFolder
        });

        foreach (var sourceSystem in importedSourceSystems)
        {
            preservedSourceSystemSecrets.TryGetValue(sourceSystem.Code, out var preserved);
            db.SourceSystemDefinitions.Add(new SourceSystemDefinition
            {
                Code = sourceSystem.Code,
                DisplayName = sourceSystem.DisplayName,
                ConnectionKind = sourceSystem.ConnectionKind,
                IsActive = sourceSystem.IsActive,
                CentralServiceUrl = sourceSystem.CentralServiceUrl,
                CentralUsername = package.IncludesSecrets ? sourceSystem.CentralUsername ?? string.Empty : preserved.CentralUsername ?? string.Empty,
                CentralPassword = package.IncludesSecrets ? sourceSystem.CentralPassword ?? string.Empty : preserved.CentralPassword ?? string.Empty
            });
        }

        if (package.CurrencyExchangeRates.Count > 0)
        {
            db.CurrencyExchangeRates.AddRange(package.CurrencyExchangeRates.Select(rate => new CurrencyExchangeRate
            {
                FromCurrency = rate.FromCurrency,
                ToCurrency = rate.ToCurrency,
                Rate = rate.Rate,
                ValidFrom = rate.ValidFrom,
                ValidTo = rate.ValidTo,
                Notes = rate.Notes,
                IsActive = rate.IsActive
            }));
        }

        if (package.FinanceReferences.Count > 0)
        {
            db.FinanceReferences.AddRange(package.FinanceReferences.Select(reference => new FinanceReference
            {
                Key = reference.Key,
                Label = reference.Label,
                Year = reference.Year,
                LocalCurrencyValue = reference.LocalCurrencyValue,
                CheckValue = reference.CheckValue,
                Notes = reference.Notes,
                IsActive = reference.IsActive
            }));
        }

        if (package.FinanceIntercompanyRules.Count > 0)
        {
            db.FinanceIntercompanyRules.AddRange(package.FinanceIntercompanyRules.Select(rule => new FinanceIntercompanyRule
            {
                ScopeKey = rule.ScopeKey,
                CustomerNumber = rule.CustomerNumber,
                CustomerNameContains = rule.CustomerNameContains,
                Notes = rule.Notes,
                IsActive = rule.IsActive
            }));
        }

        if (package.FinanceRules.Count > 0)
        {
            db.FinanceRules.AddRange(package.FinanceRules.Select(rule => new FinanceRule
            {
                ScopeKey = rule.ScopeKey,
                Year = rule.Year,
                RuleType = rule.RuleType,
                FieldName = rule.FieldName,
                MatchType = rule.MatchType,
                MatchValue = rule.MatchValue,
                NumericValue = rule.NumericValue,
                Notes = rule.Notes,
                SortOrder = rule.SortOrder,
                IsActive = rule.IsActive
            }));
        }

        var serverIdMap = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
        foreach (var server in package.HanaServers)
        {
            var entity = new HanaServer
            {
                SourceSystem = server.SourceSystem,
                Name = server.Name,
                Host = server.Host,
                Port = server.Port,
                Username = string.Empty,
                Password = string.Empty,
                DatabaseName = server.DatabaseName,
                UseSsl = server.UseSsl,
                ValidateCertificate = server.ValidateCertificate,
                AdditionalParams = server.AdditionalParams
            };
            db.HanaServers.Add(entity);
            await db.SaveChangesAsync();
            serverIdMap[server.Key] = entity.Id;
        }

        var siteIdMap = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
        var importedSiteIdBySignature = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
        foreach (var site in package.Sites)
        {
            preservedSiteSecrets.TryGetValue(BuildSiteSignature(site.Land, site.TSC, site.Schema, site.SourceSystem), out var preserved);
            var entity = new Site
            {
                HanaServerId = !string.IsNullOrWhiteSpace(site.HanaServerKey) && serverIdMap.TryGetValue(site.HanaServerKey, out var mappedServerId)
                    ? mappedServerId
                    : null,
                Schema = site.Schema,
                TSC = site.TSC,
                Land = site.Land,
                SourceSystem = site.SourceSystem,
                UsernameOverride = package.IncludesSecrets ? site.UsernameOverride ?? string.Empty : preserved.UsernameOverride ?? string.Empty,
                PasswordOverride = package.IncludesSecrets ? site.PasswordOverride ?? string.Empty : preserved.PasswordOverride ?? string.Empty,
                LocalExportFolderOverride = site.LocalExportFolderOverride,
                ManualImportFilePath = site.ManualImportFilePath,
                ManualImportLastUploadedAtUtc = site.ManualImportLastUploadedAtUtc,
                SapServiceUrl = site.SapServiceUrl,
                SapEntitySet = site.SapEntitySet,
                SapEntitySetsCache = site.SapEntitySetsCache,
                SapEntitySetsRefreshedAtUtc = site.SapEntitySetsRefreshedAtUtc,
                IsActive = site.IsActive
            };
            db.Sites.Add(entity);
            await db.SaveChangesAsync();
            siteIdMap[site.Key] = entity.Id;
            importedSiteIdBySignature[BuildSiteSignature(site.Land, site.TSC, site.Schema, site.SourceSystem)] = entity.Id;
        }

        var centralRecordsToPreserve = existingCentralRecords
            .Where(record => existingSiteSignaturesById.TryGetValue(record.SiteId, out var signature) && importedSiteIdBySignature.ContainsKey(signature))
            .Select(record =>
            {
                var signature = existingSiteSignaturesById[record.SiteId];
                return new CentralSalesRecord
                {
                    StoredAtUtc = record.StoredAtUtc,
                    SiteId = importedSiteIdBySignature[signature],
                    SourceSystem = record.SourceSystem,
                    ExtractionDate = record.ExtractionDate,
                    Tsc = record.Tsc,
                    DocumentEntry = record.DocumentEntry,
                    InvoiceNumber = record.InvoiceNumber,
                    PositionOnInvoice = record.PositionOnInvoice,
                    Material = record.Material,
                    Name = record.Name,
                    ProductGroup = record.ProductGroup,
                    ProductHierarchyCode = record.ProductHierarchyCode,
                    ProductHierarchyText = record.ProductHierarchyText,
                    ProductFamilyCode = record.ProductFamilyCode,
                    ProductFamilyText = record.ProductFamilyText,
                    ProductDivisionCode = record.ProductDivisionCode,
                    ProductDivisionText = record.ProductDivisionText,
                    ProductMappingAssigned = record.ProductMappingAssigned,
                    Quantity = record.Quantity,
                    SupplierNumber = record.SupplierNumber,
                    SupplierName = record.SupplierName,
                    SupplierCountry = record.SupplierCountry,
                    CustomerNumber = record.CustomerNumber,
                    CustomerName = record.CustomerName,
                    CustomerCountry = record.CustomerCountry,
                    CustomerIndustry = record.CustomerIndustry,
                    StandardCost = record.StandardCost,
                    StandardCostCurrency = record.StandardCostCurrency,
                    PurchaseOrderNumber = record.PurchaseOrderNumber,
                    SalesPriceValue = record.SalesPriceValue,
                    SalesCurrency = record.SalesCurrency,
                    DocumentCurrency = record.DocumentCurrency,
                    DocumentTotalForeignCurrency = record.DocumentTotalForeignCurrency,
                    DocumentTotalLocalCurrency = record.DocumentTotalLocalCurrency,
                    VatSumForeignCurrency = record.VatSumForeignCurrency,
                    VatSumLocalCurrency = record.VatSumLocalCurrency,
                    DocumentRate = record.DocumentRate,
                    CompanyCurrency = record.CompanyCurrency,
                    Incoterms2020 = record.Incoterms2020,
                    SalesResponsibleEmployee = record.SalesResponsibleEmployee,
                    PostingDate = record.PostingDate,
                    InvoiceDate = record.InvoiceDate,
                    OrderDate = record.OrderDate,
                    Land = record.Land,
                    DocumentType = record.DocumentType
                };
            })
            .ToList();

        if (centralRecordsToPreserve.Count > 0)
            db.CentralSalesRecords.AddRange(centralRecordsToPreserve);

        if (package.FieldTransformationRules.Count > 0)
        {
            db.FieldTransformationRules.AddRange(package.FieldTransformationRules.Select(r => new FieldTransformationRule
            {
                SourceSystem = r.SourceSystem,
                SourceField = r.SourceField,
                TargetField = r.TargetField,
                TransformationType = r.TransformationType,
                RuleScope = r.RuleScope,
                Argument = r.Argument,
                SortOrder = r.SortOrder,
                IsActive = r.IsActive
            }));
        }

        if (package.SapSourceDefinitions.Count > 0)
        {
            db.SapSourceDefinitions.AddRange(package.SapSourceDefinitions
                .Where(x => siteIdMap.ContainsKey(x.SiteKey))
                .Select(x => new SapSourceDefinition
                {
                    SiteId = siteIdMap[x.SiteKey],
                    Alias = x.Alias,
                    EntitySet = x.EntitySet,
                    IsPrimary = x.IsPrimary,
                    IsActive = x.IsActive,
                    SortOrder = x.SortOrder
                }));
        }

        if (package.SapJoinDefinitions.Count > 0)
        {
            db.SapJoinDefinitions.AddRange(package.SapJoinDefinitions
                .Where(x => siteIdMap.ContainsKey(x.SiteKey))
                .Select(x => new SapJoinDefinition
                {
                    SiteId = siteIdMap[x.SiteKey],
                    LeftAlias = x.LeftAlias,
                    RightAlias = x.RightAlias,
                    LeftKeys = x.LeftKeys,
                    RightKeys = x.RightKeys,
                    JoinType = x.JoinType,
                    IsActive = x.IsActive,
                    SortOrder = x.SortOrder
                }));
        }

        if (package.SapFieldMappings.Count > 0)
        {
            db.SapFieldMappings.AddRange(package.SapFieldMappings
                .Where(x => siteIdMap.ContainsKey(x.SiteKey))
                .Select(x => new SapFieldMapping
                {
                    SiteId = siteIdMap[x.SiteKey],
                    TargetField = x.TargetField,
                    SourceExpression = x.SourceExpression,
                    IsRequired = x.IsRequired,
                    IsActive = x.IsActive,
                    SortOrder = x.SortOrder
                }));
        }

        if (package.ManualExcelColumnMappings.Count > 0)
        {
            db.ManualExcelColumnMappings.AddRange(package.ManualExcelColumnMappings
                .Where(x => siteIdMap.ContainsKey(x.SiteKey))
                .Select(x => new ManualExcelColumnMapping
                {
                    SiteId = siteIdMap[x.SiteKey],
                    TargetField = x.TargetField,
                    SourceHeader = x.SourceHeader,
                    IsRequired = x.IsRequired,
                    IsActive = x.IsActive,
                    SortOrder = x.SortOrder
                }));
        }

        await db.SaveChangesAsync();
        await transaction.CommitAsync();
    }

    private static string BuildSiteSignature(string land, string tsc, string schema, string sourceSystem)
        => $"{land}|{tsc}|{schema}|{sourceSystem}".ToUpperInvariant();

    private static List<ConfigTransferSourceSystemDefinition> ResolveImportedSourceSystems(string json, ConfigTransferPackage package)
    {
        if (package.SourceSystemDefinitions.Count == 0)
            return BuildDefaultSourceSystems();

        using var document = JsonDocument.Parse(json);
        if (!document.RootElement.TryGetProperty(nameof(ConfigTransferPackage.SourceSystemDefinitions), out var sourceSystemsElement) ||
            sourceSystemsElement.ValueKind != JsonValueKind.Array)
        {
            return package.SourceSystemDefinitions;
        }

        var imported = package.SourceSystemDefinitions
            .Select((sourceSystem, index) =>
            {
                var hasExplicitConnectionKind =
                    index < sourceSystemsElement.GetArrayLength() &&
                    sourceSystemsElement[index].TryGetProperty(nameof(ConfigTransferSourceSystemDefinition.ConnectionKind), out _);

                if (hasExplicitConnectionKind)
                    return sourceSystem;

                sourceSystem.ConnectionKind = InferLegacyConnectionKind(sourceSystem.Code);
                return sourceSystem;
            })
            .ToList();

        return imported;
    }

    private static string InferLegacyConnectionKind(string code)
    {
        if (string.Equals(code, "SAP", StringComparison.OrdinalIgnoreCase))
            return SourceSystemConnectionKinds.SapGateway;

        if (string.Equals(code, "MANUAL_EXCEL", StringComparison.OrdinalIgnoreCase))
            return SourceSystemConnectionKinds.ManualExcel;

        return SourceSystemConnectionKinds.Hana;
    }

    private static List<ConfigTransferSourceSystemDefinition> BuildDefaultSourceSystems()
    {
        return
        [
            new ConfigTransferSourceSystemDefinition
            {
                Code = "SAP",
                DisplayName = "SAP",
                ConnectionKind = SourceSystemConnectionKinds.SapGateway,
                IsActive = true,
                CentralServiceUrl = string.Empty
            },
            new ConfigTransferSourceSystemDefinition
            {
                Code = "BI1",
                DisplayName = "BI1",
                ConnectionKind = SourceSystemConnectionKinds.Hana,
                IsActive = true
            },
            new ConfigTransferSourceSystemDefinition
            {
                Code = "SAGE",
                DisplayName = "SAGE",
                ConnectionKind = SourceSystemConnectionKinds.Hana,
                IsActive = true
            },
            new ConfigTransferSourceSystemDefinition
            {
                Code = "MANUAL_EXCEL",
                DisplayName = "Manual Excel",
                ConnectionKind = SourceSystemConnectionKinds.ManualExcel,
                IsActive = true
            }
        ];
    }
}