@inherits LayoutComponentBase
@implements IDisposable
@inject IProjectService ProjectService
@inject ISettingsService SettingsService
@inject IThemeService ThemeService
@inject IOllamaSetupService SetupService
@inject OllamaSettings OllamaSettings
@inject IAuthService AuthService
@inject CustomAuthStateProvider AuthStateProvider
@inject ILocalizationService Loc
@inject OperationState OpState


@inject ILocalStorageSyncService SyncService

@using AuthorBuddy.Web.Models
@using System.Threading




@if (_isLoading)
{
    <div class="splash-screen">
        <div class="splash-bg" style="background-image:url('/Assets/splash.jpg')"></div>
        <div class="splash-content">
            <div class="splash-logo">
                <img src="/Assets/logo.jpg" alt="Author Buddy" />
            </div>
            <div class="splash-loader"></div>
        </div>
    </div>
}
else
{
    <div class="page">

    @if (OpState.IsBusy)
    {
        <div class="llm-overlay">
            <div class="llm-modal">
                <div class="llm-title">
                    <span class="llm-title-spinner"></span>
                    @Loc["llm.overlay.title"]
                </div>
                <div class="llm-body">
                    <div class="llm-status">@OpState.StatusText</div>
                    @if (!string.IsNullOrEmpty(OpState.ThoughtText))
                    {
                        <div class="llm-thoughts">@OpState.ThoughtText</div>
                    }
                    else
                    {
                        <div class="llm-thoughts llm-thoughts-empty">@Loc["llm.overlay.placeholder"]</div>
                    }
                </div>
            </div>
        </div>
    }

    <div class="main-content">
        @if (_isAuthenticated)
        {
        <aside class="sidebar @(_showMobileSidebar ? "mobile-visible" : "")">
            <div class="mobile-sidebar-close" @onclick="CloseMobileSidebar">✕</div>
            <div class="sidebar-logo">
                <img src="/Assets/logo.jpg" alt="Author Buddy" />
            </div>
            <div class="nav-section">
                <button class="nav-section-header" @onclick='() => ToggleSection("file")'>
                    <span class="nav-icon">@(activeSection == "file" ? "▼" : "▶")</span>
                    @Loc["nav.menu.file"]
                </button>
                @if (activeSection == "file")
                {
                    <div class="nav-section-body">
                        @if (!_currentUserRoles.Contains(UserRole.Blogger))
                        {
                            <button class="nav-item" @onclick="CreateNewProject">@Loc["nav.menu.file.new_project"]</button>
                        }
                        <button class="nav-item" @onclick="OpenEditor">@Loc["nav.menu.file.open_editor"]</button>
                        <div class="nav-separator"></div>
                        <button class="nav-item" @onclick="ExitApp">@Loc["nav.menu.file.exit"]</button>
                    </div>
                }
            </div>
            <div class="nav-section">
                <button class="nav-section-header" @onclick='() => ToggleSection("extras")'>
                    <span class="nav-icon">@(activeSection == "extras" ? "▼" : "▶")</span>
                    @Loc["nav.menu.extras"]
                </button>
                @if (activeSection == "extras")
                {
                    <div class="nav-section-body">
                        <button class="nav-item" @onclick='() => NavigateTo("/settings")'>@Loc["nav.menu.extras.settings"]</button>
                        @if (_currentUserRoles.Contains(UserRole.Administrator))
                        {
                            <button class="nav-item" @onclick='() => NavigateTo("/models")'>@Loc["nav.menu.extras.manage_models"]</button>
                                <button class="nav-item" @onclick='() => NavigateTo("/assistant")'>@Loc["nav.menu.extras.assistant"]</button>
                                <button class="nav-item" @onclick='() => NavigateTo("/setup-assistant")'>Setup Assistent</button>
                                <div class="nav-separator"></div>
                            <button class="nav-item" @onclick='() => NavigateTo("/user-management")'>@Loc["nav.menu.extras.user_management"]</button>
                            <button class="nav-item" @onclick='() => NavigateTo("/db-admin")'>📊 DB-Admin</button>
                        }
                        else
                        {
                            <button class="nav-item" @onclick='() => NavigateTo("/assistant")'>@Loc["nav.menu.extras.assistant"]</button>
                        }
                    </div>
                }
            </div>
                    @{
                        var canMarkdown = _currentUserRoles.Contains(UserRole.Administrator) || _currentUserRoles.Contains(UserRole.Blogger);
                        var canChat = _currentUserRoles.Contains(UserRole.Administrator) || _currentUserRoles.Contains(UserRole.Chat);
                    }
            @if (canChat || canMarkdown)
            {
                <div class="nav-section">
                    <button class="nav-section-header" @onclick='() => ToggleSection("tools")'>
                        <span class="nav-icon">@(activeSection == "tools" ? "▼" : "▶")</span>
                        @Loc["nav.menu.chat"]
                    </button>
                    @if (activeSection == "tools")
                    {
                        @if (canMarkdown)
                        {
                            <div class="nav-section-body">
                                <button class="nav-item" @onclick='() => NavigateTo("/quick-markdown")'>⚡ Quick Markdown</button>
                            </div>                            
                        }
                        @if (canChat)
                        {
                            <div class="nav-section-body">
                                <button class="nav-item" @onclick='() => NavigateTo("/chat")'>💬 Chat öffnen</button>
                            </div>
                        }
                    }
                </div>
            }
       
            @if (_currentUserRoles.Contains(UserRole.Administrator) || _currentUserRoles.Contains(UserRole.Author))
            {
            <div class="nav-section">
                <button class="nav-section-header" @onclick='() => ToggleSection("projects")'>
                    <span class="nav-icon">@(activeSection == "projects" ? "▼" : "▶")</span>
                    @Loc["nav.menu.projects"]
                </button>
                @if (activeSection == "projects")
                {
                    <div class="nav-section-body">
                        <button class="nav-item nav-item-toggle" @onclick='() => showProjectList = !showProjectList'>
                            <span class="nav-icon">@(showProjectList ? "▼" : "▶")</span>
                            @Loc["nav.projects.list_title"]
                        </button>
                        @if (showProjectList)
                        {
                            <div class="nav-sublist">
                                @if (projects == null)
                                {
                                    <span class="nav-hint">@Loc["nav.projects.loading"]</span>
                                }
                                else if (projects.Count == 0)
                                {
                                    <span class="nav-hint">@Loc["nav.projects.empty"]</span>
                                }
                                else
                                {
                                    @foreach (var p in projects)
                                    {
                                        <div class="nav-item nav-item-sub @(p.Id == currentProjectId ? "active" : "")">
                                            <button class="nav-item-text" @onclick='() => SelectProject(p)'>@p.Name</button>
                                            <button class="nav-item-icon" @onclick='() => BeginCopyProject(p)' title="@Loc["nav.projects.copy"]">⧉</button>
                                        </div>
                                    }
                                }
                            </div>
                        }
                        <div class="nav-separator"></div>
                        <button class="nav-item" @onclick="CreateNewProject">@Loc["nav.projects.create"]</button>
                    </div>
                }
            </div>
            }
            @if (currentProjectId > 0 && fileTree != null)
            {
                <div class="nav-section nav-section-open">
                    <div class="nav-section-header">
                        <span>@Loc["nav.projects.files"]</span>
                        <span class="nav-header-actions">
                            <button class="nav-item-icon" @onclick="RefreshFileTree" title="@Loc["nav.projects.refresh_tree"]">↻</button>
                            @if (_selectedFiles.Count > 0)
                            {
                                <button class="nav-item-icon" @onclick="() => _showExportDialog = true" title="Export (@(_selectedFiles.Count))">⬇</button>
                            }
                        </span>
                    </div>
                    <div class="nav-section-body">
                        @foreach (var item in fileTree)
                        {
                            var cat = item.Category;
                            <div class="tree-item @(item.IsDirectory ? "dir" : "file") @(item.FullPath == currentFilePath ? "active" : "")"
                                 @onclick="() => OpenFile(item)">
                                @if (!item.IsDirectory)
                                {
                                    <input type="checkbox" class="tree-checkbox"
                                           checked="@_selectedFiles.Contains(item.FullPath)"
                                           @onclick:stopPropagation
                                           @onchange="() => ToggleFileSelection(item.FullPath)" />
                                }
                                <span class="tree-icon">@(item.IsDirectory ? "📁" : "📄")</span>
                                <span class="tree-name">@item.Name</span>
                                @if (cat != FileCategory.None)
                                {
                                    <span class="tree-category-badge @FileCategoryHelper.CssClass(cat)" title="@FileCategoryHelper.DisplayName(cat)">@FileCategoryHelper.DisplayIcon(cat)</span>
                                }
                                @if (item.IsDirectory)
                                {
                                    <button class="tree-rename" @onclick="() => BeginNewFile(item)" @onclick:stopPropagation title="@Loc["nav.projects.file.new"]">+</button>
                                }
                                else
                                {
                                    <button class="tree-cat-btn" @onclick="() => ToggleCategoryEditor(item)" @onclick:stopPropagation title="Kategorie">🏷</button>
                                    <button class="tree-rename" @onclick="() => BeginRename(item)" @onclick:stopPropagation title="@Loc["nav.projects.file.rename"]">✎</button>
                                }
                            </div>
                            @if (_editingCategoryPath == item.FullPath)
                            {
                                <div class="tree-cat-editor" @onclick:stopPropagation>
                                    <CategorySelector Current="@item.Category" ProjectId="@currentProjectId" FilePath="@item.FullPath" OnCategoryChanged="@(v => OnCategoryChanged(item, v))" />
                                    <button class="tree-cat-close" @onclick="() => _editingCategoryPath = null">✕</button>
                                </div>
                            }
                            @foreach (var child in item.Children)
                            {
                                var ccat = child.Category;
                                <div class="tree-item file tree-child @(child.FullPath == currentFilePath ? "active" : "")"
                                     @onclick="() => OpenFile(child)">
                                    <input type="checkbox" class="tree-checkbox"
                                           checked="@_selectedFiles.Contains(child.FullPath)"
                                           @onclick:stopPropagation
                                           @onchange="() => ToggleFileSelection(child.FullPath)" />
                                    <span class="tree-icon">📄</span>
                                    <span class="tree-name">@child.Name</span>
                                    @if (ccat != FileCategory.None)
                                    {
                                        <span class="tree-category-badge @FileCategoryHelper.CssClass(ccat)" title="@FileCategoryHelper.DisplayName(ccat)">@FileCategoryHelper.DisplayIcon(ccat)</span>
                                    }
                                    <button class="tree-cat-btn" @onclick="() => ToggleCategoryEditor(child)" @onclick:stopPropagation title="Kategorie">🏷</button>
                                    <button class="tree-rename" @onclick="() => BeginRename(child)" @onclick:stopPropagation title="@Loc["nav.projects.file.rename"]">✎</button>
                                </div>
                                @if (_editingCategoryPath == child.FullPath)
                                {
                                    <div class="tree-cat-editor" @onclick:stopPropagation>
                                        <CategorySelector Current="@child.Category" ProjectId="@currentProjectId" FilePath="@child.FullPath" OnCategoryChanged="@(v => OnCategoryChanged(child, v))" />
                                        <button class="tree-cat-close" @onclick="() => _editingCategoryPath = null">✕</button>
                                    </div>
                                }
                            }
                        }
                    </div>
                </div>
            }

@if (_showExportDialog)
{
    <div class="modal-overlay">
        <div class="modal-dialog" style="min-width:360px;">
            <div class="modal-title">@Loc["export.title"]</div>
            <div class="modal-body">
                <p style="margin-bottom:12px;">@Loc["export.file_count"]: <strong>@_selectedFiles.Count</strong></p>
                <div class="form-group" style="margin-bottom:12px;">
                    <label>@Loc["export.label.filename"]</label>
                    <input @bind="exportFileName" placeholder="@Loc["export.placeholder.filename"]" />
                    <small class="form-hint">@Loc["export.hint.filename"]</small>
                </div>
                <div class="form-group">
                    <label>@Loc["export.label.format"]</label>
                    <select class="form-select" @bind="exportFormat">
                        <option value="Html">HTML (.html)</option>
                        <option value="Markdown">@Loc["export.format.markdown"] (.md)</option>
                        <option value="Zip">@Loc["export.format.zip"] (.zip)</option>
                        <option value="Docx">DOCX (.docx)</option>
                        <option value="Pdf">PDF (.pdf)</option>
                    </select>
                </div>
            </div>
            <div class="modal-actions">
                <button @onclick='() => _showExportDialog = false'>@Loc["common.cancel"]</button>
                <button @onclick="DoExport" class="primary">@Loc["export.button.export"]</button>
            </div>
        </div>
    </div>
}

@if (showRenameDialog)
{
    <div class="modal-overlay">
        <div class="modal-dialog">
            <div class="modal-title">@Loc["nav.rename.title"]</div>
            <div class="modal-body">
                <div class="form-group">
                    <label>@Loc["nav.rename.label.new_name"]</label>
                    <input @bind="renameNewName" placeholder="@Loc["nav.rename.placeholder"]" />
                </div>
            </div>
            <div class="modal-actions">
                <button @onclick="CancelRename">@Loc["common.cancel"]</button>
                <button @onclick="ConfirmRename" disabled="@(string.IsNullOrWhiteSpace(renameNewName))" class="primary">@Loc["nav.rename.button.confirm"]</button>
            </div>
        </div>
    </div>
}

@if (showCopyProjectDialog)
{
    <div class="modal-overlay">
        <div class="modal-dialog">
            <div class="modal-title">@Loc["nav.copy_project.title"]</div>
            <div class="modal-body">
                <div class="form-group">
                    <label>@Loc["nav.copy_project.label.name"]</label>
                    <input @bind="copyProjectName" placeholder="@Loc["nav.copy_project.placeholder.name"]" />
                </div>
                <div class="form-group">
                    <label>@Loc["nav.copy_project.label.path"]</label>
                    <input @bind="copyProjectPath" placeholder="@Loc["nav.copy_project.placeholder.path"]" />
                    <small class="form-hint">Erlaubter Pfad: @ProjectPathHelper.AllowedBasePath</small>
                </div>
            </div>
            <div class="modal-actions">
                <button @onclick="CancelCopyProject">@Loc["common.cancel"]</button>
                <button @onclick="ConfirmCopyProject" disabled="@_copyProjectDisabled" class="primary">@Loc["nav.copy_project.button.copy"]</button>
            </div>
        </div>
    </div>
}

@if (showNewFileDialog)
{
    <div class="modal-overlay">
        <div class="modal-dialog">
            <div class="modal-title">@Loc["nav.newfile.title"]</div>
            <div class="modal-body">
                <div class="form-group">
                    <label>@Loc["nav.newfile.label.filename"]</label>
                    <input @bind="newFileName" placeholder="@Loc["nav.newfile.placeholder"]" />
                </div>
            </div>
            <div class="modal-actions">
                <button @onclick="CancelNewFile">@Loc["common.cancel"]</button>
                <button @onclick="ConfirmNewFile" disabled="@(string.IsNullOrWhiteSpace(newFileName))" class="primary">@Loc["nav.newfile.button.create"]</button>
            </div>
        </div>
    </div>
}

            @if (!string.IsNullOrEmpty(_username))
            {
                <div class="nav-section" style="border-top:1px solid var(--border-color);margin-top:8px;padding-top:4px;">
                    <div class="nav-section-header" style="cursor:default;">
                        <span style="font-size:11px;font-weight:normal;">@Loc["nav.user.logged_in_as"] @_username</span>
                    </div>
                    <div class="nav-section-body">
                        <button class="nav-item" @onclick="NavigateToSetup2FA">@Loc["nav.user.manage_2fa"]</button>
                        <button class="nav-item" @onclick="Logout">@Loc["nav.user.logout"]</button>
                    </div>
                </div>
            }

            <div class="sidebar-spacer"></div>
            <div class="sidebar-bottom-btns">
                <button class="sidebar-info-btn" @onclick="ToggleInfoOverlay" title="Info">i</button>
                <button class="sidebar-info-btn" @onclick='() => Navigation.NavigateTo("/help")' title="@Loc["nav.menu.extras.help"]">?</button>
            </div>

        </aside>
        }

        @if (_isAuthenticated)
        {
            <button class="hamburger" @onclick="ToggleMobileSidebar">☰</button>
        }
        @if (_showMobileSidebar)
        {
            <div class="mobile-sidebar-backdrop" @onclick="CloseMobileSidebar"></div>
        }
        <main class="detail-panel">
            @if (currentProjectId > 0)
            {
                <div class="main-header">
                    <h2>@currentProjectName</h2>
                </div>
            }
            @Body
        </main>
    </div>

    <footer class="status-bar">
        <span class="status-dot connected"></span>
        <span class="status-text">@OpState.StatusText</span>
        @if (OpState.IsBusy)
        {
            <progress value="@OpState.Progress" max="100"></progress>
        }
        @if (!string.IsNullOrEmpty(OpState.ThoughtText))
        {
            <span class="status-thought">@OpState.ThoughtText</span>
        }
    </footer>
</div>
}

