@page "/standorte"
@using Microsoft.AspNetCore.Components.Forms
@using Microsoft.EntityFrameworkCore
@using System.Text.Json
@using System.Reflection
@using TrafagSalesExporter.Data
@using TrafagSalesExporter.Models
@using TrafagSalesExporter.Services
@inject IDbContextFactory<AppDbContext> DbFactory
@inject IHanaQueryService HanaService
@inject ISapGatewayService SapGatewayService
@inject IAppEventLogService AppEventLogService
@inject ISnackbar Snackbar
@inject IDialogService DialogService

<PageTitle>Standorte</PageTitle>

<MudText Typo="Typo.h4" Class="mb-4">Standorte</MudText>

<MudText Typo="Typo.h5" Class="mb-2">HANA Server</MudText>
<MudPaper Class="pa-4 mb-6" Elevation="1">
    <MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@Icons.Material.Filled.Add"
               OnClick="AddServer" Class="mb-3">
        Server hinzufügen
    </MudButton>

    <MudTable Items="_servers" Dense Hover Striped>
        <HeaderContent>
            <MudTh>Name</MudTh>
            <MudTh>Host</MudTh>
            <MudTh>Port</MudTh>
            <MudTh>Username</MudTh>
            <MudTh>Verbindungsstatus</MudTh>
            <MudTh>Aktionen</MudTh>
        </HeaderContent>
        <RowTemplate>
            <MudTd>@context.Name</MudTd>
            <MudTd>@context.Host</MudTd>
            <MudTd>@context.Port</MudTd>
            <MudTd>@context.Username</MudTd>
            <MudTd>
                @if (_connectionStatus.TryGetValue(context.Id, out var status))
                {
                    <MudTooltip Text="@BuildStatusTooltip(status)">
                        <MudChip T="string" Color="@(status.Success ? Color.Success : Color.Error)" Variant="Variant.Filled" Size="Size.Small">
                            @(status.Success ? "OK" : "Fehler") - @status.Stage
                        </MudChip>
                    </MudTooltip>
                }
                else
                {
                    <MudChip T="string" Color="Color.Default" Variant="Variant.Outlined" Size="Size.Small">Nicht getestet</MudChip>
                }
            </MudTd>
            <MudTd>
                <MudIconButton Icon="@Icons.Material.Filled.Edit" Size="Size.Small"
                               OnClick="() => EditServer(context)" />
                <MudIconButton Icon="@Icons.Material.Filled.NetworkCheck" Size="Size.Small" Color="Color.Info"
                               OnClick="() => TestServerConnection(context)" />
                <MudIconButton Icon="@Icons.Material.Filled.Delete" Size="Size.Small" Color="Color.Error"
                               OnClick="() => DeleteServer(context)" />
            </MudTd>
        </RowTemplate>
    </MudTable>
</MudPaper>

<MudText Typo="Typo.h5" Class="mb-2">Standorte (Sites)</MudText>
<MudPaper Class="pa-4" Elevation="1">
    <MudButton Variant="Variant.Filled" Color="Color.Primary" StartIcon="@Icons.Material.Filled.Add"
               OnClick="AddSite" Class="mb-3">
        Neuen Standort hinzufügen
    </MudButton>

    <MudTable Items="_sites" Dense Hover Striped>
        <HeaderContent>
            <MudTh>Land</MudTh>
            <MudTh>TSC</MudTh>
            <MudTh>Schema</MudTh>
            <MudTh>Quellsystem</MudTh>
            <MudTh>Quelle</MudTh>
            <MudTh>Aktiv</MudTh>
            <MudTh>Aktionen</MudTh>
        </HeaderContent>
        <RowTemplate>
            <MudTd>@context.Land</MudTd>
            <MudTd>@context.TSC</MudTd>
            <MudTd>@context.Schema</MudTd>
            <MudTd>@context.SourceSystem</MudTd>
            <MudTd>@GetConnectionTarget(context)</MudTd>
            <MudTd>
                @if (context.IsActive)
                {
                    <MudIcon Icon="@Icons.Material.Filled.CheckCircle" Color="Color.Success" Size="Size.Small" />
                }
                else
                {
                    <MudIcon Icon="@Icons.Material.Filled.Cancel" Color="Color.Default" Size="Size.Small" />
                }
            </MudTd>
            <MudTd>
                <MudIconButton Icon="@Icons.Material.Filled.Edit" Size="Size.Small"
                               OnClick="() => EditSite(context)" />
                <MudIconButton Icon="@Icons.Material.Filled.Delete" Size="Size.Small" Color="Color.Error"
                               OnClick="() => DeleteSite(context)" />
            </MudTd>
        </RowTemplate>
    </MudTable>
</MudPaper>

<MudDialog @bind-Visible="_serverDialogVisible" Options="_dialogOptions">
    <TitleContent>
        <MudText Typo="Typo.h6">@(_editingServer.Id == 0 ? "Server hinzufügen" : "Server bearbeiten")</MudText>
    </TitleContent>
    <DialogContent>
        <MudTextField @bind-Value="_editingServer.Name" Label="Name" Required />
        <MudTextField @bind-Value="_editingServer.Host" Label="Host" Required
                      HelperText="IP oder Hostname (ohne Protokoll)" />
        <MudNumericField @bind-Value="_editingServer.Port" Label="Port"
                         HelperText="Typisch 30015 (Tenant), 30013 (SystemDB), 3xx15 für Instanz xx" />
        <MudTextField @bind-Value="_editingServer.Username" Label="Username" />
        <MudTextField @bind-Value="_editingServer.Password" Label="Password" InputType="InputType.Password" />
        <MudTextField @bind-Value="_editingServer.DatabaseName" Label="Database Name (MDC)"
                      HelperText="Nur bei Multi-Tenant Setup angeben, sonst leer lassen" />
        <MudSwitch @bind-Value="_editingServer.UseSsl" Label="SSL/TLS verwenden (encrypt=true)" Color="Color.Primary" />
        <MudSwitch @bind-Value="_editingServer.ValidateCertificate" Label="SSL-Zertifikat validieren" Color="Color.Primary"
                   Disabled="!_editingServer.UseSsl" />
        <MudTextField @bind-Value="_editingServer.AdditionalParams" Label="Zusätzliche Parameter"
                      HelperText="Optional, z.B. sslCryptoProvider=openssl;communicationTimeout=0" />
    </DialogContent>
    <DialogActions>
        <MudButton OnClick="CloseServerDialog">Abbrechen</MudButton>
        <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="SaveServer" Disabled="_savingServer">Speichern</MudButton>
    </DialogActions>
</MudDialog>

