@using LANCommander.SDK.Enums
@using LANCommander.Server.ImportExport
@using LANCommander.Server.ImportExport.Factories
@using LANCommander.Server.ImportExport.Models
@using LANCommander.Server.ImportExport.Services
@inherits FeedbackComponent<ExportDialogOptions>
@inject ArchiveService ArchiveService
@inject ExportService ExportService
@inject ExportContextFactory ExportContextFactory
@inject IMessageService MessageService
@inject NavigationManager NavigationManager
@inject ILogger<ExportDialog> Logger

<Spin Spinning="_loading">
    <Tree TItem="string"
        Checkable
        Multiple
        CheckOnClickNode="false"
        @bind-CheckedKeys="_selectedKeys">
        @foreach (var group in ExportItems.GroupBy(i => i.Type))
        {
            var size = group.Sum(i => i.Size);
            
            <TreeNode Title="@($"{group.Key.GetDisplayName()} ({group.Count()})")">
                <TitleTemplate>
                    <GridRow>
                        <GridCol Flex=@("auto")>
                            @group.Key.GetDisplayName() (@group.Count())
                        </GridCol>
                        
                        @if (size > 0)
                        {
                            <GridCol Flex=@("none")>
                                <ByteSize Value="@size" />
                            </GridCol>
                        }
                    </GridRow>
                </TitleTemplate>
                <ChildContent>
                    @foreach (var item in group)
                    {
                        <TreeNode Key="@item.Id.ToString()">
                            <TitleTemplate>
                                <GridRow>
                                    <GridCol Flex=@("auto")>
                                        @item.Name
                                    </GridCol>

                                    @if (item.Size > 0)
                                    {
                                        <GridCol Flex=@("none")>
                                            <ByteSize Value="@item.Size"/>
                                        </GridCol>
                                    }
                                </GridRow>
                            </TitleTemplate>
                        </TreeNode>
                    }
                </ChildContent>
            </TreeNode>
        }
    </Tree>
</Spin>

<Flex Justify="FlexJustify.End" Gap="FlexGap.Small" Style="margin-top: 16px;">
    <Button OnClick="Export" Type="@ButtonType.Primary" Disabled="_loading">Export</Button>
    <Button OnClick="Cancel">Cancel</Button>
</Flex>

@code {
    ExportContext ExportContext;

    IEnumerable<ExportItemInfo> ExportItems = new List<ExportItemInfo>();

    string[] _selectedKeys;
    bool _loading = true;

    protected override async Task OnInitializedAsync()
    {
        _loading = true;
        
        ExportContext = ExportContextFactory.Create();
        
        ExportContext.OnRecordError += RecordError;
        ExportContext.OnRecordAdded += RecordAdded;
        ExportContext.OnRecordProcessed += RecordProcessed;

        if (Options != null && Options.RecordId != Guid.Empty)
            ExportItems = await ExportContext.InitializeExportAsync(Options.RecordId, Options.RecordType);

        _selectedKeys = ExportItems.Select(i => i.Id.ToString()).ToArray();

        _loading = false;
    }

    private void RecordProcessed(object? sender, object e)
    {
        
    }

    private void RecordAdded(object? sender, object e)
    {
        
    }

    private void RecordError(object? sender, object e)
    {
        
    }

    async Task Export()
    {
        var selectedGuids = _selectedKeys
            .Select(k => Guid.TryParse(k, out var id) ? (Guid?)id : null)
            .Where(id => id.HasValue)
            .Select(g => g!.Value);

        await ExportContext.PrepareExportQueueAsync(selectedGuids);

        await InvokeAsync(StateHasChanged);
        
        var contextId = ExportService.EnqueueContext(ExportContext);
        
        NavigationManager.NavigateTo($"/api/Export/{contextId}", true);
    }

    async Task Cancel()
    {
        await CloseFeedbackAsync();
    }

    public override async Task OnFeedbackCancelAsync(ModalClosingEventArgs args)
    {
        //ExportContext.Dispose();
        
        await base.OnFeedbackCancelAsync(args);
    }

    public override async Task OnFeedbackOkAsync(ModalClosingEventArgs args)
    {
        //ExportContext.Dispose();
        
        await base.OnFeedbackOkAsync(args);
    }

    public async Task OnUploadCompleted(string data)
    {
        if (Guid.TryParse(data, out var objectKey))
        {
            try
            {
                var archivePath = await ArchiveService.GetArchiveFileLocationAsync(objectKey.ToString());

                ExportItems = await ExportContext.InitializeExportAsync(Options.RecordId, Options.RecordType);

                await InvokeAsync(StateHasChanged);
            }
            catch (Exception ex)
            {
                MessageService.Error("An unknown error occurred while trying to gather export details");
                Logger.LogError(ex, "An unknown error occurred while trying to gather export details");
            }
        }
        else
        {
            await InvokeAsync(StateHasChanged);

            MessageService.Error("Export file failed to generate!");
            Logger.LogError("Export file failed to generate!");

            await CloseFeedbackAsync();
        }
    }
}