@page "/storage"
@inject IHttpClientFactory HttpFactory
@inject NavigationManager Nav
@using System.Net.Http.Json
@using Pldpro.Web.Models

<PageTitle>Storage</PageTitle>

<MudText Typo="Typo.h4" GutterBottom="true">S3 Storage</MudText>

<MudPaper Class="pa-4 mb-4" Elevation="0">
    <MudStack Row="true" Spacing="2">
        <MudText Typo="Typo.h6">Buckets</MudText>
        <MudSpacer />
        <MudTextField @bind-Value="newBucketName" Placeholder="neuer Bucketname" Variant="Variant.Outlined" />
        <MudButton Color="Color.Primary" Variant="Variant.Filled" OnClick="CreateBucket">Erstellen</MudButton>
    </MudStack>

    <MudList T="BucketVm" Dense="true" Class="mt-2">
        @if (buckets is null)
        {
            <MudListItem>(lädt...)</MudListItem>
        }
        else if (!buckets.Any())
        {
            <MudListItem>(keine Buckets)</MudListItem>
        }
        else
        {
            @foreach (var b in buckets)
            {
                <MudListItem OnClick="@(() => SelectBucket(b.Name))" Class="cursor-pointer"
                             Style="@(selectedBucket == b.Name ? "font-weight:600" : "")">
                    <MudIcon Icon="@Icons.Material.Filled.Inventory2" Class="me-2" />
                    @b.Name
                </MudListItem>
            }
        }
    </MudList>
</MudPaper>

@if (!string.IsNullOrEmpty(selectedBucket))
{
    <MudPaper Class="pa-4" Elevation="0">
        <MudStack Row="true" Spacing="2">
            <MudText Typo="Typo.h6">Objekte in '@selectedBucket'</MudText>
            <MudSpacer />
            <MudTextField @bind-Value="uploadPath" Placeholder="Pfad (optional, z.B. docs/2026)" Variant="Variant.Outlined" />
            <InputFile OnChange="OnFilesSelected" />
        </MudStack>

        <MudTable Items="objects" Hover="true" Dense="true" Class="mt-2">
            <HeaderContent>
                <MudTh>Key</MudTh>
                <MudTh>Größe</MudTh>
                <MudTh>Geändert</MudTh>
                <MudTh></MudTh>
                <MudTh></MudTh>
                <MudTh></MudTh>
            </HeaderContent>
            <RowTemplate>
                <MudTd DataLabel="Key">@context.Key</MudTd>
                <MudTd DataLabel="Größe">@context.Size</MudTd>
                <MudTd DataLabel="Geändert">@context.LastModified</MudTd>
                <MudTd>
                    <MudButton Variant="Variant.Text" Color="Color.Primary" Href="@GetDownloadUrl(context.Key)" Target="_blank" StartIcon="@Icons.Material.Filled.Download">Download</MudButton>
                </MudTd>
                <MudTd>
                    @* Name = letzter Segmentteil des Keys *@
                    @{
                        var fileName = context.Key.Split('/', StringSplitOptions.RemoveEmptyEntries).LastOrDefault() ?? context.Key;
                        var encodedName = Uri.EscapeDataString(fileName);
                    }
                    <MudButton Variant="Variant.Outlined" Color="Color.Primary" Href="@($"/api/storage/buckets/{selectedBucket}/files/{encodedName}/download")" Target="_blank" StartIcon="@Icons.Material.Filled.Download">Download by Name</MudButton>
                </MudTd>

                <MudTd>
                    <MudButton Variant="Variant.Text" Color="Color.Error" StartIcon="@Icons.Material.Filled.Delete"
                               OnClick="@(async () => await ConfirmAndDelete(context.Key))">
                        Löschen
                    </MudButton>
                </MudTd>
            </RowTemplate>
        </MudTable>
    </MudPaper>
    }

