/// <summary>
///     Top-level JSON viewer and editor component. The primary entry point for consumers.
/// </summary>
public sealed partial class MokaJsonViewer : ComponentBase, IMokaJsonViewer, IAsyncDisposable
{
#region IAsyncDisposable
    /// <inheritdoc/>
    public async ValueTask DisposeAsync()
    {
        if (_disposed)
        {
            return;
        }

        _disposed = true;
        _loadVersion++;
        _searchDebounceTimer?.Dispose();
        _toastTimer?.Dispose();
        if (_loadCts is not null)
        {
            await _loadCts.CancelAsync();
            _loadCts.Dispose();
            _loadCts = null;
        }

        if (_searchCts is not null)
        {
            await _searchCts.CancelAsync();
            _searchCts.Dispose();
            _searchCts = null;
        }

        if (_treeCts is not null)
        {
            await _treeCts.CancelAsync();
            _treeCts.Dispose();
        }

        if (_statsCts is not null)
        {
            await _statsCts.CancelAsync();
            _statsCts.Dispose();
        }

        if (_documentSource is not null)
        {
            await _documentSource.DisposeAsync();
        }
        else if (_documentManager is not null)
        {
            await _documentManager.DisposeAsync();
        }

        if (_contextMenu is not null)
        {
            await _contextMenu.DisposeAsync();
        }

        if (OptionsAccessor.Value.AggressiveCleanup)
        {
            GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }
    }

#endregion
#region Injected Services
#endregion
#region Parameters
    /// <summary>
    ///     The JSON string to display. Mutually exclusive with <see cref = "JsonStream"/>.
    /// </summary>
    [Parameter]
    public string? Json { get; set; }

    /// <summary>
    ///     A stream containing JSON data. Use this for large documents.
    /// </summary>
    /// <remarks>
    ///     A seekable stream (such as a <see cref = "FileStream"/>) above
    ///     <see cref = "MokaJsonViewerOptions.LazyParsingThresholdBytes"/> is read on demand, so it can be far larger
    ///     than memory. Keep it open and don't read from it while the viewer shows it. Other streams, such as
    ///     browser uploads, are copied to memory or a temp file first.
    /// </remarks>
    [Parameter]
    public Stream? JsonStream { get; set; }

    /// <summary>
    ///     Theme mode for the viewer.
    /// </summary>
    [Parameter]
    public MokaJsonTheme Theme { get; set; } = MokaJsonTheme.Auto;

    /// <summary>
    ///     Whether the toolbar is displayed. Default is <c>true</c>.
    /// </summary>
    [Parameter]
    public bool ShowToolbar { get; set; } = true;

    /// <summary>
    ///     Whether the bottom status bar is displayed. Default is <c>true</c>.
    /// </summary>
    [Parameter]
    public bool ShowBottomBar { get; set; } = true;

    /// <summary>
    ///     Whether the breadcrumb path is displayed. Default is <c>true</c>.
    /// </summary>
    [Parameter]
    public bool ShowBreadcrumb { get; set; } = true;

    /// <summary>
    ///     Whether to show line numbers in the gutter. Default is <c>true</c>.
    /// </summary>
    [Parameter]
    public bool ShowLineNumbers { get; set; }

    /// <summary>
    ///     Whether the viewer is read-only. Default is <c>true</c>.
    /// </summary>
    [Parameter]
    public bool ReadOnly { get; set; } = true;

    /// <summary>
    ///     Initial depth to expand. Default is <c>2</c>.
    /// </summary>
    [Parameter]
    public int MaxDepthExpanded { get; set; } = 2;

    /// <summary>
    ///     Height of the viewer. Default is "400px". Use "100%" for fill.
    /// </summary>
    [Parameter]
    public string Height { get; set; } = "400px";

    /// <summary>
    ///     Callback when a node is selected.
    /// </summary>
    [Parameter]
    public EventCallback<JsonNodeSelectedEventArgs> OnNodeSelected { get; set; }

    /// <summary>
    ///     Callback when the JSON content changes in edit mode.
    /// </summary>
    [Parameter]
    public EventCallback<JsonChangeEventArgs> OnJsonChanged { get; set; }

    /// <summary>
    ///     Two-way binding callback for <see cref = "Json"/>. Enables <c>@bind-Json</c>.
    /// </summary>
    [Parameter]
    public EventCallback<string?> JsonChanged { get; set; }

    /// <summary>
    ///     Callback when an error occurs.
    /// </summary>
    [Parameter]
    public EventCallback<JsonErrorEventArgs> OnError { get; set; }

    /// <summary>
    ///     Custom context menu actions to add.
    /// </summary>
    [Parameter]
    public IReadOnlyList<MokaJsonContextAction>? ContextMenuActions { get; set; }