<style>
    .tree-category-badge {
        font-size: 11px;
        margin-left: 4px;
        display: inline-flex;
        align-items: center;
    }
    .tree-cat-btn {
        background: none;
        border: none;
        cursor: pointer;
        font-size: 12px;
        padding: 0 2px;
        opacity: 0.5;
        line-height: 1;
    }
    .tree-cat-btn:hover {
        opacity: 1;
    }
    .tree-cat-editor {
        display: flex;
        align-items: center;
        gap: 4px;
        padding: 4px 8px 4px 24px;
        background: var(--bg-card, #f0f0f0);
        border-bottom: 1px solid var(--border-color, #ddd);
    }
    .tree-cat-close {
        background: none;
        border: none;
        cursor: pointer;
        font-size: 11px;
        color: var(--text-muted, #999);
        padding: 0 4px;
    }
    .tree-cat-close:hover {
        color: var(--text-main, #333);
    }
</style>

@if (_showInfoOverlay)
{
    <div class="splash-screen" @onclick="CloseInfoOverlay">
        <div class="splash-bg" style="background-image:url('/Assets/splash.jpg')"></div>
        <div class="splash-content info-content" @onclick:stopPropagation>
            <div class="splash-logo">
                <img src="/Assets/logo.jpg" alt="Author Buddy" />
            </div>
            <h1>Author Buddy</h1>
            <p class="info-version">Version 1.0</p>
            <p class="info-copyright">&copy; 2026 Author Buddy. Alle Rechte vorbehalten.</p>
            <p class="info-homepage">
                <a href="https://example.com" target="_blank" rel="noopener noreferrer">https://example.com</a>
            </p>
            <button class="info-close-btn" @onclick="CloseInfoOverlay">Schließen</button>
        </div>
    </div>
}

@code {
    private string _username = string.Empty;
    private bool _isAuthenticated;
    private List<UserRole> _currentUserRoles = new();
    private bool _isLoading = true;
    private bool _showInfoOverlay;
    private string? activeSection;
    private bool showProjectList;
    private List<Project>? projects;
    private List<FileTreeItem>? fileTree;
    private int currentProjectId;
    private string? currentProjectName;
    private string? currentFilePath;
    private string copyProjectName = string.Empty;
    private string copyProjectPath = string.Empty;
    private bool _copyProjectDisabled => string.IsNullOrWhiteSpace(copyProjectName) || string.IsNullOrWhiteSpace(copyProjectPath);
    private Project? copyProjectSource;
    private bool showRenameDialog;
    private string renameNewName = string.Empty;
    private FileTreeItem? renameTarget;
    private bool showNewFileDialog;
    private string newFileName = string.Empty;
    private FileTreeItem? newFileParentDir;
    private bool showCopyProjectDialog;
    private bool _showMobileSidebar;
    private Action? _opStateHandler;
    private string? _editingCategoryPath;
    private HashSet<string> _selectedFiles = new();
    private bool _showExportDialog;
    private string exportFileName = string.Empty;
    private string exportFormat = "Html";
    private long _lastThoughtScrollTicks;
    private string? _lastVisitedPage;

    [Inject]
    private NavigationManager Navigation { get; set; } = default!;

    [Inject]
    private IJSRuntime JS { get; set; } = default!;

    [Inject]
    private IExportService ExportService { get; set; } = default!;

        [Parameter] public string CurrentUserId { get; set; } = "user_123"; // Aus Auth-State lesen

    private PeriodicTimer? _timer;
    private CancellationTokenSource _cts = new();



    private async Task RestoreLocalStorageFromDbAsync()
    {
        var savedState = await SyncService.GetStateAsync();
        if (savedState != null && savedState.Count > 0)
        {
            await JS.InvokeVoidAsync("blazorLocalStorage.setAll", savedState);
        }
    }

    private async Task StartSyncLoopAsync()
    {
        try
        {
            while (await _timer!.WaitForNextTickAsync(_cts.Token))
            {
                await BackupLocalStorageToDbAsync();
            }
        }
        catch (OperationCanceledException)
        {
            // Normales Beenden des Timers bei Disposing
        }
    }

    private async Task BackupLocalStorageToDbAsync()
    {
        // Liest den kompletten LocalStorage aus JS
        var currentStorage = await JS.InvokeAsync<Dictionary<string, string>>("blazorLocalStorage.getAll");

        if (currentStorage != null)
        {
            await SyncService.SaveStateAsync(currentStorage);
        }
    }



    protected override async Task OnInitializedAsync()
    {
        _opStateHandler = () => InvokeAsync(StateHasChanged);
        OpState.OnChange += _opStateHandler;
        await SettingsService.InitializeAsync();
        await Loc.InitAsync();
        OpState.SetStatus(Loc["common.status.ready"]);
        Navigation.LocationChanged += OnLocationChanged;

        // Startup Setup Check
        _ = Task.Run(async () => 
        {
            var result = await SetupService.AnalyzeSettingsAsync();
            if (!result.IsCorrect)
            {
                OpState.SetStatus("Ollama-Einstellungen suboptimal. Setup-Assistent empfohlen.", false);
            }
        });
    }

    private async Task LoadCurrentUser()
    {
        var user = await AuthService.GetCurrentUserAsync();
        _username = user?.Name ?? string.Empty;
        _isAuthenticated = user != null;
        _currentUserRoles = user?.Roles ?? new List<UserRole> { UserRole.Author };
    }

    private async Task AutoLoadLastProject()
    {
        if (currentProjectId > 0) return;
        var lastId = await SettingsService.GetLastProjectIdAsync();
        if (lastId == null) return;
        var project = projects?.FirstOrDefault(p => p.Id == lastId.Value);
        if (project != null)
        {
            SettingsService.CurrentProjectId = project.Id;
            await SettingsService.InitializeAsync();
            await SelectProject(project);
        }
    }

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        var themeChanged = OllamaSettings.Theme != ThemeService.Theme;       


        if (firstRender)
        {
            // Restore last visited page from localStorage
            _lastVisitedPage = await JS.InvokeAsync<string>("localStorage.getItem", "last_visited_page");
            if (!string.IsNullOrEmpty(_lastVisitedPage))
            {
                Navigation.NavigateTo(_lastVisitedPage);
            }

            await ThemeService.ApplyTheme(OllamaSettings.Theme);

            // Auto-login runs AFTER circuit establishment (correct scoped services)
            await LoadCurrentUser();
 
             // 1. Beim Start: Daten aus DB holen & in LocalStorage schreiben
            await RestoreLocalStorageFromDbAsync();

            // 2. Timer starten: Alle 60 Sekunden sichern
            _timer = new PeriodicTimer(TimeSpan.FromMinutes(1));
            _ = StartSyncLoopAsync();
        
            if (_isAuthenticated)
            {
                await LoadProjects();
                await LoadProjectContext();
                await AutoLoadLastProject();
            }

            _isLoading = false;
            StateHasChanged();
        }

        if (OpState.IsBusy && OpState.ThoughtText.Length > 0)
        {
            var now = DateTime.UtcNow.Ticks;
            if (now - _lastThoughtScrollTicks > TimeSpan.TicksPerMillisecond * 80)
            {
                _lastThoughtScrollTicks = now;
                await JS.InvokeVoidAsync("eval", "var el=document.querySelector('.llm-thoughts'); if(el){el.scrollTop=el.scrollHeight;}");
            }
        }
    }

    public void Dispose()
    {
        if (_opStateHandler != null)
            OpState.OnChange -= _opStateHandler;
        Navigation.LocationChanged -= OnLocationChanged;
         // Aufräumen beim Verlassen der Seite / App-Ende
        _cts.Cancel();
        _cts.Dispose();
        _timer?.Dispose();
    }

    private async void OnLocationChanged(object? sender, Microsoft.AspNetCore.Components.Routing.LocationChangedEventArgs e)
    {
        await LoadCurrentUser();
        if (_isAuthenticated)
        {
            await LoadProjects();
            await LoadProjectContext();

            if (Navigation.Uri.Contains("quick-markdown") ||
                Navigation.Uri.Contains("chat") ||
                Navigation.Uri.Contains("editor/"))
            {
                // Save current page to localStorage
                await JS.InvokeVoidAsync("localStorage.setItem", "last_visited_page", Navigation.Uri);
            }

            await BackupLocalStorageToDbAsync();
        }
        StateHasChanged();
    }

    private async Task LoadProjectContext()
    {
        currentProjectId = SettingsService.CurrentProjectId ?? 0;
        currentFilePath = SettingsService.CurrentFilePath;

        if (currentProjectId > 0)
        {
            var project = await ProjectService.GetProjectAsync(currentProjectId);
            currentProjectName = project?.Name;
            await LoadFileTree();
        }
        else
        {
            currentProjectName = null;
            fileTree = null;
        }
    }

    private async Task LoadFileTree()
    {
        try
        {
            fileTree = await ProjectService.GetProjectFileTreeAsync(currentProjectId);
        }
        catch
        {
            fileTree = new();
        }
    }

    private void ToggleCategoryEditor(FileTreeItem item)
    {
        if (_editingCategoryPath == item.FullPath)
            _editingCategoryPath = null;
        else
            _editingCategoryPath = item.FullPath;
    }

    private void OnCategoryChanged(FileTreeItem item, FileCategory newCategory)
    {
        item.Category = newCategory;
        _editingCategoryPath = null;
    }

    private async Task LoadProjects()
    {
        try
        {
            var currentUser = AuthService.CurrentUser;
            int? filterUserId = currentUser?.IsAdministrator == true ? null : currentUser?.Id;
            projects = await ProjectService.GetAllProjectsAsync(filterUserId);
        }
        catch
        {
            projects = new();
        }
    }

    private void ToggleSection(string section)
    {
        activeSection = activeSection == section ? null : section;
    }

    private void ExitApp()
    {
        activeSection = null;
        Navigation.NavigateTo("/");
    }

    private void CreateNewProject()
    {
        activeSection = null;
        Navigation.NavigateTo("/editor/newproject");
    }

    private void BeginCopyProject(Project project)
    {
        copyProjectSource = project;
        copyProjectName = project.Name + " (Kopie)";
        copyProjectPath = ProjectPathHelper.SuggestPath(project.Name + "_Kopie");
        showCopyProjectDialog = true;
    }

    private void CancelCopyProject()
    {
        showCopyProjectDialog = false;
        copyProjectSource = null;
        copyProjectName = string.Empty;
        copyProjectPath = string.Empty;
    }

    private async Task ConfirmCopyProject()
    {
        if (copyProjectSource == null || string.IsNullOrWhiteSpace(copyProjectName) || string.IsNullOrWhiteSpace(copyProjectPath))
            return;

        if (!ProjectPathHelper.IsPathAllowed(copyProjectPath))
        {
            OpState.SetStatus($"⚠ Pfad nicht erlaubt. Verwende: {ProjectPathHelper.AllowedBasePath}", true);
            showCopyProjectDialog = false;
            return;
        }

        try
        {
            var userId = (await AuthService.GetCurrentUserAsync())?.Id;
            if (userId == null) return;

            OpState.SetStatus($"{Loc["nav.status.project_copied"]} {copyProjectName}...", true);
            StateHasChanged();

            var newId = await ProjectService.CopyProjectAsync(copyProjectSource.Id, copyProjectName, copyProjectPath, userId.Value);
            await LoadProjects();

            var newProject = projects?.FirstOrDefault(p => p.Id == newId);
            if (newProject != null)
            {
                await SelectProject(newProject);
            }

            OpState.SetStatus($"{Loc["nav.status.project_copied"]} {copyProjectName}", true);
        }
        catch (Exception ex)
        {
            OpState.SetStatus($"{Loc["common.error"]} {ex.Message}", true);
        }
        finally
        {
            OpState.SetStatus(OpState.StatusText, false);
            showCopyProjectDialog = false;
            copyProjectSource = null;
            copyProjectName = string.Empty;
            copyProjectPath = string.Empty;
            StateHasChanged();
        }
    }

    private void OpenEditor()
    {
        activeSection = null;
        Navigation.NavigateTo("/editor");
    }

    private void NavigateTo(string path)
    {
        activeSection = null;
        _showMobileSidebar = false;
        Navigation.NavigateTo(path);
    }

    private void ToggleMobileSidebar()
    {
        _showMobileSidebar = !_showMobileSidebar;
    }

    private void CloseMobileSidebar()
    {
        _showMobileSidebar = false;
    }

    private void ToggleInfoOverlay()
    {
        _showInfoOverlay = !_showInfoOverlay;
    }

    private void CloseInfoOverlay()
    {
        _showInfoOverlay = false;
    }

    private void NavigateToSetup2FA()
    {
        activeSection = null;
        Navigation.NavigateTo("/setup-2fa");
    }

    private async Task Logout()
    {
        activeSection = null;
        await AuthService.LogoutAsync();
        _username = string.Empty;
        AuthStateProvider.NotifyStateChanged();
        Navigation.NavigateTo("/login", true);
    }

    private async Task SelectProject(Project project)
    {
        activeSection = "files";
        SettingsService.CurrentProjectId = project.Id;
        currentProjectId = project.Id;
        currentProjectName = project.Name;
        SettingsService.CurrentFilePath = null;
        await SettingsService.SaveLastProjectIdAsync(project.Id);
        await SettingsService.LoadProjectSettingsAsync();
        await LoadFileTree();
        Navigation.NavigateTo($"/editor/index/{project.Id}");
    }

    private async Task RefreshFileTree()
    {
        await LoadFileTree();
        StateHasChanged();
    }

    private void BeginRename(FileTreeItem item)
    {
        renameTarget = item;
        renameNewName = item.Name;
        showRenameDialog = true;
    }

    private void CancelRename()
    {
        showRenameDialog = false;
        renameTarget = null;
        renameNewName = string.Empty;
    }

    private async Task ConfirmRename()
    {
        if (renameTarget == null || string.IsNullOrWhiteSpace(renameNewName)) return;

        try
        {
            var dir = Path.GetDirectoryName(renameTarget.FullPath)!;
            var newPath = Path.Combine(dir, renameNewName);
            if (File.Exists(newPath))
            {
                OpState.SetStatus(Loc["nav.error.file_exists"]);
                return;
            }
            File.Move(renameTarget.FullPath, newPath);

            if (currentFilePath == renameTarget.FullPath)
                SettingsService.CurrentFilePath = newPath;

            OpState.SetStatus($"{Loc["nav.status.renamed_to"]} {renameNewName}");
        }
        catch (Exception ex)
        {
            OpState.SetStatus($"{Loc["common.error"]} {ex.Message}");
        }
        finally
        {
            showRenameDialog = false;
            renameTarget = null;
            renameNewName = string.Empty;
            await LoadFileTree();
            StateHasChanged();
        }
    }

    private void BeginNewFile(FileTreeItem dir)
    {
        newFileParentDir = dir;
        newFileName = string.Empty;
        showNewFileDialog = true;
    }

    private void CancelNewFile()
    {
        showNewFileDialog = false;
        newFileParentDir = null;
        newFileName = string.Empty;
    }

    private async Task ConfirmNewFile()
    {
        if (newFileParentDir == null || string.IsNullOrWhiteSpace(newFileName)) return;

        try
        {
            var path = Path.Combine(newFileParentDir.FullPath, newFileName);
            if (!path.EndsWith(".md", StringComparison.OrdinalIgnoreCase))
                path += ".md";
            if (File.Exists(path))
            {
                OpState.SetStatus(Loc["nav.error.file_exists"]);
                return;
            }
            File.WriteAllText(path, $"# {Path.GetFileNameWithoutExtension(path)}\n\n");
            OpState.SetStatus($"{Loc["nav.status.created"]} {Path.GetFileName(path)}");
        }
        catch (Exception ex)
        {
            OpState.SetStatus($"{Loc["common.error"]} {ex.Message}");
        }
        finally
        {
            showNewFileDialog = false;
            newFileParentDir = null;
            newFileName = string.Empty;
            await LoadFileTree();
            StateHasChanged();
        }
    }

    private void OpenFile(FileTreeItem item)
    {
        if (item.IsDirectory) return;
        activeSection = null;
        SettingsService.CurrentFilePath = item.FullPath;
        Navigation.NavigateTo($"/editor/file/{currentProjectId}?t={DateTime.Now.Ticks}");
    }

    private void ToggleFileSelection(string path)
    {
        if (!_selectedFiles.Remove(path))
            _selectedFiles.Add(path);
    }

    private async Task DoExport()
    {
        var format = exportFormat switch
        {
            "Html" => ExportFormat.Html,
            "Markdown" => ExportFormat.Markdown,
            "Zip" => ExportFormat.Zip,
            "Docx" => ExportFormat.Docx,
            "Pdf" => ExportFormat.Pdf,
            _ => ExportFormat.Html
        };

        var ext = format switch
        {
            ExportFormat.Html => ".html",
            ExportFormat.Markdown => ".md",
            ExportFormat.Zip => ".zip",
            ExportFormat.Docx => ".docx",
            ExportFormat.Pdf => ".pdf",
            _ => ".html"
        };

        var name = string.IsNullOrWhiteSpace(exportFileName)
            ? $"Export_{DateTime.Now:yyyyMMdd_HHmmss}"
            : exportFileName;

        var data = await ExportService.ExportAsync(currentProjectId, _selectedFiles.ToList(), format);

        var mime = format switch
        {
            ExportFormat.Html => "text/html",
            ExportFormat.Markdown => "text/markdown",
            ExportFormat.Zip => "application/zip",
            ExportFormat.Docx => "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
            ExportFormat.Pdf => "application/pdf",
            _ => "text/html"
        };

        await JS.InvokeVoidAsync("downloadFile", $"{name}{ext}", Convert.ToBase64String(data), mime);

        _showExportDialog = false;
        _selectedFiles.Clear();
    }

}