@code {
    private record BucketVm(string Name, DateTime? CreationDate);
    private record ObjectVm(string Key, long? Size, DateTime? LastModified);

    private List<BucketVm>? buckets;
    private List<ObjectVm>? objects;
    private string? selectedBucket;
    private string newBucketName = "";
    private string? uploadPath; // optionaler Pfad
    private const long StreamLimit = 512L * 1024 * 1024; // 512 MB (Program.cs erhöht Multipart-Limit)

    private HttpClient? Http;

    protected override Task OnInitializedAsync()
    {
        Http = HttpFactory.CreateClient();
        Http.BaseAddress = new Uri(Nav.BaseUri); // für relative URLs wie "/api/storage/..."
        return LoadBuckets();
    }



    private async Task LoadBuckets()
    {
        var data = await Http.GetFromJsonAsync<List<BucketVm>>("/api/storage/buckets");
        buckets = data ?? new();
        StateHasChanged();
    }

    private async Task SelectBucket(string name)
    {
        selectedBucket = name;
        objects = await Http.GetFromJsonAsync<List<ObjectVm>>($"/api/storage/buckets/{name}/objects") ?? new();
    }

    private async Task CreateBucket()
    {
        if (string.IsNullOrWhiteSpace(newBucketName)) return;
        await Http.PostAsJsonAsync("/api/storage/buckets", new S3CreateBucketDto { BucketName = newBucketName! });
        newBucketName = "";
        await LoadBuckets();
    }

    private async Task OnFilesSelected(InputFileChangeEventArgs e)
    {
        if (string.IsNullOrEmpty(selectedBucket)) return;

        foreach (var file in e.GetMultipleFiles())
        {
            using var stream = file.OpenReadStream(StreamLimit);
            using var content = new MultipartFormDataContent();
            content.Add(new StreamContent(stream), "file", file.Name);

            if (!string.IsNullOrWhiteSpace(uploadPath))
                content.Add(new StringContent(uploadPath!), "path");

            var resp = await Http.PostAsync($"/api/storage/buckets/{selectedBucket}/upload", content);
            resp.EnsureSuccessStatusCode();
        }
        // Refresh list
        objects = await Http.GetFromJsonAsync<List<ObjectVm>>($"/api/storage/buckets/{selectedBucket}/objects") ?? new();

        }
    private string GetDownloadUrl(string key)
    {
        // URL-encode für sichere Übergabe in Catch-all Route
        var encodedKey = Uri.EscapeDataString(key);
        return $"/api/storage/buckets/{selectedBucket}/download/{encodedKey}";
    }


    private async Task ConfirmAndDelete(string key)
    {
        // Simple Bestätigung; alternativ MudDialog verwenden
        var really = await JSConfirm($"Objekt löschen?\n\nBucket: {selectedBucket}\nKey: {key}");
        if (really)
        {
            await DeleteObject(key);
        }
    }


    private async Task DeleteObject(string key)
    {
        if (string.IsNullOrEmpty(selectedBucket)) return;

        var encodedKey = Uri.EscapeDataString(key);
        var url = $"/api/storage/buckets/{selectedBucket}/objects/{encodedKey}";

        var resp = await Http!.DeleteAsync(url);
        if (resp.IsSuccessStatusCode)
        {
            // Liste aktualisieren
            objects = await Http!.GetFromJsonAsync<List<ObjectVm>>($"/api/storage/buckets/{selectedBucket}/objects") ?? new();
            StateHasChanged();
        }
        else
        {
            var msg = await resp.Content.ReadAsStringAsync();
            throw new InvalidOperationException($"Delete fehlgeschlagen: {(int)resp.StatusCode} {resp.ReasonPhrase}\n{msg}");
        }
    }

    // Sehr einfache JS-Confirm-Hilfe (füge IJSRuntime-Injection hinzu)
    [Inject] private IJSRuntime JS { get; set; } = default!;
    private async Task<bool> JSConfirm(string message)
        => await JS.InvokeAsync<bool>("confirm", message);
}