    /// <summary>
    ///     Style of expand/collapse toggle indicators. Default is <see cref = "MokaJsonToggleStyle.Triangle"/>.
    /// </summary>
    [Parameter]
    public MokaJsonToggleStyle ToggleStyle { get; set; } = MokaJsonToggleStyle.Triangle;

    /// <summary>
    ///     Size of expand/collapse toggle indicators. Default is <see cref = "MokaJsonToggleSize.Small"/>.
    /// </summary>
    [Parameter]
    public MokaJsonToggleSize ToggleSize { get; set; } = MokaJsonToggleSize.Small;

    /// <summary>
    ///     Initial collapse behavior when a document is loaded. Default is <see cref = "MokaJsonCollapseMode.Depth"/>.
    /// </summary>
    [Parameter]
    public MokaJsonCollapseMode CollapseMode { get; set; } = MokaJsonCollapseMode.Depth;

    /// <summary>
    ///     Whether long values wrap to the next line. Default is <c>true</c>.
    /// </summary>
    [Parameter]
    public bool WordWrap { get; set; } = true;

    /// <summary>
    ///     Whether to show child count (e.g. "13 items") on collapsed containers. Default is <c>true</c>.
    /// </summary>
    [Parameter]
    public bool ShowChildCount { get; set; } = true;

    /// <summary>
    ///     How toolbar buttons are displayed. Overrides <see cref = "MokaJsonViewerOptions.DefaultToolbarMode"/>.
    ///     When <c>null</c>, the global default from DI is used.
    /// </summary>
    [Parameter]
    public MokaJsonToolbarMode? ToolbarMode { get; set; }

    /// <summary>
    ///     Extra content to render in the toolbar.
    /// </summary>
    [Parameter]
    public RenderFragment? ToolbarExtra { get; set; }

    /// <summary>
    ///     Whether the settings gear button is shown in the toolbar.
    ///     When <c>null</c>, the global default from DI (<see cref = "MokaJsonViewerOptions.ShowSettingsButton"/>) is used.
    /// </summary>
    [Parameter]
    public bool? ShowSettingsButton { get; set; }

    /// <summary>
    ///     Additional HTML attributes to apply to the root element.
    /// </summary>
    [Parameter(CaptureUnmatchedValues = true)]
    public Dictionary<string, object>? AdditionalAttributes { get; set; }
#endregion
#region State Fields
    /// <summary>
    ///     Debug stats from the lazy source, set only when MOKA_DEBUG_LAZY env var is set.
    ///     Used by Moka.Blazor.Json.Diagnostics overlay.
    /// </summary>
    public LazyDebugStats? DebugStats { get; private set; }

#endregion
#region Computed Properties
#endregion
#region Lifecycle
    /// <inheritdoc/>
    protected override void OnInitialized()
    {
        MokaJsonViewerOptions options = OptionsAccessor.Value;
        if (!_parentSettings.ContainsKey(nameof(Theme)))
        {
            Theme = options.DefaultTheme;
        }

        if (!_parentSettings.ContainsKey(nameof(MaxDepthExpanded)))
        {
            MaxDepthExpanded = options.DefaultExpandDepth;
        }

        BuildContextActions();
    }

    /// <inheritdoc/>
    protected override bool ShouldRender()
    {
        if (_skipNextRender)
        {
            _skipNextRender = false;
            return false;
        }

        return true;
    }

    /// <inheritdoc/>
    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender && !_cssReady)
        {
            _cssReady = true;
            StateHasChanged();
        }

        if (!_keyGuardsAttached)
        {
            _keyGuardsAttached = true;
            await TryInteropAsync(() => Interop.AttachKeyGuardsAsync(_viewerRef));
        }

        if (_focusViewerAfterRender)
        {
            _focusViewerAfterRender = false;
            await TryInteropAsync(() => _viewerRef.FocusAsync(preventScroll: true));
        }

        if (_pendingRevealPath is not null && _viewport is not null && _flatNodes is not null)
        {
            string path = _pendingRevealPath;
            _pendingRevealPath = null;
            int row = _flatNodes.FindIndex(n => !n.IsClosingBracket && n.Path == path);
            if (row >= 0)
            {
                MokaJsonTreeViewport viewport = _viewport;
                await TryInteropAsync(() => viewport.ScrollToRowAsync(row));
            }
        }
    }

    /// <inheritdoc/>
    protected override async Task OnParametersSetAsync()
    {
        if (ContextMenuActions != _previousContextMenuActions)
        {
            _previousContextMenuActions = ContextMenuActions;
            BuildContextActions();
        }

        if (Json != _previousJson || JsonStream != _previousStream)
        {
            _previousJson = Json;
            _previousStream = JsonStream;
            // The interactive render starts over with a new instance. Work done now would be thrown away, and it
            // would hold up the page's first response. A forward-only stream can also only be read once.
            if (IsPrerendering && (JsonStream is not null || Json?.Length > OptionsAccessor.Value.LazyParsingThresholdBytes))
            {
                _isLoading = true;
                return;
            }

            await LoadJsonAsync();
        }
    }

