@namespace Oqtane.Modules.Admin.RecycleBin
@inherits ModuleBase
@inject NavigationManager NavigationManager
@inject IPageModuleService PageModuleService
@inject IModuleService ModuleService
@inject IPageService PageService

<TabControl>
    <TabPanel Text="Pages">
        @if (pages.Count == 0)
        {
            <br/>
            <p>No Deleted Pages</p>
        }
        else
        {
            <Pager Items="@pages">
                <Header>
                    <th>Name</th>
                    <th>Deleted By</th>
                    <th>Deleted On</th>
                    <th>&nbsp;</th>
                    <th>&nbsp;</th>
                </Header>
                <Row>
                    <td>@context.Name</td>
                    <td>@context.DeletedBy</td>
                    <td>@context.DeletedOn</td>
                    <td><button @onclick="@(() => RestorePage(context))" class="btn btn-info" title="Restore">Restore</button></td>
                    <td><button @onclick="@(() => DeletePage(context.PageId))" class="btn btn-danger">Delete</button></td>
                </Row>
            </Pager>
        }
    </TabPanel>
    <TabPanel Text="Modules">
        @if (pageModules.Count == 0)
        {
            <br/>
            <p>No Deleted Modules</p>
        }
        else
        {
            <Pager Items="@pageModules">
                <Header>
                    <th>Page</th>
                    <th>Module</th>
                    <th>Deleted By</th>
                    <th>Deleted On</th>
                    <th>&nbsp;</th>
                    <th>&nbsp;</th>
                </Header>
                <Row>
                    <td>@PageState.Pages.Find(item => item.PageId == context.PageId).Name</td>
                    <td>@context.Title</td>
                    <td>@context.DeletedBy</td>
                    <td>@context.DeletedOn</td>
                    <td><button @onclick="@(() => RestorePageModule(context))" class="btn btn-info" title="Restore">Restore</button></td>
                    <td><button @onclick="@(() => DeletePageModule(context.PageModuleId, context.ModuleId))" class="btn btn-danger">Delete</button></td>
                </Row>
            </Pager>
        }
    </TabPanel>
</TabControl>

@code {
    public override SecurityAccessLevel SecurityAccessLevel { get { return SecurityAccessLevel.Admin; } }

    List<Page> pages { get; set; }
    List<PageModule> pageModules { get; set; }

    protected override async Task OnInitializedAsync()
    {
        try
        {
            pages = new List<Page>();
            pageModules = new List<PageModule>();
            await LoadEntities();
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Loading Deleted Pages Or Modules {Error}", ex.Message);
            AddModuleMessage("Error Loading Deleted Pages Or Modules", MessageType.Error);
        }
    }

    protected override void OnParametersSet()
    {
        pages = PageState.Pages.Where(item => item.IsDeleted).ToList();
    }

    private async Task LoadEntities()
    {
        pageModules.Clear();
        foreach (var module in PageState.Modules.Where(item => item.IsDeleted))
        {
            var pageModule = await PageModuleService.GetPageModuleAsync(module.PageModuleId);
            pageModules.Add(pageModule);
        }
    }

    private async Task RestorePage(Page Page)
    {
        try
        {
            Page.IsDeleted = false;
            await PageService.UpdatePageAsync(Page);
            await logger.LogInformation("Page Restored {Page}", Page);
            NavigationManager.NavigateTo(NavigateUrl(Reload.Site));
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Restoring Deleted Page {Page} {Error}", Page, ex.Message);
            AddModuleMessage("Error Restoring Deleted Page", MessageType.Error);
        }
    }

    private async Task DeletePage(int PageId)
    {
        try
        {
            var deletedPageModules = PageState.Modules.Where(item => item.PageId == PageId);
            await PageService.DeletePageAsync(PageId);
            foreach (var module in deletedPageModules)
            {
                await ModuleService.DeleteModuleAsync(module.ModuleId);
            }
            await logger.LogInformation("Page Permanently Deleted {PageId}", PageId);
            NavigationManager.NavigateTo(NavigateUrl(Reload.Site));
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Permanently Deleting Page {PageId} {Error}", PageId, ex.Message);
            AddModuleMessage(ex.Message, MessageType.Error);
        }
    }

    private async Task RestorePageModule(PageModule PageModule)
    {
        try
        {
            PageModule.IsDeleted = false;
            await PageModuleService.UpdatePageModuleAsync(PageModule);
            await LoadEntities();
            await logger.LogInformation("Page Module Restored {PageModule}", PageModule);
            NavigationManager.NavigateTo(NavigateUrl(Reload.Site));
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Restoring Deleted Page Module {PageModule} {Error}", PageModule, ex.Message);
            AddModuleMessage("Error Restoring Deleted Page Module", MessageType.Error);
        }
    }

    private async Task DeletePageModule(int PageModuleId, int ModuleId)
    {
        try
        {
            await PageModuleService.DeletePageModuleAsync(PageModuleId);
            if (PageState.Modules.Count(item => item.ModuleId == ModuleId) == 1)
            {
                await ModuleService.DeleteModuleAsync(ModuleId);
            }
            PageState.Modules.RemoveAt(PageState.Modules.FindIndex(item => item.ModuleId == ModuleId));
            await LoadEntities();
            await logger.LogInformation("Page Module Permanently Deleted {PageModuleId}", PageModuleId);
            NavigationManager.NavigateTo(NavigateUrl(Reload.Site));
        }
        catch (Exception ex)
        {
            await logger.LogError(ex, "Error Permanently Deleting Page Module {PageModuleId} {Error}", PageModuleId, ex.Message);
            AddModuleMessage("Error Permanently Deleting Page Module", MessageType.Error);
        }
    }
}