@inherits ShadcnBlazor.Extras.Dialogs.DialogBase

@using System.Text.Json
@using LucideBlazor
@using Moonlight.Shared.Http
@using Moonlight.Shared.Http.Events
@using ShadcnBlazor.Dialogs
@using ShadcnBlazor.Extras.AlertDialogs
@using ShadcnBlazor.Progresses
@using ShadcnBlazor.Spinners

@inject AlertDialogService AlertService
@inject HttpClient HttpClient

<DialogHeader>
    <DialogTitle>
        Updating instance...
    </DialogTitle>
</DialogHeader>

<div class="grid grid-cols-1 xl:grid-cols-2 w-full gap-5">
    <div class="text-base flex flex-col p-2 gap-y-0.5">
        @for (var i = 0; i < Steps.Length; i++)
        {
            if (CurrentStep == i)
            {
                <div class="flex flex-row items-center gap-x-2">
                    <Spinner ClassName="size-4"/>
                    <span>
                        @Steps[i]
                    </span>
                </div>
            }
            else
            {
                if (i < CurrentStep)
                {
                    <div class="flex flex-row items-center gap-x-2">
                        <CheckIcon ClassName="text-green-500 size-4"/>
                        <span>
                            @Steps[i]
                        </span>
                    </div>
                }
                else
                {
                    <div class="text-muted-foreground flex flex-row items-center gap-x-2">
                        <span class="size-4"></span>
                        @Steps[i]
                    </div>
                }
            }
        }
    </div>
    <div class="bg-black text-white rounded-lg font-mono h-96 flex flex-col-reverse overflow-auto p-3 scrollbar-thin">
        @for (var i = LogLines.Count - 1; i >= 0; i--)
        {
            <div>
                @LogLines[i]
            </div>
        }
    </div>
</div>

<DialogFooter>
    <Progress Value="@Progress"></Progress>
</DialogFooter>

@code
{
    private int Progress = 0;

    private int CurrentStep;

    private string[] Steps =
    [
        "Preparing",
        "Updating configuration files",
        "Starting rebuild task",
        "Building docker image",
        "Redeploying container instance",
        "Waiting for container instance to start up",
        "Update complete"
    ];

    private List<string?> LogLines = new();

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (!firstRender)
            return;

        CurrentStep = 0;
        Progress = 0;
        await InvokeAsync(StateHasChanged);

        await Task.Delay(2000);

        CurrentStep = 1;
        Progress = 20;
        await InvokeAsync(StateHasChanged);

        await Task.Delay(2000);

        CurrentStep = 2;
        Progress = 30;
        await InvokeAsync(StateHasChanged);

        var response = await HttpClient.SendAsync(
            new HttpRequestMessage(HttpMethod.Post, "api/admin/ch/rebuild"),
            HttpCompletionOption.ResponseHeadersRead
        );

        await using var responseStream = await response.Content.ReadAsStreamAsync();
        using var streamReader = new StreamReader(responseStream);

        do
        {
            try
            {
                var line = await streamReader.ReadLineAsync();

                if (line == null)
                    break;

                if (string.IsNullOrWhiteSpace(line))
                    continue;

                var data = line.Trim("data: ");
                var deserializedData = JsonSerializer.Deserialize<RebuildEvent>(data, Constants.SerializerOptions);

                switch (deserializedData.Type)
                {
                    case RebuildEventType.Log:
                        LogLines.Add(deserializedData.Data);
                        break;

                    case RebuildEventType.Step:

                        switch (deserializedData.Data)
                        {
                            case "BuildImage":
                                CurrentStep = 3;
                                Progress = 40;
                                await InvokeAsync(StateHasChanged);
                                break;

                            case "ServiceDown":
                                CurrentStep = 4;
                                Progress = 60;
                                await InvokeAsync(StateHasChanged);
                                break;

                            case "ServiceUp":
                                CurrentStep = 4;
                                Progress = 80;
                                await InvokeAsync(StateHasChanged);
                                break;
                        }

                        break;
                }

                await InvokeAsync(StateHasChanged);
            }
            catch (Exception e)
            {
                // TODO: Log
                break;
            }
        } while (true);
        
        CurrentStep = 5;
        Progress = 90;
        await InvokeAsync(StateHasChanged);

        // Ping instance until its reachable again
        while (true)
        {
            try
            {
                await HttpClient.GetStringAsync("api/ping");
                break;
            }
            catch (Exception)
            {
                // Ignored
            }
            
            await Task.Delay(3000);
        }
        
        CurrentStep = 6;
        Progress = 100;
        await InvokeAsync(StateHasChanged);

        await Task.Delay(1000);

        await AlertService.SuccessAsync(
            "Update completed",
            "Update successfully completed. Please refresh the page to load new frontend changes"
        );

        await CloseAsync();
    }
}