@* TwinCAT address picker:
     1. Static ADS variable name (free text) → verbatim (always available).
     2. (DriverOperator-gated, when the driver supports online discovery) Browse the ADS symbol
        tree captured by the universal DiscoveryDriverBrowser. *@
@implements IAsyncDisposable
@using Microsoft.AspNetCore.Authorization
@using ZB.MOM.WW.OtOpcUa.AdminUI.Browsing
@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-8">
        <label class="form-label">ADS variable name</label>
        <input type="text" class="form-control form-control-sm mono" placeholder="MAIN.fValue"
               @bind="_varName" @bind:after="OnChangedAsync" />
        <div class="form-text">
            Full ADS symbol path, e.g. <code>MAIN.fValue</code> or <code>GVL.iCounter</code>.
        </div>
    </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 controller
            </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 controller.</div>
            <DriverBrowseTree SessionToken="_token" OnNodeSelected="OnTreeSelectAsync"
                              SelectedNodeId="@_varName" />
        </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 TwinCAT).</summary>
    [Parameter] public string DriverType { get; set; } = "TwinCAT";
    /// <summary>Live accessor for the selected driver's DriverConfig JSON (browse connect config).</summary>
    [Parameter] public Func<string> GetConfigJson { get; set; } = () => "{}";

    private string _varName = "";
    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 = _varName;
        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 ADS symbol path).
        if (node.Kind != BrowseNodeKind.Leaf) return;
        _varName = node.NodeId;
        await OnChangedAsync();
    }

    private async Task OnChangedAsync()
    {
        _built = _varName;
        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;
    }
}