<MudDialog @bind-Visible="_siteDialogVisible" Options="_dialogOptions">
    <TitleContent>
        <MudText Typo="Typo.h6">@(_editingSite.Id == 0 ? "Standort hinzufügen" : "Standort bearbeiten")</MudText>
    </TitleContent>
    <DialogContent>
        <MudTextField @bind-Value="_editingSite.Schema" Label="Schema" Required />
        <MudTextField @bind-Value="_editingSite.TSC" Label="TSC" Required />
        <MudTextField @bind-Value="_editingSite.Land" Label="Land" Required />
        <MudSelect @bind-Value="_editingSite.SourceSystem" Label="Quellsystem" Required>
            @foreach (var system in _sourceSystems)
            {
                <MudSelectItem Value="@system">@system</MudSelectItem>
            }
        </MudSelect>
        <MudTextField @bind-Value="_editingSite.UsernameOverride" Label="Username Override"
                      HelperText="Optional. Wenn leer, wird der zentrale Username des Quellsystems verwendet." />
        <MudTextField @bind-Value="_editingSite.PasswordOverride" Label="Password Override" InputType="InputType.Password"
                      HelperText="Optional. Wenn leer, wird das zentrale Passwort des Quellsystems verwendet." />
        <MudTextField @bind-Value="_editingSite.LocalExportFolderOverride" Label="Lokaler Exportpfad Override"
                      HelperText="Optional. Wenn leer, wird der zentrale Standardpfad für Standort-Dateien verwendet." />
        <MudCheckBox @bind-Value="_editingSite.IsActive" Label="Aktiv" />

        <MudDivider Class="my-4" />

        @if (IsSapSite())
        {
            <MudText Typo="Typo.h6" Class="mb-2">SAP Gateway</MudText>
            <MudAlert Severity="Severity.Info" Dense="true" Variant="Variant.Outlined" Class="mb-3">
                Die Service-URL zeigt auf den OData-Service. Die verfügbaren Entity Sets werden nur per Knopfdruck aktualisiert und lokal zwischengespeichert.
            </MudAlert>
            <MudTextField @bind-Value="_editingSite.SapServiceUrl" Label="SAP Service URL" Required
                          HelperText="z.B. http://server:8000/sap/opu/odata/sap/ZPOWERBI_EINKAUF_SRV/" />
            <MudStack Row Spacing="2" Class="mb-3">
                <MudButton Variant="Variant.Outlined" Color="Color.Info" OnClick="RefreshSapEntitySets"
                           StartIcon="@Icons.Material.Filled.Refresh" Disabled="_refreshingSapEntitySets">
                    @if (_refreshingSapEntitySets)
                    {
                        <MudProgressCircular Size="Size.Small" Indeterminate Class="mr-2" />
                        @("Lade...")
                    }
                    else
                    {
                        @("Quellen refreshen")
                    }
                </MudButton>
                @if (_editingSite.SapEntitySetsRefreshedAtUtc.HasValue)
                {
                    <MudText Typo="Typo.caption" Class="mt-2">
                        Letzter Refresh: @_editingSite.SapEntitySetsRefreshedAtUtc.Value.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss")
                    </MudText>
                }
            </MudStack>
            <MudDivider Class="my-4" />
            <MudStack Row Justify="Justify.SpaceBetween" AlignItems="AlignItems.Center" Class="mb-2">
                <MudText Typo="Typo.h6">SAP Quellen</MudText>
                <MudButton Variant="Variant.Outlined" StartIcon="@Icons.Material.Filled.Add" OnClick="AddSapSource">Quelle hinzufügen</MudButton>
            </MudStack>
            <MudText Typo="Typo.caption" Class="mb-2">
                Pro Quelle Alias und Entity Set definieren. Joins verwenden links/rechts kommagetrennte Schlüsselfelder wie `VBELN,POSNR`. Feldmappings erwarten `Alias.Feldname` oder Konstanten wie `=SAP`.
            </MudText>
            <MudTable Items="_sapSources" Dense Hover Striped>
                <HeaderContent>
                    <MudTh>Alias</MudTh>
                    <MudTh>Entity Set</MudTh>
                    <MudTh>Primär</MudTh>
                    <MudTh>Aktiv</MudTh>
                    <MudTh>Aktionen</MudTh>
                </HeaderContent>
                <RowTemplate>
                    <MudTd><MudTextField @bind-Value="context.Alias" Dense /></MudTd>
                    <MudTd>
                        <MudSelect @bind-Value="context.EntitySet" Dense>
                            @foreach (var entitySet in _sapEntitySetsCache)
                            {
                                <MudSelectItem Value="@entitySet">@entitySet</MudSelectItem>
                            }
                        </MudSelect>
                    </MudTd>
                    <MudTd><MudCheckBox @bind-Value="context.IsPrimary" Dense /></MudTd>
                    <MudTd><MudCheckBox @bind-Value="context.IsActive" Dense /></MudTd>
                    <MudTd><MudIconButton Icon="@Icons.Material.Filled.Delete" Color="Color.Error" Size="Size.Small" OnClick="() => RemoveSapSource(context)" /></MudTd>
                </RowTemplate>
            </MudTable>

            <MudDivider Class="my-4" />
            <MudStack Row Justify="Justify.SpaceBetween" AlignItems="AlignItems.Center" Class="mb-2">
                <MudText Typo="Typo.h6">SAP Joins</MudText>
                <MudStack Row Spacing="2">
                    <MudButton Variant="Variant.Outlined" Color="Color.Info" StartIcon="@Icons.Material.Filled.AutoFixHigh"
                               OnClick="AutoMatchSapJoins">
                        Auto-Match
                    </MudButton>
                    <MudButton Variant="Variant.Outlined" StartIcon="@Icons.Material.Filled.Add" OnClick="AddSapJoin">Join hinzufügen</MudButton>
                </MudStack>
            </MudStack>
            <MudTable Items="_sapJoins" Dense Hover Striped>
                <HeaderContent>
                    <MudTh>Links</MudTh>
                    <MudTh>Left Keys</MudTh>
                    <MudTh>Rechts</MudTh>
                    <MudTh>Right Keys</MudTh>
                    <MudTh>Typ</MudTh>
                    <MudTh>Aktiv</MudTh>
                    <MudTh>Aktionen</MudTh>
                </HeaderContent>
                <RowTemplate>
                    <MudTd>
                        <MudSelect @bind-Value="context.LeftAlias" Dense>
                            @foreach (var alias in GetSapAliases())
                            {
                                <MudSelectItem Value="@alias">@alias</MudSelectItem>
                            }
                        </MudSelect>
                    </MudTd>
                    <MudTd>
                        <MudSelect T="string"
                                   SelectedValues="GetSelectedJoinKeys(context.LeftKeys)"
                                   SelectedValuesChanged="@(values => context.LeftKeys = string.Join(',', values))"
                                   MultiSelection="true"
                                   Dense>
                            @foreach (var field in GetAvailableJoinFields(context.LeftAlias, context.LeftKeys))
                            {
                                <MudSelectItem Value="@field">@field</MudSelectItem>
                            }
                        </MudSelect>
                    </MudTd>
                    <MudTd>
                        <MudSelect @bind-Value="context.RightAlias" Dense>
                            @foreach (var alias in GetSapAliases())
                            {
                                <MudSelectItem Value="@alias">@alias</MudSelectItem>
                            }
                        </MudSelect>
                    </MudTd>
                    <MudTd>
                        <MudSelect T="string"
                                   SelectedValues="GetSelectedJoinKeys(context.RightKeys)"
                                   SelectedValuesChanged="@(values => context.RightKeys = string.Join(',', values))"
                                   MultiSelection="true"
                                   Dense>
                            @foreach (var field in GetAvailableJoinFields(context.RightAlias, context.RightKeys))
                            {
                                <MudSelectItem Value="@field">@field</MudSelectItem>
                            }
                        </MudSelect>
                    </MudTd>
                    <MudTd>
                        <MudSelect @bind-Value="context.JoinType" Dense>
                            <MudSelectItem Value="@("Left")">Left</MudSelectItem>
                        </MudSelect>
                    </MudTd>
                    <MudTd><MudCheckBox @bind-Value="context.IsActive" Dense /></MudTd>
                    <MudTd><MudIconButton Icon="@Icons.Material.Filled.Delete" Color="Color.Error" Size="Size.Small" OnClick="() => RemoveSapJoin(context)" /></MudTd>
                </RowTemplate>
            </MudTable>

            <MudDivider Class="my-4" />
            <MudStack Row Justify="Justify.SpaceBetween" AlignItems="AlignItems.Center" Class="mb-2">
                <MudText Typo="Typo.h6">Feldmappings ins zentrale Schema</MudText>
                <MudStack Row Spacing="2">
                    <MudButton Variant="Variant.Outlined" Color="Color.Info" StartIcon="@Icons.Material.Filled.Schema"
                               OnClick="RefreshSapSourceFields" Disabled="_refreshingSapSourceFields">
                        @if (_refreshingSapSourceFields)
                        {
                            <MudProgressCircular Size="Size.Small" Indeterminate Class="mr-2" />
                            @("Lade Felder...")
                        }
                        else
                        {
                            @("Felder aus Quellen laden")
                        }
                    </MudButton>
                    <MudButton Variant="Variant.Outlined" StartIcon="@Icons.Material.Filled.Add" OnClick="AddSapMapping">Mapping hinzufügen</MudButton>
                </MudStack>
            </MudStack>
            <MudText Typo="Typo.caption" Class="mb-2">
                Source Expressions werden aus den hinzugefügten SAP-Quellen als `Alias.Feldname` gelesen. Vorhandene manuelle Werte bleiben auswählbar.
            </MudText>
            <MudTable Items="_sapMappings" Dense Hover Striped>
                <HeaderContent>
                    <MudTh>Zielfeld</MudTh>
                    <MudTh>Source Expression</MudTh>
                    <MudTh>Pflicht</MudTh>
                    <MudTh>Aktiv</MudTh>
                    <MudTh>Aktionen</MudTh>
                </HeaderContent>
                <RowTemplate>
                    <MudTd>
                        <MudSelect @bind-Value="context.TargetField" Dense>
                            @foreach (var field in _salesRecordFields)
                            {
                                <MudSelectItem Value="@field">@field</MudSelectItem>
                            }
                        </MudSelect>
                    </MudTd>
                    <MudTd>
                        <MudSelect T="string" @bind-Value="context.SourceExpression" Dense>
                            @foreach (var expression in GetAvailableSourceExpressions(context.SourceExpression))
                            {
                                <MudSelectItem Value="@expression">@expression</MudSelectItem>
                            }
                        </MudSelect>
                    </MudTd>
                    <MudTd><MudCheckBox @bind-Value="context.IsRequired" Dense /></MudTd>
                    <MudTd><MudCheckBox @bind-Value="context.IsActive" Dense /></MudTd>
                    <MudTd><MudIconButton Icon="@Icons.Material.Filled.Delete" Color="Color.Error" Size="Size.Small" OnClick="() => RemoveSapMapping(context)" /></MudTd>
                </RowTemplate>
            </MudTable>
        }
        else if (IsManualExcelSite())
        {
            <MudText Typo="Typo.h6" Class="mb-2">Manueller Excel-Import</MudText>
            <MudAlert Severity="Severity.Info" Dense="true" Variant="Variant.Outlined" Class="mb-3">
                Für diesen Standort wird keine SAP- oder HANA-Verbindung verwendet. Es wird die hier hinterlegte Excel-Datei gelesen und in `CentralSalesRecords` übernommen.
            </MudAlert>
            <InputFile OnChange="UploadManualImportFileAsync" accept=".xlsx" />
            @if (_uploadingManualImport)
            {
                <MudText Typo="Typo.caption" Class="mt-2">Datei wird hochgeladen...</MudText>
            }
            @if (!string.IsNullOrWhiteSpace(_editingSite.ManualImportFilePath))
            {
                <MudPaper Class="pa-3 mt-3" Elevation="0">
                    <MudText Typo="Typo.body2">Datei: @_editingSite.ManualImportFilePath</MudText>
                    <MudText Typo="Typo.caption">
                        Letzter Upload: @(_editingSite.ManualImportLastUploadedAtUtc?.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss") ?? "-")
                    </MudText>
                </MudPaper>
            }
            else
            {
                <MudText Typo="Typo.caption" Class="mt-2">Noch keine Datei hinterlegt.</MudText>
            }
        }
        else
        {
            <MudText Typo="Typo.h6" Class="mb-2">HANA-Verbindung</MudText>
            <MudAlert Severity="Severity.Info" Dense="true" Variant="Variant.Outlined" Class="mb-3">
                Host, Port und technische HANA-Parameter kommen von dieser Verbindung. Username und Password hier dienen nur noch als Fallback für bestehende Einträge.
            </MudAlert>
            <MudTextField @bind-Value="_editingSiteServer.Name" Label="Verbindungsname" Required
                          HelperText="Interner Anzeigename für diesen Standort" />
            <MudTextField @bind-Value="_editingSiteServer.Host" Label="Host oder ServerNode" Required
                          HelperText="z.B. hana01 oder hana01:30015 oder derselbe HanaServer-Wert wie in Power BI" />
            <MudNumericField @bind-Value="_editingSiteServer.Port" Label="Port"
                             HelperText="Wird ignoriert, wenn im Host bereits ein Port enthalten ist" />
            <MudTextField @bind-Value="_editingSiteServer.Username" Label="Username" />
            <MudTextField @bind-Value="_editingSiteServer.Password" Label="Password" InputType="InputType.Password" />
            <MudTextField @bind-Value="_editingSiteServer.DatabaseName" Label="Database Name (MDC)"
                          HelperText="Nur bei Multi-Tenant Setup angeben, sonst leer lassen" />
            <MudSwitch @bind-Value="_editingSiteServer.UseSsl" Label="SSL/TLS verwenden (encrypt=true)" Color="Color.Primary" />
            <MudSwitch @bind-Value="_editingSiteServer.ValidateCertificate" Label="SSL-Zertifikat validieren" Color="Color.Primary"
                       Disabled="!_editingSiteServer.UseSsl" />
            <MudTextField @bind-Value="_editingSiteServer.AdditionalParams" Label="Zusätzliche Parameter"
                          HelperText="Optional, z.B. sslCryptoProvider=openssl;communicationTimeout=0" />
        }
    </DialogContent>
    <DialogActions>
        <MudButton OnClick="CloseSiteDialog" Disabled="_savingSite || _uploadingManualImport">Abbrechen</MudButton>
        <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="SaveSite" Disabled="_savingSite || _refreshingSapEntitySets || _uploadingManualImport">Speichern</MudButton>
    </DialogActions>
</MudDialog>

@code {
    private readonly string[] _sourceSystems = ["SAP", "BI1", "SAGE", "MANUAL_EXCEL"];
    private readonly Dictionary<int, ConnectionTestResult> _connectionStatus = new();
    private List<HanaServer> _servers = new();
    private List<Site> _sites = new();
    private List<string> _sapEntitySetsCache = [];
    private List<string> _sapAvailableSourceExpressions = [];
    private Dictionary<string, List<string>> _sapSourceFieldMap = new(StringComparer.OrdinalIgnoreCase);
    private List<SapSourceDefinition> _sapSources = [];
    private List<SapJoinDefinition> _sapJoins = [];
    private List<SapFieldMapping> _sapMappings = [];
    private readonly string[] _salesRecordFields = typeof(SalesRecord)
        .GetProperties(BindingFlags.Public | BindingFlags.Instance)
        .Select(p => p.Name)
        .ToArray();
    private HanaServer _editingServer = new();
    private Site _editingSite = new();
    private HanaServer _editingSiteServer = new();
    private bool _serverDialogVisible;
    private bool _siteDialogVisible;
    private bool _refreshingSapEntitySets;
    private bool _refreshingSapSourceFields;
    private bool _savingServer;
    private bool _savingSite;
    private bool _uploadingManualImport;
    private readonly DialogOptions _dialogOptions = new() { MaxWidth = MaxWidth.Small, FullWidth = true };

    protected override async Task OnInitializedAsync()
    {
        await LoadDataAsync();
    }

    private async Task LoadDataAsync()
    {
        using var db = await DbFactory.CreateDbContextAsync();
        _servers = await db.HanaServers.OrderBy(s => s.Name).ToListAsync();
        _sites = await db.Sites.Include(s => s.HanaServer).OrderBy(s => s.Land).ToListAsync();
    }

    private void AddServer()
    {
        _editingServer = new HanaServer { Port = 30015 };
        _serverDialogVisible = true;
    }

    private void EditServer(HanaServer server)
    {
        _editingServer = CloneServer(server);
        _serverDialogVisible = true;
    }

    private async Task SaveServer()
    {
        if (_savingServer)
            return;

        _savingServer = true;
        try
        {
        using var db = await DbFactory.CreateDbContextAsync();
        if (_editingServer.Id == 0)
        {
            db.HanaServers.Add(_editingServer);
        }
        else
        {
            var existing = await db.HanaServers.FindAsync(_editingServer.Id);
            if (existing is not null)
            {
                existing.Name = _editingServer.Name;
                existing.Host = _editingServer.Host;
                existing.Port = _editingServer.Port;
                existing.Username = _editingServer.Username;
                existing.Password = _editingServer.Password;
                existing.DatabaseName = _editingServer.DatabaseName;
                existing.UseSsl = _editingServer.UseSsl;
                existing.ValidateCertificate = _editingServer.ValidateCertificate;
                existing.AdditionalParams = _editingServer.AdditionalParams;
            }
        }

        await db.SaveChangesAsync();
        _serverDialogVisible = false;
        await LoadDataAsync();
        Snackbar.Add("Server gespeichert", Severity.Success);
        }
        finally
        {
            _savingServer = false;
        }
    }

    private async Task DeleteServer(HanaServer server)
    {
        var result = await DialogService.ShowMessageBox(
            "Server löschen",
            $"Server '{server.Name}' wirklich löschen?",
            yesText: "Löschen", cancelText: "Abbrechen");

        if (result != true) return;

        try
        {
            using var db = await DbFactory.CreateDbContextAsync();
            var linkedSites = await db.Sites
                .Where(s => s.HanaServerId == server.Id)
                .OrderBy(s => s.Land)
                .Select(s => $"{s.Land} ({s.TSC})")
                .ToListAsync();

            if (linkedSites.Count > 0)
            {
                Snackbar.Add(
                    $"Server kann nicht gelöscht werden. Noch verknüpfte Standorte: {string.Join(", ", linkedSites)}",
                    Severity.Warning);
                return;
            }

            var entity = await db.HanaServers.FindAsync(server.Id);
            if (entity is not null)
            {
                db.HanaServers.Remove(entity);
                await db.SaveChangesAsync();
            }
        }
        catch (Exception ex)
        {
            Snackbar.Add($"Server konnte nicht gelöscht werden: {ex.Message}", Severity.Error);
            return;
        }

        await LoadDataAsync();
        Snackbar.Add("Server gelöscht", Severity.Info);
    }

    private async Task TestServerConnection(HanaServer server)
    {
        await AppEventLogService.WriteAsync("HANA", "Server-Test aus UI gestartet",
            details: server.GetConnectionStringPreview());
        var result = await Task.Run(() => HanaService.TestConnectionDetailed(server));
        _connectionStatus[server.Id] = result;

        if (result.Success)
        {
            Snackbar.Add($"Verbindung zu '{server.Name}' erfolgreich.", Severity.Success);
        }
        else
        {
            Snackbar.Add($"{server.Name}: {result.ExceptionType} - {result.ErrorMessage}", Severity.Error);
        }
    }

    private static string BuildStatusTooltip(ConnectionTestResult status)
    {
        var stamp = status.TestedAtUtc.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
        if (status.Success)
            return $"Letzter Test: {stamp}\nStage: {status.Stage}\n{status.ConnectionStringPreview}";

        return $"Letzter Test: {stamp}\nStage: {status.Stage}\nFehler: {status.ErrorMessage}\n{status.ConnectionStringPreview}";
    }

    private void AddSite()
    {
        _editingSite = new Site
        {
            IsActive = true,
            SourceSystem = "SAP",
            HanaServerId = null,
            ManualImportFilePath = string.Empty
        };
        _sapEntitySetsCache = [];
        _sapAvailableSourceExpressions = [];
        _sapSourceFieldMap = new(StringComparer.OrdinalIgnoreCase);
        _sapSources = [];
        _sapJoins = [];
        _sapMappings = [];
        _editingSiteServer = CreateDefaultSiteServer();
        _siteDialogVisible = true;
    }

    private void EditSite(Site site)
    {
        _editingSite = new Site
        {
            Id = site.Id,
            HanaServerId = site.HanaServerId,
            Schema = site.Schema,
            TSC = site.TSC,
            Land = site.Land,
            SourceSystem = string.IsNullOrWhiteSpace(site.SourceSystem) ? "SAP" : site.SourceSystem,
            UsernameOverride = site.UsernameOverride,
            PasswordOverride = site.PasswordOverride,
            LocalExportFolderOverride = site.LocalExportFolderOverride,
            ManualImportFilePath = site.ManualImportFilePath,
            ManualImportLastUploadedAtUtc = site.ManualImportLastUploadedAtUtc,
            SapServiceUrl = site.SapServiceUrl,
            SapEntitySet = site.SapEntitySet,
            SapEntitySetsCache = site.SapEntitySetsCache,
            SapEntitySetsRefreshedAtUtc = site.SapEntitySetsRefreshedAtUtc,
            IsActive = site.IsActive
        };
        _sapEntitySetsCache = ParseSapEntitySets(site.SapEntitySetsCache);
        using var db = DbFactory.CreateDbContext();
        _sapSources = db.SapSourceDefinitions.Where(s => s.SiteId == site.Id).OrderBy(s => s.SortOrder).ThenBy(s => s.Id).ToList();
        _sapJoins = db.SapJoinDefinitions.Where(j => j.SiteId == site.Id).OrderBy(j => j.SortOrder).ThenBy(j => j.Id).ToList();
        _sapMappings = db.SapFieldMappings.Where(m => m.SiteId == site.Id).OrderBy(m => m.SortOrder).ThenBy(m => m.Id).ToList();
        _sapAvailableSourceExpressions = BuildSourceExpressionsFromMappings();
        _sapSourceFieldMap = BuildSourceFieldMapFromJoins();
        _editingSiteServer = site.HanaServer is null
            ? CreateDefaultSiteServer(site)
            : CloneServer(site.HanaServer);
        _siteDialogVisible = true;
    }

    private async Task SaveSite()
    {
        if (_savingSite)
            return;

        _savingSite = true;
        try
        {
            using var db = await DbFactory.CreateDbContextAsync();
            var serverId = UsesHanaConnection() ? await SaveOrCreateSiteServerAsync(db) : (int?)null;
            _editingSite.HanaServerId = serverId;
            _editingSite.SapEntitySetsCache = SerializeSapEntitySets(_sapEntitySetsCache);

            if (_editingSite.Id == 0)
            {
                db.Sites.Add(_editingSite);
            }
            else
            {
                var existing = await db.Sites.FindAsync(_editingSite.Id);
                if (existing is not null)
                {
                    existing.HanaServerId = serverId;
                    existing.Schema = _editingSite.Schema;
                    existing.TSC = _editingSite.TSC;
                    existing.Land = _editingSite.Land;
                    existing.SourceSystem = _editingSite.SourceSystem;
                    existing.UsernameOverride = _editingSite.UsernameOverride;
                    existing.PasswordOverride = _editingSite.PasswordOverride;
                    existing.LocalExportFolderOverride = _editingSite.LocalExportFolderOverride;
                    existing.ManualImportFilePath = _editingSite.ManualImportFilePath;
                    existing.ManualImportLastUploadedAtUtc = _editingSite.ManualImportLastUploadedAtUtc;
                    existing.SapServiceUrl = _editingSite.SapServiceUrl;
                    existing.SapEntitySet = _editingSite.SapEntitySet;
                    existing.SapEntitySetsCache = _editingSite.SapEntitySetsCache;
                    existing.SapEntitySetsRefreshedAtUtc = _editingSite.SapEntitySetsRefreshedAtUtc;
                    existing.IsActive = _editingSite.IsActive;
                }
            }

            await db.SaveChangesAsync();
            await SaveSapConfigurationAsync(db, _editingSite.Id);
            _siteDialogVisible = false;
            await LoadDataAsync();
            Snackbar.Add("Standort gespeichert", Severity.Success);
        }
        catch (Exception ex)
        {
            Snackbar.Add($"Speichern fehlgeschlagen: {ex.Message}", Severity.Error);
        }
        finally
        {
            _savingSite = false;
        }
    }

    private async Task DeleteSite(Site site)
    {
        var result = await DialogService.ShowMessageBox(
            "Standort löschen",
            $"Standort '{site.Land}' wirklich löschen?",
            yesText: "Löschen", cancelText: "Abbrechen");

        if (result != true) return;

        using var db = await DbFactory.CreateDbContextAsync();
        var entity = await db.Sites.FindAsync(site.Id);
        if (entity is not null)
        {
            var sources = await db.SapSourceDefinitions.Where(s => s.SiteId == site.Id).ToListAsync();
            var joins = await db.SapJoinDefinitions.Where(j => j.SiteId == site.Id).ToListAsync();
            var mappings = await db.SapFieldMappings.Where(m => m.SiteId == site.Id).ToListAsync();
            var centralRows = await db.CentralSalesRecords.Where(r => r.SiteId == site.Id).ToListAsync();
            if (sources.Count > 0) db.SapSourceDefinitions.RemoveRange(sources);
            if (joins.Count > 0) db.SapJoinDefinitions.RemoveRange(joins);
            if (mappings.Count > 0) db.SapFieldMappings.RemoveRange(mappings);
            if (centralRows.Count > 0) db.CentralSalesRecords.RemoveRange(centralRows);
            db.Sites.Remove(entity);
            await db.SaveChangesAsync();
        }

        await LoadDataAsync();
        Snackbar.Add("Standort gelöscht", Severity.Info);
    }

    private static string GetServerNode(HanaServer? server)
    {
        if (server is null || string.IsNullOrWhiteSpace(server.Host))
            return "-";

        return server.Host.Contains(':', StringComparison.Ordinal) ? server.Host : $"{server.Host}:{server.Port}";
    }

    private static string GetConnectionTarget(Site site)
    {
        var sourceSystem = string.IsNullOrWhiteSpace(site.SourceSystem) ? "SAP" : site.SourceSystem;
        if (string.Equals(sourceSystem, "SAP", StringComparison.OrdinalIgnoreCase))
            return string.IsNullOrWhiteSpace(site.SapServiceUrl) ? "-" : site.SapServiceUrl;
        if (string.Equals(sourceSystem, "MANUAL_EXCEL", StringComparison.OrdinalIgnoreCase))
            return string.IsNullOrWhiteSpace(site.ManualImportFilePath) ? "-" : Path.GetFileName(site.ManualImportFilePath);

        return GetServerNode(site.HanaServer);
    }

    private HanaServer CreateDefaultSiteServer(Site? site = null)
    {
        var label = !string.IsNullOrWhiteSpace(site?.Land) ? site!.Land : site?.TSC;
        if (string.IsNullOrWhiteSpace(label))
            label = "Neuer Standort";

        return new HanaServer
        {
            Name = $"{label} HANA",
            Port = 30015
        };
    }

    private static HanaServer CloneServer(HanaServer server)
    {
        return new HanaServer
        {
            Id = server.Id,
            Name = server.Name,
            Host = server.Host,
            Port = server.Port,
            Username = server.Username,
            Password = server.Password,
            DatabaseName = server.DatabaseName,
            UseSsl = server.UseSsl,
            ValidateCertificate = server.ValidateCertificate,
            AdditionalParams = server.AdditionalParams
        };
    }

    private async Task<int> SaveOrCreateSiteServerAsync(AppDbContext db)
    {
        _editingSiteServer.Name = string.IsNullOrWhiteSpace(_editingSiteServer.Name)
            ? $"{_editingSite.Land} HANA".Trim()
            : _editingSiteServer.Name.Trim();
        _editingSite.UsernameOverride = _editingSite.UsernameOverride.Trim();
        _editingSite.PasswordOverride = _editingSite.PasswordOverride.Trim();
        _editingSite.LocalExportFolderOverride = _editingSite.LocalExportFolderOverride.Trim();
        _editingSite.ManualImportFilePath = _editingSite.ManualImportFilePath.Trim();
        _editingSite.SapServiceUrl = _editingSite.SapServiceUrl.Trim();
        _editingSite.SapEntitySet = _editingSite.SapEntitySet.Trim();
        _editingSiteServer.Host = _editingSiteServer.Host.Trim();
        _editingSiteServer.Username = _editingSiteServer.Username.Trim();
        _editingSiteServer.DatabaseName = _editingSiteServer.DatabaseName.Trim();
        _editingSiteServer.AdditionalParams = _editingSiteServer.AdditionalParams.Trim();

        if (string.IsNullOrWhiteSpace(_editingSiteServer.Host))
            throw new InvalidOperationException("Host oder ServerNode muss gesetzt sein.");

        if (_editingSite.HanaServerId == 0)
        {
            db.HanaServers.Add(_editingSiteServer);
            await db.SaveChangesAsync();
            return _editingSiteServer.Id;
        }

        var sharedUseCount = await db.Sites.CountAsync(s => s.HanaServerId == _editingSite.HanaServerId && s.Id != _editingSite.Id);
        if (sharedUseCount > 0)
        {
            var dedicatedServer = CloneServer(_editingSiteServer);
            dedicatedServer.Id = 0;
            db.HanaServers.Add(dedicatedServer);
            await db.SaveChangesAsync();
            return dedicatedServer.Id;
        }

        var existingServer = await db.HanaServers.FindAsync(_editingSite.HanaServerId);
        if (existingServer is null)
        {
            db.HanaServers.Add(_editingSiteServer);
            await db.SaveChangesAsync();
            return _editingSiteServer.Id;
        }

        existingServer.Name = _editingSiteServer.Name;
        existingServer.Host = _editingSiteServer.Host;
        existingServer.Port = _editingSiteServer.Port;
        existingServer.Username = _editingSiteServer.Username;
        existingServer.Password = _editingSiteServer.Password;
        existingServer.DatabaseName = _editingSiteServer.DatabaseName;
        existingServer.UseSsl = _editingSiteServer.UseSsl;
        existingServer.ValidateCertificate = _editingSiteServer.ValidateCertificate;
        existingServer.AdditionalParams = _editingSiteServer.AdditionalParams;
        await db.SaveChangesAsync();
        return existingServer.Id;
    }

    private bool IsSapSite() => string.Equals(_editingSite.SourceSystem, "SAP", StringComparison.OrdinalIgnoreCase);
    private bool IsManualExcelSite() => string.Equals(_editingSite.SourceSystem, "MANUAL_EXCEL", StringComparison.OrdinalIgnoreCase);
    private bool UsesHanaConnection() => !IsSapSite() && !IsManualExcelSite();

    private async Task RefreshSapEntitySets()
    {
        if (_refreshingSapEntitySets)
            return;

        _refreshingSapEntitySets = true;
        try
        {
            if (string.IsNullOrWhiteSpace(_editingSite.SapServiceUrl))
                throw new InvalidOperationException("SAP Service URL muss gesetzt sein.");

            using var db = await DbFactory.CreateDbContextAsync();
            var settings = await db.ExportSettings.FirstOrDefaultAsync() ?? new();
            var username = string.IsNullOrWhiteSpace(_editingSite.UsernameOverride) ? settings.SapUsername : _editingSite.UsernameOverride;
            var password = string.IsNullOrWhiteSpace(_editingSite.PasswordOverride) ? settings.SapPassword : _editingSite.PasswordOverride;

            if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password))
                throw new InvalidOperationException("Für SAP sind weder zentrale Zugangsdaten noch Standort-Overrides gesetzt.");

            await AppEventLogService.WriteAsync("SAP", "Refresh aus UI gestartet", siteId: _editingSite.Id, land: _editingSite.Land,
                details: _editingSite.SapServiceUrl);
            var entitySets = await SapGatewayService.GetEntitySetsAsync(_editingSite.SapServiceUrl, username.Trim(), password.Trim());
            _sapEntitySetsCache = entitySets;
            _editingSite.SapEntitySetsCache = SerializeSapEntitySets(entitySets);
            _editingSite.SapEntitySetsRefreshedAtUtc = DateTime.UtcNow;

            if (!string.IsNullOrWhiteSpace(_editingSite.SapEntitySet) &&
                !_sapEntitySetsCache.Contains(_editingSite.SapEntitySet, StringComparer.OrdinalIgnoreCase))
            {
                _editingSite.SapEntitySet = string.Empty;
            }

            Snackbar.Add($"{entitySets.Count} SAP Entity Sets geladen.", Severity.Success);
            await AppEventLogService.WriteAsync("SAP", "Refresh aus UI erfolgreich", siteId: _editingSite.Id, land: _editingSite.Land,
                details: $"EntitySets={entitySets.Count}");
        }
        catch (Exception ex)
        {
            Snackbar.Add(ex.Message, Severity.Error);
            await AppEventLogService.WriteAsync("SAP", "Refresh aus UI fehlgeschlagen", "Error", siteId: _editingSite.Id, land: _editingSite.Land,
                details: ex.ToString());
        }
        finally
        {
            _refreshingSapEntitySets = false;
        }
    }

    private void CloseServerDialog()
    {
        if (_savingServer)
            return;

        _serverDialogVisible = false;
    }

    private void CloseSiteDialog()
    {
        if (_savingSite || _refreshingSapEntitySets || _uploadingManualImport)
            return;

        _siteDialogVisible = false;
    }

    private async Task UploadManualImportFileAsync(InputFileChangeEventArgs args)
    {
        if (_uploadingManualImport)
            return;

        var file = args.File;
        if (file is null)
            return;

        _uploadingManualImport = true;
        try
        {
            var extension = Path.GetExtension(file.Name);
            if (!string.Equals(extension, ".xlsx", StringComparison.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException("Bitte eine Excel-Datei mit Endung .xlsx auswählen.");
            }

            var uploadDirectory = Path.Combine(AppContext.BaseDirectory, "manual-imports");
            Directory.CreateDirectory(uploadDirectory);

            var safeBaseName = string.Concat(Path.GetFileNameWithoutExtension(file.Name).Select(ch =>
                char.IsLetterOrDigit(ch) || ch == '-' || ch == '_' ? ch : '_'));
            if (string.IsNullOrWhiteSpace(safeBaseName))
                safeBaseName = "manual_import";

            var targetPath = Path.Combine(uploadDirectory, $"{safeBaseName}_{Guid.NewGuid():N}{extension}");

            await using (var sourceStream = file.OpenReadStream(maxAllowedSize: 50 * 1024 * 1024))
            await using (var targetStream = File.Create(targetPath))
            {
                await sourceStream.CopyToAsync(targetStream);
            }

            _editingSite.ManualImportFilePath = targetPath;
            _editingSite.ManualImportLastUploadedAtUtc = DateTime.UtcNow;
            Snackbar.Add("Excel-Datei hochgeladen.", Severity.Success);
            await AppEventLogService.WriteAsync("ManualImport", "Excel-Datei hochgeladen", siteId: _editingSite.Id, land: _editingSite.Land, details: targetPath);
        }
        catch (Exception ex)
        {
            Snackbar.Add($"Upload fehlgeschlagen: {ex.Message}", Severity.Error);
            await AppEventLogService.WriteAsync("ManualImport", "Excel-Upload fehlgeschlagen", "Error", siteId: _editingSite.Id, land: _editingSite.Land, details: ex.ToString());
        }
        finally
        {
            _uploadingManualImport = false;
        }
    }

    private static List<string> ParseSapEntitySets(string json)
    {
        if (string.IsNullOrWhiteSpace(json))
            return [];

        try
        {
            return JsonSerializer.Deserialize<List<string>>(json) ?? [];
        }
        catch
        {
            return [];
        }
    }

    private static string SerializeSapEntitySets(List<string> entitySets)
        => JsonSerializer.Serialize(entitySets);

    private void AddSapSource()
    {
        _sapSources.Add(new SapSourceDefinition
        {
            Alias = $"SRC{_sapSources.Count + 1}",
            EntitySet = _sapEntitySetsCache.FirstOrDefault() ?? string.Empty,
            IsActive = true,
            IsPrimary = _sapSources.Count == 0,
            SortOrder = _sapSources.Count
        });
    }

    private void RemoveSapSource(SapSourceDefinition source)
    {
        _sapSources.Remove(source);
    }

    private void AddSapJoin()
    {
        _sapJoins.Add(new SapJoinDefinition
        {
            JoinType = "Left",
            IsActive = true,
            SortOrder = _sapJoins.Count
        });
    }

    private void AutoMatchSapJoins()
    {
        var activeSources = _sapSources
            .Where(s => s.IsActive && !string.IsNullOrWhiteSpace(s.Alias))
            .OrderBy(s => s.SortOrder)
            .ThenBy(s => s.Id)
            .ToList();

        if (activeSources.Count < 2)
        {
            Snackbar.Add("Für Auto-Match werden mindestens zwei aktive SAP-Quellen benötigt.", Severity.Warning);
            return;
        }

        if (_sapSourceFieldMap.Count == 0)
        {
            Snackbar.Add("Bitte zuerst 'Felder aus Quellen laden' ausführen.", Severity.Warning);
            return;
        }

        var primary = activeSources.FirstOrDefault(s => s.IsPrimary) ?? activeSources.First();
        var createdOrUpdated = 0;

        foreach (var source in activeSources.Where(s => !string.Equals(s.Alias, primary.Alias, StringComparison.OrdinalIgnoreCase)))
        {
            if (!_sapSourceFieldMap.TryGetValue(primary.Alias, out var leftFields) || leftFields.Count == 0)
                continue;
            if (!_sapSourceFieldMap.TryGetValue(source.Alias, out var rightFields) || rightFields.Count == 0)
                continue;

            var matchingFields = leftFields
                .Intersect(rightFields, StringComparer.OrdinalIgnoreCase)
                .OrderBy(x => x, StringComparer.OrdinalIgnoreCase)
                .ToList();

            if (matchingFields.Count == 0)
                continue;

            var existingJoin = _sapJoins.FirstOrDefault(j =>
                string.Equals(j.LeftAlias, primary.Alias, StringComparison.OrdinalIgnoreCase) &&
                string.Equals(j.RightAlias, source.Alias, StringComparison.OrdinalIgnoreCase));

            var keyList = string.Join(',', matchingFields);
            if (existingJoin is null)
            {
                _sapJoins.Add(new SapJoinDefinition
                {
                    LeftAlias = primary.Alias,
                    RightAlias = source.Alias,
                    LeftKeys = keyList,
                    RightKeys = keyList,
                    JoinType = "Left",
                    IsActive = true,
                    SortOrder = _sapJoins.Count
                });
            }
            else
            {
                existingJoin.LeftKeys = keyList;
                existingJoin.RightKeys = keyList;
                existingJoin.JoinType = "Left";
                existingJoin.IsActive = true;
            }

            createdOrUpdated++;
        }

        if (createdOrUpdated == 0)
        {
            Snackbar.Add("Kein passender Join-Vorschlag gefunden.", Severity.Info);
            return;
        }

        NormalizeSapConfigCollections();
        Snackbar.Add($"{createdOrUpdated} Join-Vorschläge gesetzt.", Severity.Success);
    }

    private void RemoveSapJoin(SapJoinDefinition join)
    {
        _sapJoins.Remove(join);
    }

    private void AddSapMapping()
    {
        _sapMappings.Add(new SapFieldMapping
        {
            TargetField = _salesRecordFields.First(),
            SourceExpression = _sapAvailableSourceExpressions.FirstOrDefault() ?? "=SAP",
            IsActive = true,
            SortOrder = _sapMappings.Count
        });
    }

    private void RemoveSapMapping(SapFieldMapping mapping)
    {
        _sapMappings.Remove(mapping);
    }

    private IEnumerable<string> GetSapAliases()
        => _sapSources.Where(s => !string.IsNullOrWhiteSpace(s.Alias)).Select(s => s.Alias).Distinct(StringComparer.OrdinalIgnoreCase);

    private async Task SaveSapConfigurationAsync(AppDbContext db, int siteId)
    {
        var oldSources = await db.SapSourceDefinitions.Where(s => s.SiteId == siteId).ToListAsync();
        var oldJoins = await db.SapJoinDefinitions.Where(j => j.SiteId == siteId).ToListAsync();
        var oldMappings = await db.SapFieldMappings.Where(m => m.SiteId == siteId).ToListAsync();
        if (oldSources.Count > 0) db.SapSourceDefinitions.RemoveRange(oldSources);
        if (oldJoins.Count > 0) db.SapJoinDefinitions.RemoveRange(oldJoins);
        if (oldMappings.Count > 0) db.SapFieldMappings.RemoveRange(oldMappings);

        if (IsSapSite())
        {
            NormalizeSapConfigCollections();
            foreach (var source in _sapSources)
                source.SiteId = siteId;
            foreach (var join in _sapJoins)
                join.SiteId = siteId;
            foreach (var mapping in _sapMappings)
                mapping.SiteId = siteId;
            db.SapSourceDefinitions.AddRange(_sapSources);
            db.SapJoinDefinitions.AddRange(_sapJoins);
            db.SapFieldMappings.AddRange(_sapMappings);
        }

        await db.SaveChangesAsync();
    }

    private void NormalizeSapConfigCollections()
    {
        for (var i = 0; i < _sapSources.Count; i++)
            _sapSources[i].SortOrder = i;
        for (var i = 0; i < _sapJoins.Count; i++)
            _sapJoins[i].SortOrder = i;
        for (var i = 0; i < _sapMappings.Count; i++)
            _sapMappings[i].SortOrder = i;

        var selectedPrimaryIndex = _sapSources.FindIndex(s => s.IsPrimary);
        var primarySource = selectedPrimaryIndex >= 0 ? _sapSources[selectedPrimaryIndex] : _sapSources.FirstOrDefault();
        foreach (var source in _sapSources)
            source.IsPrimary = primarySource is not null && ReferenceEquals(source, primarySource);
        if (_sapSources.Count > 0 && _sapSources.All(s => !s.IsPrimary))
            _sapSources[0].IsPrimary = true;
    }

    private async Task RefreshSapSourceFields()
    {
        if (_refreshingSapSourceFields)
            return;

        _refreshingSapSourceFields = true;
        try
        {
            if (string.IsNullOrWhiteSpace(_editingSite.SapServiceUrl))
                throw new InvalidOperationException("SAP Service URL muss gesetzt sein.");

            var activeSources = _sapSources
                .Where(s => s.IsActive && !string.IsNullOrWhiteSpace(s.Alias) && !string.IsNullOrWhiteSpace(s.EntitySet))
                .OrderBy(s => s.SortOrder)
                .ThenBy(s => s.Id)
                .ToList();

            if (activeSources.Count == 0)
                throw new InvalidOperationException("Es gibt keine aktiven SAP-Quellen mit Alias und Entity Set.");

            using var db = await DbFactory.CreateDbContextAsync();
            var settings = await db.ExportSettings.FirstOrDefaultAsync() ?? new();
            var username = string.IsNullOrWhiteSpace(_editingSite.UsernameOverride) ? settings.SapUsername : _editingSite.UsernameOverride;
            var password = string.IsNullOrWhiteSpace(_editingSite.PasswordOverride) ? settings.SapPassword : _editingSite.PasswordOverride;

            if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password))
                throw new InvalidOperationException("Für SAP sind weder zentrale Zugangsdaten noch Standort-Overrides gesetzt.");

            var expressions = new List<string> { "=SAP" };
            var sourceFieldMap = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
            foreach (var source in activeSources)
            {
                var fieldNames = await SapGatewayService.GetEntityFieldNamesAsync(_editingSite.SapServiceUrl, source.EntitySet, username.Trim(), password.Trim());
                sourceFieldMap[source.Alias] = fieldNames;
                expressions.AddRange(fieldNames.Select(field => $"{source.Alias}.{field}"));
            }

            _sapAvailableSourceExpressions = expressions
                .Where(x => !string.IsNullOrWhiteSpace(x))
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .OrderBy(x => x, StringComparer.OrdinalIgnoreCase)
                .ToList();
            _sapSourceFieldMap = sourceFieldMap;

            foreach (var current in BuildSourceExpressionsFromMappings())
            {
                if (!_sapAvailableSourceExpressions.Contains(current, StringComparer.OrdinalIgnoreCase))
                    _sapAvailableSourceExpressions.Add(current);
            }

            _sapAvailableSourceExpressions = _sapAvailableSourceExpressions
                .Distinct(StringComparer.OrdinalIgnoreCase)
                .OrderBy(x => x, StringComparer.OrdinalIgnoreCase)
                .ToList();

            Snackbar.Add($"{_sapAvailableSourceExpressions.Count} Source Expressions geladen.", Severity.Success);
        }
        catch (Exception ex)
        {
            Snackbar.Add(ex.Message, Severity.Error);
        }
        finally
        {
            _refreshingSapSourceFields = false;
        }
    }

    private IEnumerable<string> GetAvailableSourceExpressions(string? currentValue)
    {
        var expressions = new List<string>(_sapAvailableSourceExpressions);
        if (!string.IsNullOrWhiteSpace(currentValue) && !expressions.Contains(currentValue, StringComparer.OrdinalIgnoreCase))
            expressions.Insert(0, currentValue);

        return expressions;
    }

    private List<string> BuildSourceExpressionsFromMappings()
        => _sapMappings
            .Select(m => m.SourceExpression)
            .Where(x => !string.IsNullOrWhiteSpace(x))
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .OrderBy(x => x, StringComparer.OrdinalIgnoreCase)
            .ToList();

    private Dictionary<string, List<string>> BuildSourceFieldMapFromJoins()
    {
        var result = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);

        foreach (var join in _sapJoins)
        {
            AddJoinKeysToFieldMap(result, join.LeftAlias, join.LeftKeys);
            AddJoinKeysToFieldMap(result, join.RightAlias, join.RightKeys);
        }

        return result;
    }

    private static void AddJoinKeysToFieldMap(Dictionary<string, List<string>> target, string alias, string keys)
    {
        if (string.IsNullOrWhiteSpace(alias))
            return;

        if (!target.TryGetValue(alias, out var fields))
        {
            fields = [];
            target[alias] = fields;
        }

        foreach (var key in GetSelectedJoinKeys(keys))
        {
            if (!fields.Contains(key, StringComparer.OrdinalIgnoreCase))
                fields.Add(key);
        }

        fields.Sort(StringComparer.OrdinalIgnoreCase);
    }

    private IEnumerable<string> GetAvailableJoinFields(string? alias, string? currentKeys)
    {
        var values = new List<string>();
        if (!string.IsNullOrWhiteSpace(alias) && _sapSourceFieldMap.TryGetValue(alias, out var fields))
            values.AddRange(fields);

        foreach (var key in GetSelectedJoinKeys(currentKeys))
        {
            if (!values.Contains(key, StringComparer.OrdinalIgnoreCase))
                values.Add(key);
        }

        return values
            .Where(x => !string.IsNullOrWhiteSpace(x))
            .Distinct(StringComparer.OrdinalIgnoreCase)
            .OrderBy(x => x, StringComparer.OrdinalIgnoreCase)
            .ToList();
    }

    private static HashSet<string> GetSelectedJoinKeys(string? keys)
        => keys?
            .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
            .Where(x => !string.IsNullOrWhiteSpace(x))
            .ToHashSet(StringComparer.OrdinalIgnoreCase)
            ?? [];
}