@page "/deco-templates"
@using ErsatzTV.Application.Scheduling
@using ErsatzTV.Application.Tree
@implements IDisposable
@inject ILogger<DecoTemplates> Logger
@inject ISnackbar Snackbar
@inject IMediator Mediator
@inject IDialogService Dialog

<MudForm Style="max-height: 100%">
    <div class="d-flex flex-column" style="height: 100vh; overflow-x: auto">
        <MudContainer MaxWidth="MaxWidth.ExtraLarge" Class="pt-8">
            <MudText Typo="Typo.h5" Class="mb-2">Deco Template Groups</MudText>
            <MudDivider Class="mb-6"/>
            <MudStack Row="true" Breakpoint="Breakpoint.SmAndDown" Class="form-field-stack gap-md-8 mb-5">
                <div class="d-flex">
                    <MudText>Deco Template Group Name</MudText>
                </div>
                <MudTextField @bind-Value="_decoTemplateGroupName" For="@(() => _decoTemplateGroupName)"/>
            </MudStack>
            <MudStack Row="true" Breakpoint="Breakpoint.SmAndDown" Class="form-field-stack gap-md-8 mb-5">
                <div class="d-flex"></div>
                <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="@(_ => AddDecoTemplateGroup())" StartIcon="@Icons.Material.Filled.Add">
                    Add Deco Template Group
                </MudButton>
            </MudStack>
            <MudText Typo="Typo.h5" Class="mt-10 mb-2">Deco Templates</MudText>
            <MudDivider Class="mb-6"/>
            <MudStack Row="true" Breakpoint="Breakpoint.SmAndDown" Class="form-field-stack gap-md-8 mb-5">
                <div class="d-flex">
                    <MudText>Deco Template Group</MudText>
                </div>
                <MudSelect @bind-Value="_selectedDecoTemplateGroup">
                    @foreach (DecoTemplateGroupViewModel decoTemplateGroup in _decoTemplateGroups)
                    {
                        <MudSelectItem Value="@decoTemplateGroup">@decoTemplateGroup.Name</MudSelectItem>
                    }
                </MudSelect>
            </MudStack>
            <MudStack Row="true" Breakpoint="Breakpoint.SmAndDown" Class="form-field-stack gap-md-8 mb-5">
                <div class="d-flex">
                    <MudText>Deco Template Name</MudText>
                </div>
                <MudTextField @bind-Value="_decoTemplateName" For="@(() => _decoTemplateName)"/>
            </MudStack>
            <MudStack Row="true" Breakpoint="Breakpoint.SmAndDown" Class="form-field-stack gap-md-8 mb-5">
                <div class="d-flex"></div>
                <MudButton Variant="Variant.Filled" Color="Color.Primary" OnClick="@(_ => AddDecoTemplate())" StartIcon="@Icons.Material.Filled.Add">
                    Add Deco Template
                </MudButton>
            </MudStack>
            <MudStack Row="true" Breakpoint="Breakpoint.SmAndDown" Class="form-field-stack gap-md-8 mb-5">
                <div class="d-flex"></div>
                <MudTreeView T="DecoTemplateTreeItemViewModel" Items="@_treeItems" Hover="true" Style="width: 100%">
                    <ItemTemplate Context="item">
                        <MudTreeViewItem T="DecoTemplateTreeItemViewModel" Items="@item.Value!.TreeItems" Icon="@item.Value.Icon" Value="@item.Value">
                            <BodyContent>
                                <div style="display: grid; grid-template-columns: 1fr auto; align-items: center; width: 100%">
                                    <MudGrid Justify="Justify.FlexStart">
                                        <MudItem xs="5">
                                            <MudText>@item.Value.Text</MudText>
                                        </MudItem>
                                    </MudGrid>
                                    <div style="justify-self: end;">
                                        @foreach (int decoTemplateId in Optional(item.Value.DecoTemplateId))
                                        {
                                            <MudIconButton Icon="@Icons.Material.Filled.Edit" Size="Size.Medium" Color="Color.Inherit" Href="@($"deco-templates/{decoTemplateId}")"/>
                                        }
                                        <MudIconButton Icon="@Icons.Material.Filled.Delete" Size="Size.Medium" Color="Color.Inherit" OnClick="@(_ => DeleteItem(item.Value))"/>
                                    </div>
                                </div>
                            </BodyContent>
                        </MudTreeViewItem>
                    </ItemTemplate>
                </MudTreeView>
            </MudStack>
        </MudContainer>
    </div>
</MudForm>

