LANCommander/LANCommander.Launcher/UI/Components/PlayButton.razor

@implements IDisposable
@using LANCommander.Launcher.Data.Models
@using LANCommander.Launcher.Models
@using System.Diagnostics
@using LANCommander.SDK.Helpers
@inject SDK.Client Client
@inject GameService GameService
@inject LibraryService LibraryService
@inject InstallService InstallService
@inject ModalService ModalService
@inject MessageService MessageService
@inject MessageBusService MessageBusService

@if (IsRunning)
{
    <Popconfirm Title="Do you want to stop this game?" OkText="Yes" OnConfirm="() => Stop()">
        <Button Type="@ButtonType.Primary" Size="@ButtonSize.Large" Icon="@IconType.Outline.CaretRight">Running</Button>
    </Popconfirm>
}
else
{
    <Space Direction="@DirectionVHType.Horizontal">
        <SpaceItem>
            <Button Type="@ButtonType.Primary" Size="@ButtonSize.Large" Icon="@IconType.Outline.CaretRight" OnClick="() => Run()">Play</Button>
        </SpaceItem>

        <SpaceItem>
            <Dropdown>
                <Overlay>
                    <Menu>
                        <LibraryItemContextMenu Model="LibraryItem" MenuExtra="MenuExtra" />
                    </Menu>
                </Overlay>

                <ChildContent>
                    <Button Type="@ButtonType.Default" Size="@ButtonSize.Large" Icon="@IconType.Outline.Ellipsis" />
                </ChildContent>
            </Dropdown>
        </SpaceItem>
    </Space>
}

@code {
    [Parameter] public Guid LibraryItemId { get; set; }
    [Parameter] public Models.ListItem LibraryItem { get; set; }
    [Parameter] public RenderFragment MenuExtra { get; set; }

    Timer StateTimer;
    Settings Settings;
    bool IsRunning = false;

    protected override async Task OnInitializedAsync()
    {
        StateTimer = new Timer(state => { InvokeAsync(UpdateState); }, null, 0, 250);
        Settings = SettingService.GetSettings();
    }

    protected override async Task OnParametersSetAsync()
    {
        if (LibraryItem == null && LibraryItemId != Guid.Empty)
            LibraryItem = await LibraryService.GetItemAsync(LibraryItemId);
    }

    async Task UpdateState()
    {
        if (!IsRunning && Client.Games.IsRunning(LibraryItem.Key))
        {
            IsRunning = true;

            await InvokeAsync(StateHasChanged);
        }
        else if (IsRunning && !Client.Games.IsRunning(LibraryItem.Key))
        {
            IsRunning = false;

            await InvokeAsync(StateHasChanged);
        }
    }

    async Task Run()
    {
        var game = LibraryItem.DataItem as Game;
        var actions = await Client.Games.GetActionsAsync(game.InstallDirectory, game.Id);

        if (actions == null || actions.Count() == 0)
        {
            MessageService.Error("No actions found!");
            return;
        }        

        var primaryActions = actions.Where(a => a.IsPrimaryAction);

        if (primaryActions.Count() == 0)
        {
            MessageService.Error("No primary action found!");
            return;
        }

        if (primaryActions.Count() == 1)
        {
            var task = GameService.Run(game, primaryActions.First());

            await InvokeAsync(StateHasChanged);

            await task;
        }
        else
        {
            var modalOptions = new ModalOptions()
            {
                Title = $"Play {game.Title}",
                Maximizable = false,
                DefaultMaximized = false,
                Closable = true,
                Footer = null,
                Centered = true,
                WrapClassName = "game-actions-dialog",
                OnCancel = async (e) =>
                {
                    Client.Lobbies.ReleaseSteam();
                },
                AfterClose = async () =>
                {
                    Client.Lobbies.ReleaseSteam();
                }
            };

            var model = new ActionSelectorDialogOptions
            {
                Actions = actions.Where(a => a.IsPrimaryAction),
                Game = game
            };

            var modalRef = ModalService.CreateModal<ActionSelectorDialog, ActionSelectorDialogOptions, Process>(modalOptions, model);
        }
    }

    async Task Stop()
    {
        await Client.Games.Stop(LibraryItem.Key);

        await InvokeAsync(StateHasChanged);
    }

    public void Dispose()
    {
        StateTimer.Dispose();
    }
}