@using LucideBlazor
@using Microsoft.AspNetCore.Authorization
@using Microsoft.AspNetCore.Components.Authorization
@using Moonlight.Frontend.UI.Admin.Modals
@using Moonlight.Shared
@using Moonlight.Shared.Http
@using Moonlight.Shared.Http.Requests
@using Moonlight.Shared.Http.Responses
@using Moonlight.Shared.Http.Responses.Admin.ApiKeys
@using ShadcnBlazor.DataGrids
@using ShadcnBlazor.Dropdowns
@using ShadcnBlazor.Extras.AlertDialogs
@using ShadcnBlazor.Extras.Dialogs
@using ShadcnBlazor.Tabels
@using ShadcnBlazor.Buttons
@using ShadcnBlazor.Extras.Toasts

@inject ToastService ToastService
@inject DialogService DialogService
@inject AlertDialogService AlertDialogService
@inject IAuthorizationService AuthorizationService
@inject HttpClient HttpClient

<div class="flex flex-row justify-between mt-5">
    <div class="flex flex-col">
        <h1 class="text-xl font-semibold">API Keys</h1>
        <div class="text-muted-foreground">
            Manage API keys for your instance
        </div>
    </div>
    <div class="flex flex-row gap-x-1.5">
        <Button @onclick="CreateAsync" disabled="@(!CreateAccess.Succeeded)">
            <PlusIcon/>
            Create
        </Button>
    </div>
</div>

<div class="mt-3">
    <DataGrid @ref="Grid" TGridItem="ApiKeyDto" Loader="LoadAsync" PageSize="10" ClassName="bg-card">
        <PropertyColumn Field="k => k.Id"/>
        <TemplateColumn Identifier="@nameof(ApiKeyDto.Name)" IsFilterable="true" Title="Name">
            <CellTemplate>
                <TableCell>
                    <a class="text-primary" href="#" @onclick="() => EditAsync(context)" @onclick:preventDefault>
                        @context.Name
                    </a>
                </TableCell>
            </CellTemplate>
        </TemplateColumn>
        <PropertyColumn IsFilterable="true"
                        Identifier="@nameof(ApiKeyDto.Description)" Field="k => k.Description" HeadClassName="hidden lg:table-cell" CellClassName="hidden lg:table-cell" />
        <TemplateColumn Identifier="@nameof(ApiKeyDto.ValidUntil)" Title="Valid until" HeadClassName="hidden lg:table-cell">
            <CellTemplate>
                <TableCell ClassName="hidden lg:table-cell">
                    @{
                        var diff = context.ValidUntil - DateTimeOffset.UtcNow;
                        var text = string.Format(diff.TotalSeconds < 0 ? "Expired since {0}" : "Expires in {0}", Formatter.FormatDuration(diff));
                    }
                    
                    <span>
                        @text
                    </span>
                </TableCell>
            </CellTemplate>
        </TemplateColumn>
        <TemplateColumn>
            <CellTemplate>
                <TableCell>
                    <div class="flex flex-row items-center justify-end me-3">
                        <DropdownMenu>
                            <DropdownMenuTrigger>
                                <Slot Context="dropdownSlot">
                                    <Button Size="ButtonSize.IconSm" Variant="ButtonVariant.Ghost"
                                            @attributes="dropdownSlot">
                                        <EllipsisIcon/>
                                    </Button>
                                </Slot>
                            </DropdownMenuTrigger>
                            <DropdownMenuContent SideOffset="2">
                                <DropdownMenuItem OnClick="() => EditAsync(context)" Disabled="@(!EditAccess.Succeeded)">
                                    Edit
                                    <DropdownMenuShortcut>
                                        <PenIcon/>
                                    </DropdownMenuShortcut>
                                </DropdownMenuItem>
                                <DropdownMenuItem OnClick="() => DeleteAsync(context)"
                                                  Variant="DropdownMenuItemVariant.Destructive"
                                                  Disabled="@(!DeleteAccess.Succeeded)">
                                    Delete
                                    <DropdownMenuShortcut>
                                        <TrashIcon/>
                                    </DropdownMenuShortcut>
                                </DropdownMenuItem>
                            </DropdownMenuContent>
                        </DropdownMenu>
                    </div>
                </TableCell>
            </CellTemplate>
        </TemplateColumn>
    </DataGrid>
</div>

@code
{
    [CascadingParameter] public Task<AuthenticationState> AuthState { get; set; }
    
    private DataGrid<ApiKeyDto> Grid;
    
    private AuthorizationResult EditAccess;
    private AuthorizationResult DeleteAccess;
    private AuthorizationResult CreateAccess;

    protected override async Task OnInitializedAsync()
    {
        var authState = await AuthState;
        
        EditAccess = await AuthorizationService.AuthorizeAsync(authState.User, Permissions.ApiKeys.Edit);
        DeleteAccess = await AuthorizationService.AuthorizeAsync(authState.User, Permissions.ApiKeys.Delete);
        CreateAccess = await AuthorizationService.AuthorizeAsync(authState.User, Permissions.ApiKeys.Create);
    }

    private async Task<DataGridResponse<ApiKeyDto>> LoadAsync(DataGridRequest<ApiKeyDto> request)
    {
        var query = $"?startIndex={request.StartIndex}&length={request.Length}";
        var filterOptions = request.Filters.Count > 0 ? new FilterOptions(request.Filters) : null;

        var response = await HttpClient.GetFromJsonAsync<PagedData<ApiKeyDto>>(
            $"api/admin/apiKeys{query}&filterOptions={filterOptions}",
            SerializationContext.Default.Options
        );

        return new DataGridResponse<ApiKeyDto>(response!.Data, response.TotalLength);
    }

    private async Task CreateAsync()
    {
        await DialogService.LaunchAsync<CreateApiKeyDialog>(parameters =>
        {
            parameters[nameof(CreateApiKeyDialog.OnSubmit)] = async () =>
            {
                await Grid.RefreshAsync();
            };
        });
    }

    private async Task EditAsync(ApiKeyDto key)
    {
        await DialogService.LaunchAsync<UpdateApiKeyDialog>(parameters =>
        {
            parameters[nameof(UpdateApiKeyDialog.Key)] = key;
            parameters[nameof(UpdateApiKeyDialog.OnSubmit)] = async () =>
            {
                await Grid.RefreshAsync();
            };
        });
    }

    private async Task DeleteAsync(ApiKeyDto key)
    {
        await AlertDialogService.ConfirmDangerAsync(
            $"Deletion of API key {key.Name}",
            "Do you really want to delete this API key? This action cannot be undone",
            async () =>
            {
                var response = await HttpClient.DeleteAsync($"api/admin/apiKeys/{key.Id}");
                response.EnsureSuccessStatusCode();

                await ToastService.SuccessAsync("API Key deletion", $"Successfully deleted API key {key.Name}");

                await Grid.RefreshAsync();
            }
        );
    }
}