@code {
    private CancellationTokenSource _cts;
    private readonly List<TreeItemData<DecoTemplateTreeItemViewModel>> _treeItems = [];
    private List<DecoTemplateGroupViewModel> _decoTemplateGroups = [];
    private DecoTemplateGroupViewModel _selectedDecoTemplateGroup;
    private string _decoTemplateGroupName;
    private string _decoTemplateName;

    public void Dispose()
    {
        _cts?.Cancel();
        _cts?.Dispose();
    }

    protected override async Task OnParametersSetAsync()
    {
        _cts?.Cancel();
        _cts?.Dispose();
        _cts = new CancellationTokenSource();
        var token = _cts.Token;

        try
        {
            _decoTemplateGroups = await Mediator.Send(new GetAllDecoTemplateGroups(), token);

            _treeItems.Clear();
            TreeViewModel tree = await Mediator.Send(new GetDecoTemplateTree(), token);
            foreach (TreeGroupViewModel group in tree.Groups)
            {
                _treeItems.Add(new TreeItemData<DecoTemplateTreeItemViewModel> { Value = new DecoTemplateTreeItemViewModel(group) });
            }
        }
        catch (OperationCanceledException)
        {
            // do nothing
        }
    }

    private async Task AddDecoTemplateGroup()
    {
        if (!string.IsNullOrWhiteSpace(_decoTemplateGroupName))
        {
            Either<BaseError, DecoTemplateGroupViewModel> result = await Mediator.Send(new CreateDecoTemplateGroup(_decoTemplateGroupName), _cts.Token);

            foreach (BaseError error in result.LeftToSeq())
            {
                Snackbar.Add(error.Value, Severity.Error);
                Logger.LogError("Unexpected error adding decoTemplate group: {Error}", error.Value);
            }

            foreach (DecoTemplateGroupViewModel decoTemplateGroup in result.RightToSeq())
            {
                _treeItems.Add(new TreeItemData<DecoTemplateTreeItemViewModel> { Value = new DecoTemplateTreeItemViewModel(decoTemplateGroup) });
                _treeItems.Sort((x, y) => string.Compare(x.Value?.Text, y.Value?.Text, StringComparison.CurrentCulture));
                _decoTemplateGroupName = null;

                _decoTemplateGroups = await Mediator.Send(new GetAllDecoTemplateGroups(), _cts.Token);
                await InvokeAsync(StateHasChanged);
            }
        }
    }

    private async Task AddDecoTemplate()
    {
        if (_selectedDecoTemplateGroup is not null && !string.IsNullOrWhiteSpace(_decoTemplateName))
        {
            Either<BaseError, DecoTemplateViewModel> result = await Mediator.Send(new CreateDecoTemplate(_selectedDecoTemplateGroup.Id, _decoTemplateName), _cts.Token);

            foreach (BaseError error in result.LeftToSeq())
            {
                Snackbar.Add(error.Value, Severity.Error);
                Logger.LogError("Unexpected error adding decoTemplate: {Error}", error.Value);
            }

            foreach (DecoTemplateViewModel decoTemplate in result.RightToSeq())
            {
                foreach (DecoTemplateTreeItemViewModel item in _treeItems.Map(i => i.Value).Where(item => item.DecoTemplateGroupId == _selectedDecoTemplateGroup.Id))
                {
                    item.TreeItems.Add(new TreeItemData<DecoTemplateTreeItemViewModel> { Value = new DecoTemplateTreeItemViewModel(decoTemplate) });
                    item.TreeItems.Sort((x, y) => string.Compare(x.Value?.Text, y.Value?.Text, StringComparison.CurrentCulture));
                }

                _decoTemplateName = null;
                await InvokeAsync(StateHasChanged);
            }
        }
    }

    private async Task DeleteItem(DecoTemplateTreeItemViewModel treeItem)
    {
        foreach (int decoTemplateGroupId in Optional(treeItem.DecoTemplateGroupId))
        {
            var parameters = new DialogParameters { { "EntityType", "decoTemplate group" }, { "EntityName", treeItem.Text } };
            var options = new DialogOptions { CloseButton = true, MaxWidth = MaxWidth.ExtraSmall };

            IDialogReference dialog = await Dialog.ShowAsync<DeleteDialog>("Delete DecoTemplate Group", parameters, options);
            DialogResult result = await dialog.Result;
            if (result is not null && !result.Canceled)
            {
                await Mediator.Send(new DeleteDecoTemplateGroup(decoTemplateGroupId), _cts.Token);
                _treeItems.RemoveAll(i => i.Value?.DecoTemplateGroupId == decoTemplateGroupId);
                if (_selectedDecoTemplateGroup?.Id == decoTemplateGroupId)
                {
                    _selectedDecoTemplateGroup = null;
                }

                _decoTemplateGroups = await Mediator.Send(new GetAllDecoTemplateGroups(), _cts.Token);
                await InvokeAsync(StateHasChanged);
            }
        }

        foreach (int decoTemplateId in Optional(treeItem.DecoTemplateId))
        {
            var parameters = new DialogParameters { { "EntityType", "decoTemplate" }, { "EntityName", treeItem.Text } };
            var options = new DialogOptions { CloseButton = true, MaxWidth = MaxWidth.ExtraSmall };

            IDialogReference dialog = await Dialog.ShowAsync<DeleteDialog>("Delete DecoTemplate", parameters, options);
            DialogResult result = await dialog.Result;
            if (result is not null && !result.Canceled)
            {
                await Mediator.Send(new DeleteDecoTemplate(decoTemplateId), _cts.Token);
                foreach (DecoTemplateTreeItemViewModel parent in _treeItems.Map(i => i.Value))
                {
                    parent.TreeItems.RemoveAll(i => i.Value == treeItem);
                }

                await InvokeAsync(StateHasChanged);
            }
        }
    }

}