#endregion
#region Toolbar Handlers
#endregion
#region Search Handlers
#endregion
#region Tree Interaction Handlers
#region Settings Panel
    /// <inheritdoc/>
    public override Task SetParametersAsync(ParameterView parameters)
    {
        if (_userSettings.Count == 0)
        {
            RecordParentSettings(parameters);
            return base.SetParametersAsync(parameters);
        }

        var values = new Dictionary<string, object?>(parameters.ToDictionary());
        foreach ((string name, object? userValue)in _userSettings.ToList())
        {
            if (!values.TryGetValue(name, out object? incoming))
            {
                continue;
            }

            if (_parentSettings.TryGetValue(name, out object? previous) && Equals(previous, incoming))
            {
                values[name] = userValue;
            }
            else
            {
                _userSettings.Remove(name);
            }
        }

        RecordParentSettings(parameters);
        return base.SetParametersAsync(ParameterView.FromDictionary(values));
    }

#endregion
#endregion
#region Context Action Builders
#endregion
#region Private Helpers
#endregion
#region IMokaJsonViewer Implementation
    /// <inheritdoc/>
    public async ValueTask NavigateToAsync(string jsonPointer, CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(jsonPointer);
        await InvokeAsync(async () =>
        {
            if (!IsWithinScope(jsonPointer))
            {
                _scopedPath = null;
            }

            _treeFlattener.ExpandAncestors(jsonPointer);
            await HandleSelect(jsonPointer);
            await RefreshFlatNodesAsync(jsonPointer);
        });
    }

    /// <inheritdoc/>
    public void ExpandToDepth(int depth)
    {
        if (_documentSource is not { } source)
        {
            return;
        }

        if (_isLazyMode)
        {
            RunDetached(async () =>
            {
                await Task.Run(() => _treeFlattener.ExpandToDepth(source, depth, JsonExpandLimits.LargeDocument));
                await InvokeAsync(() => RefreshFlatNodesAsync());
            });
            return;
        }

        _treeFlattener.ExpandToDepth(source, depth);
        RefreshFlatNodes();
    }

    /// <inheritdoc/>
    public void CollapseAll()
    {
        _treeFlattener.CollapseAll();
        RefreshFlatNodes();
    }

    /// <inheritdoc/>
    public void ExpandAll() => RunDetached(ExpandAllAsync);
    /// <inheritdoc/>
    public ValueTask ExpandAllAsync() => new(InvokeAsync(HandleExpandAll));
    /// <inheritdoc/>
    public async ValueTask<int> SearchAsync(string query, JsonSearchOptions? options = null, CancellationToken cancellationToken = default)
    {
        JsonSearchOptions searchOptions = options ?? new JsonSearchOptions();
        int matchCount = 0;
        await InvokeAsync(async () =>
        {
            _searchQuery = query;
            _searchCaseSensitive = searchOptions.CaseSensitive;
            _searchUseRegex = searchOptions.UseRegex;
            _searchRequestId++;
            _searchDebounceTimer?.Dispose();
            _searchDebounceTimer = null;
            CancelSearch();
            matchCount = await RunSearchAsync(query, searchOptions, true, cancellationToken);
        });
        return matchCount;
    }

    /// <inheritdoc/>
    public void NextMatch() => RunDetached(NextMatchAsync);
    /// <inheritdoc/>
    public ValueTask NextMatchAsync() => new(InvokeAsync(() => NavigateSearchAsync(true)));
    /// <inheritdoc/>
    public void PreviousMatch() => RunDetached(PreviousMatchAsync);
    /// <inheritdoc/>
    public ValueTask PreviousMatchAsync() => new(InvokeAsync(() => NavigateSearchAsync(false)));
    /// <inheritdoc/>
    public void ClearSearch()
    {
        _searchQuery = null;
        ResetSearchState();
        RefreshFlatNodes();
    }

    /// <inheritdoc/>
    public void Undo() => RunDetached(UndoAsync);
    /// <inheritdoc/>
    public ValueTask UndoAsync() => new(InvokeAsync(UndoCoreAsync));
    /// <inheritdoc/>
    public void Redo() => RunDetached(RedoAsync);
    /// <inheritdoc/>
    public ValueTask RedoAsync() => new(InvokeAsync(RedoCoreAsync));
    /// <inheritdoc/>
    public string GetJson(bool indented = true) => _documentSource?.GetJsonString(indented) ?? string.Empty;
    /// <inheritdoc/>
    public string? SelectedPath { get; private set; }
    /// <inheritdoc/>
    public bool IsEditing => _activeEdit is not null;
#endregion
}