@* FOCAS address picker:
     1. Static parameter group + parameter ID → axis:5 (always available).
     2. (DriverOperator-gated, when the driver supports online discovery) Browse the FixedTree
        device model captured by the universal DiscoveryDriverBrowser. FOCAS opens take a few
        seconds longer than other drivers — its FixedTree cache fills post-connect and the browser
        runs an UntilStable settle loop; the _opening spinner covers the wait. *@
@implements IAsyncDisposable
@using Microsoft.AspNetCore.Authorization
@using ZB.MOM.WW.OtOpcUa.AdminUI.Browsing
@using ZB.MOM.WW.OtOpcUa.AdminUI.Components.Shared.Drivers.Pickers
@using ZB.MOM.WW.OtOpcUa.Commons.Browsing
@inject IBrowserSessionService BrowserService
@inject AuthenticationStateProvider AuthState
@inject IAuthorizationService AuthorizationService

<div class="row g-3">
    <div class="col-md-4">
        <label class="form-label">Parameter group</label>
        <select class="form-select form-select-sm" @bind="_group" @bind:after="OnChangedAsync">
            <option value="axis">axis</option>
            <option value="spindle">spindle</option>
            <option value="program">program</option>
            <option value="status">status</option>
        </select>
    </div>
    <div class="col-md-3">
        <label class="form-label">Parameter ID</label>
        <input type="number" class="form-control form-control-sm" min="0"
               @bind="_parameterId" @bind:after="OnChangedAsync" />
    </div>
</div>

@if (_canBrowse)
{
    <div class="mt-3 d-flex align-items-center gap-2">
        @if (_token == Guid.Empty)
        {
            <button type="button" class="btn btn-outline-primary btn-sm"
                    disabled="@_opening" @onclick="OpenBrowseAsync">
                @if (_opening) { <span class="spinner-border spinner-border-sm me-1"></span> }
                Browse machine
            </button>
        }
        else
        {
            <span class="chip chip-ok">Browser open</span>
            <button type="button" class="btn btn-outline-secondary btn-sm"
                    disabled="@_opening" @onclick="RefreshBrowseAsync">
                @if (_opening) { <span class="spinner-border spinner-border-sm me-1"></span> }
                Refresh
            </button>
            <button type="button" class="btn btn-outline-secondary btn-sm" @onclick="CloseBrowseAsync">
                Close
            </button>
        }
        @if (_openError is not null) { <span class="chip chip-bad" title="@_openError">@TruncatedError()</span> }
    </div>

    @if (_token != Guid.Empty)
    {
        <div class="mt-2">
            <div class="form-text mb-1">Snapshot taken at open/refresh time — click Refresh to re-read the machine.</div>
            <DriverBrowseTree SessionToken="_token" OnNodeSelected="OnTreeSelectAsync"
                              SelectedNodeId="@_built" />
        </div>
    }
}

<div class="mt-3">
    <span class="text-muted small">Result:</span>
    <code class="mono ms-2">@_built</code>
</div>

@code {
    [Parameter] public string CurrentAddress { get; set; } = "";
    [Parameter] public EventCallback<string> CurrentAddressChanged { get; set; }
    /// <summary>Driver type used to open a universal browse session (defaults to FOCAS).</summary>
    [Parameter] public string DriverType { get; set; } = "FOCAS";
    /// <summary>Live accessor for the selected driver's DriverConfig JSON (browse connect config).</summary>
    [Parameter] public Func<string> GetConfigJson { get; set; } = () => "{}";

    private string _group = "axis";
    private int _parameterId = 0;
    private string _built = "";

    private Guid _token = Guid.Empty;
    private bool _opening;
    private bool _canBrowse;
    private string? _openError;

    protected override async Task OnInitializedAsync()
    {
        var auth = await AuthState.GetAuthenticationStateAsync();
        var authResult = await AuthorizationService.AuthorizeAsync(auth.User, null, AdminUiPolicies.DriverOperator);
        // CanBrowse constructs a throwaway driver — evaluate once, not per render.
        _canBrowse = authResult.Succeeded && BrowserService.CanBrowse(DriverType, GetConfigJson() ?? "{}");
        _built = FocasAddressBuilder.Build(_group, _parameterId);
        await CurrentAddressChanged.InvokeAsync(_built);
    }

    private async Task OpenBrowseAsync()
    {
        _opening = true; _openError = null; StateHasChanged();
        try
        {
            var json = GetConfigJson() ?? "{}";
            var result = await BrowserService.OpenAsync(DriverType, json, default);
            if (result.Ok) _token = result.Token;
            else _openError = result.Message;
        }
        finally { _opening = false; StateHasChanged(); }
    }

    private async Task RefreshBrowseAsync()
    {
        await CloseBrowseAsync();
        await OpenBrowseAsync();
    }

    private async Task CloseBrowseAsync()
    {
        var t = _token; _token = Guid.Empty; StateHasChanged();
        if (t != Guid.Empty) await BrowserService.CloseAsync(t);
    }

    private async Task OnTreeSelectAsync(BrowseNode node)
    {
        // Folders fire the same callback — commit only on a leaf. The captured NodeId is the
        // driver FullName (FixedTree address), which the group/id builder cannot reconstruct, so
        // commit it directly rather than through OnChangedAsync.
        if (node.Kind != BrowseNodeKind.Leaf) return;
        _built = node.NodeId;
        await CurrentAddressChanged.InvokeAsync(_built);
    }

    private async Task OnChangedAsync()
    {
        _built = FocasAddressBuilder.Build(_group, _parameterId);
        await CurrentAddressChanged.InvokeAsync(_built);
    }

    private string TruncatedError() =>
        _openError is null ? "" : (_openError.Length > 60 ? _openError[..60] + "…" : _openError);

    public ValueTask DisposeAsync()
    {
        if (_token != Guid.Empty)
        {
            // Fire-and-forget — don't block circuit teardown on a slow capture.
            _ = BrowserService.CloseAsync(_token);
        }
        return ValueTask.CompletedTask;
    }
}