@page "/media/libraries"
@using MediatR.Courier
@using ErsatzTV.Application.Libraries
@using ErsatzTV.Application.Libraries.Queries
@using ErsatzTV.Application.MediaSources.Commands
@using ErsatzTV.Application.Plex.Commands
@using ErsatzTV.Core.Metadata
@using System.Threading
@using ErsatzTV.Application.Jellyfin
@using ErsatzTV.Application.Jellyfin.Commands
@using ErsatzTV.Application.Emby
@using ErsatzTV.Application.Emby.Commands
@implements IDisposable
@inject IMediator _mediator
@inject IEntityLocker _locker
@inject ChannelWriter<IBackgroundServiceRequest> _workerChannel
@inject ChannelWriter<IPlexBackgroundServiceRequest> _plexWorkerChannel
@inject ChannelWriter<IJellyfinBackgroundServiceRequest> _jellyfinWorkerChannel
@inject ChannelWriter<IEmbyBackgroundServiceRequest> _embyWorkerChannel
@inject ICourier _courier

<MudContainer MaxWidth="MaxWidth.ExtraLarge" Class="pt-8">
    <MudTable Hover="true" Items="_libraries" Dense="true">
        <ToolBarContent>
            <MudText Typo="Typo.h6">Libraries</MudText>
        </ToolBarContent>
        <ColGroup>
            <col/>
            <col/>
            <col/>
            <col style="width: 180px;"/>
        </ColGroup>
        <HeaderContent>
            <MudTh>Library Kind</MudTh>
            <MudTh>Name</MudTh>
            <MudTh>Media Kind</MudTh>
            <MudTh/>
        </HeaderContent>
        <RowTemplate>
            <MudTd DataLabel="Library Kind">@context.LibraryKind</MudTd>
            <MudTd DataLabel="Name">@context.Name</MudTd>
            <MudTd DataLabel="Media Kind">@context.MediaKind</MudTd>
            <MudTd>
                <div style="align-items: center; display: flex;">
                    @if (_locker.IsLibraryLocked(context.Id))
                    {
                        <div style="width: 48px">
                            @if (_progressByLibrary[context.Id] > 0)
                            {
                                <MudText Color="Color.Primary">
                                    @($"{_progressByLibrary[context.Id]} %")
                                </MudText>
                            }
                        </div>
                        <div style="align-items: center; display: flex; height: 48px; justify-content: center; width: 48px;">
                            <MudProgressCircular Color="Color.Primary" Size="Size.Small" Indeterminate="true"/>
                        </div>
                    }
                    else
                    {
                        <div style="width: 48px"></div>
                        <MudTooltip Text="Scan Library">
                            <MudIconButton Icon="@Icons.Material.Filled.Refresh"
                                           Disabled="@_locker.IsLibraryLocked(context.Id)"
                                           OnClick="@(_ => ScanLibrary(context))">
                            </MudIconButton>
                        </MudTooltip>
                    }
                    <MudTooltip Text="Search Library">
                        <MudIconButton Icon="@Icons.Material.Filled.Search"
                                       Link="@($"/search?query=library_id%3a{context.Id}")">
                        </MudIconButton>
                    </MudTooltip>
                </div>
            </MudTd>
        </RowTemplate>
    </MudTable>
</MudContainer>

@code {
    private IList<LibraryViewModel> _libraries;
    private Dictionary<int, int> _progressByLibrary;

    protected override void OnInitialized()
    {
        _locker.OnLibraryChanged += LockChanged;
        _courier.Subscribe<LibraryScanProgress>(HandleScanProgress);
    }

    protected override async Task OnParametersSetAsync() => await LoadLibraries();

    private async Task LoadLibraries()
    {
        _libraries = await _mediator.Send(new GetAllLibraries());
        _progressByLibrary = _libraries.ToDictionary(vm => vm.Id, _ => 0);
    }

    private async Task ScanLibrary(LibraryViewModel library)
    {
        if (_locker.LockLibrary(library.Id))
        {
            switch (library)
            {
                case LocalLibraryViewModel:
                    await _workerChannel.WriteAsync(new ForceScanLocalLibrary(library.Id));
                    break;
                case PlexLibraryViewModel:
                    await _plexWorkerChannel.WriteAsync(new ForceSynchronizePlexLibraryById(library.Id));
                    break;
                case JellyfinLibraryViewModel:
                    await _jellyfinWorkerChannel.WriteAsync(new ForceSynchronizeJellyfinLibraryById(library.Id));
                    break;
                case EmbyLibraryViewModel:
                    await _embyWorkerChannel.WriteAsync(new ForceSynchronizeEmbyLibraryById(library.Id));
                    break;
            }

            StateHasChanged();
        }
    }

    private void LockChanged(object sender, EventArgs e) =>
        InvokeAsync(StateHasChanged);

    private async Task HandleScanProgress(LibraryScanProgress libraryScanProgress, CancellationToken cancellationToken)
    {
        try
        {
            if (_progressByLibrary != null && _progressByLibrary.ContainsKey(libraryScanProgress.LibraryId))
            {
                _progressByLibrary[libraryScanProgress.LibraryId] = (int) (libraryScanProgress.Progress * 100);
                await InvokeAsync(StateHasChanged);
            }
        }
        catch (Exception)
        {
    // ignore
        }
    }

    void IDisposable.Dispose()
    {
        _locker.OnLibraryChanged -= LockChanged;
        _courier.UnSubscribe<LibraryScanProgress>(HandleScanProgress);
    }

}