@page "/Services"
@using LibSystemdCli.Models
@using System.Text.RegularExpressions
@using SystemdCtl.Client.Abstractions
@* @attribute [StreamRendering] *@
@rendermode InteractiveWebAssembly
@inject NavigationManager NavigationManager


<PageTitle>Services</PageTitle>

<h1>Services</h1>

<span>
    <label>Type: </label>
    <InputSelect @bind-Value="TypeFilter">
        <option value="">All</option>
        @foreach (var i in UnitTypes) {
            <option value="@i">@Capitalize(i)</option>
        }
    </InputSelect>
</span>
<span>
    <InputCheckbox @bind-Value="@ShowSystem"></InputCheckbox>
    <label>Show system services</label>
</span>

@if (filteredItems is not { Count: > 0 }) {
    <p>
        <em>Loading...</em>
    </p>
}
else {
    <table class="table">
        <thead>
            <tr>
                <th>Service</th>
                <th>Description</th>
                <th>Status</th>
                <th></th>
            </tr>
        </thead>
        <tbody>
            @foreach (var unit in filteredItems) {
                <tr>
                    <td>@unit.Unit</td>
                    <td>@unit.Description</td>
                    <td>@unit.Active</td>
                    <td><LinkButton href="@($"/Service/{unit.Unit}/Manage")">Manage</LinkButton></td>
                </tr>
                @foreach (var frag in unit.FragmentPaths) {
                    <tr>
                        <td/>
                        <td>@frag</td>
                        <td/>
                    </tr>
                }
            }
        </tbody>
    </table>
}

@code {

    private static Regex[] AlwaysHidden = new Regex[] {
        //services
        new Regex(@"^systemd-fsck@.*\.service$"),
        new Regex(@"^modprobe@.*\.service$"),
        new Regex(@"^xen.*\.service$"),
        new Regex(@"^virt.*\.service$"),
        new Regex(@"^libvirt.*\.service$"),
        new Regex(@"^systemd-.*\.service$"),
        //sockets
        new Regex(@"^virt.*\.socket$"),
        new Regex(@"^systemd.*\.socket$"),
        new Regex(@"^libvirt.*\.socket$"),
        //device
        new(@"^dev-disk-by.*\.device$"),
        new(@"^sys-device.*\.device$"),
        new(@".*-by\\x2d.*\.device$"),
        //mount
        new(@"^run-credentials.*\.mount"),
        //target
        new(@"^blockdev@dev-disk-by.*\.target$")
    };

    private static bool IsClient => !Environment.CommandLine.Contains("/");
    private List<SystemdUnitListItem>? items = new();
    private List<SystemdUnitListItem>? filteredItems = new();
    private List<string> UnitTypes = new();
    private string _typeFilter = "";
    private bool _showSystem;

    public string TypeFilter {
        get => _typeFilter;
        set {
            _typeFilter = value;
            FilterItems();
        }
    }

    public bool ShowSystem {
        get => _showSystem;
        set {
            _showSystem = value;
            FilterItems();
        }
    }

    protected override async Task OnInitializedAsync() {
        // await Task.Delay(500);

        // items = await SystemdExecutor.GetUnits();
        Console.WriteLine("OnInitializedAsync");
        await ReloadItems();
    }

    private async Task ReloadItems() {
        if (!IsClient) return;

        items.Clear();
        var Http = new StreamingHttpClient() { BaseAddress = new Uri(NavigationManager.BaseUri) };
        var _items = Http.GetAsyncEnumerableFromJsonAsync<SystemdUnitListItem>("/api/listUnits");
        await foreach (var item in _items) {
            items.Add(item);
            if (items.Count % 10 == 0)
                await FilterItems();
        }

        await FilterItems();
    }

    private async Task FilterItems() {
        var filter = items.Where(x => true);//!AlwaysHidden.Any(y => y.IsMatch(x.Unit)));
        if (!_showSystem)
            filter = filter.Where(x => !x.IsSystem);

        UnitTypes = filter.Select(x => x.UnitType).Distinct().ToList();
        filter = filter.Where(x => x.Unit.EndsWith(TypeFilter)).ToList();

        filteredItems = filter.ToList();
        StateHasChanged();
    }

    private string Capitalize(string input) {
        return input switch {
            null => throw new ArgumentNullException(nameof(input)),
            "" => throw new ArgumentException($"{nameof(input)} cannot be empty", nameof(input)),
            _ => input.First().ToString().ToUpper() + input[1..]
        };
    }

}